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

package/dist/workspace-notice.js

@@ -0,0 +1,254 @@
+import { SessionId } from '@deepseek-ai/dsh-session';
+import { AssistantStreamAccumulator, BlockAssembler, createAssistantMessage, freezeMessage, 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 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');
+    // The persistence definition is an optional host service, not an installed private writer.
+    const persistence = ctx.get('sessionPersistence');
+    const live = id && typeof registry?.get === 'function' ? registry.get(id) : undefined;
+    const 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 会话及其官方持久化读取能力，才能确认工作区说明；本次未启动远端。', '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);
+}
+async function acknowledge(method, receipt) {
+    const result = await method(receipt);
+    if (!object(result) || result.ok !== true)
+        throw unknown(result);
+}
+function receipt(marker, outcome) {
+    const base = { noticeId: marker.noticeId, surface: 'provider', claimId: marker.claimId, sessionId: marker.sessionId, provider: marker.loginProvider };
+    return outcome === 'delivered' ? { ...base, outcome, deliveryId: marker.deliveryId } : { ...base, outcome };
+}
+async function reportUnknown(method, marker, cause) {
+    let failure = cause;
+    try {
+        await acknowledge(method, receipt(marker, 'unknown'));
+    }
+    catch (reportFailure) {
+        failure = new AggregateError([cause, reportFailure], '工作区说明的核对和未知状态记录均未完成');
+    }
+    throw unknown(failure);
+}
+async function readDurable(services, offset, length) {
+    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(offset, length);
+        if (!result || !Array.isArray(result.events))
+            throw unknown();
+        return result.events;
+    }
+    finally {
+        if (typeof handle?.close === 'function')
+            await handle.close();
+    }
+}
+function validateRecord(event, sessionId) {
+    const marker = parseWorkspaceNoticeMarker(event.data.message);
+    if (!marker || marker.sessionId !== sessionId || event.surfaceOp !== 'append' || event.data.interrupted === true || !Array.isArray(event.data.stream))
+        throw unknown();
+    const assembler = new BlockAssembler();
+    for (const member of expandAssistantStream(event.data.stream))
+        assembler.push(member.chunk);
+    if (assembler.finish.kind !== 'stop' || !isDeepStrictEqual(assembler.blocks(), event.data.message.content)
+        || !isDeepStrictEqual(assembler.replayState, event.data.message.source.replayState) || assembler.usage !== undefined || event.data.usage !== undefined)
+        throw unknown();
+    return marker;
+}
+function ownRecords(events, sessionId, agent) {
+    const found = [];
+    for (const event of events) {
+        if (event.type !== 'assistant/message' || event.data.message.source.provider !== agent.id)
+            continue;
+        const raw = rawMarker(event.data.message);
+        if (raw?.kind !== 'workspace-notice')
+            continue;
+        // A fork may retain an ancestor's notice. It is never this Session's claim.
+        if (string(raw.sessionId) && raw.sessionId !== sessionId)
+            continue;
+        const marker = validateRecord(event, sessionId);
+        if (marker.provider !== agent.id || marker.loginProvider !== agent.loginProvider)
+            throw unknown();
+        found.push({ event, marker });
+    }
+    const notices = new Map();
+    for (const { marker } of found) {
+        if (notices.has(marker.noticeId))
+            throw unknown();
+        notices.set(marker.noticeId, marker.deliveryId);
+    }
+    return found;
+}
+function activeRequest(session, definition) {
+    let turn, step, model, 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;
+                model = event.data.header.config.model;
+                break;
+        }
+    if (!Number.isSafeInteger(turn) || turn < 1 || !Number.isSafeInteger(step) || step < 1 || provider !== definition.id || !string(model))
+        throw unknown();
+    return { turn: turn, step: step, model };
+}
+function buildRecord(services, definition, notice, resolved) {
+    const { session } = services, { turn, step, model } = activeRequest(session, definition), text = noticeText(notice.workspaceName);
+    const base = createAssistantMessage({ content: [{ type: 'text', text }], source: { provider: definition.id, model } });
+    const marker = { kind: 'workspace-notice', version: 1, provider: definition.id, loginProvider: definition.loginProvider,
+        sessionId: session.id, noticeId: notice.noticeId, claimId: notice.claimId, deliveryId: base.id, messageId: base.id,
+        workspaceName: notice.workspaceName, bindingId: resolved.bindingId, workspaceId: resolved.workspaceId };
+    const chunks = [{ type: 'block-start', index: 0, blockType: 'text' }, { type: 'text-delta', index: 0, text },
+        { type: 'block-end', index: 0, block: { type: 'text', text } }, { type: 'finish', reason: { kind: 'stop' }, replayState: { response: marker } }];
+    const accumulator = new AssistantStreamAccumulator(), assembler = new BlockAssembler();
+    for (const chunk of chunks)
+        assembler.push(accumulator.push({ time: Date.now(), chunk }).chunk);
+    const message = freezeMessage({ ...base, source: { ...base.source, replayState: assembler.replayState } });
+    // This public append is the actual ordinary-reply consumption point, not an emitted-yield guess.
+    const event = session.append('assistant/message', { turn, step, message, stream: [...accumulator.snapshot()] }, { surfaceOp: 'append' });
+    return { event, marker };
+}
+export function createWorkspaceNoticeConsumer(ctx, agent) {
+    const flights = new Map();
+    const reconcile = async (request, api) => {
+        request.signal?.throwIfAborted();
+        const services = requireServices(ctx, request), method = requireAcknowledge(api);
+        let stored;
+        try {
+            const events = await readDurable(services);
+            stored = ownRecords(events, services.session.id, agent);
+            const live = ownRecords(services.session.snapshotEvents(), services.session.id, agent);
+            if (live.some(item => !stored.some(record => record.marker.deliveryId === item.marker.deliveryId && isDeepStrictEqual(record.event, item.event))))
+                throw unknown();
+        }
+        catch (error) {
+            throw unknown(error);
+        }
+        for (const { marker } of stored) {
+            try {
+                await acknowledge(method, receipt(marker, 'delivered'));
+            }
+            catch (error) {
+                await reportUnknown(method, marker, error);
+            }
+        }
+        request.signal?.throwIfAborted();
+    };
+    const deliver = async (notice, resolved, request, api) => {
+        request.signal?.throwIfAborted();
+        const services = requireServices(ctx, request), method = 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 key = JSON.stringify([services.session.id, notice.noticeId, notice.claimId]);
+        const current = flights.get(key);
+        if (current)
+            return current;
+        const operation = (async () => {
+            let pending;
+            try {
+                const snapshot = services.session.snapshotEvents();
+                for (const event of snapshot) {
+                    if (event.type !== 'assistant/message' || event.data.message.source.provider === agent.id || !AGENTS.some(item => item.id === event.data.message.source.provider))
+                        continue;
+                    const raw = rawMarker(event.data.message);
+                    if (raw?.kind === 'workspace-notice' && raw.noticeId === notice.noticeId && raw.sessionId === services.session.id)
+                        throw unknown();
+                }
+                const records = ownRecords(snapshot, services.session.id, agent);
+                const prior = records.find(item => item.marker.noticeId === notice.noticeId);
+                if (prior) {
+                    if (prior.marker.claimId !== notice.claimId || prior.marker.workspaceId !== resolved.workspaceId || prior.marker.bindingId !== resolved.bindingId || prior.marker.workspaceName !== notice.workspaceName)
+                        throw unknown();
+                    pending = prior;
+                }
+                else
+                    pending = buildRecord(services, agent, notice, resolved);
+                const persisted = await readDurable(services, pending.event.seq, 1);
+                const event = persisted[0];
+                if (event?.type !== 'assistant/message' || !isDeepStrictEqual(event, pending.event))
+                    throw unknown();
+                validateRecord(event, services.session.id);
+                await acknowledge(method, receipt(pending.marker, 'delivered'));
+            }
+            catch (error) {
+                if (pending)
+                    return reportUnknown(method, pending.marker, error);
+                throw unknown(error);
+            }
+            request.signal?.throwIfAborted();
+        })();
+        flights.set(key, operation);
+        try {
+            await operation;
+        }
+        finally {
+            if (flights.get(key) === operation)
+                flights.delete(key);
+        }
+    };
+    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.0",
+  "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.0.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.0",
+    "@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"
+  ]
+}