annotatable-html 0.0.0-stage → 1.45.3

package/lib/codex-desktop.js

@@ -0,0 +1,130 @@
+'use strict';
+
+// The Windows desktop app owns a separate stdio app-server. Use its inherited
+// app-tools pipe instead of resuming the same thread in an unrelated daemon.
+var net = require('net');
+var os = require('os');
+var crypto = require('crypto');
+var MAX_FRAME = 8 * 1024 * 1024;
+
+class DesktopRpc {
+  constructor(pipePath) {
+    this.pipePath = pipePath;
+    this.pending = new Map();
+    this.nextId = 0;
+    this.buffer = Buffer.alloc(0);
+  }
+  async open() {
+    await new Promise((resolve, reject) => {
+      var timer = setTimeout(() => { this.close(); reject(new Error('Codex 桌面连接超时')); }, 10000);
+      this.socket = net.createConnection(this.pipePath);
+      this.socket.once('connect', () => { clearTimeout(timer); resolve(); });
+      this.socket.on('data', chunk => this.receive(chunk));
+      this.socket.on('error', error => { clearTimeout(timer); this.abort(error); reject(error); });
+      this.socket.on('close', () => {
+        clearTimeout(timer);
+        var error = new Error('Codex 桌面连接已关闭；请在当前桌面会话重挂监听');
+        this.abort(error); reject(error);
+      });
+    });
+  }
+  abort(error) {
+    if (!this.failure) this.failure = error;
+    for (const pending of this.pending.values()) { clearTimeout(pending.timer); pending.reject(error); }
+    this.pending.clear();
+    if (this.socket) this.socket.destroy();
+  }
+  receive(chunk) {
+    this.buffer = Buffer.concat([this.buffer, chunk]);
+    while (this.buffer.length >= 4) {
+      var size = os.endianness() === 'LE' ? this.buffer.readUInt32LE(0) : this.buffer.readUInt32BE(0);
+      if (size > MAX_FRAME) { this.abort(new Error('Codex 桌面响应超过大小限制')); return; }
+      if (this.buffer.length < size + 4) return;
+      var message;
+      try { message = JSON.parse(this.buffer.subarray(4, size + 4).toString('utf8')); }
+      catch (_) { this.abort(new Error('Codex 桌面返回无效 JSON')); return; }
+      this.buffer = this.buffer.subarray(size + 4);
+      var pending = this.pending.get(message.id);
+      if (!pending) continue;
+      this.pending.delete(message.id); clearTimeout(pending.timer);
+      if (message.error) pending.reject(new Error('Codex 桌面接口失败：' + message.error.message));
+      else pending.resolve(message.result);
+    }
+  }
+  request(method, params) {
+    if (this.failure) return Promise.reject(this.failure);
+    return new Promise((resolve, reject) => {
+      var id = ++this.nextId;
+      var body = Buffer.from(JSON.stringify({ id: id, jsonrpc: '2.0', method: method, params: params }));
+      if (body.length > MAX_FRAME) { reject(new Error('Codex 桌面请求超过大小限制')); return; }
+      var header = Buffer.alloc(4);
+      if (os.endianness() === 'LE') header.writeUInt32LE(body.length); else header.writeUInt32BE(body.length);
+      var timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error('Codex 桌面 ' + method + ' 超时；结果不确定，请先核对会话，不要重复发送'));
+      }, 15000);
+      this.pending.set(id, { resolve: resolve, reject: reject, timer: timer });
+      try { this.socket.write(Buffer.concat([header, body])); }
+      catch (error) { this.pending.delete(id); clearTimeout(timer); reject(error); }
+    });
+  }
+  async call(tool, args, context) {
+    var result = await this.request('tools/call', {
+      callerSource: 'codex', namespace: 'codex_app', hostId: 'local',
+      callId: 'annotatable-' + crypto.randomUUID(), threadId: context.threadId,
+      turnId: context.turnId, tool: tool, arguments: args
+    });
+    if (!result || result.success !== true) throw new Error('Codex 桌面工具 ' + tool + ' 未成功；批注仍保留在文档中');
+    var item = (result.contentItems || []).find(item => item.type === 'inputText');
+    if (!item) throw new Error('Codex 桌面工具 ' + tool + ' 缺少结果');
+    try { return JSON.parse(item.text); }
+    catch (_) { throw new Error('Codex 桌面工具 ' + tool + ' 返回无效结果'); }
+  }
+  close() { this.abort(new Error('Codex 桌面连接已结束')); }
+}
+
+class DesktopNotifier {
+  constructor(pipePath, threadId, turnId) {
+    if (!pipePath || !threadId || !turnId) throw new Error('Codex 桌面通知缺少连接、会话或来源轮次');
+    this.rpc = new DesktopRpc(pipePath);
+    this.context = { threadId: threadId, turnId: turnId };
+    this.kind = 'desktop';
+  }
+  async open() {
+    await this.rpc.open();
+    var result = await this.rpc.request('tools/list', { threadStartKind: 'all' });
+    for (const name of ['read_thread', 'send_message_to_thread']) {
+      if (!(result.tools || []).some(tool => tool.namespace === 'codex_app' && tool.name === name)) {
+        throw new Error('Codex 桌面不提供 ' + name + '；无法恢复自动通知');
+      }
+    }
+    return this.read();
+  }
+  async read() {
+    var result = await this.rpc.call('read_thread', {
+      threadId: this.context.threadId, hostId: 'local', turnLimit: 1,
+      includeOutputs: false, maxOutputCharsPerItem: 0
+    }, this.context);
+    if (!result.thread || result.thread.id !== this.context.threadId || result.thread.hostId !== 'local') {
+      throw new Error('Codex 桌面返回了其他会话；停止监听');
+    }
+    return result;
+  }
+  async notify(hit, options) {
+    var prompt = '【批注工具自动通知】用户指定的页面收到待回应批注。请按 annotatable-html 工作流读取完整批注并回复，完成后重新挂同一页面的监听。\n' +
+      '这条消息由本机监听程序发出，不是用户新输入。\nPOLL_HIT ' + JSON.stringify(hit);
+    if (options && options.managed) {
+      prompt = '【指定页面批注自动续接】请读取并回复用户已指定页面的待回应批注。\n' +
+        '后台续接程序负责后续监听，不要重挂 poll 或启动另一个控制器。长回复通过 UTF-8 JSON 文件交给批注 CLI，完成后核对落盘。\n' +
+        'POLL_HIT ' + JSON.stringify(hit);
+    }
+    var result = await this.rpc.call('send_message_to_thread', {
+      threadId: this.context.threadId, hostId: 'local', prompt: prompt
+    }, this.context);
+    if (result.threadId !== this.context.threadId) throw new Error('Codex 桌面未确认目标会话收到通知');
+    return { threadId: result.threadId, transport: this.kind };
+  }
+  close() { this.rpc.close(); }
+}
+
+module.exports = { DesktopRpc: DesktopRpc, DesktopNotifier: DesktopNotifier };

