@ai-workbench/remote-agent 0.8.28 → 0.8.29

package/README.md

@@ -1,10 +1,10 @@
-# AI Workbench 远程助手 · @ai-workbench/remote-agent@0.8.28 · 插件 → 添加插件
+# AI Workbench 远程助手 · @ai-workbench/remote-agent@0.8.29 · 插件 → 添加插件
 
 通过官方 DSH 插件入口使用 Claude（远程主机）与 Codex（远程主机）。登录和工作区来源由“远程主机连接”组件提供；员工在原生工作区和模型菜单中选择文件夹与型号。
 
 文件和命令在所选的本机或主机目录执行，订阅凭据留在主机。插件不改写 DSH 的默认模型，不为员工创建同名主机目录，已有主机会话只提取一次原有主机来源并保存。
 
-需要远程主机连接组件 0.7.29 或更新的 0.7.x，以及联网助手 0.4.9。主机来源保存于官方 storage.domain 的会话元数据表，每轮仅由连接组件检查一次主机目录，不检查本机占位目录。
+需要远程主机连接组件 0.7.29 或更新的 0.7.x、联网助手 0.4.9，以及支持公开会话归属接口的主机组件 S0.4.26。主机来源保存于官方 storage.domain 的会话元数据表，每轮仅由连接组件检查一次主机目录，不检查本机占位目录。
 
 Claude 本机 Bash 会单独消费员工桥代理的控制诊断，不把它交给模型当作命令输出；真实传输中断仍提示结果未知。命令自身的标准输出、标准错误与退出码照常返回。
 
@@ -16,7 +16,7 @@ Claude 本机 Bash 会单独消费员工桥代理的控制诊断，不把它交
 
 同一 DSH 会话切换 Claude/Codex 时，切回会接本品牌最近的远端会话，并补充它尚未见过的可见对话；首次使用某品牌则带入全部可见历史。工具内部状态、推理和技术详情不转交。历史超出既有 `acpMaxMessageBytes` 容量时，只带能容纳的最近完整轮，并在技术详情说明省略数量；当前输入保持完整，超限仍明确失败。没有新增设置、重试或时限。
 
-断线会结束本轮；已派发的操作可能已部分执行，请先检查文件。恢复连接后可在原会话继续。旧进程清理和技术详情记录尽力而为，不阻止发起下一轮；如果上一轮仍占用原生线程，续接会明确失败并说明本轮输入未发送，不新建替代线程。自动定位、清理同一会话/线程的已断开旧进程仍需 S 提供公开能力，当前不会自动杀旧进程或冒称已恢复。原生本机会话恢复的兼容性及实际设备结果见本轮交付证据，未验证项不作为已通过。
+断线会结束本轮；已派发的操作可能已部分执行，请先检查文件。恢复连接后可在原会话继续。旧进程清理和技术详情记录尽力而为，不阻止发起下一轮。续接明确遇到原线程被占用时，使用 S0.4.26 的会话归属和原子结束接口：只有唯一匹配的旧进程确实已断开、主机明确确认退出后，才接回同一线程一次；不会新建替代线程、重发用户输入或抢占活跃会话。旧版无归属进程不能安全清理，需等待主机按现有策略回收；失败或释放结果未知则说明本轮输入未发送。原生本机会话恢复的兼容性及实际设备结果见本轮交付证据，未验证项不作为已通过。
 
 DSH 启动和打开模型菜单时读取一次主机型号列表。发送时不再查询目录或预核所选型号；所选型号不可用时，请在模型菜单重新选择。
 

package/dist/acp.d.ts

@@ -6,6 +6,7 @@ import type { BrokerTransport } from './broker.ts';
 import { type SanitizedObservation } from './conversation-details.ts';
 import { type ModelConfigurationSnapshot } from './model-configuration.ts';
 import type { EmployeeRouting } from './employee-relay.ts';
