@zgeoff/atc 2.8.2 → 2.9.0

package/src/mcp/types.ts

@@ -0,0 +1,78 @@
+import type { ApprovalState } from './approval-state';
+import type { openMCPAuth } from './open-mcp-auth';
+
+// The slice of the daemon client the tool handlers need.
+export interface FleetCaller {
+  readonly sendRequest: (
+    m: string,
+    p?: Readonly<Record<string, unknown>>,
+  ) => Promise<Readonly<Record<string, unknown>>>;
+}
+
+export interface ToolContext {
+  readonly callerSessionID: string | null;
+
+  // Who a sent message is from. A `fixed` sender is always used; a `default`
+  // one gives way to a sender the tool call gives.
+  readonly sender: { readonly kind: 'fixed' | 'default'; readonly name: string };
+}
+
+/**
+ * The columns of the authorization server's database that atc reads and
+ * writes itself. better-auth owns the tables and their migrations; dates are
+ * ISO 8601 strings and string lists are JSON arrays.
+ */
+export interface MCPAuthSchema {
+  readonly oauthClient: {
+    readonly id: string;
+    readonly clientId: string;
+    readonly name: string | null;
+    readonly redirectUris: string;
+    readonly createdAt: string | null;
+  };
+  readonly oauthAccessToken: {
+    readonly id: string;
+    readonly token: string;
+    readonly clientId: string;
+    readonly sessionId: string | null;
+    readonly authorizationCodeId: string | null;
+  };
+  readonly oauthRefreshToken: {
+    readonly id: string;
+    readonly clientId: string;
+    readonly sessionId: string | null;
+    readonly authorizationCodeId: string | null;
+    readonly scopes: string;
+    readonly createdAt: string;
+    readonly expiresAt: string;
+    readonly revoked: string | null;
+  };
+  readonly oauthConsent: { readonly id: string; readonly clientId: string };
+  readonly oauthResource: { readonly identifier: string };
+  readonly session: { readonly id: string; readonly expiresAt: string };
+
+  // When each grant last reached /mcp, keyed by the grant's authorization code id.
+  readonly atc_grant_use: { readonly grant_id: string; readonly last_used_at: string };
+}
+
+/**
+ * The authorization server's store: the better-auth instance and the
+ * database under it.
+ */
+type MCPAuth = Awaited<ReturnType<typeof openMCPAuth>>;
+
+// What every HTTP route reads: the daemon, the server's own identity, the
+// authorization server, and the approvals waiting for the operator.
+export interface HTTPServerContext {
+  readonly caller: FleetCaller;
+  readonly build: string;
+
+  // The public origin: the OAuth issuer.
+  readonly origin: string;
+
+  // `<origin>/mcp`: the one resource every token is bound to.
+  readonly resource: string;
+  readonly store: MCPAuth;
+  readonly approvals: ApprovalState;
+  readonly printApproval: (line: string) => void;
+}

package/src/mcp/verify-oauth-query.ts

@@ -0,0 +1,42 @@
+import { constantTimeEqual, makeSignature } from 'better-auth/crypto';
+
+/**
+ * Whether a signed authorization query is one better-auth signed with this
+ * secret and has not expired: exactly one `sig`, matching the HMAC of every
+ * other parameter sorted by name and then value, and an `exp` still ahead.
+ */
+export async function verifyOAuthQuery(oauthQuery: string, secret: string): Promise<boolean> {
+  const params = new URLSearchParams(oauthQuery);
+
+  const signatures = params.getAll('sig');
+  const [signature] = signatures;
+  const expiresAt = Number(params.get('exp')) * 1000;
+
+  if (signatures.length !== 1 || signature === undefined || signature === '') {
+    return false;
+  }
+
+  params.delete('sig');
+
+  // Ordered by name, then by value, comparing code units as better-auth does
+  // when it signs; the NUL separator sorts a name before any longer name it
+  // prefixes.
+  const canonical = new URLSearchParams(
+    [...params].toSorted(([keyA, valueA], [keyB, valueB]) => {
+      const a = `${keyA}\u0000${valueA}`;
+      const b = `${keyB}\u0000${valueB}`;
+
+      if (a === b) {
+        return 0;
+      }
+
+      return a < b ? -1 : 1;
+    }),
+  );
+
+  const expected = await makeSignature(canonical.toString(), secret);
+
+  return (
+    constantTimeEqual(signature, expected) && Number.isFinite(expiresAt) && expiresAt >= Date.now()
+  );
+}