package/lib/codex-headless.js

@@ -0,0 +1,129 @@
+'use strict';
+
+var fs = require('fs');
+var path = require('path');
+var JsonProcess = require('./duty-process').JsonProcess;
+var util = require('util');
+
+function canonicalPath(value) { return path.resolve(value).replace(/\\/g, '/').toLowerCase(); }
+function readSettings(thread) {
+  if (!thread || !thread.id || !thread.path || !thread.modelProvider || !thread.model) throw new Error('会话缺少可核对的续接设置');
+  var fd = fs.openSync(thread.path, 'r'), size, buffer;
+  try {
+    size = fs.fstatSync(fd).size; buffer = Buffer.alloc(Math.min(size, 4 * 1024 * 1024));
+    fs.readSync(fd, buffer, 0, buffer.length, size - buffer.length);
+  } finally { fs.closeSync(fd); }
+  var tail = buffer.toString('utf8').split(/\r?\n/);
+  var context;
+  for (var line of tail) {
+    try { var row = JSON.parse(line); if (row.type === 'turn_context') context = row.payload; } catch (_) {}
+  }
+  if (!context || !context.permission_profile || !context.sandbox_policy || !context.approval_policy) {
+    throw new Error('无法核对会话原有权限；保留批注，不启动无头模型');
+  }
+  if (canonicalPath(context.cwd) !== canonicalPath(thread.cwd) || context.model !== thread.model) {
+    throw new Error('会话元数据与最近轮次设置不一致');
+  }
+  return { model: thread.model, modelProvider: thread.modelProvider, cwd: thread.cwd,
+    reasoningEffort: context.effort || thread.reasoningEffort || null,
+    approvalPolicy: context.approval_policy, approvalsReviewer: context.approvals_reviewer || 'user',
+    sandbox: context.sandbox_policy, permissionProfile: context.permission_profile, rolloutPath: thread.path };
+}
+function normalizeSandbox(policy, cwd) {
+  var type = { 'workspace-write': 'workspaceWrite', 'read-only': 'readOnly', 'danger-full-access': 'dangerFullAccess', 'external-sandbox': 'externalSandbox' }[policy.type] || policy.type;
+  var result = { type: type, network: policy.networkAccess === undefined ? policy.network_access || false : policy.networkAccess };
+  if (type === 'workspaceWrite') {
+    result.roots = Array.from(new Set([cwd].concat(policy.writableRoots || policy.writable_roots || []).map(canonicalPath))).sort();
+    result.excludeTmp = !!(policy.excludeTmpdirEnvVar || policy.exclude_tmpdir_env_var);
+    result.excludeSlash = !!(policy.excludeSlashTmp || policy.exclude_slash_tmp);
+  }
+  return result;
+}
+function assertRestored(saved, restored) {
+  var valid = restored.thread && restored.thread.id && restored.model === saved.model && restored.modelProvider === saved.modelProvider &&
+    canonicalPath(restored.cwd) === canonicalPath(saved.cwd) &&
+    util.isDeepStrictEqual(saved.approvalPolicy, restored.approvalPolicy) && saved.approvalsReviewer === restored.approvalsReviewer &&
+    util.isDeepStrictEqual(normalizeSandbox(saved.sandbox, saved.cwd), normalizeSandbox(restored.sandbox, restored.cwd));
+  if (!valid) throw new Error('无头恢复后的模型、目录或权限不一致；未启动回复轮次');
+}
+
+class StdioRpc extends JsonProcess {
+  constructor(binary, home, cwd) {
+    var env = require('./duty-process').agentEnv({ CODEX_HOME: home });
+    super(binary, ['app-server', '--stdio'], { cwd: cwd, env: env });
+  }
+  async open() {
+    await this.request('initialize', { clientInfo: { name: 'annotatable_duty', version: require('../package.json').version }, capabilities: { experimentalApi: true } });
+    this.send({ method: 'initialized', params: {} });
+  }
+}
+
+async function runHeadless(binding, hit, options) {
+  options = options || {};
+  if (binding.settings.rolloutPath) {
+    var latest = readSettings({ id: binding.threadId, path: binding.settings.rolloutPath, model: binding.settings.model,
+      modelProvider: binding.settings.modelProvider, cwd: binding.settings.cwd });
+    if (!util.isDeepStrictEqual(latest, binding.settings)) throw new Error('注册后会话设置已改变；请重新注册，不自动覆盖原设置');
+  }
+  var released = await (options.checkReleased || require('./duty-process').released)(binding.desktop.owners);
+  if (!released.released) throw new Error('桌面运行时尚未确认退出；不启动第二份会话');
+  var rpc = options.rpc || new StdioRpc(binding.binary, binding.codexHome, binding.settings.cwd);
+  var record = { startedAt: Date.now(), threadId: binding.threadId, pid: rpc.child && rpc.child.pid, outcome: 'starting', events: [] };
+  if (options.onStart) options.onStart(record);
+  var turnId;
+  var requestError;
+  var terminal;
+  var timeout;
+  var finished = new Promise((resolve, reject) => { terminal = { resolve: resolve, reject: reject }; });
+  // Avoid an unhandled rejection while initialization is still in progress.
+  finished.catch(function () {});
+  function interrupt(reason) {
+    requestError = reason;
+    if (turnId) rpc.request('turn/interrupt', { threadId: binding.threadId, turnId: turnId }).catch(function () {});
+  }
+  rpc.on('serverRequest', message => {
+    if (message.method === 'item/tool/call') {
+      rpc.send({ id: message.id, result: { success: false, contentItems: [{ type: 'inputText', text: '当前为无头宿主，桌面动态工具不可用。使用内置命令执行工具运行本地批注 CLI；不要申请扩大权限。' }] } });
+      record.events.push({ kind: 'desktop-tool-unavailable', tool: message.params.tool });
+    } else if (/requestApproval$/.test(message.method)) {
+      rpc.send({ id: message.id, result: { decision: 'decline' } });
+      interrupt('需要人工审批；批注保留待处理');
+    } else {
+      rpc.send({ id: message.id, error: { code: -32601, message: 'Unattended request requires a user or an unavailable host' } });
+      interrupt('无头宿主无法处理 ' + message.method);
+    }
+  });
+  rpc.on('notification', message => {
+    if (message.params && message.params.threadId && message.params.threadId !== binding.threadId) return;
+    if (message.method === 'turn/completed') {
+      record.turnStatus = message.params.turn.status;
+      terminal.resolve(message.params.turn);
+    }
+    if (message.method === 'item/completed' && message.params.item && message.params.item.type === 'agentMessage') {
+      record.finalMessage = message.params.item.text;
+    }
+  });
+  rpc.on('exit', () => terminal.reject(new Error('无头进程在轮次完成前退出')));
+  try {
+    await rpc.open();
+    var restored = await rpc.request('thread/resume', { threadId: binding.threadId, excludeTurns: true, model: binding.settings.model });
+    if (!restored.thread || restored.thread.id !== binding.threadId) throw new Error('恢复到了其他会话');
+    assertRestored(binding.settings, restored);
+    record.restored = { model: restored.model, modelProvider: restored.modelProvider, cwd: restored.cwd,
+      approvalPolicy: restored.approvalPolicy, approvalsReviewer: restored.approvalsReviewer, sandbox: restored.sandbox };
+    if (!(await (options.checkReleased || require('./duty-process').released)(binding.desktop.owners)).released) throw new Error('桌面已重开；不启动无头回复轮次');
+    var prompt = require('./duty').prompt(binding, hit, { headless: true });
+    var started = await rpc.request('turn/start', { threadId: binding.threadId, input: [{ type: 'text', text: prompt }], effort: binding.settings.reasoningEffort || undefined });
+    turnId = started.turn.id; record.turnId = turnId;
+    if (requestError) interrupt(requestError);
+    timeout = setTimeout(() => { interrupt('无头处理超时，保留待办'); setTimeout(() => terminal.reject(new Error(requestError)), 10000).unref(); }, options.timeoutMs || 300000);
+    var turn = await finished;
+    if (requestError || turn.status !== 'completed') throw new Error(requestError || '无头轮次未完成：' + turn.status);
+    record.outcome = 'completed';
+    return record;
+  } catch (error) { record.outcome = 'failed'; record.error = error.message; throw Object.assign(error, { dutyRun: record }); }
+  finally { clearTimeout(timeout); await rpc.close(); record.finishedAt = Date.now(); if (options.onFinish) options.onFinish(record); }
+}
+
+module.exports = { readSettings: readSettings, normalizeSandbox: normalizeSandbox, assertRestored: assertRestored,
+  StdioRpc: StdioRpc, runHeadless: runHeadless, canonicalPath: canonicalPath };

