[TypeScript client] feat: RPC & in-memory transports

package.json

@@ -70,6 +70,11 @@
       "types": "./dist/index.d.ts",
       "src": "./src/index.ts",
       "default": "./dist/index.js"
+    },
+    "./client": {
+      "types": "./dist/client/index.d.ts",
+      "src": "./src/client/index.ts",
+      "default": "./dist/client/index.js"
     }
   }
 }

src/Cli.test-d.ts

@@ -159,6 +159,28 @@ test('Cta accepts object form', () => {
   expectTypeOf<{ command: 'auth login'; description: 'Log in' }>().toMatchTypeOf<Cli.Cta>()
 })
 
+test('OpenAPI-mounted operations are included in CLI command map type', () => {
+  const cli = Cli.create('test').command('api', {
+    fetch: () => new Response('{}'),
+    openapi: {
+      paths: {
+        '/users': {
+          get: {
+            operationId: 'listUsers',
+            responses: { '200': { description: 'ok' } },
+          },
+        },
+      },
+    },
+  })
+
+  expectTypeOf<typeof cli>().toMatchTypeOf<
+    Cli.Cli<{
+      'api listUsers': { args: Record<string, unknown>; options: Record<string, unknown> }
+    }>
+  >()
+})
+
 test('Cta narrows strings and objects to registered commands', () => {
   type Commands = {
     get: { args: { id: number }; options: {} }

src/Cli.test.ts

@@ -4175,6 +4175,7 @@ describe('Command.execute', () => {
 async function fetchJson(cli: Cli.Cli<any, any, any>, req: Request) {
   const res = await cli.fetch(req)
   const body = await res.json()
+  expect(body.meta.duration).toMatch(/^\d+ms$/)
   body.meta.duration = '<stripped>'
   return { status: res.status, body }
 }
@@ -4243,6 +4244,179 @@ describe('fetch', () => {
     expect(res.body.error.message).toContain("Did you mean 'health'?")
   })
 
+  test('RPC route maps protocol failures to HTTP statuses', async () => {
+    const cli = Cli.create('app').command(
+      Cli.create('group').command('leaf', {
+        run() {
+          return null
+        },
+      }),
+    )
+    cli.command('raw', { fetch: () => new Response('{}') })
+
+    expect(
+      await fetchJson(
+        cli,
+        new Request('http://localhost/_incur/rpc', {
+          method: 'POST',
+          body: JSON.stringify({ command: '' }),
+        }),
+      ),
+    ).toMatchInlineSnapshot(`
+      {
+        "body": {
+          "error": {
+            "code": "INVALID_RPC_REQUEST",
+            "message": "RPC command is required.",
+          },
+          "meta": {
+            "command": "",
+            "duration": "<stripped>",
+          },
+          "ok": false,
+        },
+        "status": 400,
+      }
+    `)
+
+    expect(
+      await fetchJson(
+        cli,
+        new Request('http://localhost/_incur/rpc', {
+          method: 'POST',
+          body: JSON.stringify({ command: 'group' }),
+        }),
+      ),
+    ).toMatchInlineSnapshot(`
+      {
+        "body": {
+          "error": {
+            "code": "COMMAND_GROUP",
+            "message": "'group' is a command group. Specify a subcommand.",
+          },
+          "meta": {
+            "command": "group",
+            "duration": "<stripped>",
+          },
+          "ok": false,
+        },
+        "status": 400,
+      }
+    `)
+
+    expect(
+      await fetchJson(
+        cli,
+        new Request('http://localhost/_incur/rpc', {
+          method: 'POST',
+          body: JSON.stringify({ command: 'raw' }),
+        }),
+      ),
+    ).toMatchInlineSnapshot(`
+      {
+        "body": {
+          "error": {
+            "code": "FETCH_GATEWAY",
+            "message": "'raw' is a raw fetch gateway and cannot be called with structured RPC.",
+          },
+          "meta": {
+            "command": "raw",
+            "duration": "<stripped>",
+          },
+          "ok": false,
+        },
+        "status": 400,
+      }
+    `)
+
+    expect(
+      await fetchJson(
+        cli,
+        new Request('http://localhost/_incur/rpc', {
+          method: 'POST',
+          body: JSON.stringify({ command: 'missing' }),
+        }),
+      ),
+    ).toMatchInlineSnapshot(`
+      {
+        "body": {
+          "error": {
+            "code": "COMMAND_NOT_FOUND",
+            "message": "'missing' is not a command for 'app'.",
+          },
+          "meta": {
+            "command": "missing",
+            "duration": "<stripped>",
+          },
+          "ok": false,
+        },
+        "status": 404,
+      }
+    `)
+  })
+
+  test('discovery routes map failures to envelopes', async () => {
+    const cli = Cli.create('app').command('status', {
+      run() {
+        return { ok: true }
+      },
+    })
+
+    expect(await fetchJson(cli, new Request('http://localhost/_incur/help?command=missing')))
+      .toMatchInlineSnapshot(`
+      {
+        "body": {
+          "error": {
+            "code": "COMMAND_NOT_FOUND",
+            "message": "Unknown command 'missing'.",
+          },
+          "meta": {
+            "duration": "<stripped>",
+            "resource": "help",
+          },
+          "ok": false,
+        },
+        "status": 404,
+      }
+    `)
+
+    expect(await fetchJson(cli, new Request('http://localhost/_incur/skill?name=../x')))
+      .toMatchInlineSnapshot(`
+      {
+        "body": {
+          "error": {
+            "code": "INVALID_SKILL_NAME",
+            "message": "Unsafe skill name.",
+          },
+          "meta": {
+            "duration": "<stripped>",
+            "resource": "skill",
+          },
+          "ok": false,
+        },
+        "status": 400,
+      }
+    `)
+
+    expect(await fetchJson(cli, new Request('http://localhost/_incur/skill?name=missing')))
+      .toMatchInlineSnapshot(`
+      {
+        "body": {
+          "error": {
+            "code": "SKILL_NOT_FOUND",
+            "message": "Unknown skill 'missing'.",
+          },
+          "meta": {
+            "duration": "<stripped>",
+            "resource": "skill",
+          },
+          "ok": false,
+        },
+        "status": 404,
+      }
+    `)
+  })
+
   test('GET / with root command → 200', async () => {
     const cli = Cli.create('test', { run: () => ({ root: true }) })
     expect(await fetchJson(cli, new Request('http://localhost/'))).toMatchInlineSnapshot(`