package/src/mcp-http-server.ts

@@ -0,0 +1,75 @@
+import { mkdirSync } from 'node:fs';
+import { bootDaemonClient } from './client/boot-daemon';
+import { collectClients } from './mcp/collect-clients';
+import { openMCPAuth } from './mcp/open-mcp-auth';
+import { ReconnectingCaller } from './mcp/reconnecting-caller';
+import { startMCPHTTPServer } from './mcp/start-mcp-http-server';
+import { daemonSocketPath, mcpAuthDBFile, stateDir } from './shared/config';
+import { loadMCPHTTPConfig } from './shared/load-mcp-http-config';
+
+interface MCPHTTPFlags {
+  readonly host: string | null;
+  readonly port: number | null;
+  readonly publicURL: string | null;
+}
+
+/**
+ * Runs `atc mcp --http` in the foreground: boots the daemon when it is down
+ * and serves MCP over HTTP until Ctrl-C. Approval codes print here, so the
+ * terminal running it is where the operator approves a client.
+ */
+export async function runMCPHTTPServer(build: string, flags: MCPHTTPFlags): Promise<void> {
+  const config = loadMCPHTTPConfig();
+
+  const boot = await bootDaemonClient();
+
+  boot.client.stop();
+
+  mkdirSync(stateDir, { recursive: true });
+
+  const caller = new ReconnectingCaller(daemonSocketPath, build);
+
+  const server = await startMCPHTTPServer({
+    caller,
+    build,
+    host: flags.host ?? config.host,
+    port: flags.port ?? config.port,
+    publicURL: flags.publicURL ?? config.publicURL,
+    allowedHosts: config.allowedHosts,
+    dbPath: mcpAuthDBFile,
+
+    // The line carries a client's name, so control and format characters
+    // are dropped before it reaches the operator's terminal.
+    printApproval: (line) => {
+      console.log(line.replaceAll(/[\p{Cc}\p{Cf}]/gu, ''));
+    },
+  });
+
+  console.log(`atc mcp --http: serving ${server.origin}/mcp, listening on ${server.url}`);
+
+  const admin = await openMCPAuth({ dbPath: mcpAuthDBFile, origin: null });
+  const clients = await collectClients(admin.db);
+
+  await admin.close();
+
+  if (clients.length === 0) {
+    console.log(
+      'No clients can connect yet. Add one with: atc clients add <name> --redirect-uri <uri>',
+    );
+  }
+
+  const stopServing = async () => {
+    await server.stop();
+    await caller.stop();
+
+    process.exit(0);
+  };
+
+  process.on('SIGINT', () => {
+    void stopServing();
+  });
+
+  process.on('SIGTERM', () => {
+    void stopServing();
+  });
+}

package/src/mcp-server.ts

@@ -1,225 +1,6 @@
-import { z } from 'zod';
 import { bootDaemonClient } from './client/boot-daemon';