package/lib/codex.js

@@ -0,0 +1,216 @@
+'use strict';
+
+/* Optional Codex notification transport. No settings or credentials are changed.
+ * The control socket uses WebSocket; app-server proxy forwards its raw bytes.
+ * Node 22+ supplies WebSocket, so the package keeps its zero-dependency install. */
+var fs = require('fs');
+var path = require('path');
+var os = require('os');
+var net = require('net');
+var cp = require('child_process');
+var runPoll = require('./poll-process.js').runPoll;
+
+function binaryFor(opts) {
+  if (opts.codexBin) return opts.codexBin;
+  if (process.platform === 'win32') {
+    var home = process.env.CODEX_HOME || path.join(os.homedir(), '.codex');
+    var managed = path.join(home, 'packages', 'app-server-daemon', 'current', 'bin', 'codex.exe');
+    if (fs.existsSync(managed)) return managed;
+  }
+  return 'codex';
+}
+
+class CodexRpc {
+  constructor(binary) {
+    if (typeof WebSocket !== 'function') throw new Error('Codex 通知需要 Node.js 22+；普通 poll 仍支持 Node.js 14+');
+    this.nextId = 0;
+    this.pending = new Map();
+    this.stderr = '';
+    this.child = cp.spawn(binary, ['app-server', 'proxy'], { windowsHide: true, stdio: ['pipe', 'pipe', 'pipe'] });
+    this.child.stderr.on('data', chunk => { this.stderr = (this.stderr + chunk).slice(-2000); });
+    this.child.on('error', err => this.abort(err));
+    this.child.stdin.on('error', err => this.abort(err));
+    this.child.on('exit', code => {
+      if (!this.closing) this.abort(new Error('Codex proxy 已退出 (' + code + ')：' + this.stderr));
+    });
+    this.bridge = net.createServer(socket => {
+      this.socket = socket;
+      socket.on('error', err => this.abort(err));
+      socket.pipe(this.child.stdin);
+      this.child.stdout.pipe(socket);
+    });
+  }
+  abort(err) {
+    this.failure = err;
+    for (const waiter of this.pending.values()) { clearTimeout(waiter.timer); waiter.reject(err); }
+    this.pending.clear();
+    if (this.socket) this.socket.destroy();
+  }
+  request(method, params) {
+    return new Promise((resolve, reject) => {
+      if (this.failure) { reject(this.failure); return; }
+      const id = ++this.nextId;
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error('Codex ' + method + ' 超时'));
+      }, 10000);
+      this.pending.set(id, { resolve, reject, timer });
+      try { this.ws.send(JSON.stringify({ id, method, params })); }
+      catch (err) { clearTimeout(timer); this.pending.delete(id); reject(err); }
+    });
+  }
+  async open() {
+    await new Promise((resolve, reject) => {
+      this.bridge.once('error', reject);
+      this.bridge.listen(0, '127.0.0.1', resolve);
+    });
+    if (this.failure) throw this.failure;
+    this.ws = new WebSocket('ws://127.0.0.1:' + this.bridge.address().port);
+    this.ws.addEventListener('message', event => {
+      let msg;
+      try { msg = JSON.parse(event.data); } catch (_) { return; }
+      const waiter = this.pending.get(msg.id);
+      if (!waiter) return;
+      this.pending.delete(msg.id);
+      clearTimeout(waiter.timer);
+      if (msg.error) waiter.reject(new Error(JSON.stringify(msg.error)));
+      else waiter.resolve(msg.result);
+    });
+    this.ws.addEventListener('close', () => {
+      if (!this.closing) this.abort(new Error('Codex 控制连接已关闭'));
+    });
+    await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => reject(new Error('Codex WebSocket 握手超时：' + this.stderr)), 10000);
+      this.ws.addEventListener('open', () => { clearTimeout(timer); resolve(); }, { once: true });
+      this.ws.addEventListener('error', () => { clearTimeout(timer); reject(this.failure || new Error('Codex WebSocket 握手失败：' + this.stderr)); }, { once: true });
+    });
+    await this.request('initialize', {
+      clientInfo: { name: 'annotatable_html', title: 'Annotatable HTML', version: require('../package.json').version },
+      capabilities: { experimentalApi: true }
+    });
+    this.ws.send(JSON.stringify({ method: 'initialized', params: {} }));
+  }
+  async read(threadId, includeTurns) {
+    return (await this.request('thread/read', { threadId, includeTurns: !!includeTurns })).thread;
+  }
+  close() {
+    this.closing = true;
+    this.abort(new Error('Codex 连接已结束'));
+    if (this.ws) this.ws.close();
+    this.bridge.close();
+    this.child.stdin.end();
+    this.child.kill();
+  }
+}
+
+async function withRpc(opts, action) {
+  var rpc = new CodexRpc(binaryFor(opts));
+  try { await rpc.open(); return await action(rpc); }
+  finally { rpc.close(); }
+}
+
+async function pollAnnotations(htmlPath, opts) {
+  opts = opts || {};
+  var threadId = opts.codexThread || process.env.CODEX_THREAD_ID;
+  if (!threadId) throw new Error('缺少 Codex 会话 ID：在目标会话中运行，或传 --codex-thread ID');
+  var notifier;
+  try {
+    notifier = await createNotifier(threadId, opts);
+    console.log('CODEX_READY ' + JSON.stringify({ threadId: threadId, transport: notifier.kind }));
+    var result = await runPoll(htmlPath, opts);
+    if (result.hit) {
+      var notified = await notifier.notify(result.hit);
+      console.log('CODEX_NOTIFIED ' + JSON.stringify(Object.assign({ file: result.hit.file }, notified)));
+    }
+    process.exitCode = result.code;
+  } finally { if (notifier) notifier.close(); }
+}
+
+function requireLoaded(thread) {
+  if (!thread || !thread.status || !['active', 'idle'].includes(thread.status.type)) {
+    throw new Error('目标会话未加载到此 app-server；聊天记录存在不代表可通知。请从托管该会话的 Codex 桌面重新启动监听，勿在其他服务 resume 同一会话');
+  }
+}
+
+async function createNotifier(threadId, opts) {
+  opts = opts || {};
+  var mode = opts.codexTransport || 'auto';
+  if (!['auto', 'desktop', 'app-server'].includes(mode)) throw new Error('未知 Codex 通知方式：' + mode);
+  var pipePath = opts.codexPipe || process.env.CODEX_APP_TOOLS_PIPE_PATH;
+  var notifier;
+  try {
+    if (mode === 'desktop' || (mode === 'auto' && pipePath)) {
+      if (!pipePath) throw new Error('缺少 CODEX_APP_TOOLS_PIPE_PATH；请在 Codex 桌面会话中启动监听');
+      var turnId = opts.codexTurn || process.env.CODEX_TURN_ID;
+      if (!turnId) {
+        // Read only the persisted turn id for call provenance. Never resume a
+        // thread here: the desktop service remains the sole runtime owner.
+        var turns = await withRpc(opts, rpc => rpc.request('thread/turns/list', {
+          threadId: threadId, limit: 1, sortDirection: 'desc', itemsView: 'notLoaded'
+        }));
+        turnId = turns.data && turns.data[0] && turns.data[0].id;
+        if (!turnId) throw new Error('无法读取来源轮次；请用 --codex-turn 指定当前轮次 ID');
+      }
+      notifier = new (require('./codex-desktop.js').DesktopNotifier)(pipePath, threadId, turnId);
+      await notifier.open();
+    } else {
+      var rpc = new CodexRpc(binaryFor(opts));
+      notifier = { kind: 'app-server', close: () => rpc.close(), notify: async hit => {
+        requireLoaded(await rpc.read(threadId));
+        var result = await rpc.request('turn/start', { threadId: threadId, input: [], toolOutput: {
+          name: 'annotatable_poll', output: 'POLL_HIT ' + JSON.stringify(hit)
+        } });
+        return { threadId: threadId, turnId: result.turn.id, transport: 'app-server' };
+      } };
+      await rpc.open();
+      requireLoaded(await rpc.read(threadId));
+    }
+    return notifier;
+  } catch (error) { if (notifier) notifier.close(); throw error; }
+}
+
+async function dutyBinding(file, options) {
+  var threadId = options.codexThread || process.env.CODEX_THREAD_ID;
+  if (!/^[a-f0-9-]{36}$/i.test(threadId || '')) throw new Error('续接必须绑定明确的 Codex 会话编号');
+  var pipePath = options.codexPipe || process.env.CODEX_APP_TOOLS_PIPE_PATH;
+  if (!pipePath) throw new Error('请从目标桌面会话注册页面，不根据最近聊天猜测目标');
+  var binary = options.codexBin || process.env.CODEX_APP_RUNTIME_CLI_PATH || binaryFor(options);
+  var notifier = await createNotifier(threadId, { codexTransport: 'desktop', codexPipe: pipePath, codexTurn: options.codexTurn, codexBin: binary });
+  var rpc, processes = require('./duty-process');
+  try {
+    var desktop = await processes.pipeOwners(pipePath);
+    rpc = new CodexRpc(binary); await rpc.open();
+    var settings = require('./codex-headless').readSettings(await rpc.read(threadId, false));
+    return { threadId: threadId, binary: binary, codexHome: process.env.CODEX_HOME || path.join(os.homedir(), '.codex'), settings: settings,
+      desktop: { pipePath: pipePath, turnId: notifier.context.turnId, owners: desktop.owners.map(processes.identity), main: processes.identity(desktop.main) } };
+  } finally { notifier.close(); if (rpc) rpc.close(); }
+}
+function createDutyAdapter(getBinding, updateBinding) {
+  var notifier, processes = require('./duty-process');
+  async function online() {
+    if (notifier) {
+      try { var r = await notifier.read(); return { available: true, active: r.thread.status.type === 'active', notify: hit => notifier.notify(hit, { managed: true }) }; }
+      catch (_) { notifier.close(); notifier = null; }
+    }
+    var current = getBinding(), successes = [];
+    for (var candidate of processes.pipeCandidates(current.desktop.pipePath)) {
+      var item;
+      try {
+        item = await createNotifier(current.threadId, { codexTransport: 'desktop', codexPipe: candidate, codexTurn: current.desktop.turnId, codexBin: current.binary });
+        var owner = await processes.pipeOwners(candidate);
+        successes.push({ notifier: item, owners: owner.owners.map(processes.identity), main: processes.identity(owner.main), pipe: candidate });
+      } catch (_) { if (item) item.close(); }
+    }
+    if (successes.length !== 1) { successes.forEach(x => x.notifier.close()); return null; }
+    var selected = successes[0]; notifier = selected.notifier;
+    updateBinding(Object.assign({}, current, { desktop: { pipePath: selected.pipe, owners: selected.owners, main: selected.main, turnId: current.desktop.turnId } }));
+    var result = await notifier.read();
+    return { available: true, active: result.thread.status.type === 'active', notify: hit => notifier.notify(hit, { managed: true }) };
+  }
+  return { online: online, released: () => processes.released(getBinding().desktop.owners),
+    run: (hit, onStart) => require('./codex-headless').runHeadless(getBinding(), hit, { onStart: onStart }),
+    close: () => { if (notifier) notifier.close(); } };
+}
+
+module.exports = { CodexRpc: CodexRpc, pollAnnotations: pollAnnotations,
+  createNotifier: createNotifier, requireLoaded: requireLoaded, dutyBinding: dutyBinding, createDutyAdapter: createDutyAdapter };