@ai-workbench/remote-agent 0.0.0-stage → 0.8.1

package/dist/workspace-notice.js

@@ -0,0 +1,273 @@
+import { SessionId } from '@deepseek-ai/dsh-session';
+import { BlockAssembler, expandAssistantStream } from '@deepseek-ai/dsh-llm';
+import { isDeepStrictEqual } from 'node:util';
+import { AGENTS } from "./agents.js";
+import { NeedError } from "./remote.js";
+const object = (value) => value !== null && typeof value === 'object' && !Array.isArray(value) && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
+const string = (value) => typeof value === 'string' && value.length > 0;
+const workspaceName = (value) => string(value) && value !== '.' && value !== '..' && !/[\u0000-\u001f\u007f/\\]/u.test(value);
+function noticeText(name) {
+    // The native reply renderer accepts Markdown; escape the precise verified name as ordinary text.
+    return `此工作区对应远程主机上的 ${name.replace(/[\\`*_{}\[\]()<>#+.!|~-]/gu, '\\$&')}；本地文件不会自动上传。`;
+}
+function rawMarker(message) {
+    if (!object(message) || !object(message.source) || !object(message.source.replayState) || !object(message.source.replayState.response))
+        return;
+    return message.source.replayState.response;
+}
+export function parseWorkspaceNoticeMarker(message) {
+    if (!object(message) || message.role !== 'assistant' || !string(message.id) || !object(message.source))
+        return;
+    const source = message.source, marker = rawMarker(message), definition = AGENTS.find(item => item.id === source.provider);
+    if (!object(source.replayState) || Object.keys(source.replayState).some(key => key !== 'response'))
+        return;
+    if (!marker || !definition || source.kind !== 'model' || !string(source.model) || marker.kind !== 'workspace-notice' || marker.version !== 1
+        || marker.provider !== definition.id || marker.loginProvider !== definition.loginProvider
+        || !['sessionId', 'noticeId', 'claimId', 'deliveryId', 'messageId', 'bindingId', 'workspaceId'].every(key => string(marker[key]))
+        || marker.messageId !== message.id || marker.deliveryId !== message.id || !workspaceName(marker.workspaceName)
+        || !Array.isArray(message.content) || message.content.length !== 1 || !object(message.content[0])
+        || message.content[0].type !== 'text' || message.content[0].text !== noticeText(marker.workspaceName))
+        return;
+    return marker;
+}
+/** Only this plugin's complete, source-bound notice may be excluded from remote model history. */
+export function isWorkspaceNoticeMessage(message) { return parseWorkspaceNoticeMarker(message) !== undefined; }
+function rawPresentation(message) {
+    const response = rawMarker(message), presentation = response && object(response.presentation) ? response.presentation : undefined;
+    return presentation && object(presentation.workspaceNotice) ? presentation.workspaceNotice : undefined;
+}
+function shape(value) {
+    if (!object(value))
+        return false;
+    const agent = AGENTS.find(a => a.id === value.provider);
+    return !!agent && value.kind === 'workspace-notice' && value.version === 2 && value.loginProvider === agent.loginProvider
+        && ['sessionId', 'noticeId', 'claimId', 'bindingId', 'workspaceId'].every(k => string(value[k])) && workspaceName(value.workspaceName)
+        && Number.isSafeInteger(value.turn) && value.turn > 0 && Number.isSafeInteger(value.step) && value.step > 0
+        && value.blockIndex === 0 && value.text === noticeText(value.workspaceName) + '\n\n';
+}
+export function workspaceNoticeFromMessage(message) {
+    if (!object(message) || message.role !== 'assistant' || !object(message.source) || message.source.kind !== 'model')
+        return;
+    const marker = rawPresentation(message), pointer = rawMarker(message);
+    if (!shape(marker) || message.source.provider !== marker.provider || pointer?.agent !== marker.provider || pointer.dshSessionId !== marker.sessionId
+        || pointer.bindingId !== marker.bindingId || pointer.workspaceId !== marker.workspaceId || !Array.isArray(message.content))
+        return;
+    const block = message.content[marker.blockIndex];
+    if (!object(block) || block.type !== 'text' || block.text !== marker.text)
+        return;
+    return marker;
+}
+/** Preserve the model answer and exact remote replay pointer; ordinary text is never searched. */
+export function withoutWorkspaceNotice(message) {
+    const marker = workspaceNoticeFromMessage(message);
+    if (!marker)
+        return message;
+    return { ...message, content: message.content.filter((_block, index) => index !== marker.blockIndex) };
+}
+function unknown(cause) {
+    return Object.assign(new NeedError('PROJECT_NOTICE_DELIVERY_UNKNOWN', '工作区说明的最终回复持久回执无法核对；请联系管理员核对，本次未继续派发远端请求。', '完整的官方最终会话记录和L工作区说明回执'), cause === undefined ? {} : { cause });
+}
+function requireServices(ctx, request) {
+    const id = string(request.sessionId) ? SessionId(request.sessionId) : undefined;
+    const registry = ctx.get('agents'), store = ctx.get('sessions'), persistence = ctx.get('sessionPersistence');
+    const live = id && typeof registry?.get === 'function' ? registry.get(id) : undefined, session = live?.session;
+    if (!id || !live || live.id !== id || !session || session.id !== id || typeof store?.get !== 'function' || store.get(id) !== session
+        || typeof session.snapshotEvents !== 'function' || typeof session.append !== 'function' || typeof store.flush !== 'function' || typeof persistence?.open !== 'function') {
+        throw new NeedError('DEPENDENCY_REQUIRED', '我需要当前真实会话及官方持久化读取能力，才能确认工作区说明；本次未启动远端。', 'DSH agents、sessions、sessionPersistence公共能力');
+    }
+    return { session, flush: () => store.flush(session), persistence };
+}
+function requireAcknowledge(api) {
+    const method = api.acknowledgeWorkspaceNotice;
+    if (typeof method !== 'function')
+        throw new NeedError('DEPENDENCY_REQUIRED', '我需要工作区说明回执能力；本次未启动远端。', 'L acknowledgeWorkspaceNotice公共接口');
+    return method.bind(api);
+}
+function receipt(marker, outcome, deliveryId) {
+    const base = { noticeId: marker.noticeId, surface: 'provider', claimId: marker.claimId, sessionId: marker.sessionId, provider: marker.loginProvider };
+    if (outcome === 'delivered' && string(deliveryId))
+        return { ...base, outcome, deliveryId };
+    return { ...base, outcome: 'unknown' };
+}
+async function acknowledge(method, value) {
+    const result = await method(value);
+    if (!object(result) || result.ok !== true)
+        throw unknown(result);
+}
+async function reportUnknown(api, marker, cause) {
+    let failure = cause;
+    try {
+        await acknowledge(requireAcknowledge(api), receipt(marker, 'unknown'));
+    }
+    catch (error) {
+        failure = new AggregateError([cause, error], '说明核对和未知状态记录均未完成');
+    }
+    throw unknown(failure);
+}
+async function readDurable(services) {
+    if (!await services.flush())
+        throw unknown();
+    const handle = await services.persistence.open(services.session.id, 'read');
+    try {
+        if (!handle || handle.id !== services.session.id || handle.header?.id !== services.session.id || handle.access !== 'read' || typeof handle.read !== 'function' || typeof handle.close !== 'function')
+            throw unknown();
+        const result = await handle.read();
+        if (!result || !Array.isArray(result.events))
+            throw unknown();
+        return result.events;
+    }
+    finally {
+        if (typeof handle?.close === 'function')
+            await handle.close();
+    }
+}
+function validateFinal(event, marker, events) {
+    if (event.surfaceOp !== 'append' || event.data.interrupted === true || !Array.isArray(event.data.stream)
+        || event.data.turn !== marker.turn || event.data.step !== marker.step || !isDeepStrictEqual(workspaceNoticeFromMessage(event.data.message), marker))
+        throw unknown();
+    // Chat renders the last final for a step. An earlier append is not enough.
+    if (events.some(e => e.type === 'assistant/message' && e.surfaceOp === 'append' && e.seq > event.seq && e.data.turn === marker.turn && e.data.step === marker.step))
+        throw unknown();
+    const assembler = new BlockAssembler();
+    for (const member of expandAssistantStream(event.data.stream))
+        assembler.push(member.chunk);
+    if (!['stop', 'max-tokens'].includes(assembler.finish.kind) || !isDeepStrictEqual(assembler.blocks(), event.data.message.content)
+        || !isDeepStrictEqual(assembler.replayState, event.data.message.source.replayState))
+        throw unknown();
+}
+function activeRequest(session, agent) {
+    let turn, step, provider;
+    for (const event of session.snapshotEvents())
+        switch (event.type) {
+            case 'turn/start':
+                turn = event.data.turn;
+                step = undefined;
+                break;
+            case 'turn/end':
+                turn = undefined;
+                step = undefined;
+                break;
+            case 'step/start':
+                if (event.data.turn !== turn)
+                    throw unknown();
+                step = event.data.step;
+                break;
+            case 'step/end':
+                step = undefined;
+                break;
+            case 'request/header':
+                provider = event.data.header.config.provider;
+                break;
+        }
+    if (!Number.isSafeInteger(turn) || turn < 1 || !Number.isSafeInteger(step) || step < 1 || provider !== agent.id)
+        throw unknown();
+    return { turn: turn, step: step };
+}
+export function createWorkspaceNoticeConsumer(ctx, agent) {
+    const pending = new Map();
+    const flights = new Map();
+    const failures = new Map();
+    const verify = async (sessionId, api, marker, event) => {
+        try {
+            const services = requireServices(ctx, { mode: 'session', sessionId }), events = await readDurable(services);
+            const current = event ? events.find(e => e.seq === event.seq) : undefined;
+            if (!event || current?.type !== 'assistant/message' || !isDeepStrictEqual(current, event))
+                throw unknown();
+            validateFinal(current, marker, events);
+            await acknowledge(requireAcknowledge(api), receipt(marker, 'delivered', current.data.message.id));
+            pending.delete(sessionId);
+            failures.delete(sessionId);
+        }
+        catch (error) {
+            return reportUnknown(api, marker, error);
+        }
+    };
+    ctx.on('session/event', (session, event) => {
+        const preparation = pending.get(session.id);
+        if (!preparation)
+            return;
+        const { marker, api } = preparation;
+        let relevant;
+        if (event.type === 'assistant/message' && event.data.turn === marker.turn && event.data.step === marker.step && event.data.message.source.provider === agent.id)
+            relevant = event;
+        else if (event.type === 'turn/end' && event.data.turn === marker.turn && !session.snapshotEvents().some(e => e.type === 'assistant/message' && e.data.turn === marker.turn && e.data.step === marker.step && e.data.message.source.provider === agent.id))
+            relevant = undefined;
+        else
+            return;
+        if (flights.has(session.id))
+            return;
+        // Wait for the synchronous event dispatch to enqueue the writer, then flush.
+        const operation = Promise.resolve().then(() => verify(session.id, api, marker, relevant));
+        flights.set(session.id, operation);
+        void operation.catch(error => { failures.set(session.id, error); });
+    });
+    const reconcile = async (request, api) => {
+        request.signal?.throwIfAborted();
+        const services = requireServices(ctx, request);
+        requireAcknowledge(api);
+        const flight = flights.get(services.session.id);
+        if (flight) {
+            try {
+                await flight;
+                return;
+            }
+            finally {
+                if (flights.get(services.session.id) === flight)
+                    flights.delete(services.session.id);
+            }
+        }
+        const events = await readDurable(services), seen = new Set();
+        let found = false;
+        for (const event of services.session.snapshotEvents()) {
+            if (event.type !== 'assistant/message')
+                continue;
+            const raw = rawPresentation(event.data.message);
+            if (!shape(raw) || raw.provider !== agent.id || raw.sessionId !== services.session.id)
+                continue;
+            if (seen.has(raw.noticeId))
+                return reportUnknown(api, raw, unknown());
+            seen.add(raw.noticeId);
+            found = true;
+            const durable = events.find(e => e.seq === event.seq);
+            if (durable?.type !== 'assistant/message' || !isDeepStrictEqual(durable, event))
+                return reportUnknown(api, raw, unknown());
+            try {
+                validateFinal(durable, raw, events);
+                await acknowledge(requireAcknowledge(api), receipt(raw, 'delivered', durable.data.message.id));
+                failures.delete(services.session.id);
+                pending.delete(services.session.id);
+            }
+            catch (error) {
+                return reportUnknown(api, raw, error);
+            }
+        }
+        if (!found && failures.has(services.session.id))
+            throw unknown(failures.get(services.session.id));
+        request.signal?.throwIfAborted();
+    };
+    const deliver = async (notice, resolved, request, api) => {
+        request.signal?.throwIfAborted();
+        const services = requireServices(ctx, request);
+        requireAcknowledge(api);
+        if (!notice || !string(notice.noticeId) || !string(notice.claimId) || notice.messageKey !== 'remote-workspace-binding' || !workspaceName(notice.workspaceName)
+            || resolved.sessionId !== services.session.id || !string(resolved.bindingId) || !string(resolved.workspaceId) || resolved.project?.name !== notice.workspaceName)
+            throw unknown();
+        const { turn, step } = activeRequest(services.session, agent);
+        const marker = { kind: 'workspace-notice', version: 2, provider: agent.id, loginProvider: agent.loginProvider, sessionId: services.session.id,
+            noticeId: notice.noticeId, claimId: notice.claimId, workspaceName: notice.workspaceName, bindingId: resolved.bindingId, workspaceId: resolved.workspaceId, turn, step, blockIndex: 0, text: noticeText(notice.workspaceName) + '\n\n' };
+        const prior = pending.get(services.session.id);
+        if (prior) {
+            if (!isDeepStrictEqual(prior.marker, marker))
+                throw unknown();
+            return prior.marker;
+        }
+        const recorded = services.session.snapshotEvents().filter((e) => e.type === 'assistant/message').find(e => workspaceNoticeFromMessage(e.data.message)?.noticeId === notice.noticeId);
+        if (recorded) {
+            await reconcile(request, api);
+            return undefined;
+        }
+        pending.set(services.session.id, { marker, api });
+        return marker;
+    };
+    return { reconcile, deliver };
+}

