@canonmsg/codex-plugin 0.29.4 → 0.30.1

package/scripts/smoke-attach.mjs

@@ -0,0 +1,222 @@
+#!/usr/bin/env node
+
+// Real local Codex protocol, fake localhost model and Canon publisher. No model
+// API or Canon account calls. Build Core, SDK and this package before running.
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { createServer as httpServer } from 'node:http';
+import { createServer as netServer } from 'node:net';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import WebSocket from 'ws';
+import { createAttachedNativeSession, createFileAttachedSessionStore } from '@canonmsg/core';
+import { createCanonAttachedSessionPublisher } from '@canonmsg/agent-sdk';
+import { CodexAttachedSessionAdapter } from '../dist/attached-session-adapter.js';
+
+const binary = process.argv[2] ?? 'codex';
+const directory = await mkdtemp(join(tmpdir(), 'canon-attach-smoke-'));
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function until(predicate, description) {
+  for (let attempt = 0; attempt < 300; attempt += 1) {
+    if (await predicate()) return;
+    await sleep(50);
+  }
+  throw new Error(`Timed out: ${description}`);
+}
+async function listen(server) {
+  await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+  return server.address().port;
+}
+
+let providerCalls = 0;
+let requestApprovalOnNextModelCall = false;
+const provider = httpServer((request, response) => {
+  request.resume();
+  providerCalls += 1;
+  const item = requestApprovalOnNextModelCall ? {
+    id: 'approval_function', type: 'function_call', call_id: 'approval_call', name: 'exec_command',
+    arguments: JSON.stringify({
+      cmd: 'printf canon-approval-smoke', sandbox_permissions: 'require_escalated',
+      justification: 'Disposable approval routing check; the native client will decline.',
+    }),
+  } : {
+    id: `message_${providerCalls}`, type: 'message', role: 'assistant', status: 'completed',
+    content: [{ type: 'output_text', text: `Mock answer ${providerCalls}.`, annotations: [] }],
+  };
+  requestApprovalOnNextModelCall = false;
+  const result = {
+    id: `response_${providerCalls}`, object: 'response', model: 'probe', status: 'completed',
+    output: [item], usage: { input_tokens: 1, output_tokens: 1, total_tokens: 2 },
+  };
+  response.writeHead(200, { 'content-type': 'text/event-stream' });
+  for (const event of [
+    { type: 'response.created', response: { ...result, status: 'in_progress', output: [] } },
+    { type: 'response.output_item.added', output_index: 0, item: item.type === 'message' ? { ...item, status: 'in_progress', content: [] } : item },
+    ...(item.type === 'message' ? [{ type: 'response.output_text.delta', output_index: 0, content_index: 0, item_id: item.id, delta: item.content[0].text }] : []),
+    { type: 'response.output_item.done', output_index: 0, item },
+    { type: 'response.completed', response: result },
+  ]) response.write(`data: ${JSON.stringify(event)}\n\n`);
+  response.end();
+});
+const modelPort = await listen(provider);
+const reservation = netServer();
+const port = await listen(reservation);
+await new Promise((resolve) => reservation.close(resolve));
+const endpoint = `ws://127.0.0.1:${port}`;
+const { CODEX_INTERNAL_ORIGINATOR_OVERRIDE: _originatorOverride, ...serverEnv } = process.env;
+const server = spawn(binary, ['app-server', '--disable', 'plugins', '--disable', 'apps', '--listen', endpoint], {
+  cwd: directory, env: serverEnv, stdio: ['ignore', 'pipe', 'pipe'],
+});
+let serverError = '';
+server.stderr.on('data', (data) => { serverError = `${serverError}${data}`.slice(-1_000); });
+server.stdout.resume();
+let socket;
+let native;
+let controller;
+let threadId;
+const events = [];
+const nativeRequests = [];
+const observerRequests = [];
+const observerResponses = [];
+const published = new Map();
+const errors = [];
+
+try {
+  await until(async () => {
+    if (server.exitCode !== null) throw new Error(`Codex exited: ${serverError}`);
+    return fetch(`http://127.0.0.1:${port}/readyz`).then((result) => result.ok).catch(() => false);
+  }, 'shared app-server readiness');
+  socket = new WebSocket(endpoint);
+  await new Promise((resolve, reject) => { socket.once('open', resolve); socket.once('error', reject); });
+  let sequence = 0;
+  const pending = new Map();
+  socket.on('message', (data) => {
+    const message = JSON.parse(data.toString());
+    if (message.method) {
+      if ('id' in message) nativeRequests.push(message);
+      else events.push(message);
+      return;
+    }
+    const waiter = pending.get(message.id);
+    if (!waiter) { events.push(message); return; }
+    pending.delete(message.id);
+    clearTimeout(waiter.timer);
+    if (message.error) waiter.reject(new Error(JSON.stringify(message.error)));
+    else waiter.resolve(message.result);
+  });
+  native = (method, params = {}) => new Promise((resolve, reject) => {
+    const id = ++sequence;
+    const timer = setTimeout(() => { pending.delete(id); reject(new Error(`Timeout: ${method}`)); }, 10_000);
+    pending.set(id, { resolve, reject, timer });
+    socket.send(JSON.stringify({ id, method, params }));
+  });
+  await native('initialize', { clientInfo: { name: 'canon_attachment_smoke', version: '0.0.0' }, capabilities: { experimentalApi: true } });
+  socket.send(JSON.stringify({ method: 'initialized' }));
+  const started = await native('thread/start', {
+    cwd: directory, ephemeral: false, model: 'probe', modelProvider: 'canon_smoke',
+    approvalPolicy: 'on-request', sandbox: 'read-only',
+    config: {
+      mcp_servers: {}, 'features.apps': false, 'features.plugins': false,
+      'model_providers.canon_smoke': {
+        name: 'Canon local mock provider', base_url: `http://127.0.0.1:${modelPort}/v1`,
+        wire_api: 'responses', requires_openai_auth: false,
+      },
+    },
+  });
+  threadId = started.thread.id;
+  async function nativeTurn(text) {
+    const result = await native('turn/start', { threadId, input: [{ type: 'text', text }] });
+    await until(() => events.some((event) => event.method === 'turn/completed' && event.params.turn.id === result.turn.id), 'native turn completion');
+    return result.turn.id;
+  }
+  await nativeTurn('Private text from before attachment.');
+  const binding = { environmentId: 'smoke', agentId: 'smoke-agent', conversationId: 'smoke-room', provider: 'codex', nativeSessionId: threadId };
+  const publisher = createCanonAttachedSessionPublisher({
+    async sendProactiveMessage(conversationId, text, options) {
+      assert.equal(conversationId, binding.conversationId);
+      const payload = JSON.stringify({ text, options });
+      if (published.has(options.messageId)) assert.equal(published.get(options.messageId), payload);
+      published.set(options.messageId, payload);
+      return { messageId: options.messageId, conversationId };
+    },
+  }, binding);
+  const attach = async () => {
+    const value = createAttachedNativeSession({
+      binding, adapter: new CodexAttachedSessionAdapter({ endpoint, threadId, createSocket(url) {
+        const observer = new WebSocket(url);
+        observer.on('message', (data) => {
+          const message = JSON.parse(data.toString());
+          if (message.method && 'id' in message) observerRequests.push(message);
+        });
+        const send = observer.send.bind(observer);
+        observer.send = (data, ...args) => {
+          const message = JSON.parse(data.toString());
+          if ('id' in message && !message.method) observerResponses.push(message);
+          return send(data, ...args);
+        };
+        return observer;
+      } }),
+      store: createFileAttachedSessionStore(join(directory, 'attachment.json')), publisher,
+      onError: (error, operation) => errors.push(`${operation}: ${error.message}`),
+    });
+    await value.start();
+    return value;
+  };
+  controller = await attach();
+  assert.equal(published.size, 0, 'Private history must not be imported');
+  await nativeTurn('New input on the native surface.');
+  await controller.reconcile();
+  assert.equal(published.size, 2, 'Local user and assistant messages should both publish');
+  const accepted = await controller.submit({ messageId: 'canon-input-1', text: 'Input from the Canon surface.' });
+  assert.equal(accepted.status, 'accepted');
+  await until(() => events.some((event) => event.method === 'turn/completed' && event.params.turn.id === accepted.turnId), 'Canon-triggered native completion');
+  await controller.reconcile();
+  assert.equal(published.size, 3, 'The Canon input echo must be suppressed');
+  const sameInput = await controller.submit({ messageId: 'canon-input-1', text: 'Input from the Canon surface.' });
+  assert.equal(sameInput.replayed, true, 'Duplicate Canon delivery must not execute twice');
+  assert.equal(providerCalls, 3);
+  const observed = await native('thread/read', { threadId, includeTurns: true });
+  assert.ok(JSON.stringify(observed.thread.turns).includes('Input from the Canon surface.'), 'Native client must see Canon input in its own transcript');
+  await controller.stop();
+  await nativeTurn('Private work after a graceful detach.');
+  controller = await attach();
+  assert.equal(published.size, 3, 'Graceful detachment must exclude later private work');
+  await nativeTurn('New shared input after reattaching.');
+  await controller.reconcile();
+  assert.equal(published.size, 5);
+  requestApprovalOnNextModelCall = true;
+  const approvalTurn = await controller.submit({ messageId: 'canon-approval-input', text: 'Exercise native approval routing with the disposable mock command.' });
+  assert.equal(approvalTurn.status, 'accepted');
+  const approvalForTurn = (request) => request.method === 'item/commandExecution/requestApproval' && request.params.turnId === approvalTurn.turnId;
+  await until(() => nativeRequests.some(approvalForTurn) && observerRequests.some(approvalForTurn), 'approval delivered to both native and attached clients');
+  const nativeApproval = nativeRequests.find(approvalForTurn);
+  assert.equal(nativeApproval.id, observerRequests.find(approvalForTurn).id, 'Both clients should see the same pending approval');
+  assert.equal(observerResponses.length, 0, 'The Canon observer must not answer native approval requests');
+  assert.ok(!events.some((event) => event.method === 'turn/completed' && event.params.turn.id === approvalTurn.turnId), 'The turn must wait for the native approval decision');
+  // Decline from the native surface. The mock command is never executed.
+  socket.send(JSON.stringify({ id: nativeApproval.id, result: { decision: 'decline' } }));
+  await until(() => events.some((event) => event.method === 'turn/completed' && event.params.turn.id === approvalTurn.turnId), 'completion after native approval decline');
+  assert.ok(events.some((event) => event.method === 'serverRequest/resolved' && event.params.requestId === nativeApproval.id), 'Native decision should resolve the shared approval');
+  assert.ok(events.some((event) => event.method === 'item/completed' && event.params.item.id === nativeApproval.params.itemId && event.params.item.status === 'declined'), 'The requested command must be declined without execution');
+  await controller.reconcile();
+  assert.equal(published.size, 6, 'Only the final assistant text should mirror from the Canon approval turn');
+  assert.equal(observerResponses.length, 0);
+  assert.equal(errors.length, 0, errors.join('\n'));
+  await controller.stop();
+  const alive = await native('thread/read', { threadId });
+  assert.equal(alive.thread.id, threadId, 'Detachment must leave the shared runner available');
+  console.log(JSON.stringify({ passed: true, nativeAndCanonInput: true, privateHistoryExcluded: true, echoSuppressed: true, replayDeduplicated: true, nativeApprovalRouting: true, detachKeepsNativeAlive: true, publishedMessages: published.size, localMockModelCalls: providerCalls }));
+} finally {
+  await controller?.stop().catch(() => {});
+  if (threadId && socket?.readyState === WebSocket.OPEN) {
+    await native('thread/delete', { threadId }).catch((error) => console.error(`Could not delete disposable thread ${threadId}: ${error.message}`));
+  }
+  socket?.terminate();
+  server.kill('SIGTERM');
+  await sleep(500);
+  if (server.exitCode === null) server.kill('SIGKILL');
+  provider.closeAllConnections();
+  await new Promise((resolve) => provider.close(resolve));
+  await rm(directory, { recursive: true, force: true });
+}