+import type { SessionOwnership } from './broker-ownership.ts';
 export type ApprovalOutcome = 'allowed-once' | 'rejected' | 'cancelled' | 'unavailable';
 export interface AcpHooks {
     closeDiagnostics?: CloseDiagnostics;
@@ -25,6 +26,7 @@ export interface AcpHooks {
     onEmployeeNotice?: (notice: string) => void;
     onDetail?: (detail: Readonly<SanitizedObservation>) => void;
     broker?: BrokerTransport;
+    sessionOwnership?: SessionOwnership;
     employeeExecution?: (params: unknown, signal?: AbortSignal) => Promise<Record<string, unknown>>;
 }
 export interface EmployeeExecutionMeta {

package/dist/acp.js

@@ -1,6 +1,6 @@
 import { employeeExecutionInfo, employeeMcpSummary, employeeHttpNotice } from "./employee-info.js";
 import { employeeAdapterCodes, employeeOpenCauseCodes } from "./employee-reasons.js";
-import { CloseDiagnostics, withFirstFailureEvidence } from "./close-diagnostics.js";
+import { CloseDiagnostics, closeCode, withFirstFailureEvidence } from "./close-diagnostics.js";
 import * as acp from '@agentclientprotocol/sdk/unstable';
 import { NeedError } from "./remote.js";
 import { employeeFailure } from "./presentation.js";
@@ -505,17 +505,37 @@ export class AcpSession {
             this.employeeRouting = routing;
             const params = { cwd, mcpServers: routing ? structuredClone(routing.mcpServers) : [], ...((routing || this.employeeMeta) ? { _meta: { ...(this.employeeMeta ? { awEmployeeExecution: this.employeeMeta } : {}), ...(routing ? { claudeCode: { options: employeeClaudeOptions(routing) } } : {}) } } : {}), ...(systemPrompt && !(resumeId && this.codexNewSessionOnly) ? { systemPrompt: { mode: 'append', content: [{ type: 'text', text: systemPrompt }] } } : {}) };
             const configRevision = this.resetConfiguration();
+            const restore = async (operation) => {
+                try {
+                    return await operation();
+                }
+                catch (error) {
+                    if (!resumeId || acpNeed(error).code !== 'REMOTE_SESSION_BUSY' || !this.hooks.sessionOwnership)
+                        throw error;
+                    this.detail({ kind: 'session', severity: 'info', code: 'REMOTE_SESSION_BUSY', summary: '原远端会话被占用，正在核对同一会话与线程的已断开旧进程；尚未发送用户输入。' });
+                    try {
+                        await this.hooks.sessionOwnership.stopDetached(resumeId, signal);
+                        signal?.throwIfAborted();
+                    }
+                    catch (failure) {
+                        this.detail({ kind: 'session', severity: 'warning', code: 'REMOTE_SESSION_RELEASE_UNCONFIRMED', summary: '旧会话释放未获确认，本轮没有再次接续或发送用户输入。', payload: { reason: failure instanceof NeedError ? failure.requires : closeCode(failure, 'BROKER_CONTROL_FAILED') } });
+                        throw failure;
+                    }
+                    this.detail({ kind: 'session', severity: 'info', code: 'REMOTE_SESSION_RELEASE_CONFIRMED', summary: '主机已确认原会话的已断开旧进程退出，继续接回同一远端会话一次。' });
+                    return operation(); // Exactly one continuation, only after the explicit release receipt.
+                }
+            };
             if (resumeId) {
                 this.sessionId = resumeId;
                 if (this.negotiated.sessionCapabilities?.resume) {
-                    const result = await this.stage('acp-session-resume', () => this.connection.agent.request(acp.methods.agent.session.resume, { ...params, sessionId: resumeId }, { cancellationSignal: signal }));
+                    const result = await restore(() => this.stage('acp-session-resume', () => this.connection.agent.request(acp.methods.agent.session.resume, { ...params, sessionId: resumeId }, { cancellationSignal: signal })));
                     this.lifecycleConfiguration(result, configRevision);
                     this.method = acp.methods.agent.session.resume;
                 }
                 else {
                     if (!this.negotiated.loadSession)
                         throw new NeedError('RESUME_UNSUPPORTED', '远端未声明会话恢复或加载能力，不能恢复原会话', '支持 session/resume 或 session/load 的 agent');
-                    const result = await this.stage('acp-session-load', () => this.connection.agent.request(acp.methods.agent.session.load, { ...params, sessionId: resumeId }, { cancellationSignal: signal }));
+                    const result = await restore(() => this.stage('acp-session-load', () => this.connection.agent.request(acp.methods.agent.session.load, { ...params, sessionId: resumeId }, { cancellationSignal: signal })));
                     this.lifecycleConfiguration(result, configRevision);
                     this.method = acp.methods.agent.session.load;
                 }
@@ -528,6 +548,7 @@ export class AcpSession {
                 this.lifecycleConfiguration(result, configRevision);
                 this.method = acp.methods.agent.session.new;
             }
+            await this.hooks.sessionOwnership?.bind(this.sessionId, signal);
             this.ready = true;
             this.cwd = cwd;
             this.systemPrompt = systemPrompt ?? '';

package/dist/broker-ownership.d.ts

@@ -0,0 +1,10 @@
+import { type BrokerIo } from './broker.ts';
+export interface SessionOwnership {
+    bind(remoteSessionId: string, signal?: AbortSignal): Promise<void>;
+    stopDetached(remoteSessionId: string, signal?: AbortSignal): Promise<void>;
+}
+/** S0426 public control only: no process/lock scans or client ownership journal. */
+export declare function brokerOwnership(io: BrokerIo, command: (args: string[]) => string, started: {
+    id: string;
+    instanceId: string;
+}, receipt: unknown, dshSessionId: string, provider: 'codex' | 'claude'): SessionOwnership;

package/dist/broker-ownership.js

@@ -0,0 +1,59 @@
+import { controlJson } from "./broker.js";
+import { NeedError } from "./remote.js";
+import { closeCode } from "./close-diagnostics.js";
+const record = (v) => v !== null && typeof v === 'object' && !Array.isArray(v) ? v : undefined;
+const line = (v) => typeof v === 'string' && v.length > 0 && !/[\r\n\0]/.test(v);
+const same = (value, expected) => { const row = record(value); return row?.dshSessionId === expected.dshSessionId && row.provider === expected.provider && row.remoteSessionId === expected.remoteSessionId; };
+const busy = (reason) => new NeedError('REMOTE_SESSION_BUSY', '原会话仍被上一轮占用，本轮输入未发送。', '已断开旧会话的安全释放尚未确认；' + reason + (reason === 'OWNERSHIP_NOT_FOUND_OR_LEGACY' ? '；没有可证明归属的旧会话，不结束任何旧进程，请等待主机按现有策略回收。' : ''));
+/** S0426 public control only: no process/lock scans or client ownership journal. */
+export function brokerOwnership(io, command, started, receipt, dshSessionId, provider) {
+    let owner = { dshSessionId, provider, remoteSessionId: null };
+    const initial = record(receipt);
+    if (!line(dshSessionId) || initial?.ownershipProtocolVersion !== 1 || !same(initial.ownership, owner))
+        throw new NeedError('BROKER_OWNERSHIP_UNAVAILABLE', '主机会话缺少归属能力，本轮输入未发送；请联系管理员更新主机组件。', 'S >=0.4.26 / ownershipProtocolVersion:1');
+    const flags = (value) => ['--dsh-session-id', value.dshSessionId, '--provider', value.provider, '--remote-session-id', value.remoteSessionId];
+    const confirmed = (value, id, instanceId, expected) => value?.id === id && value.instanceId === instanceId && value.ownershipProtocolVersion === 1 && same(value.ownership, expected);
+    return {
+        async bind(remoteSessionId, signal) {
+            signal?.throwIfAborted();
+            if (!line(remoteSessionId))
+                throw new NeedError('BROKER_OWNERSHIP_INVALID', '远端会话编号无法绑定，本轮输入未发送。', 'S0426单行原生会话编号');
+            const next = { ...owner, remoteSessionId };
+            const value = record(controlJson(await io.run(command(['bind', started.id, '--if-instance', started.instanceId, ...flags(next), ...(owner.remoteSessionId === null ? [] : ['--if-remote-session-id', owner.remoteSessionId])]), signal)));
+            signal?.throwIfAborted();
+            if (value?.type !== 'bound' || !confirmed(value, started.id, started.instanceId, next))
+                throw new NeedError('BROKER_OWNERSHIP_UNCONFIRMED', '主机未确认会话归属，本轮输入未发送。', 'S0426精确归属绑定回执');
+            owner = next;
+        },
+        async stopDetached(remoteSessionId, signal) {
+            try {
+                signal?.throwIfAborted();
+                if (!line(remoteSessionId))
+                    throw busy('OWNERSHIP_INVALID');
+                const wanted = { ...owner, remoteSessionId };
+                const entries = controlJson(await io.run(command(['list']), signal));
+                signal?.throwIfAborted();
+                if (!Array.isArray(entries) || entries.some(row => !record(row)))
+                    throw busy('OWNERSHIP_LIST_INVALID');
+                const matches = entries.map(record).filter(row => same(row?.ownership, wanted));
+                if (matches.length !== 1)
+                    throw busy(matches.length ? 'OWNERSHIP_AMBIGUOUS' : 'OWNERSHIP_NOT_FOUND_OR_LEGACY');
+                const row = matches[0];
+                if (row.id === started.id || !line(row.id) || !line(row.instanceId) || row.ownershipProtocolVersion !== 1)
+                    throw busy('OWNERSHIP_UNAVAILABLE');
+                const lifecycle = record(row.lifecycle);
+                if (!['running', 'exited'].includes(row.state) || lifecycle?.attached !== false || !line(lifecycle.detachedAt))
+                    throw busy('SESSION_NOT_DETACHED');
+                const value = record(controlJson(await io.run(command(['stop-detached', row.id, '--if-instance', row.instanceId, ...flags(wanted)]), signal)));
+                signal?.throwIfAborted();
+                if (value?.type !== 'killed' || !confirmed(value, row.id, row.instanceId, wanted) || value.agentExited !== true || value.processGroupExited !== true)
+                    throw busy('STOP_UNCONFIRMED');
+            }
+            catch (error) {
+                if (error instanceof NeedError && error.code === 'REMOTE_SESSION_BUSY')
+                    throw error;
+                throw busy(closeCode(error, 'BROKER_CONTROL_FAILED'));
+            }
+        },
+    };
+}

package/dist/broker-runtime.js

@@ -12,6 +12,7 @@ import { BrokerTransport, brokerCommand, brokerId, sshIo, controlJson } from "./
 import { CODEX_AGENT } from "./agents.js";
 import { NeedError } from "./remote.js";
 import { identity } from "./provider.js";
+import { brokerOwnership } from "./broker-ownership.js";
 /** Each invocation owns a new agent. Context resumes by native session ID, never by reattaching a broker. */
 export function brokerFactory(_get, _ask, configuration, provided) {
     return async (target, project, request) => {
@@ -25,7 +26,7 @@ export function brokerFactory(_get, _ask, configuration, provided) {
         const command = (args) => brokerCommand(target, args);
         const diagnostics = request.closeDiagnostics ?? new CloseDiagnostics(detail => request.detailChannel?.record(detail));
         const id = brokerId(request.sessionId + '/' + randomUUID(), agent.id);
-        const startCommand = command(['start', id, '--cwd', project.path, '--settings', target.session.settingsPath, '--', agent.command]);
+        const startCommand = command(['start', id, '--cwd', project.path, '--settings', target.session.settingsPath, '--dsh-session-id', request.sessionId, '--provider', agent.loginProvider, '--', agent.command]);
         // environments.toml overrides CODEX_EXEC_SERVER_URL. Refuse that host default rather
         // than allowing a local-workspace resume to select a host executor.
         const employeeStart = request.employeeScope && agent.loginProvider === 'codex';
@@ -47,7 +48,9 @@ export function brokerFactory(_get, _ask, configuration, provided) {
         };
         const aborted = () => channel.fail(new NeedError('ABORTED', '本轮已取消。', '确认主机状态'), { layer: 'broker', initiator: 'broker.open-signal', reason: 'ABORTED', action: 'abort' });
         request.signal?.addEventListener('abort', aborted, { once: true });
+        let sessionOwnership;
         try {
+            sessionOwnership = brokerOwnership(io, command, { id, instanceId: started.instanceId }, started, request.sessionId, agent.loginProvider);
             request.signal?.throwIfAborted();
             await channel.connect();
         }
@@ -58,6 +61,6 @@ export function brokerFactory(_get, _ask, configuration, provided) {
         finally {
             request.signal?.removeEventListener('abort', aborted);
         }
-        return { identity: identity(target), cwd: project.path, closeDiagnostics: diagnostics, broker: channel, acpTransport: channel, dispose, detach: dispose };
+        return { identity: identity(target), cwd: project.path, closeDiagnostics: diagnostics, broker: channel, sessionOwnership, acpTransport: channel, dispose, detach: dispose };
     };
 }

package/dist/index.js

@@ -363,7 +363,7 @@ export class CodexRemoteAdapter extends LlmAdapter {
                 let failure;
                 const push = (chunks) => { queue.push(...chunks); wake?.(); wake = undefined; };
                 let promptPermit;
-                const hooks = { closeDiagnostics: runtime.closeDiagnostics, broker: runtime.broker, employeeExecution: runtime.employeeExecution, ...this.permissions ? { promptGuard: () => {
+                const hooks = { closeDiagnostics: runtime.closeDiagnostics, broker: runtime.broker, sessionOwnership: runtime.sessionOwnership, employeeExecution: runtime.employeeExecution, ...this.permissions ? { promptGuard: () => {
                             if (!promptPermit)
                                 throw new NeedError('PERMISSION_POLICY_CHANGED', '当前权限没有保持确认，本次没有继续派发。', '当前权限代次和同值回执');
                             return promptPermit;

package/dist/presentation.js

@@ -42,6 +42,9 @@ export function employeeFailure(code, brand = 'codex', promptDispatched = true)
         POLICY_DENIED: '这个账号暂时不能使用，请联系公司账号管理员。',
         SESSION_CONTEXT_MISMATCH: '远程主机连接已改变，请重新开始本次检查。',
         REMOTE_SESSION_BUSY: '原会话仍被主机上的上一轮占用，' + (promptDispatched ? '本轮请求未能完成' : '本轮输入未发送') + '；请稍后在原会话重新发送。若持续占用，请联系管理员检查上一轮主机会话。',
+        BROKER_OWNERSHIP_UNAVAILABLE: '主机会话组件缺少安全续接能力，本轮输入未发送；请联系管理员更新主机组件。',
+        BROKER_OWNERSHIP_UNCONFIRMED: '主机尚未确认这条会话的归属，本轮输入未发送；请检查远程主机连接后在原会话重试。',
+        BROKER_OWNERSHIP_INVALID: '远端会话编号无法确认，本轮输入未发送；请联系管理员查看技术详情。',
         ABORTED: promptDispatched ? '本轮已停止。操作可能已部分执行，请先确认文件；恢复连接后可在原会话继续。' : '本轮已停止，本轮输入未发送；恢复连接后可在原会话重新发送。',
         CONFIRMATION_REQUIRED: '请先选择是否打开授权窗口。',
         CONTEXT_UNSUPPORTED: '远程 Codex 暂不支持这类会话内容，请联系管理员。',

package/dist/provider.d.ts

@@ -14,6 +14,7 @@ import type { SourceAdmissionStage } from './workspace-source.ts';
 import type { LocalWorkspaceContext } from '@ai-workbench/connect/api';
 import type { EmployeeRouting } from './employee-relay.ts';
 import type { HostWorkspacePresentation } from './input.ts';
+import type { SessionOwnership } from './broker-ownership.ts';
 export interface EmployeeExecution {
     hostCwd: string;
     routing: EmployeeRouting;
@@ -37,6 +38,7 @@ export interface Runtime {
         readable: ReadableStream<Uint8Array>;
     } | AgentApp | ExtendedAgentApp;
     broker?: BrokerTransport;
+    sessionOwnership?: SessionOwnership;
     loginRequired?: () => Promise<void>;
     dispose?: (cause?: CloseCause) => Promise<void>;
     binding?: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-workbench/remote-agent",
-  "version": "0.8.28",
+  "version": "0.8.29",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",