support for other API clients

Author: shivam96anand

package.json

@@ -1,6 +1,6 @@
 {
   "name": "restbro",
-  "version": "1.1.4",
+  "version": "1.2.0",
   "description": "A modern API testing tool similar to Postman and Insomnia",
   "main": "dist/main/main/index.js",
   "scripts": {

src/main/modules/__tests__/ipc-manager.test.ts

@@ -179,6 +179,8 @@ describe('ipc-manager.ts', () => {
         IPC_CHANNELS.FILE_READ_BINARY,
         IPC_CHANNELS.FILE_PICK_FOR_UPLOAD,
         IPC_CHANNELS.IMPORT_PARSE_PREVIEW,
+        IPC_CHANNELS.IMPORT_PARSE_FOLDER_PREVIEW,
+        IPC_CHANNELS.IMPORT_PICK_FOLDER,
         IPC_CHANNELS.IMPORT_COMMIT,
         IPC_CHANNELS.COLLECTIONS_STATE_GET,
         IPC_CHANNELS.COLLECTIONS_STATE_SET,

src/main/modules/importers/__tests__/bruno-bru-parser.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect, it } from 'vitest';
+import { parseBruFile, dictToRecord, findBlock } from '../bruno-bru-parser';
+
+describe('bruno .bru parser', () => {
+  it('parses dict blocks with disabled keys', () => {
+    const text = `meta {
+  name: Get Users
+  type: http
+  seq: 1
+}
+
+headers {
+  Accept: application/json
+  ~X-Disabled: nope
+}
+`;
+    const blocks = parseBruFile(text);
+    expect(blocks).toHaveLength(2);
+    expect(blocks[0].name).toBe('meta');
+    if (blocks[0].body.kind !== 'dict') throw new Error('expected dict');
+    expect(dictToRecord(blocks[0].body.entries)).toEqual({
+      name: 'Get Users',
+      type: 'http',
+      seq: '1',
+    });
+
+    if (blocks[1].body.kind !== 'dict') throw new Error('expected dict');
+    expect(blocks[1].body.entries).toHaveLength(2);
+    expect(blocks[1].body.entries[1]).toMatchObject({
+      key: 'X-Disabled',
+      value: 'nope',
+      enabled: false,
+    });
+    // Disabled keys are dropped by dictToRecord.
+    expect(dictToRecord(blocks[1].body.entries)).toEqual({
+      Accept: 'application/json',
+    });
+  });
+
+  it('captures raw body blocks verbatim including braces', () => {
+    const text = `body:json {
+  {
+    "name": "alice",
+    "tags": { "x": 1 }
+  }
+}
+`;
+    const blocks = parseBruFile(text);
+    const body = findBlock(blocks, 'body:json');
+    expect(body).toBeDefined();
+    if (body!.body.kind !== 'raw') throw new Error('expected raw');
+    expect(body!.body.text).toContain('"name": "alice"');
+    expect(body!.body.text).toContain('"tags": { "x": 1 }');
+  });
+
+  it('throws on unmatched braces', () => {
+    expect(() => parseBruFile('headers {\n  a: b\n')).toThrow(/unmatched/);
+  });
+
+  it('handles CRLF line endings', () => {
+    const text = 'meta {\r\n  name: X\r\n}\r\n';
+    const blocks = parseBruFile(text);
+    expect(blocks).toHaveLength(1);
+    if (blocks[0].body.kind !== 'dict') throw new Error('expected dict');
+    expect(dictToRecord(blocks[0].body.entries)).toEqual({ name: 'X' });
+  });
+});

src/main/modules/importers/__tests__/bruno.test.ts

@@ -0,0 +1,181 @@
+import { describe, expect, it, beforeEach, afterEach } from 'vitest';
+import { promises as fs } from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { isBrunoCollectionDir, mapBrunoCollection } from '../bruno';
+
+async function writeFile(p: string, content: string): Promise<void> {
+  await fs.mkdir(path.dirname(p), { recursive: true });
+  await fs.writeFile(p, content, 'utf-8');
+}
+
+describe('bruno collection importer', () => {
+  let tmpDir = '';
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'restbro-bruno-'));
+  });
+
+  afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it('isBrunoCollectionDir true when bruno.json declares collection', async () => {
+    await writeFile(
+      path.join(tmpDir, 'bruno.json'),
+      JSON.stringify({ name: 'My API', version: '1', type: 'collection' })
+    );
+    expect(await isBrunoCollectionDir(tmpDir)).toBe(true);
+  });
+
+  it('isBrunoCollectionDir false for an unrelated folder', async () => {
+    await writeFile(path.join(tmpDir, 'README.md'), 'hi');
+    expect(await isBrunoCollectionDir(tmpDir)).toBe(false);
+  });
+
+  it('maps a typical collection: nested folders, request, env', async () => {
+    await writeFile(
+      path.join(tmpDir, 'bruno.json'),
+      JSON.stringify({ name: 'Users API', version: '1', type: 'collection' })
+    );
+
+    // Folder with custom display name
+    await writeFile(
+      path.join(tmpDir, 'Users', 'folder.bru'),
+      `meta {\n  name: User Endpoints\n}\n`
+    );
+
+    // GET request with headers, query, bearer auth
+    await writeFile(
+      path.join(tmpDir, 'Users', 'GetUser.bru'),
+      `meta {
+  name: Get User
+  type: http
+  seq: 1
+}
+
+get {
+  url: {{baseUrl}}/users/{{id}}
+  body: none
+  auth: bearer
+}
+
+headers {
+  Accept: application/json
+}
+
+params:query {
+  verbose: true
+  ~skip: x
+}
+
+auth:bearer {
+  token: {{token}}
+}
+`
+    );
+
+    // POST request with json body
+    await writeFile(
+      path.join(tmpDir, 'Users', 'CreateUser.bru'),
+      `meta {
+  name: Create User
+  type: http
+  seq: 2
+}
+
+post {
+  url: {{baseUrl}}/users
+  body: json
+  auth: none
+}
+
+body:json {
+  {
+    "name": "alice"
+  }
+}
+`
+    );
+
+    // Environment
+    await writeFile(
+      path.join(tmpDir, 'environments', 'Dev.bru'),
+      `vars {
+  baseUrl: https://api.dev
+  token: xyz
+}
+`
+    );
+
+    const { rootFolder, environments } = await mapBrunoCollection(tmpDir);
+
+    expect(rootFolder.name).toBe('Users API');
+    expect(rootFolder.children).toHaveLength(1);
+
+    const folder = rootFolder.children![0];
+    expect(folder.type).toBe('folder');
+    expect(folder.name).toBe('User Endpoints');
+    expect(folder.children).toHaveLength(2);
+
+    // Children sorted alphabetically by file name → CreateUser, GetUser
+    const create = folder.children!.find((c) => c.name === 'Create User')!;
+    const get = folder.children!.find((c) => c.name === 'Get User')!;
+
+    expect(get.request!.method).toBe('GET');
+    expect(get.request!.url).toBe('{{baseUrl}}/users/{{id}}');
+    expect(get.request!.headers).toEqual({ Accept: 'application/json' });
+    expect(get.request!.params).toEqual({ verbose: 'true' });
+    expect(get.request!.auth).toEqual({
+      type: 'bearer',
+      config: { token: '{{token}}' },
+    });
+
+    expect(create.request!.method).toBe('POST');
+    expect(create.request!.body).toEqual({
+      type: 'json',
+      content: '  {\n    "name": "alice"\n  }',
+    });
+
+    expect(environments).toHaveLength(1);
+    expect(environments[0].name).toBe('Dev');
+    expect(environments[0].variables).toEqual({
+      baseUrl: 'https://api.dev',
+      token: 'xyz',
+    });
+  });
+
+  it('skips files that do not contain a verb block', async () => {
+    await writeFile(
+      path.join(tmpDir, 'bruno.json'),
+      JSON.stringify({ name: 'C', version: '1', type: 'collection' })
+    );
+    await writeFile(
+      path.join(tmpDir, 'NotARequest.bru'),
+      `meta {\n  name: stub\n}\n`
+    );
+    const { rootFolder } = await mapBrunoCollection(tmpDir);
+    expect(rootFolder.children).toEqual([]);
+  });
+
+  it('falls back to filename when meta.name is missing', async () => {
+    await writeFile(
+      path.join(tmpDir, 'bruno.json'),
+      JSON.stringify({ name: 'C', version: '1', type: 'collection' })
+    );
+    await writeFile(
+      path.join(tmpDir, 'Ping.bru'),
+      `get {\n  url: https://x/ping\n  body: none\n  auth: none\n}\n`
+    );
+    const { rootFolder } = await mapBrunoCollection(tmpDir);
+    expect(rootFolder.children).toHaveLength(1);
+    expect(rootFolder.children![0].name).toBe('Ping');
+    expect(rootFolder.children![0].request!.url).toBe('https://x/ping');
+  });
+
+  it('throws when given a non-Bruno folder', async () => {
+    await expect(mapBrunoCollection(tmpDir)).rejects.toThrow(
+      /not a Bruno collection/
+    );
+  });
+});