package/scripts/smoke-work-sessions.mjs

@@ -0,0 +1,218 @@
+#!/usr/bin/env node
+// Real shared Codex protocol with a localhost fake model and Canon publisher.
+// No real model/Canon calls; no HOME/CODEX_HOME or existing-session changes.
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { createServer as httpServer } from 'node:http';
+import { createServer as netServer } from 'node:net';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import WebSocket from 'ws';
+import { createAttachedNativeSession, createFileAttachedSessionStore } from '@canonmsg/core';
+import { createCanonAttachedSessionPublisher } from '@canonmsg/agent-sdk';
+import { CodexWorkSessionProvider } from '../dist/work-session-provider.js';
+
+const directory = await mkdtemp(join(tmpdir(), 'canon-work-session-smoke-'));
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function until(predicate, label) {
+  for (let attempt = 0; attempt < 300; attempt += 1) {
+    if (await predicate()) return;
+    await sleep(50);
+  }
+  throw new Error(`Timed out: ${label}`);
+}
+async function listen(server) {
+  await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+  return server.address().port;
+}
+
+let modelCalls = 0;
+let catalogCalls = 0;
+let askApproval = false;
+const model = httpServer((request, response) => {
+  request.resume();
+  if (request.method === 'GET' && request.url?.startsWith('/v1/models')) {
+    catalogCalls += 1;
+    // Exercise the native server's built-in model catalog fallback.
+    response.writeHead(404, { 'content-type': 'application/json' });
+    response.end(JSON.stringify({ error: 'This disposable provider does not implement model discovery.' }));
+    return;
+  }
+  assert.equal(request.method, 'POST');
+  assert.equal(request.url, '/v1/responses');
+  modelCalls += 1;
+  const item = askApproval ? {
+    id: `function_${modelCalls}`, type: 'function_call', call_id: `approval_${modelCalls}`, name: 'exec_command',
+    arguments: JSON.stringify({ cmd: 'printf canon-work-session-smoke', sandbox_permissions: 'require_escalated', justification: 'Disposable test; the command will be declined.' }),
+  } : { id: `message_${modelCalls}`, type: 'message', role: 'assistant', status: 'completed', content: [{ type: 'output_text', text: `Mock answer ${modelCalls}.`, annotations: [] }] };
+  askApproval = false;
+  const result = { id: `response_${modelCalls}`, object: 'response', model: 'probe', status: 'completed', output: [item], usage: { input_tokens: 1, output_tokens: 1, total_tokens: 2 } };
+  response.writeHead(200, { 'content-type': 'text/event-stream' });
+  for (const event of [
+    { type: 'response.created', response: { ...result, status: 'in_progress', output: [] } },
+    { type: 'response.output_item.added', output_index: 0, item },
+    { type: 'response.output_item.done', output_index: 0, item },
+    { type: 'response.completed', response: result },
+  ]) response.write(`data: ${JSON.stringify(event)}\n\n`);
+  response.end();
+});
+const modelPort = await listen(model);
+const reservation = netServer();
+const port = await listen(reservation);
+await new Promise((resolve) => reservation.close(resolve));
+const endpoint = `ws://127.0.0.1:${port}`;
+const { CODEX_INTERNAL_ORIGINATOR_OVERRIDE: _originatorOverride, ...serverEnv } = process.env;
+const server = spawn(process.argv[2] ?? 'codex', [
+  'app-server', '--disable', 'plugins', '--disable', 'apps', '--listen', endpoint,
+  '-c', 'model_provider="canon_smoke"',
+  '-c', `model_providers.canon_smoke={name="Canon local mock provider",base_url="http://127.0.0.1:${modelPort}/v1",wire_api="responses",requires_openai_auth=false}`,
+], { cwd: directory, env: serverEnv, stdio: ['ignore', 'pipe', 'pipe'] });
+server.stdout.resume();
+let serverError = '';
+server.stderr.on('data', (data) => { serverError = `${serverError}${data}`.slice(-1_000); });
+
+let provider;
+let controller;
+let native;
+let threadId;
+const bridgeRequests = [];
+const nativeResponses = [];
+const published = new Map();
+const errors = [];
+const bridge = { request(request, { signal }) {
+  return new Promise((resolve) => { bridgeRequests.push({ request, signal, resolve }); });
+} };
+function makeProvider() {
+  return new CodexWorkSessionProvider({ endpoint, cwd: directory, defaultExecutionMode: 'locked',
+    createSocket(url) {
+      const socket = new WebSocket(url);
+      const send = socket.send.bind(socket);
+      socket.send = (data, ...args) => {
+        const message = JSON.parse(data.toString());
+        if ('id' in message && !message.method) nativeResponses.push(message);
+        return send(data, ...args);
+      };
+      return socket;
+    },
+    onError: (error) => errors.push(error.message),
+  });
+}
+async function connectNative() {
+  const socket = new WebSocket(endpoint);
+  await new Promise((resolve, reject) => { socket.once('open', resolve); socket.once('error', reject); });
+  let sequence = 0;
+  const pending = new Map();
+  const events = [];
+  const requests = [];
+  socket.on('message', (data) => {
+    const message = JSON.parse(data.toString());
+    if (message.method) { ('id' in message ? requests : events).push(message); return; }
+    const waiter = pending.get(message.id);
+    if (!waiter) return;
+    pending.delete(message.id);
+    clearTimeout(waiter.timer);
+    message.error ? waiter.reject(new Error(JSON.stringify(message.error))) : waiter.resolve(message.result);
+  });
+  const rpc = (method, params = {}) => new Promise((resolve, reject) => {
+    const id = ++sequence;
+    const timer = setTimeout(() => { pending.delete(id); reject(new Error(`Timeout: ${method}`)); }, 10_000);
+    pending.set(id, { resolve, reject, timer });
+    socket.send(JSON.stringify({ id, method, params }));
+  });
+  await rpc('initialize', { clientInfo: { name: 'canon_work_session_smoke', version: '0.0.0' }, capabilities: { experimentalApi: true } });
+  socket.send(JSON.stringify({ method: 'initialized' }));
+  return { socket, rpc, events, requests };
+}
+
+try {
+  await until(async () => {
+    if (server.exitCode !== null) throw new Error(serverError);
+    return fetch(`http://127.0.0.1:${port}/readyz`).then((result) => result.ok).catch(() => false);
+  }, 'native server readiness');
+  provider = makeProvider();
+  const catalog = await provider.catalog();
+  assert.ok(catalog.models.length > 0);
+  assert.ok(!JSON.stringify(catalog).includes(directory), 'Private catalog must not expose raw cwd');
+  const created = await provider.create({ mode: 'create', projectId: catalog.projects[0].id,
+    modelId: catalog.defaults.modelId, executionMode: 'locked', permissionMode: 'workspace' },
+  { requestId: 'create-smoke', conversationId: 'room', agentId: 'agent' });
+  threadId = created.nativeSessionId;
+  const binding = { environmentId: 'smoke', agentId: 'agent', conversationId: 'room', provider: 'codex', nativeSessionId: threadId };
+  const publisher = createCanonAttachedSessionPublisher({ async sendProactiveMessage(conversationId, text, options) {
+    const payload = JSON.stringify({ text, options });
+    if (published.has(options.messageId)) assert.equal(published.get(options.messageId), payload);
+    published.set(options.messageId, payload);
+    return { messageId: options.messageId, conversationId };
+  } }, binding);
+  async function attach() {
+    const value = createAttachedNativeSession({ binding, adapter: await provider.open(threadId, bridge),
+      store: createFileAttachedSessionStore(join(directory, 'journal.json')), publisher,
+      onError: (error, operation) => errors.push(`${operation}: ${error.message}`),
+    });
+    await value.start();
+    return value;
+  }
+  controller = await attach();
+  assert.equal(modelCalls, 0, 'Creating/attaching an empty session must not inject a warmup turn');
+  assert.equal(published.size, 0);
+  askApproval = true;
+  const first = await controller.submit({ messageId: 'canon-first', text: 'First real input from Canon.' });
+  assert.equal(first.status, 'accepted');
+  await until(() => bridgeRequests.length === 1, 'Canon receives approval without any native client');
+  assert.equal(bridgeRequests[0].request.kind, 'approval');
+  bridgeRequests[0].resolve({ kind: 'approval', decision: 'deny' });
+  await until(async () => { await controller.reconcile(); return controller.getState().activeTurnId === null && published.size === 1; }, 'first Canon turn completion');
+  assert.equal(nativeResponses.length, 1);
+  assert.deepEqual(nativeResponses[0].result, { decision: 'decline' });
+
+  native = await connectNative();
+  const resumed = await native.rpc('thread/resume', { threadId, excludeTurns: true });
+  assert.equal(resumed.thread.id, threadId, 'Native client resumes the exact created session');
+  const local = await native.rpc('turn/start', { threadId, input: [{ type: 'text', text: 'Input from the native surface.' }] });
+  await until(() => native.events.some((event) => event.method === 'turn/completed' && event.params.turn.id === local.turn.id), 'native turn');
+  await controller.reconcile();
+  assert.equal(published.size, 3, 'Native user and assistant text should mirror once');
+
+  askApproval = true;
+  const second = await controller.submit({ messageId: 'canon-second', text: 'Native client will answer this approval.' });
+  await until(() => bridgeRequests.length === 2 && native.requests.some((request) => request.params.turnId === second.turnId), 'shared approval delivery');
+  const approval = native.requests.find((request) => request.params.turnId === second.turnId);
+  native.socket.send(JSON.stringify({ id: approval.id, result: { decision: 'decline' } }));
+  await until(() => bridgeRequests[1].signal.aborted, 'native answer cancels Canon interaction');
+  bridgeRequests[1].resolve({ kind: 'approval', decision: 'allow' });
+  await until(async () => { await controller.reconcile(); return controller.getState().activeTurnId === null && published.size === 4; }, 'native approval resolution');
+  assert.equal(nativeResponses.length, 1, 'A late Canon answer must not override the native decision');
+
+  askApproval = true;
+  await controller.submit({ messageId: 'canon-third', text: 'Recover this pending approval after the Canon host restarts.' });
+  await until(() => bridgeRequests.length === 3, 'approval before host restart');
+  await controller.stop();
+  await provider.close();
+  assert.equal(bridgeRequests[2].signal.aborted, true);
+  provider = makeProvider();
+  controller = await attach();
+  await until(() => bridgeRequests.length === 4, 'pending native approval replay after reconnect');
+  assert.equal(bridgeRequests[3].request.nativeRequestId, bridgeRequests[2].request.nativeRequestId);
+  bridgeRequests[3].resolve({ kind: 'approval', decision: 'deny' });
+  await until(async () => { await controller.reconcile(); return controller.getState().activeTurnId === null && published.size === 5; }, 'recovered approval turn');
+  assert.equal(errors.length, 0, errors.join('\n'));
+  await controller.stop();
+  await provider.close();
+  assert.equal((await native.rpc('thread/read', { threadId, includeTurns: false })).thread.id, threadId);
+  console.log(JSON.stringify({ passed: true, emptySessionWithoutWarmup: true, canonApprovalWithoutNativeUi: true, nativeAndCanonInput: true, nativeAnswerCancelsCanon: true, pendingApprovalRecovery: true, publishedMessages: published.size, localMockModelCalls: modelCalls, localCatalogCalls: catalogCalls }));
+} finally {
+  await controller?.stop().catch(() => {});
+  await provider?.close().catch(() => {});
+  if (threadId && server.exitCode === null) {
+    native ??= await connectNative().catch(() => null);
+    if (native) await native.rpc('thread/delete', { threadId }).catch((error) => console.error(`Could not delete disposable native thread: ${error.message}`));
+  }
+  native?.socket.terminate();
+  server.kill('SIGTERM');
+  await sleep(400);
+  if (server.exitCode === null) server.kill('SIGKILL');
+  model.closeAllConnections();
+  await new Promise((resolve) => model.close(resolve));
+  await rm(directory, { recursive: true, force: true });
+}