@ai-workbench/remote-agent 0.8.21 → 0.8.23

package/dist/broker.js

@@ -1,10 +1,9 @@
 import { closeCode } from "./close-diagnostics.js";
 import { spawn } from 'node:child_process';
 import { createHash } from 'node:crypto';
-import { ProtocolBoundary } from "./protocol-boundary.js";
 import { NeedError, shellQuote } from "./remote.js";
 import { CODEX_AGENT } from "./agents.js";
-/** One byte stream / SDK app, multiple SSH attachments. Input is never replayed. */
+/** One byte stream / SDK app over one SSH attachment of a new agent. Input is never replayed. */
 export class BrokerTransport {
     readable;
     writable;
@@ -19,26 +18,15 @@ export class BrokerTransport {
     lease = new AbortController();
     listeners = new Set();
     permits = new Map();
-    approvalSent = false;
-    unconfirmed = new Set();
+    promptPermit;
     failure;
     heartbeat;
-    boundary;
-    recovering = false;
-    promptSent = false;
-    preparingInputs = 0;
     inputTail = Promise.resolve();
     exclusive(operation) { const task = this.inputTail.then(operation); this.inputTail = task.catch(() => { }); return task; }
     constructor(options) {
         if (!Number.isSafeInteger(options.maxFrameBytes) || options.maxFrameBytes < 1)
             throw new NeedError('SETTINGS_REQUIRED', '我需要 brokerMaxFrameBytes', '管理员确认 brokerMaxFrameBytes');
         this.options = options;
-        this.cursor = options.initialSequence ?? 0;
-        if (!Number.isSafeInteger(this.cursor) || this.cursor < 0)
-            throw new NeedError('RECOVERY_CURSOR_INVALID', '会话恢复位置无效', '已处理的安全游标');
-        if (options.maxMessageBytes)
-            this.boundary = new ProtocolBoundary(options.maxMessageBytes);
-        this.recovering = !!options.recoverySessionId;
         this.lease.abort();
         this.readable = new ReadableStream({ start: c => { this.output = c; }, pull: () => { this.attachment?.stdout.resume(); }, cancel: reason => { this.close({ layer: 'broker', initiator: 'broker.reader-cancel', reason: closeCode(reason, 'BROKER_READER_CANCELLED'), action: 'close' }); } });
         this.writable = new WritableStream({ write: bytes => this.write(bytes), close: () => this.close({ layer: 'broker', initiator: 'broker.writer-close', reason: 'BROKER_WRITER_CLOSED', action: 'close' }), abort: reason => this.close({ layer: 'broker', initiator: 'broker.writer-abort', reason: closeCode(reason, 'BROKER_WRITER_ABORTED'), action: 'abort' }) });
@@ -46,50 +34,11 @@ export class BrokerTransport {
     get online() { return this.attached && !this.ended; }
     get generation() { return this.epoch; }
     get signal() { return this.lease.signal; }
-    get lastSequence() { return this.cursor; }
     get error() { return this.failure; }
-    get promptInFlight() { return this.promptSent; }
-    processedMessage(message) { this.boundary?.consumed(message); }
-    checkpointSequence() { return this.online && this.preparingInputs === 0 && !!this.boundary?.complete && !this.approvalSent && this.unconfirmed.size === 0 ? this.cursor : null; }
-    async commitCheckpoint(commit) { return this.exclusive(async () => { const cursor = this.checkpointSequence(); if (cursor === null)
-        return false; await commit(cursor); return true; }); }
-    finishRecovery() { if (!this.boundary?.wholeLine)
-        throw new NeedError('RECOVERY_INCOMPLETE_OUTPUT', '原会话输出停在不完整消息中', '安全结束并新建会话'); this.recovering = false; }
-    async replayThrough(sequence, signal) {
-        const inspect = () => { signal?.throwIfAborted(); if (this.failure)
-            throw this.failure; if (this.cursor >= sequence) {
-            if (!this.boundary?.wholeLine)
-                throw new NeedError('RECOVERY_INCOMPLETE_OUTPUT', '原会话输出不完整', '安全结束并新建会话');
-            return true;
-        } return false; };
-        if (inspect())
-            return;
-        await new Promise((resolve, reject) => { let off = () => { }; const clear = () => { off(); signal?.removeEventListener('abort', changed); }; const changed = () => { try {
-            if (inspect()) {
-                clear();
-                resolve();
-            }
-        }
-        catch (error) {
-            clear();
-            reject(error);
-        } }; off = this.onChange(changed); signal?.addEventListener('abort', changed, { once: true }); changed(); });
-    }
     stopHeartbeat() { if (this.heartbeat !== undefined)
         clearInterval(this.heartbeat); this.heartbeat = undefined; }
-    recoveryMessage(message) {
-        const params = message.params;
-        if (Object.hasOwn(message, 'id') || message.method !== 'session/update' || params?.sessionId !== this.options.recoverySessionId || !['available_commands_update', 'current_mode_update', 'config_option_update', 'session_info_update', 'usage_update'].includes(params?.update?.sessionUpdate ?? ''))
-            throw new NeedError('RECOVERY_UNSAFE_OUTPUT', '原会话有未确认输出或旧交互，不能代答', '安全结束并新建会话');
-        this.options.onRecoveryUpdate?.(message);
-    }
-    authorizeResponse(id, generation) { this.permits.set(JSON.stringify(id), generation); }
-    /** Called only by the ACP protocol layer after a matching result or current-turn output. */
-    acknowledge(method) { this.unconfirmed.delete(method); }
-    /** A matching terminal prompt response settles all approval replies in that turn. */
-    completePrompt() { this.promptSent = false; this.unconfirmed.delete('session/prompt'); this.approvalSent = false; for (const key of this.unconfirmed)
-        if (key.startsWith('response:'))
-            this.unconfirmed.delete(key); }
+    authorizeResponse(id, generation, valid) { this.permits.set(JSON.stringify(id), { generation, valid }); }
+    authorizePrompt(valid) { this.promptPermit = valid; }
     onChange(fn) { this.listeners.add(fn); return () => this.listeners.delete(fn); }
     changed() { for (const fn of this.listeners)
         fn(); }
@@ -126,28 +75,6 @@ export class BrokerTransport {
         }
         catch { /* Reader already cancelled. */ }
     }
-    async waitOnline(signal) {
-        signal?.throwIfAborted();
-        if (this.online)
-            return;
-        if (this.ended)
-            throw this.failure ?? new NeedError('SESSION_ENDED', '远端会话已结束', '重新建立会话');
-        await new Promise((resolve, reject) => {
-            const done = () => { off(); signal?.removeEventListener('abort', abort); };
-            const changed = () => { if (this.online) {
-                done();
-                resolve();
-            }
-            else if (this.ended) {
-                done();
-                reject(this.failure ?? new NeedError('SESSION_ENDED', '远端会话已结束', '重新建立会话'));
-            } };
-            const abort = () => { done(); reject(new NeedError('ABORTED', '本轮已取消', '确认主机状态')); };
-            const off = this.onChange(changed);
-            signal?.addEventListener('abort', abort, { once: true });
-            changed();
-        });
-    }
     connect() {
         if (this.online)
             return Promise.resolve();
@@ -159,7 +86,7 @@ export class BrokerTransport {
         return this.joining;
     }
     async attach() {
-        const child = await this.options.attach(this.cursor);
+        const child = await this.options.attach();
         if (this.ended) {
             this.options.observeClose?.({ layer: 'broker', initiator: 'broker.late-attachment', reason: 'SESSION_ENDED', action: 'terminate' });
             child.kill('SIGTERM');
@@ -233,10 +160,7 @@ export class BrokerTransport {
             if (seq !== this.cursor + 1)
                 throw new NeedError('REPLAY_GAP', '主机输出存在缺口，不能安全继续审批', '显式结束或恢复原会话');
             if (f.channel === 'stdout') {
-                const bytes = Buffer.from(f.data, 'base64');
-                this.boundary?.receive(bytes, this.recovering ? message => this.recoveryMessage(message) : undefined);
-                if (!this.recovering && !this.options.discardOutput)
-                    this.output.enqueue(bytes);
+                this.output.enqueue(Buffer.from(f.data, 'base64'));
             }
             this.cursor = seq;
             this.changed();
@@ -281,28 +205,14 @@ export class BrokerTransport {
                 fatal(new NeedError('BROKER_ATTACH_FAILED', '主机会话附着失败；根因未查明', '有效的原员工 SSH/broker 连接'));
                 return;
             }
-            // A matching remote receipt can precede the local stdin write callback.
-            // The protocol ledger, rather than that callback's timing, owns delivery.
-            if (this.approvalSent || this.unconfirmed.size) {
-                fatal(new NeedError('INPUT_DELIVERY_UNCONFIRMED', '输入或审批应答尚无协议收件证明时连接中断；不会重发或再次批准', '显式结束原进程并检查项目状态'));
-                return;
-            }
-            this.notice('CONNECTION_LOST', '连接中断，主机可能正在等待你的审批；重连前不发送审批');
-            void this.options.onDisconnect?.().catch(error => this.fail(error instanceof NeedError ? error : new NeedError('RECONNECT_FAILED', '续接失败，根因未查明', '恢复原连接')));
+            // A real disconnect ends this turn; the next turn starts a new agent.
+            fatal(new NeedError('CONNECTION_LOST', '主机会话连接已中断，恢复后可在原会话继续。', '当前主机连接'));
         };
         child.once('error', () => detached({ layer: 'broker', initiator: 'broker.attachment-error', reason: 'BROKER_ATTACHMENT_ERROR', action: 'failure' }));
         child.once('close', (code, signal) => detached({ layer: 'broker', initiator: 'broker.attachment-close', reason: 'BROKER_ATTACHMENT_CLOSED', action: 'exit', exitCode: code, signal }));
         return connected.promise.finally(off);
     }
-    async write(bytes) {
-        this.preparingInputs++;
-        try {
-            return await this.exclusive(() => this.send(bytes));
-        }
-        finally {
-            this.preparingInputs--;
-        }
-    }
+    write(bytes) { return this.exclusive(() => this.send(bytes)); }
     async send(bytes) {
         if (!this.online || !this.attachment)
             throw new NeedError('INPUT_DELIVERY_UNCONFIRMED', '连接不在线，输入没有排队或重放', '恢复连接并确认原会话状态');
@@ -314,22 +224,42 @@ export class BrokerTransport {
             throw new NeedError('ACP_INPUT_INVALID', 'ACP 输出不是一条完整 JSON 消息', '有效的 ACP SDK 字节输出');
         }
         const selected = response.result?.outcome?.outcome === 'selected';
+        const prompt = response.method === 'session/prompt', promptPermit = prompt ? this.promptPermit : undefined;
         const generation = this.epoch;
         const child = this.attachment;
+        const permit = this.permits.get(JSON.stringify(response.id));
+        const policyCurrent = () => { try {
+            return !permit?.valid || permit.valid();
+        }
+        catch {
+            return false;
+        } };
+        const currentPrompt = () => {
+            let valid = true;
+            try {
+                valid = !promptPermit || promptPermit();
+            }
+            catch {
+                valid = false;
+            }
+            if (!valid) {
+                this.options.observeClose?.({ layer: 'broker', initiator: 'broker.permission-dispatch-gate', reason: 'PERMISSION_POLICY_CHANGED', operation: 'session/prompt', action: 'failure' });
+                throw new NeedError('PERMISSION_POLICY_CHANGED', '派发权限已变化或无法核对，原输入没有重放。', '当前权限代次；已写出部分的结果仍待确认');
+            }
+        };
         const eligible = () => {
             if (!this.online || this.attachment !== child || this.epoch !== generation)
                 throw new NeedError('INPUT_DELIVERY_UNCONFIRMED', '连接已改变，未重放输入或审批', '原连接的有效发送许可');
-            if (selected && this.permits.get(JSON.stringify(response.id)) !== generation)
-                throw new NeedError('APPROVAL_STALE', '连接已改变，旧审批未发送', '重连后的本次审批');
+            if (selected && (permit?.generation !== generation || this.permits.get(JSON.stringify(response.id)) !== permit || !policyCurrent()))
+                throw new NeedError('APPROVAL_STALE', '连接或权限已改变，旧审批未发送', '当前连接和当前权限代次的本次审批');
+            if (prompt)
+                currentPrompt();
         };
         eligible();
-        await this.options.beforeInput?.();
-        eligible();
-        if (selected) {
+        if (selected)
             this.permits.delete(JSON.stringify(response.id));
-            this.approvalSent = true;
-        }
-        this.unconfirmed.add(response.method ?? 'response:' + JSON.stringify(response.id));
+        if (prompt && this.promptPermit === promptPermit)
+            this.promptPermit = undefined;
         const chunks = [];
         if (this.options.leased) {
             const size = Math.floor((this.options.controlMaxBytes - Buffer.byteLength(JSON.stringify({ type: 'input', data: '' }))) / 4) * 3;
@@ -340,20 +270,20 @@ export class BrokerTransport {
         }
         else
             chunks.push(Buffer.from(bytes));
-        for (const [index, chunk] of chunks.entries()) {
+        for (const chunk of chunks) {
             if (!this.online || this.attachment !== child || this.epoch !== generation)
                 throw new NeedError('INPUT_DELIVERY_UNCONFIRMED', '分块发送期间断线，未重放输入', '原主机连接');
+            if (selected && !policyCurrent())
+                throw new NeedError('APPROVAL_STALE', '权限已变化，原审批未继续发送', '当前权限代次的本次审批；已写出部分的结果仍待确认');
+            if (prompt)
+                currentPrompt();
             await new Promise((resolve, reject) => {
                 const closed = () => { cleanup(); reject(new NeedError('INPUT_DELIVERY_UNCONFIRMED', '输入送达未确认，未重发', '确认原进程状态')); };
                 const cleanup = () => { child.removeListener('close', closed); };
                 child.once('close', closed);
-                if (response.method === 'session/prompt' && index === chunks.length - 1)
-                    this.promptSent = true;
                 child.stdin.write(chunk, error => { cleanup(); error ? reject(new NeedError('INPUT_DELIVERY_UNCONFIRMED', '输入送达失败，未重发', '确认原进程状态')) : resolve(); });
             });
         }
-        if (!response.method)
-            this.boundary?.responded(response.id);
     }
 }
 export function controlNeed(stderr) {
@@ -397,7 +327,6 @@ export function sshIo(target, argv, maxControlBytes) {
         }) };
 }
 export function brokerCommand(t, args) { return `AW_SESSION_ROOT=${shellQuote(t.session.root)} ${shellQuote(t.session.command)} ${args.map(shellQuote).join(' ')}`; }
-export function legacyBrokerId(sessionId, agentId = CODEX_AGENT.id) { return (agentId === CODEX_AGENT.id ? 'x' : 'a') + createHash('sha256').update(agentId === CODEX_AGENT.id ? sessionId : agentId + '/' + sessionId).digest('hex').slice(0, 23); }
 export function brokerId(sessionId, agentId = CODEX_AGENT.id) { return 'r' + createHash('sha256').update(agentId + '/' + sessionId).digest('hex').slice(0, 23); }
 export function controlJson(text) {
     try {

package/dist/catalog-ssh.d.ts

@@ -1,44 +1,15 @@
 import { ModelConfigurationError } from './model-configuration.ts';
 import type { ConnectTarget } from './provider.ts';
 export interface CatalogSshEvent {
-    version: 1;
-    eventId: string;
-    stage: 'started' | 'closed';
     provider: 'claude' | 'codex';
-    startedAt: string;
-    endedAt: string | null;
-    pid: number | null;
-    command: string;
-    argv: string[];
-    target: {
-        host: string;
-        username: string;
-        port: number;
-        knownHostsFile: string;
-        proxyCommand: string;
-    };
     exitCode: number | null;
     signal: string | null;
     stdoutBytes: number;
     stderrBytes: number;
-    stderr: string;
-    stderrSha256: string;
-    stdoutSha256: string;
-    hostErrorCode: string | null;
-    hostErrorMessage: string | null;
-    elapsedMs: number | null;
-    stderrUtf8Valid: boolean;
+    elapsedMs: number;
     failureCode: string | null;
-    stderrComplete: boolean;
-    processErrorCode?: string | null;
-    diagnosticWriteError?: string;
-    connection?: {
-        instanceId: string;
-        epoch: number;
-        phase: string;
-    } | null;
+    processErrorCode: string | null;
 }
-export declare const diagnosticLocation = "\u8BBE\u7F6E \u2192 \u6A21\u578B";
 /** Preserve ordinary line boundaries; never persist raw structured secrets. */
 export declare function catalogSafeText(value: string): string;
 export declare class CatalogSshError extends ModelConfigurationError {

package/dist/catalog-ssh.js

@@ -7,10 +7,8 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     return path;
 };
 import { spawn } from 'node:child_process';
-import { createHash, randomUUID } from 'node:crypto';
 import { ModelConfigurationError } from "./model-configuration.js";
 import { sanitizeDisplayLabel, sanitizeObservation } from "./conversation-details.js";
-export const diagnosticLocation = '设置 → 模型';
 /** Strings inside serialized JSON use the same rules as ordinary stderr. */
 function renderDiagnosticJson(wire) {
     try {
@@ -57,7 +55,6 @@ export class CatalogSshError extends ModelConfigurationError {
     }
     get diagnostic() { return '目录连接技术详情：' + JSON.stringify(this.event); }
 }
-const hash = (value) => createHash('sha256').update(value).digest('hex');
 /** Each query starts a fresh strict L SSH invocation. No connection pool or retry. */
 export async function runCatalog(target, command, signal, maxBytes, observe) {
     const provider = command === '/usr/local/aw-host/bin/aw-model-catalog --provider claude' ? 'claude' : command === '/usr/local/aw-host/bin/aw-model-catalog --provider codex' ? 'codex' : undefined;
@@ -75,29 +72,18 @@ export async function runCatalog(target, command, signal, maxBytes, observe) {
         throw new ModelConfigurationError('远程主机连接组件缺少可信 SSH 能力');
     }
     signal.throwIfAborted();
-    const safeTarget = { host: catalogSafeText(target.host), username: catalogSafeText(target.username), port: target.port, knownHostsFile: catalogSafeText(target.knownHostsFile), proxyCommand: catalogSafeText(target.proxyCommand) };
     const tick = performance.now();
-    const base = { version: 1, eventId: randomUUID(), provider, startedAt: new Date().toISOString(), command, argv: argv.map(catalogSafeText), target: safeTarget };
     return new Promise((resolve, reject) => {
         const child = spawn('ssh', argv, { stdio: ['ignore', 'pipe', 'pipe'] });
         const output = [], diagnostics = [];
         let total = 0, stdoutBytes = 0, stderrBytes = 0, processErrorCode = null, failure;
-        const stdoutHash = createHash('sha256'), stderrHash = createHash('sha256');
-        const event = (stage, extra = {}) => ({ ...base, stage, endedAt: null, pid: child.pid ?? null, exitCode: null, signal: null, stdoutBytes, stderrBytes, stderr: '', stderrSha256: hash(Buffer.alloc(0)), stdoutSha256: hash(Buffer.alloc(0)), hostErrorCode: null, hostErrorMessage: null, elapsedMs: null, stderrUtf8Valid: true, failureCode: null, stderrComplete: true, ...extra });
-        const first = event('started');
-        const started = Promise.resolve().then(() => observe?.(first));
-        started.catch(() => { });
         const abort = () => { failure ??= { code: 'MODEL_CATALOG_CANCELLED', reason: '连接已改变或目录查询已取消' }; child.kill('SIGTERM'); };
         signal.addEventListener('abort', abort, { once: true });
         const receive = (buffer, stdout) => {
-            if (stdout) {
+            if (stdout)
                 stdoutBytes += buffer.length;
-                stdoutHash.update(buffer);
-            }
-            else {
+            else
                 stderrBytes += buffer.length;
-                stderrHash.update(buffer);
-            }
             total += buffer.length;
             if (failure)
                 return;
@@ -114,15 +100,7 @@ export async function runCatalog(target, command, signal, maxBytes, observe) {
         child.once('close', (code, closeSignal) => {
             void (async () => {
                 signal.removeEventListener('abort', abort);
-                let value = '', hostErrorCode = null, hostErrorMessage = null, typed = false, stderrUtf8Valid = true;
-                let stderr;
-                try {
-                    stderr = new TextDecoder('utf-8', { fatal: true }).decode(Buffer.concat(diagnostics));
-                }
-                catch {
-                    stderrUtf8Valid = false;
-                    stderr = Buffer.concat(diagnostics).toString('utf8');
-                }
+                let value = '', typed = false;
                 try {
                     value = new TextDecoder('utf-8', { fatal: true }).decode(Buffer.concat(output));
                 }
@@ -130,26 +108,18 @@ export async function runCatalog(target, command, signal, maxBytes, observe) {
                     failure ??= { code: 'MODEL_CATALOG_UTF8_INVALID', reason: '主机目录响应不是有效 UTF-8，未替换模型值' };
                 }
                 try {
-                    const wire = JSON.parse(value);
-                    typed = wire?.ok === false;
-                    if (typed && typeof wire.error?.code === 'string' && /^[A-Z][A-Z0-9_]*$/.test(wire.error.code))
-                        hostErrorCode = wire.error.code;
-                    if (typed && typeof wire.error?.message === 'string')
-                        hostErrorMessage = catalogSafeText(wire.error.message);
+                    typed = JSON.parse(value)?.ok === false;
                 }
                 catch { }
                 if (!failure && code !== 0 && !typed)
-                    failure = { code: 'SSH_EXIT_NONZERO', reason: '与主机的目录查询连接未完成，请到' + diagnosticLocation + '查看诊断。' };
-                if (!failure && code === 0 && stderrBytes && !typed)
-                    failure = { code: 'MODEL_CATALOG_STDERR', reason: '目录命令返回了非预期诊断输出，请到' + diagnosticLocation + '查看诊断。' };
-                const final = event('closed', { endedAt: new Date().toISOString(), exitCode: code ?? null, signal: closeSignal ?? null, stderr: catalogSafeText(stderr), stderrUtf8Valid, elapsedMs: performance.now() - tick, stderrSha256: stderrHash.digest('hex'), stdoutSha256: stdoutHash.digest('hex'), hostErrorCode, hostErrorMessage, failureCode: failure?.code ?? null, processErrorCode, stderrComplete: Buffer.concat(diagnostics).length === stderrBytes });
+                    failure = { code: 'SSH_EXIT_NONZERO', reason: '模型列表暂时无法读取，请检查连接后重新打开模型菜单。' };
+                const final = { provider, exitCode: code ?? null, signal: closeSignal ?? null, stdoutBytes, stderrBytes, elapsedMs: performance.now() - tick, failureCode: failure?.code ?? null, processErrorCode };
+                console.info('[remote-agent] model-list ' + provider + ' exit=' + final.exitCode + ' bytes=' + stdoutBytes + ' elapsedMs=' + final.elapsedMs.toFixed(1));
                 try {
-                    await started;
-                    await observe?.(final);
+                    void Promise.resolve(observe?.(final)).catch(() => console.warn('[remote-agent] 模型列表查询日志未保存'));
                 }
                 catch {
-                    reject(new CatalogSshError((failure?.reason ?? '目录查询未能确认') + '；目录诊断也未能保存，请到' + diagnosticLocation + '查看诊断。', { ...final, diagnosticWriteError: 'CATALOG_DIAGNOSTIC_WRITE_FAILED' }));
-                    return;
+                    console.warn('[remote-agent] 模型列表查询日志未保存');
                 }
                 if (failure) {
                     reject(new CatalogSshError(failure.reason, final));

package/dist/claude-local.d.ts

@@ -33,6 +33,6 @@ interface Options {
         shell: (options: Parameters<typeof createEmployeeShell>[0]) => EmployeeShell;
     };
 }
-/** Local source only. Host and legacy-host remain with the original provider. */
+/** Local source only. Host source remains with the host provider. */
 export declare function createClaudeLocalProvider(options: Options): LocalRuntimeProvider;
 export {};