@ai-workbench/remote-agent 0.8.1 → 0.8.5

package/dist/remote-details.js

@@ -23,7 +23,7 @@ function kind(observation) {
         return observation.severity === 'action-required' ? 'action-required' : 'unknown';
     return { extension: 'extensions', tool: 'tools', need: 'action-required', notice: 'extensions', session: 'extensions' }[observation.kind] ?? observation.kind;
 }
-async function privateDirectory(path) {
+export async function privateDirectory(path) {
     if (!isAbsolute(path))
         throw failure('REMOTE_DETAIL_STORAGE_FAILED');
     // Existing parent/profile ownership is the host's responsibility; reject symlinks
@@ -57,7 +57,7 @@ async function privateDirectory(path) {
     if ((info.mode & 0o077) !== 0 || (process.getuid && info.uid !== process.getuid()))
         throw failure('REMOTE_DETAIL_STORAGE_FAILED');
 }
-async function durableWrite(path, value) {
+export async function durableWrite(path, value) {
     const file = await open(path, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
     try {
         await file.writeFile(JSON.stringify(value) + '\n');
@@ -74,7 +74,7 @@ async function durableWrite(path, value) {
         await parent.close();
     }
 }
-async function readJournal(path) {
+export async function readJournal(path) {
     const file = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
     try {
         const info = await file.stat();
@@ -88,9 +88,139 @@ async function readJournal(path) {
 }
 export function createRemoteDetails(options) {
     const root = join(options.profileDir, 'ai-workbench-remote-agent', 'diagnostics');
-    const scopes = new Map();
+    const scopes = new Map(), loginScopes = new Map();
     const initialize = async () => { await privateDirectory(join(options.profileDir, 'ai-workbench-remote-agent')); await privateDirectory(root); };
-    return { async open(request) {
+    return {
+        async recordLoginFailure(request) {
+            await initialize();
+            const eventId = randomUUID(), diagnostic = request.diagnostic;
+            // The original observed IDs and full approved snapshot are durable before any L call.
+            await durableWrite(join(root, eventId + '.json'), { version: 1, eventId, kind: 'login-check', code: request.code, sessionHash: request.sessionId ? hash(request.sessionId) : null, diagnostic, delivery: 'pending' });
+            if (!request.sessionId)
+                throw failure('REMOTE_DETAIL_SCOPE_INVALID');
+            const sessionId = request.sessionId, provider = diagnostic.provider, api = options.getApi(), connection = diagnostic.connection;
+            const stable = () => { const now = api?.getConnectionState(); if (!api || options.getApi() !== api || now?.phase !== 'connected' || now.instanceId !== connection.instanceId || now.epoch !== connection.epoch)
+                throw failure('CONNECTION_LOST'); };
+            stable();
+            if (api.getContractInfo?.().loginDiagnostics !== 1 || !['appendLoginDiagnostic', 'getLoginDiagnosticReceipt', 'listLoginDiagnostics'].every(key => typeof api[key] === 'function'))
+                throw failure('TECHNICAL_DETAILS_UNAVAILABLE', '技术详情暂不可用，请更新远程主机连接组件。');
+            const parent = join(root, 'login');
+            await privateDirectory(parent);
+            const key = hash(sessionId + '\0' + provider), dir = join(parent, key);
+            await privateDirectory(dir);
+            const scope = loginScopes.get(key) ?? { tail: Promise.resolve(), maximum: 0, loaded: false };
+            loginScopes.set(key, scope);
+            const operation = scope.tail.then(async () => {
+                stable();
+                const generation = connection.instanceId + '\0' + connection.epoch;
+                if (!scope.loaded || scope.generation !== generation) {
+                    const names = await readdir(dir);
+                    for (const name of names) {
+                        const match = /^(\d+)-([0-9a-f-]+)\.json$/.exec(name);
+                        if (!match)
+                            continue;
+                        const sequence = Number(match[1]);
+                        if (!Number.isSafeInteger(sequence))
+                            throw failure('REMOTE_DETAIL_STORAGE_FAILED');
+                        scope.maximum = Math.max(scope.maximum, sequence);
+                        const saved = await readJournal(join(dir, name));
+                        if (!object(saved) || !object(saved.detail) || saved.detail.sequence !== sequence || saved.detail.eventId !== match[2] || saved.detail.sessionId !== sessionId || saved.detail.provider !== provider)
+                            throw failure('REMOTE_DETAIL_STORAGE_FAILED');
+                        const settled = 'settled-' + match[2] + '.json';
+                        if (names.includes(settled)) {
+                            const receipt = await readJournal(join(dir, settled));
+                            if (!object(receipt) || receipt.eventId !== match[2] || !['recorded', 'rejected'].includes(receipt.state))
+                                throw failure('REMOTE_DETAIL_STORAGE_FAILED');
+                            continue;
+                        }
+                        stable();
+                        const receipt = unwrap(await api.getLoginDiagnosticReceipt({ eventId: match[2], sessionId, provider }));
+                        stable();
+                        if (receipt.eventId !== match[2] || !receipt.recorded)
+                            throw failure('REMOTE_DETAIL_DELIVERY_UNKNOWN');
+                        if (!isDeepStrictEqual(receipt.detail, saved.detail))
+                            throw failure('REMOTE_DETAIL_RECEIPT_INVALID');
+                        await durableWrite(join(dir, settled), { eventId: match[2], state: 'recorded' });
+                    }
+                    let cursor, previous = -1, count = 0, expected;
+                    const seen = new Set();
+                    do {
+                        stable();
+                        const page = unwrap(await api.listLoginDiagnostics({ sessionId, provider, ...(cursor ? { cursor } : {}) }));
+                        stable();
+                        if (!object(page) || !Array.isArray(page.items) || ![page.total, page.unknownCount, page.actionRequiredCount].every(n => Number.isSafeInteger(n) && n >= 0))
+                            throw failure('REMOTE_DETAIL_RESPONSE_INVALID');
+                        const counts = { total: page.total, unknownCount: page.unknownCount, actionRequiredCount: page.actionRequiredCount };
+                        if (expected && !isDeepStrictEqual(expected, counts))
+                            throw failure('REMOTE_DETAIL_RESPONSE_INVALID');
+                        expected = counts;
+                        for (const entry of page.items) {
+                            if (entry.sessionId !== sessionId || entry.provider !== provider || !Number.isSafeInteger(entry.sequence) || entry.sequence < 0 || entry.sequence <= previous)
+                                throw failure('REMOTE_DETAIL_RESPONSE_INVALID');
+                            previous = entry.sequence;
+                            scope.maximum = Math.max(scope.maximum, entry.sequence);
+                            count++;
+                        }
+                        cursor = page.nextCursor;
+                        if (cursor !== undefined && (typeof cursor !== 'string' || !cursor || seen.has(cursor)))
+                            throw failure('REMOTE_DETAIL_CURSOR_INVALID');
+                        if (cursor)
+                            seen.add(cursor);
+                    } while (cursor);
+                    if (count !== expected?.total)
+                        throw failure('REMOTE_DETAIL_RESPONSE_INVALID');
+                    scope.loaded = true;
+                    scope.generation = generation;
+                }
+                const mismatch = diagnostic.reason === 'LOGIN_INSTANCE_MISMATCH', unsupported = !!diagnostic.officialReasonRejected;
+                const reason = mismatch ? 'LOGIN_INSTANCE_MISMATCH' : unsupported ? 'OFFICIAL_REASON_UNSUPPORTED' : diagnostic.reason;
+                // L 0.7.11: observed evidence never changes the current connection scope.
+                const login = { phase: diagnostic.login.phase, instanceId: diagnostic.login.instanceId, logins: Object.fromEntries(Object.entries(diagnostic.login.logins).filter(([, v]) => typeof v === 'boolean' || v === 'absent')), queuedProviders: diagnostic.login.queuedProviders, checkingProviders: diagnostic.login.checkingProviders };
+                const payload = { reason, connection: { ...connection }, login, ...(mismatch ? { observedLoginInstanceId: diagnostic.login.instanceId } : {}), ...(diagnostic.officialReason ? { officialReason: diagnostic.officialReason } : {}), ...(unsupported && !mismatch ? { officialReasonRejected: diagnostic.officialReasonRejected } : {}) };
+                // The two payload reasons are exclusive in L's contract. Preserve both facts
+                // using the approved fixed summary and full digest, without inventing a field.
+                const rejected = diagnostic.officialReasonRejected;
+                const summary = '登录检查：' + diagnostic.reason + (rejected ? '; OFFICIAL_REASON_UNSUPPORTED; bytes=' + rejected.bytes + '; SHA256=' + rejected.sha256 : '');
+                const context = request.context ?? { turn: null, step: null };
+                if (!identifier(context.turn) || !identifier(context.step))
+                    throw failure('REMOTE_DETAIL_SCOPE_INVALID');
+                const sequence = scope.maximum + 1;
+                if (!Number.isSafeInteger(sequence))
+                    throw failure('REMOTE_DETAIL_SEQUENCE_INVALID');
+                scope.maximum = sequence;
+                const detail = { version: 1, eventId, instanceId: connection.instanceId, epoch: connection.epoch, sessionId, provider, turn: context.turn, step: context.step, sequence, kind: 'login-check', severity: 'action-required', code: request.code, summary, method: diagnostic.source, payload };
+                await durableWrite(join(dir, sequence + '-' + eventId + '.json'), { state: 'pending', detail });
+                stable();
+                let response;
+                try {
+                    response = await api.appendLoginDiagnostic(structuredClone(detail));
+                }
+                catch {
+                    stable();
+                    const receipt = unwrap(await api.getLoginDiagnosticReceipt({ eventId, sessionId, provider }));
+                    stable();
+                    if (receipt.eventId !== eventId)
+                        throw failure('REMOTE_DETAIL_RECEIPT_INVALID');
+                    if (!receipt.recorded)
+                        throw failure('REMOTE_DETAIL_DELIVERY_UNKNOWN');
+                    if (!isDeepStrictEqual(receipt.detail, detail))
+                        throw failure('REMOTE_DETAIL_RECEIPT_INVALID');
+                    await durableWrite(join(dir, 'settled-' + eventId + '.json'), { eventId, state: 'recorded' });
+                    return;
+                }
+                stable();
+                if (response?.ok === false)
+                    await durableWrite(join(dir, 'settled-' + eventId + '.json'), { eventId, state: 'rejected', code: response.error.code });
+                const ack = unwrap(response);
+                if (ack.eventId !== eventId || ack.recorded !== true)
+                    throw failure('REMOTE_DETAIL_RESPONSE_INVALID');
+                await durableWrite(join(dir, 'settled-' + eventId + '.json'), { eventId, state: 'recorded' });
+            });
+            scope.tail = operation.then(() => { }, () => { scope.loaded = false; });
+            await operation;
+            return { eventId, recorded: true };
+        },
+        async open(request) {
             if (!request.sessionId || !request.identity || !request.connection.instanceId || !Number.isSafeInteger(request.connection.epoch) || request.connection.epoch < 0 || !['claude', 'codex'].includes(request.provider))
                 throw failure('REMOTE_DETAIL_SCOPE_INVALID');
             try {
@@ -246,5 +376,6 @@ export function createRemoteDetails(options) {
                 async flush() { await tail; if (firstFailure)
                     throw firstFailure.error; stable(); },
             };
-        } };
+        }
+    };
 }

package/dist/remote.d.ts

@@ -1,3 +1,4 @@
+import type { LoginDiagnostic } from './login-diagnostic.ts';
 import type { ChildProcessWithoutNullStreams } from 'node:child_process';
 /** Development-only direct SSH. Product transports must consume L's exported sshArgs (v0.2). */
 export interface DevelopmentSshTarget {
@@ -16,6 +17,8 @@ export interface Need {
 export declare class NeedError extends Error {
     code: string;
     requires: string;
+    technical?: LoginDiagnostic;
+    officialReason?: string;
     constructor(code: string, message: string, requires: string);
 }
 export declare function shellQuote(value: string): string;

package/dist/remote.js

@@ -2,6 +2,8 @@ import { spawn } from 'node:child_process';
 export class NeedError extends Error {
     code;
     requires;
+    technical;
+    officialReason;
     constructor(code, message, requires) {
         super(message);
         this.name = 'NeedError';

package/dist/rpc-namespace.d.ts

@@ -0,0 +1,3 @@
+import type { Stream } from '@agentclientprotocol/sdk/unstable';
+/** Public Stream only. Server request/approval IDs are never changed. */
+export declare function isolateRpcIds(stream: Stream): Stream;

package/dist/rpc-namespace.js

@@ -0,0 +1,50 @@
+import { randomUUID } from 'node:crypto';
+import { NeedError } from "./remote.js";
+/** Public Stream only. Server request/approval IDs are never changed. */
+export function isolateRpcIds(stream) {
+    const prefix = randomUUID() + '/';
+    const pending = new Map();
+    const readable = stream.readable.pipeThrough(new TransformStream({ transform(message, controller) {
+            const raw = message;
+            if (!raw.method && Object.hasOwn(raw, 'id')) {
+                if (typeof raw.id !== 'string' || !pending.has(raw.id))
+                    throw new NeedError('ACP_FOREIGN_RESPONSE', '收到不属于当前客户端的协议响应', '原会话的完整客户端状态');
+                const id = pending.get(raw.id);
+                pending.delete(raw.id);
+                controller.enqueue({ ...raw, id });
+            }
+            else
+                controller.enqueue(message);
+        } }));
+    const writable = new WritableStream({ async write(message) {
+            const raw = message;
+            let outgoing = raw;
+            if (typeof raw.method === 'string' && Object.hasOwn(raw, 'id')) {
+                const id = prefix + JSON.stringify(raw.id);
+                pending.set(id, raw.id);
+                outgoing = { ...raw, id };
+            }
+            else if (raw.method === '$/cancel_request' && raw.params && typeof raw.params === 'object') {
+                const params = raw.params;
+                outgoing = { ...raw, params: { ...params, requestId: prefix + JSON.stringify(params.requestId) } };
+            }
+            const writer = stream.writable.getWriter();
+            try {
+                await writer.write(outgoing);
+            }
+            finally {
+                writer.releaseLock();
+            }
+        }, async close() { const writer = stream.writable.getWriter(); try {
+            await writer.close();
+        }
+        finally {
+            writer.releaseLock();
+        } }, async abort(reason) { const writer = stream.writable.getWriter(); try {
+            await writer.abort(reason);
+        }
+        finally {
+            writer.releaseLock();
+        } } });
+    return { readable, writable };
+}

package/dist/stage-timing.d.ts

@@ -0,0 +1,27 @@
+import type { DetailObservation } from './conversation-details.ts';
+export declare const STAGES: Readonly<{
+    readonly 'login-ready': "登录就绪检查";
+    readonly 'connection-confirm': "核对当前连接状态";
+    readonly 'input-prepare': "准备本轮输入";
+    readonly 'workspace-resolve': "解析工作区";
+    readonly 'details-open': "打开技术详情";
+    readonly 'details-flush': "等待技术详情持久确认";
+    readonly 'workspace-notice': "记录工作区说明";
+    readonly 'broker-list': "查询主机会话";
+    readonly 'broker-start': "启动主机会话";
+    readonly 'broker-attach': "连接主机会话";
+    readonly 'acp-initialize': "初始化远程模型";
+    readonly 'acp-session-new': "新建模型会话";
+    readonly 'acp-session-load': "加载模型会话";
+    readonly 'acp-session-resume': "恢复模型会话";
+    readonly 'acp-prompt': "模型处理本轮（含等待审批）";
+}>;
+export type Stage = keyof typeof STAGES;
+/** Passive client observations; no thresholds, retries, or remote-clock claims. */
+export declare class StageTiming {
+    private readonly started;
+    private pending;
+    private sink?;
+    bind(sink: (detail: DetailObservation) => void): void;
+    run<T>(phase: Stage, operation: () => Promise<T>): Promise<T>;
+}

package/dist/stage-timing.js

@@ -0,0 +1,39 @@
+export const STAGES = Object.freeze({
+    'login-ready': '登录就绪检查', 'connection-confirm': '核对当前连接状态', 'input-prepare': '准备本轮输入', 'workspace-resolve': '解析工作区',
+    'details-open': '打开技术详情', 'details-flush': '等待技术详情持久确认', 'workspace-notice': '记录工作区说明',
+    'broker-list': '查询主机会话', 'broker-start': '启动主机会话', 'broker-attach': '连接主机会话',
+    'acp-initialize': '初始化远程模型', 'acp-session-new': '新建模型会话',
+    'acp-session-load': '加载模型会话', 'acp-session-resume': '恢复模型会话',
+    'acp-prompt': '模型处理本轮（含等待审批）',
+});
+/** Passive client observations; no thresholds, retries, or remote-clock claims. */
+export class StageTiming {
+    started = performance.now();
+    pending = [];
+    sink;
+    bind(sink) {
+        this.sink = sink;
+        const pending = this.pending;
+        this.pending = [];
+        for (const detail of pending)
+            sink(detail);
+    }
+    async run(phase, operation) {
+        const started = performance.now();
+        let outcome = 'failed';
+        try {
+            const result = await operation();
+            outcome = 'ok';
+            return result;
+        }
+        finally {
+            const ended = performance.now();
+            const durationMs = ended - started, elapsedMs = ended - this.started;
+            const detail = { kind: 'session', severity: outcome === 'ok' ? 'info' : 'warning', code: 'REMOTE_STAGE_TIMING', summary: STAGES[phase] + '：' + durationMs.toFixed(1) + '毫秒', payload: { phase, durationMs, elapsedMs, outcome, clock: 'client-monotonic' } };
+            if (this.sink)
+                this.sink(detail);
+            else
+                this.pending.push(detail);
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-workbench/remote-agent",
-  "version": "0.8.1",
+  "version": "0.8.5",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -19,7 +19,7 @@
     "cordis.patch.yml"
   ],
   "scripts": {
-    "test": "npm run build && node --test lib/test/*.test.js",
+    "test": "npm run build && node --test --test-concurrency=1 lib/test/*.test.js",
     "typecheck": "node node_modules/typescript/bin/tsc --noEmit",
     "build": "node node_modules/typescript/bin/tsc && node node_modules/typescript/bin/tsc -p tsconfig.build.json && chmod 755 lib/src/sdk-ssh-wrapper.js dist/sdk-ssh-wrapper.js && node tools/build-client.mjs",
     "probe:host": "node tools/probe-host.ts",
@@ -36,7 +36,7 @@
     "zod": "4.6.7"
   },
   "devDependencies": {
-    "@ai-workbench/connect": "file:test/fixtures/ai-workbench-connect-0.7.9.tgz",
+    "@ai-workbench/connect": "file:test/fixtures/ai-workbench-connect-0.7.13.tgz",
     "@deepseek-ai/cordis": "4.0.4",
     "@deepseek-ai/cordis-plugin-group": "1.0.4",
     "@deepseek-ai/cordis-plugin-include": "1.0.9",
@@ -56,7 +56,7 @@
     "@deepseek-ai/dsh-attachment": "0.2.0-rc.2"
   },
   "peerDependencies": {
-    "@ai-workbench/connect": "~0.7.9",
+    "@ai-workbench/connect": "~0.7.13",
     "@deepseek-ai/cordis": "4.0.4",
     "@deepseek-ai/dsh-llm": "0.2.0-rc.2",
     "@deepseek-ai/dsh-typert-protocol": "0.2.0-rc.2",