package/locale/en.json

@@ -0,0 +1,10 @@
+{
+  "meta": {
+    "title": "Codex (Remote Host)",
+    "description": "Run Codex sessions through a remote host. Administrators: use Settings → Open configuration file to edit the existing plugin entry. See README for the six fields and approved defaults."
+  },
+  "configuration": {
+    "administratorNote": "Administrators: use Settings → Open configuration file to edit the existing plugin entry. See README for the six fields and approved defaults.",
+    "providerName": "Codex (Remote Host)"
+  }
+}

package/locale/zh.json

@@ -0,0 +1,10 @@
+{
+  "meta": {
+    "title": "远程主机ACP",
+    "description": "通过远程主机运行Claude与Codex。首版不支持总是允许和歧义审批选项、已有Claude会话中立即生效的系统上下文变更；完整说明见README。管理员从官方设置打开配置文件修改已有条目。"
+  },
+  "configuration": {
+    "administratorNote": "管理员：从设置使用“打开配置文件”，修改已有插件条目；六个字段和已批准默认值见 README。",
+    "providerName": "Codex（远程主机）"
+  }
+}

package/package.json

@@ -1,6 +1,99 @@
 {
   "name": "@ai-workbench/remote-agent",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.8.1",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./client": "./dist/client.js",
+    "./package.json": "./package.json",
+    "./locale/*.json": "./locale/*.json"
+  },
+  "files": [
+    "dist",
+    "locale",
+    "cordis.patch.yml"
+  ],
+  "scripts": {
+    "test": "npm run build && node --test 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",
+    "probe:broker": "node tools/probe-broker.ts",
+    "pack:artifact": "node tools/pack-artifact.mjs",
+    "probe:formal": "node tools/probe-formal.mjs"
+  },
+  "engines": {
+    "node": ">=24.13.1"
+  },
+  "dependencies": {
+    "@agentclientprotocol/sdk": "2.0.0",
+    "@openai/codex-sdk": "0.163.0",
+    "zod": "4.6.7"
+  },
+  "devDependencies": {
+    "@ai-workbench/connect": "file:test/fixtures/ai-workbench-connect-0.7.9.tgz",
+    "@deepseek-ai/cordis": "4.0.4",
+    "@deepseek-ai/cordis-plugin-group": "1.0.4",
+    "@deepseek-ai/cordis-plugin-include": "1.0.9",
+    "@deepseek-ai/cordis-plugin-loader": "1.0.5",
+    "@deepseek-ai/cordis-plugin-timer": "1.1.6",
+    "@deepseek-ai/dsh-agent": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-api-gateway": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-client-connection": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-llm": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-typert-protocol": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-typert-registry": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-user-approval": "0.2.0-rc.2",
+    "@deepseek-ai/schemastery": "3.18.4",
+    "@types/node": "24.10.0",
+    "typescript": "5.9.3",
+    "@deepseek-ai/dsh-session": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-attachment": "0.2.0-rc.2"
+  },
+  "peerDependencies": {
+    "@ai-workbench/connect": "~0.7.9",
+    "@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",
+    "@deepseek-ai/schemastery": "3.18.4",
+    "@deepseek-ai/dsh-session": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-agent": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-user-approval": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-attachment": "0.2.0-rc.2"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "inject": [
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-connection"
+      ],
+      "platform": "web"
+    }
+  },
+  "peerDependenciesMeta": {
+    "@ai-workbench/connect": {
+      "optional": true
+    }
+  },
+  "description": "通过远程主机运行Claude与Codex会话。",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "keywords": [
+    "dsh",
+    "dsh-plugin",
+    "deepseek-harness",
+    "acp",
+    "claude",
+    "codex"
+  ]
+}