src/main/modules/importers/__tests__/curl.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, it } from 'vitest';
+import { isCurlCommand, mapCurlCommand } from '../curl';
+
+describe('curl importer', () => {
+  describe('isCurlCommand', () => {
+    it('detects a curl command', () => {
+      expect(isCurlCommand('curl https://x')).toBe(true);
+      expect(isCurlCommand('  CURL  -X POST https://x')).toBe(true);
+    });
+    it('rejects non-curl text', () => {
+      expect(isCurlCommand('GET https://x')).toBe(false);
+      expect(isCurlCommand('')).toBe(false);
+    });
+  });
+
+  it('maps a typical curl command to a single-request collection', () => {
+    const { rootFolder } = mapCurlCommand(
+      `curl -X POST 'https://api.example.com/users' \\
+   -H 'Accept: application/json' \\
+   -H 'Content-Type: application/json' \\
+   -d '{"name":"alice"}'`
+    );
+    expect(rootFolder.children).toHaveLength(1);
+    const req = rootFolder.children![0].request!;
+    expect(req.method).toBe('POST');
+    expect(req.url).toBe('https://api.example.com/users');
+    expect((req.headers as Record<string, string>).Accept).toBe(
+      'application/json'
+    );
+    expect(req.body).toEqual({
+      type: 'json',
+      content: '{"name":"alice"}',
+    });
+  });
+});