@ai-workbench/remote-agent 0.8.19 → 0.8.23

package/dist/provider.js

@@ -4,8 +4,6 @@ import { loginDiagnostic, loginReason } from "./login-diagnostic.js";
 import { NeedError } from "./remote.js";
 import { CONNECTION_REQUIRED, TEST_HOST_NOTICE } from "./presentation.js";
 import { CODEX_AGENT } from "./agents.js";
-import { StageTiming } from "./stage-timing.js";
-import { confirmLegacyWorkspaceSource } from "./workspace-source.js";
 export function requireLoginCoordinator(api) {
     if (!['getConnectionState', 'getLoginPromptState', 'requestLoginPrompt', 'refreshLoginPrompts'].every(key => typeof api[key] === 'function'))
         throw new NeedError('CONNECT_API_MISMATCH', '我需要 connect-api 0.6.1 的统一登录询问与连接状态能力', 'L >=0.6.1');
@@ -138,10 +136,10 @@ export function identity(t) { return `${t.username}@${t.host}:${t.port}`; }
 /** Reject draft.3 and legacy runtime rather than inventing workspace bindings. */
 export function requireNativeWorkspace(api) {
     if (typeof api.getContractInfo !== 'function')
-        throw new NeedError('DEPENDENCY_REQUIRED', '我需要新版远程主机连接组件提供原生工作区绑定', 'L connect-api 0.7.0 / native-local-v1');
+        throw new NeedError('DEPENDENCY_REQUIRED', '我需要新版远程主机连接组件提供原生工作区绑定', 'L connect-api 0.7.0 / ensureReady / resolveSessionProject');
     const info = api.getContractInfo();
-    if (info?.apiVersion !== '0.7.0' || info.status !== 'implemented' || info.workspaceBinding !== 'native-local-v1' || !['ensureReady', 'resolveSessionProject', 'acknowledgeWorkspaceNotice'].every(key => typeof api[key] === 'function'))
-        throw new NeedError('DEPENDENCY_REQUIRED', '我需要新版远程主机连接组件提供原生工作区绑定', 'L connect-api 0.7.0 / native-local-v1');
+    if (info?.apiVersion !== '0.7.0' || info.status !== 'implemented' || !['ensureReady', 'resolveSessionProject'].every(key => typeof api[key] === 'function'))
+        throw new NeedError('DEPENDENCY_REQUIRED', '我需要新版远程主机连接组件提供原生工作区绑定', 'L connect-api 0.7.0 / ensureReady / resolveSessionProject');
 }
 /** Authorization stays in L; ensureReady only checks and records the need. */
 export async function offerLogin(connect, request, currentApi, agent = CODEX_AGENT) {
@@ -189,32 +187,20 @@ export function connectProvider(get, options = {}) {
     let employee;
     const admissions = new WeakMap();
     const preflight = async (request) => {
-        request.timing ??= new StageTiming();
         request.signal?.throwIfAborted();
         const api = get();
         if (!api)
             throw new NeedError('DEPENDENCY_REQUIRED', CONNECTION_REQUIRED, 'aiWorkbenchConnect');
         requireNativeWorkspace(api);
         requireLoginCoordinator(api);
-        if (request.mode === 'one-shot' && !agent.oneShot)
-            throw new NeedError('MODE_UNSUPPORTED', '此远程模型仅支持会话模式', '使用会话模式');
-        const confirmedSource = options.workspaceSource ? await confirmLegacyWorkspaceSource(get, api, request, options.workspaceSource) : undefined;
         let sourceStage = 'input-acceptance';
-        if (confirmedSource && !request.recordEarlyFailure)
-            request.recordEarlyFailure = (error, stage) => confirmedSource.recordFailure(error, stage);
         try {
-            confirmedSource?.assertCurrent();
             if (options.employee) {
                 const module = await import("./employee-provider.js");
-                request.localAcceptance = await module.acceptEmployeeUserTurn(get, options.employee, agent, api, request);
-            }
-            confirmedSource?.assertCurrent();
-            if (confirmedSource) {
-                const previous = request.localAdmissionCheck;
-                request.localAdmissionCheck = () => { confirmedSource.assertCurrent(); previous?.(); };
+                request.localContext = await module.inspectEmployeeWorkspace(get, options.employee, agent, api, request);
             }
             sourceStage = 'login-readiness';
-            const { target, connection } = await request.timing.run('login-ready', async () => {
+            const { target, connection } = await (async () => {
                 request.localAdmissionCheck?.();
                 const before = api.getConnectionState();
                 const target = await ensureReady(api, agent.loginProvider, request.signal);
@@ -224,11 +210,9 @@ export function connectProvider(get, options = {}) {
                     throw new NeedError('CONNECTION_LOST', '远程主机连接组件已更换', '当前员工连接');
                 const connection = await waitForLogin(api, agent.loginProvider, before, get, request.signal);
                 return { target, connection };
-            });
+            })();
             if (request.identity && request.identity !== identity(target))
                 throw new NeedError('SESSION_CONTEXT_MISMATCH', '员工主机与原会话不一致，请新建会话', '原员工主机');
-            if (options.employee && request.localAcceptance)
-                await (await import("./employee-provider.js")).validateEmployeeUserTurn(get, options.employee, api, request, connection);
             request.localAdmissionCheck?.();
             admissions.set(request, { api, target, connection });
             sourceStage = 'local-admission';
@@ -236,7 +220,6 @@ export function connectProvider(get, options = {}) {
             if (locations && (locations.phase === 'failed' || locations.phase === 'disposed') && locations.instanceId === connection.instanceId && locations.epoch === connection.epoch && locations.need)
                 throw connectNeedError(locations.need);
             await options.local?.admit?.(request, api, connection, target);
-            confirmedSource?.assertCurrent();
         }
         catch (error) {
             admissions.delete(request);
@@ -244,8 +227,6 @@ export function connectProvider(get, options = {}) {
             request.recordEarlyFailure = undefined;
             if (record)
                 await record(error, sourceStage);
-            else
-                await confirmedSource?.recordFailure(error, sourceStage);
             throw error;
         }
     };
@@ -255,16 +236,13 @@ export function connectProvider(get, options = {}) {
         const admitted = admissions.get(request);
         admissions.delete(request);
         const { api, target, connection } = admitted;
-        const stable = () => request.timing.run('connection-confirm', () => waitForLogin(api, agent.loginProvider, connection, get, request.signal));
-        await stable();
-        request.localAdmissionCheck?.();
         if (!request.sessionId)
             throw new NeedError('PROJECT_BINDING_REQUIRED', '我需要当前会话和已选择的工作区，请使用原生工作区入口', 'DSH会话与原生工作区');
-        const host = await hostWorkspaceGuard(get, api, connection, target, request, options.workspaceSource?.workspace, agent.loginProvider);
+        const host = await hostWorkspaceGuard(get, api, connection, target, request, options.workspace, agent.loginProvider);
         try {
             if (!host && options.employee) {
                 employee ??= import("./employee-provider.js").then(module => module.createEmployeeProvider(get, options, agent));
-                const local = await (await employee)({ api, target, connection, request, stable: signal => request.timing.run('connection-confirm', () => waitForLogin(api, agent.loginProvider, connection, get, signal)) });
+                const local = await (await employee)({ api, target, connection, request });
                 if (local) {
                     local.loginRequired = () => offerLogin(api, request, get, agent);
                     return local;
@@ -272,79 +250,33 @@ export function connectProvider(get, options = {}) {
             }
             if (!host && agent.loginProvider === 'claude' && options.local) {
                 const runtime = await options.local(request, api, connection, target);
-                if (runtime) {
-                    try {
-                        await stable();
-                    }
-                    catch (error) {
-                        await runtime.dispose?.();
-                        throw error;
-                    }
+                if (runtime)
                     return runtime;
-                }
             }
-            if (!host) {
-                await options.notice?.reconcile(request, api);
-                await stable();
-            }
-            const resolved = await request.timing.run('workspace-resolve', async () => host ? host.resolve() : unwrap(await awaitL(() => api.resolveSessionProject(request.sessionId, { provider: agent.loginProvider, purpose: 'user-turn' }), request.signal)));
-            await stable();
-            host?.assertCurrent();
-            if (!resolved || resolved.instanceId !== connection.instanceId || resolved.epoch !== connection.epoch)
-                throw new NeedError('CONNECTION_LOST', '工作区解析回复已失效', '当前连接代次');
-            validateTarget(resolved.target);
+            // A local source must have been handled by its employee provider above.
+            // Host execution requires an explicit host location; no name-based resolver.
+            if (!host)
+                throw new NeedError('WORKSPACE_LOCATION_REQUIRED', '请选择文件夹来源；改变来源后请新建会话。', '已选择的本机或主机文件夹');
+            const resolved = await host.resolve();
             const project = resolved.project;
-            const source = resolved.source;
-            if (resolved.sessionId !== request.sessionId || !resolved.workspaceId || !resolved.bindingId || !Number.isSafeInteger(resolved.bindingRevision) || resolved.bindingRevision < 1 || !sameTarget(target, resolved.target) || !project || (!host && (source !== undefined && source !== 'legacy-host' || typeof project.name !== 'string' || !project.name || project.name === '.' || project.name === '..' || /[\\/\x00-\x1f\x7f]/.test(project.name) || project.path !== resolved.target.projectRoot + '/' + project.name)))
-                throw new NeedError('PROJECT_BINDING_INVALID', '工作区绑定与当前会话或可信主机不一致', 'L核验的原生工作区绑定');
             if (request.cwd && request.cwd !== project.path || request.bindingId && request.bindingId !== resolved.bindingId || request.workspaceId && request.workspaceId !== resolved.workspaceId)
                 throw new NeedError(host ? 'PROJECT_BINDING_INVALID' : 'SESSION_CONTEXT_MISMATCH', host ? '文件来源已改，请新建会话继续；原会话历史仍可查看。' : '原会话的工作区绑定已改变，请新建会话', '原工作区绑定');
-            const details = await request.timing.run('details-open', async () => options.details?.(request, api, connection, target));
+            const details = await options.details?.(request, api, connection, target);
             try {
-                if (details)
-                    request.timing.bind(detail => details.record(detail));
-                await stable();
-                host?.assertCurrent();
-                let workspaceNotice = undefined;
-                const notice = !host && 'notice' in resolved ? resolved.notice : undefined;
-                if (notice) {
-                    if (!options.notice)
-                        throw new NeedError('DEPENDENCY_REQUIRED', '我需要官方会话持久记录来确认工作区说明', '官方会话与持久化服务');
-                    workspaceNotice = await request.timing.run('workspace-notice', () => options.notice.deliver(notice, resolved, request, api));
-                    await stable();
-                }
                 if (!options.open)
                     throw new NeedError('RUNTIME_REQUIRED', '我需要主机运行适配器', '主机broker适配');
-                const observedBinding = host ? undefined : api.getWorkspaceBindingState?.();
-                const validateContext = async (ignoreCancellation = false) => {
-                    const check = () => waitForLogin(api, agent.loginProvider, connection, get, ignoreCancellation ? undefined : request.signal);
-                    await check();
-                    if (host && !ignoreCancellation)
-                        await host.resolve();
-                    if (observedBinding) {
-                        const current = api.getWorkspaceBindingState();
-                        if (current.instanceId !== observedBinding.instanceId || !current.items.some(item => item.bindingId === resolved.bindingId && item.workspaceId === resolved.workspaceId && item.status === 'ready'))
-                            throw new NeedError('SESSION_CONTEXT_MISMATCH', '当前工作区绑定已改变，原会话操作未执行', '原生会话原绑定');
-                    }
-                    await check();
-                    if (!ignoreCancellation)
-                        host?.assertCurrent();
-                };
-                host?.assertCurrent();
-                const runtime = await options.open(resolved.target, project, { ...request, ...(host ? { signal: host.signal } : {}), agent, bindingId: resolved.bindingId, workspaceId: resolved.workspaceId, bindingRevision: resolved.bindingRevision, detailChannel: details, validateContext });
+                const runtime = await options.open(resolved.target, project, { ...request, ...(host ? { signal: host.signal } : {}), agent, bindingId: resolved.bindingId, workspaceId: resolved.workspaceId, bindingRevision: resolved.bindingRevision, detailChannel: details });
                 try {
-                    await stable();
                     host?.observeRuntime(runtime);
                 }
                 catch (error) {
-                    await runtime.dispose?.();
+                    void runtime.dispose?.().catch(() => console.warn('HOST_CLEANUP_FAILED'));
                     throw error;
                 }
                 if (host)
                     retainHostScope(runtime, host);
                 runtime.hostWorkspace = host && 'directory' in resolved ? Object.freeze({ cwd: resolved.directory.path }) : undefined;
                 // The transport can outlive a turn; presentation belongs only to this invocation.
-                runtime.workspaceNotice = workspaceNotice || undefined;
                 runtime.details = details ?? runtime.details;
                 runtime.binding = { bindingId: resolved.bindingId, workspaceId: resolved.workspaceId, revision: resolved.bindingRevision };
                 runtime.connection = { ...connection };
@@ -352,13 +284,6 @@ export function connectProvider(get, options = {}) {
                 return runtime;
             }
             catch (error) {
-                try {
-                    await details?.flush();
-                }
-                catch (diagnostic) {
-                    const code = (value) => value instanceof NeedError && /^[A-Z][A-Z0-9_]*$/.test(value.code) ? value.code : 'UNKNOWN_FAILURE';
-                    throw new NeedError('CONVERSATION_DETAILS_FAILED', '技术详情未能保存；本轮已停止', `原错误代码 ${code(error)}；诊断错误代码 ${code(diagnostic)}`);
-                }
                 throw error;
             }
         }

package/dist/readiness.js

@@ -39,12 +39,6 @@ import { unwrap, awaitL, requireLoginCoordinator, requireLoginState } from "./pr
 import { NeedError } from "./remote.js";
 import { CONNECTION_REQUIRED, employeeFailure } from "./presentation.js";
 import { CODEX_AGENT } from "./agents.js";
-function details(target) {
-    const h = target.hostContext;
-    if (!h)
-        return [];
-    return [{ label: '主机配置', value: h.enforcement }, { label: '检查退出码', value: String(h.checkExitCode) }, ...h.failedChecks.map(item => ({ label: '未通过检查', value: `${item.id}（${item.status}）` })), ...h.unverifiedChecks.map(item => ({ label: '未核实检查', value: `${item.id}（${item.status}）` }))];
-}
 function blocked(code, technical = [], agent = CODEX_AGENT) {
     return { phase: 'blocked', loginStatus: 'unknown', title: `无法确认 ${agent.name.zh} 登录状态`, message: employeeFailure(code, agent.loginProvider), technical: [...technical, { label: '诊断代码', value: code }] };
 }
@@ -61,7 +55,7 @@ function snapshot(api, agent = CODEX_AGENT) {
     if (!connection.instanceId || state.instanceId !== connection.instanceId)
         return denied('AUTH_STATUS_INVALID', [diagnostic('LOGIN_INSTANCE_MISMATCH')]);
     requireLoginState(state);
-    const technical = details({ hostContext: state.technicalDetails?.hostContext });
+    const technical = [];
     if (state.phase === 'blocked' || state.phase === 'disposed')
         return denied(state.technicalDetails?.code ?? 'AUTH_STATUS_INVALID', [...technical, diagnostic(state.phase === 'disposed' ? 'LOGIN_PHASE_DISPOSED' : 'LOGIN_PHASE_BLOCKED')]);
     if (state.queuedProviders?.includes(brand) || state.checkingProviders.includes(brand) || state.phase === 'authorizing' && state.provider === brand)

package/dist/remote-details.d.ts

@@ -1,9 +1,30 @@
-import { type DetailObservation } from './conversation-details.ts';
+import { type DetailObservation, type JsonValue } from './conversation-details.ts';
 import type { LoginDiagnostic } from './login-diagnostic.ts';
-import type { ConnectApi as LConnectApi, ConnectionState } from '@ai-workbench/connect/api';
-export type { RemoteConversationDetail as RemoteDetail } from '@ai-workbench/connect/api';
-type Connection = Pick<ConnectionState, 'instanceId' | 'epoch' | 'phase'>;
-export type RemoteDetailsApi = Pick<LConnectApi, 'getConnectionState'> & Partial<Pick<LConnectApi, 'getContractInfo' | 'appendRemoteConversationDetail' | 'getRemoteConversationDetailReceipt' | 'listRemoteConversationDetails' | 'appendLoginDiagnostic' | 'getLoginDiagnosticReceipt' | 'listLoginDiagnostics'>>;
+type Connection = {
+    instanceId: string;
+    epoch: number;
+    phase: string;
+};
+export interface RemoteDetail {
+    version: 1;
+    eventId: string;
+    instanceId: string | null;
+    epoch: number | null;
+    sessionId: string;
+    provider: 'claude' | 'codex';
+    turn: string | number | null;
+    step: string | number | null;
+    sequence: number;
+    kind: string;
+    severity: 'info' | 'warning' | 'action-required';
+    code: string;
+    summary: string;
+    method?: string;
+    payload: JsonValue;
+}
+export interface RemoteDetailsApi {
+    getConnectionState(): Connection;
+}
 export interface DetailChannel {
     record(observation: DetailObservation): void;
     beginTurn(ids: {
@@ -11,26 +32,31 @@ export interface DetailChannel {
         step: string | number | null;
     }): void;
     endTurn(): void;
-    flush(): Promise<void>;
 }
 export interface DetailRequest {
     sessionId: string;
     provider: 'claude' | 'codex';
     identity: string;
-    connection: Connection;
-    readonly localAcceptanceId?: string;
+    connection?: Connection;
 }
 export declare function privateDirectory(path: string): Promise<void>;
-export declare function durableWrite(path: string, value: unknown): Promise<void>;
-export declare function readJournal(path: string): Promise<unknown>;
 export interface DiagnosticBinding {
     api: RemoteDetailsApi | undefined;
     connection: Connection | undefined;
 }
+/** Diagnostics are best effort. No delivery journal, receipt lookup, replay or turn gate. */
 export declare function createRemoteDetails(options: {
-    profileDir: string;
-    getApi: () => RemoteDetailsApi | undefined;
+    profileDir?: string;
+    getApi?: () => unknown;
+    warn?: (line: string) => void;
 }): {
+    /** Await queued best-effort writes only when releasing the profile, never before dispatch. */
+    dispose(): Promise<void>;
+    releaseSession(sessionId: string): void;
+    read(query: {
+        sessionId: string;
+        provider: "claude" | "codex";
+    }): Promise<RemoteDetail[]>;
     recordLocalFailure(request: {
         sessionId?: string;
         provider: "claude" | "codex";
@@ -46,8 +72,7 @@ export declare function createRemoteDetails(options: {
             step: string | number | null;
         };
     }): Promise<{
-        eventId: string;
-        recorded: true;
+        eventId: `${string}-${string}-${string}-${string}-${string}`;
     }>;
     recordPreflightCheck(request: {
         sessionId?: string;
@@ -58,10 +83,9 @@ export declare function createRemoteDetails(options: {
             step: string | number | null;
         };
         binding?: DiagnosticBinding;
-        assertScope?: () => void;
     }): Promise<{
-        eventId: string;
-        recorded: true;
+        eventId: `${string}-${string}-${string}-${string}-${string}`;
     }>;
     open(request: DetailRequest): Promise<DetailChannel>;
 };
+export {};