-import { DaemonError } from './protocol/daemon-error';
-import { REQUEST_PARAM_SCHEMAS } from './protocol/request-param-schemas';
-import { isRecord } from './shared/report';
-
-// The slice of the daemon client the tool handlers need.
-interface FleetCaller {
-  readonly sendRequest: (
-    m: string,
-    p?: Readonly<Record<string, unknown>>,
-  ) => Promise<Readonly<Record<string, unknown>>>;
-}
-
-const PROTOCOL_FALLBACK = '2025-06-18';
-
-interface MCPTool {
-  readonly name: string;
-  readonly description: string;
-  readonly inputSchema: Readonly<Record<string, unknown>>;
-}
-
-const NO_INPUT: Readonly<Record<string, unknown>> = z.toJSONSchema(z.strictObject({}));
-
-/**
- * The session id shape MCP tool schemas require: present and described.
- * The wire request schemas below share a defaulted-session shape instead,
- * since they tolerate an absent session by defaulting it to an empty
- * string.
- */
-const SESSION_ID_BASE = z.object({
-  session: z.string().describe('The atc session id, from atc_session_list'),
-});
-
-const SESSION_INPUT: Readonly<Record<string, unknown>> = z.toJSONSchema(SESSION_ID_BASE.strict());
-const SPAWN_SCHEMA = REQUEST_PARAM_SCHEMAS['session.spawn'];
-
-const SPAWN_INPUT: Readonly<Record<string, unknown>> = z.toJSONSchema(
-  z.strictObject({
-    cwd: SPAWN_SCHEMA.shape.cwd.describe('Absolute path of the working directory'),
-    name: SPAWN_SCHEMA.shape.name.describe('Session name; defaults to the directory basename'),
-    prompt: SPAWN_SCHEMA.shape.prompt.describe('First message for the session'),
-    agent: SPAWN_SCHEMA.shape.agent.describe(
-      'Which registered agent id to spawn; defaults to claude',
-    ),
-    detached: z
-      .boolean()
-      .optional()
-      .describe(
-        'Spawn a top-level session. By default a spawn from inside an atc session becomes a sub-session of it: listed under it, pinned with it, killed with it.',
-      ),
-  }),
-  { io: 'input' },
-);
-
-const SESSION_READ_INPUT: Readonly<Record<string, unknown>> = z.toJSONSchema(
-  SESSION_ID_BASE.extend({
-    cursor: z
-      .string()
-      .optional()
-      .describe(
-        'The cursor a previous atc_session_read returned; omit to read from the start of the conversation',
-      ),
-    limit: z
-      .number()
-      .int()
-      .min(1)
-      .max(200)
-      .optional()
-      .describe('Most rows to return; defaults to 50'),
-  }).strict(),
-  { io: 'input' },
-);
-
-const EVENTS_READ_INPUT: Readonly<Record<string, unknown>> = z.toJSONSchema(
-  z.strictObject({
-    cursor: z
-      .string()
-      .optional()
-      .describe(
-        'The cursor a previous atc_events_read returned; omit to get the most recent events',
-      ),
-    limit: z
-      .number()
-      .int()
-      .min(1)
-      .max(200)
-      .optional()
-      .describe('Most events to return; defaults to 50'),
-    waitMs: z
-      .number()
-      .int()
-      .min(0)
-      .max(30_000)
-      .optional()
-      .describe(
-        'How long to wait for a new event when none is pending, in milliseconds; defaults to 0, capped at 30000. Keep it short.',
-      ),
-  }),
-  { io: 'input' },
-);
-
-const TOOLS: readonly MCPTool[] = [
-  {
-    name: 'atc_session_list',
-    description:
-      'List every session the atc daemon hosts: id, name, working directory, state (running, needs_you, done, exited), unread flag, and last activity.',
-    inputSchema: NO_INPUT,
-  },
-  {
-    name: 'atc_session_spawn',
-    description:
-      'Spawn a new session in a directory. Optional agent is an agent id the daemon has registered, such as claude, grok, or codex; omitted agent is always Claude, never the TUI last-used value. An unregistered id is rejected. Called from inside an atc session, the new session is a sub-session of the caller unless detached is true. Returns the new session descriptor. Give it a prompt to start it working immediately.',
-    inputSchema: SPAWN_INPUT,
-  },
-  {
-    name: 'atc_session_input',
-    description:
-      'Type a line of text into a running session, as if the operator typed it and pressed enter. Use it to answer a session that is waiting on input.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        session: { type: 'string', description: 'The atc session id' },
-        text: { type: 'string', description: 'The line to type; a newline is appended' },
-      },
-      required: ['session', 'text'],
-      additionalProperties: false,
-    },
-  },
-  {
-    name: 'atc_session_screen',
-    description:
-      'Read the current terminal screen of a session as plain text, without attaching to it. Use it to see what a session printed or what it is waiting on before answering it with atc_session_input. A killed session keeps its last screen.',
-    inputSchema: SESSION_INPUT,
-  },
-  {
-    name: 'atc_session_update',
-    description:
-      'Rename and/or pin a session. Renames stick against auto-summaries; pinned sessions lead every list. A sub-session pins with its parent, so pin the parent instead. Use this to organise the fleet: name sessions after their task.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        session: { type: 'string', description: 'The atc session id' },
-        name: { type: 'string', description: 'New display name; omit to keep' },
-        pinned: { type: 'boolean', description: 'Pin or unpin; omit to keep' },
-      },
-      required: ['session'],
-      additionalProperties: false,
-    },
-  },
-  {
-    name: 'atc_session_kill',
-    description: 'Kill a session. A second kill on a dead session removes it from the list.',
-    inputSchema: SESSION_INPUT,
-  },
-  {
-    name: 'atc_session_ack',
-    description: 'Clear a session unread flag without attaching to it.',
-    inputSchema: SESSION_INPUT,
-  },
-  {
-    name: 'atc_resume_command',
-    description:
-      'Build the shell command that reopens a session outside atc (cd into its directory and claude --resume its id).',
-    inputSchema: SESSION_INPUT,
-  },
-  {
-    name: 'atc_dirs_list',
-    description: 'List directories sessions were previously spawned from, most recent first.',
-    inputSchema: NO_INPUT,
-  },
-  {
-    name: 'atc_session_get',
-    description:
-      'Read one session in a single call: its descriptor (state, unread flag, last activity message), the prompt it was spawned with, when it last reported activity, the prompt or question it is waiting on while it needs you (read-only; answer it with atc_session_input), and the final message of its latest finished turn.',
-    inputSchema: SESSION_INPUT,
-  },
-  {
-    name: 'atc_session_read',
-    description:
-      "Read a session's conversation a page at a time, oldest first: user and assistant messages with tool uses summarised. Pass the returned cursor to continue where you left off; more is true when the page stopped before the end. Claude sessions only; other agents answer unsupported.",
-    inputSchema: SESSION_READ_INPUT,
-  },
-  {
-    name: 'atc_events_read',
-    description:
-      'Catch up on the fleet: session events (started, prompt-submitted, needs-input, turn-done, ended) since a cursor, oldest first, each with the session id and name. Without a cursor it returns the most recent events. Pass the returned cursor next time. waitMs holds the call open until an event arrives.',
-    inputSchema: EVENTS_READ_INPUT,
-  },
-  {
-    name: 'atc_session_message',
-    description:
-      "Send a session a message and get its id back. Follow up by polling atc_message_get with the id until its status is answered, which returns the session's final reply; don't read the session's screen or transcript to check on it. The message waits in the session inbox until the session takes it, and its status moves accepted, delivered, answered. A message is refused as unsupported when the session's agent has no message tap (Grok, Codex), or when a Claude session reported SessionStart more than 15 seconds ago and no tap has attached since. It is refused as session_dead when the session has no live process and as no_such_session for an unknown id. Otherwise it queues, including while a session restores or after its tap dropped. The message is never typed into the terminal.",
-    inputSchema: {
-      type: 'object',
-      properties: {
-        session: { type: 'string', description: 'The atc session id, from atc_session_list' },
-        text: { type: 'string', description: 'The message text' },
-        from: {
-          type: 'string',
-          description:
-            'Who the message is from; defaults to the calling session id, or mcp outside a session',
-        },
-      },
-      required: ['session', 'text'],
-      additionalProperties: false,
-    },
-  },
-  {
-    name: 'atc_message_get',
-    description:
-      'Read one message sent with atc_session_message: its id, session, from, text, status (accepted, delivered, or answered), the answer once answered, and the sentAt, deliveredAt, and answeredAt timestamps. Poll it until the status is answered.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        message: { type: 'string', description: 'The message id atc_session_message returned' },
-      },
-      required: ['message'],
-      additionalProperties: false,
-    },
-  },
-];
+import { answerRPCRequest } from './mcp/answer-rpc-request';
+import type { FleetCaller, ToolContext } from './mcp/types';
 
 /**
  * An MCP server over stdio bridging to the atc daemon: any MCP client —
@@ -231,6 +12,16 @@ export async function runMCPServer(build: string): Promise<void> {
 
   const client = boot.client;
 
+  // The server inherits the calling session's id from its environment, so a
+  // spawn from inside a session nests under it by default.
+  const inherited = process.env['ATC_SESSION_ID'];
+  const callerSessionID = inherited === undefined || inherited === '' ? null : inherited;
+
+  const toolContext: ToolContext = {
+    callerSessionID,
+    sender: { kind: 'default', name: callerSessionID ?? 'mcp' },
+  };
+
   const decoder = new TextDecoder('utf-8');
 
   let buffer = '';
@@ -257,7 +48,7 @@ export async function runMCPServer(build: string): Promise<void> {
 
       void (async () => {
         try {
-          await applyRPCLine(client, build, line);
+          await answerRPCLine(client, build, toolContext, line);
         } catch {
           // A failed line gets no response, the way a malformed one gets none.
         } finally {
@@ -273,7 +64,12 @@ export async function runMCPServer(build: string): Promise<void> {
   client.stop();
 }
 
-async function applyRPCLine(client: FleetCaller, build: string, line: string): Promise<void> {
+async function answerRPCLine(
+  caller: FleetCaller,
+  build: string,
+  toolContext: ToolContext,
+  line: string,
+): Promise<void> {
   let parsed: unknown;
 
   try {
@@ -282,233 +78,9 @@ async function applyRPCLine(client: FleetCaller, build: string, line: string): P
     return;
   }
 
-  if (!isRecord(parsed) || typeof parsed['method'] !== 'string') {
-    return;
-  }
-
-  const method = parsed['method'];
-  const id = parsed['id'];
-  const params = isRecord(parsed['params']) ? parsed['params'] : {};
-
-  // Notifications carry no id and get no response.
-  if (id === undefined || id === null) {
-    return;
-  }
-
-  if (typeof id !== 'string' && typeof id !== 'number') {
-    return;
-  }
-
-  switch (method) {
-    case 'initialize': {
-      const requested = params['protocolVersion'];
-
-      sendResult(id, {
-        protocolVersion: typeof requested === 'string' ? requested : PROTOCOL_FALLBACK,
-        capabilities: { tools: {} },
-        serverInfo: { name: 'atc', version: build },
-      });
-
-      return;
-    }
-    case 'ping': {
-      sendResult(id, {});
-
-      return;
-    }
-    case 'tools/list': {
-      sendResult(id, { tools: TOOLS });
-
-      return;
-    }
-    case 'tools/call': {
-      await applyToolCall(client, id, params);
-
-      return;
-    }
-    default: {
-      sendError(id, -32_601, `unknown method '${method}'`);
-    }
-  }
-}
-
-async function applyToolCall(
-  client: FleetCaller,
-  id: string | number,
-  params: Readonly<Record<string, unknown>>,
-): Promise<void> {
-  const name = typeof params['name'] === 'string' ? params['name'] : '';
-  const args = isRecord(params['arguments']) ? params['arguments'] : {};
-
-  try {
-    const text = await runTool(client, name, args);
-
-    sendResult(id, { content: [{ type: 'text', text }] });
-  } catch (error) {
-    let msg = String(error);
-
-    if (error instanceof DaemonError) {
-      msg = `${error.code}: ${error.message}`;
-    } else if (error instanceof Error) {
-      msg = error.message;
-    }
-
-    sendResult(id, { content: [{ type: 'text', text: msg }], isError: true });
-  }
-}
-
-async function runTool(
-  client: FleetCaller,
-  name: string,
-  args: Readonly<Record<string, unknown>>,
-): Promise<string> {
-  switch (name) {
-    case 'atc_session_list': {
-      const ok = await client.sendRequest('session.list');
-
-      return JSON.stringify(ok['sessions'], null, 2);
-    }
-    case 'atc_session_spawn': {
-      const rawAgent = args['agent'];
-
-      // The server inherits the calling session's id from its environment,
-      // so a spawn from inside a session nests under it by default.
-      const caller = process.env['ATC_SESSION_ID'];
-      const nested = args['detached'] !== true && caller !== undefined && caller !== '';
-
-      const params = {
-        cwd: args['cwd'],
-        ...(typeof args['name'] === 'string' ? { name: args['name'] } : {}),
-        ...(typeof args['prompt'] === 'string' ? { prompt: args['prompt'] } : {}),
-        ...(rawAgent === undefined ? {} : { agent: rawAgent }),
-        cols: 100,
-        rows: 30,
-      };
-
-      const ok = nested
-        ? await sendNestedSpawn(client, params, caller)
-        : await client.sendRequest('session.spawn', params);
-
-      return JSON.stringify(ok['session'], null, 2);
-    }
-    case 'atc_session_input': {
-      await client.sendRequest('session.input', {
-        session: args['session'],
-        d: `${typeof args['text'] === 'string' ? args['text'] : ''}\n`,
-      });
-
-      return 'sent';
-    }
-    case 'atc_session_screen': {
-      const ok = await client.sendRequest('session.screen', { session: args['session'] });
-
-      return typeof ok['text'] === 'string' ? ok['text'] : JSON.stringify(ok);
-    }
-    case 'atc_session_update': {
-      await client.sendRequest('session.update', {
-        session: args['session'],
-        ...(typeof args['name'] === 'string' ? { name: args['name'] } : {}),
-        ...(typeof args['pinned'] === 'boolean' ? { pinned: args['pinned'] } : {}),
-      });
-
-      return 'updated';
-    }
-    case 'atc_session_kill': {
-      await client.sendRequest('session.kill', { session: args['session'] });
-
-      return 'killed';
-    }
-    case 'atc_session_ack': {
-      await client.sendRequest('session.ack', { session: args['session'] });
-
-      return 'acked';
-    }
-    case 'atc_resume_command': {
-      const ok = await client.sendRequest('session.resumeCommand', { session: args['session'] });
-
-      return typeof ok['command'] === 'string' ? ok['command'] : JSON.stringify(ok);
-    }
-    case 'atc_dirs_list': {
-      const ok = await client.sendRequest('dirs.list');
-
-      return JSON.stringify(ok['dirs'], null, 2);
-    }
-    case 'atc_session_get': {
-      const ok = await client.sendRequest('session.get', { session: args['session'] });
-
-      return JSON.stringify(ok, null, 2);
-    }
-    case 'atc_session_read': {
-      const ok = await client.sendRequest('session.read', {
-        session: args['session'],
-        ...(typeof args['cursor'] === 'string' ? { cursor: args['cursor'] } : {}),
-        ...(typeof args['limit'] === 'number' ? { limit: args['limit'] } : {}),
-      });
-
-      return JSON.stringify(ok, null, 2);
-    }
-    case 'atc_events_read': {
-      const ok = await client.sendRequest('events.read', {
-        ...(typeof args['cursor'] === 'string' ? { cursor: args['cursor'] } : {}),
-        ...(typeof args['limit'] === 'number' ? { limit: args['limit'] } : {}),
-        ...(typeof args['waitMs'] === 'number' ? { waitMs: args['waitMs'] } : {}),
-      });
-
-      return JSON.stringify(ok, null, 2);
-    }
-    case 'atc_session_message': {
-      const caller = process.env['ATC_SESSION_ID'];
-      const given = args['from'];
-      let from = 'mcp';
-
-      if (typeof given === 'string' && given !== '') {
-        from = given;
-      } else if (caller !== undefined && caller !== '') {
-        from = caller;
-      }
-
-      const ok = await client.sendRequest('session.message', {
-        session: args['session'],
-        text: args['text'],
-        from,
-      });
-
-      return JSON.stringify(ok, null, 2);
-    }
-    case 'atc_message_get': {
-      const ok = await client.sendRequest('message.get', { message: args['message'] });
-
-      return JSON.stringify(ok, null, 2);
-    }
-    default: {
-      throw new Error(`unknown tool '${name}'`);
-    }
-  }
-}
-
-function sendResult(id: string | number, result: Readonly<Record<string, unknown>>): void {
-  process.stdout.write(`${JSON.stringify({ jsonrpc: '2.0', id, result })}\n`);
-}
-
-function sendError(id: string | number, code: number, message: string): void {
-  process.stdout.write(`${JSON.stringify({ jsonrpc: '2.0', id, error: { code, message } })}\n`);
-}
-
-// The inherited id can point at a session another daemon hosts, or one
-// this daemon no longer lists; the spawn then lands top-level instead of
-// failing the tool call.
-async function sendNestedSpawn(
-  client: FleetCaller,
-  params: Readonly<Record<string, unknown>>,
-  parent: string,
-): Promise<Readonly<Record<string, unknown>>> {
-  try {
-    return await client.sendRequest('session.spawn', { ...params, parent });
-  } catch (error) {
-    if (error instanceof DaemonError && error.code === 'no_such_session') {
-      return client.sendRequest('session.spawn', params);
-    }
+  const outcome = await answerRPCRequest(parsed, { caller, build, toolContext });
 
-    throw error;
+  if (outcome.kind === 'reply') {
+    process.stdout.write(`${JSON.stringify(outcome.body)}\n`);
   }
 }