dsh-plugin-bridge 0.2.11 → 0.3.1

package/lib/dsh-alpha-host.js

@@ -0,0 +1,276 @@
+/**
+ * DSH v0.1.2 alpha typed-controller adapter.
+ *
+ * The alpha removed the legacy ApiProxy service.  Keep that product change at
+ * this boundary: migration code continues to consume BridgeHost, while this
+ * adapter talks to the Host controllers structurally so the package can still
+ * be built against the current rc.2 SDK.
+ */
+import { randomUUID } from 'node:crypto';
+import { createApiProxyHost, probeApiProxy } from './api-rpc.js';
+import { REQUIRED_BRIDGE_CAPABILITIES, } from './host.js';
+import { RpcError } from './rpc.js';
+const ALPHA_METHODS = {
+    'session.list': services => services.sessionController?.list,
+    'session.create': services => services.sessionController?.create,
+    'session.history': services => services.sessionController?.inspect,
+    'session.models': services => services.sessionController?.modelCatalog,
+    'session.selectModel': services => services.sessionController?.selectModel,
+    'session.prompt': services => services.sessionController?.prompt,
+    'session.cancel': services => services.sessionController?.cancel,
+    'session.rename': services => services.sessionController?.rename,
+    'workspace.list': services => services.workspaceRegistry?.list,
+    'workspace.archiveSession': services => services.workspaceController?.archiveSession,
+    'agentPreset.list': services => services.agentPresets?.remoteExportList,
+    'goal.create': services => services.goals?.remoteExportCreate,
+    'goal.pause': services => services.goals?.pause,
+};
+function service(ctx, name) {
+    try {
+        const getter = ctx.get;
+        if (typeof getter === 'function') {
+            const found = getter.call(ctx, name);
+            if (found !== undefined)
+                return found;
+        }
+    }
+    catch {
+        // Cordis returns undefined for an unavailable optional service; custom
+        // Context implementations may throw instead, so fall through to fixtures.
+    }
+    try {
+        return ctx[name];
+    }
+    catch {
+        return undefined;
+    }
+}
+function servicesOf(ctx) {
+    return {
+        apiProxy: service(ctx, 'apiProxy'),
+        sessionController: service(ctx, 'sessionController'),
+        workspaceRegistry: service(ctx, 'workspaceRegistry'),
+        workspaceController: service(ctx, 'workspaceController'),
+        agentPresets: service(ctx, 'agentPresets'),
+        goals: service(ctx, 'goals'),
+    };
+}
+function failureOf(error) {
+    const value = error;
+    return value?.failure ?? value?.rpc ?? {
+        code: value?.code,
+        message: value?.message,
+        details: value?.details,
+    };
+}
+async function invoke(method, operation) {
+    try {
+        return await operation();
+    }
+    catch (error) {
+        if (error instanceof RpcError)
+            throw error;
+        const failure = failureOf(error);
+        throw new RpcError(method, failure.code ?? 'internal', failure.message ?? (error instanceof Error ? error.message : String(error)), failure.details);
+    }
+}
+function required(method, value) {
+    if (value === undefined)
+        throw new RpcError(method, 'unavailable', `DSH alpha host 没有提供 ${method}`);
+    return value;
+}
+function projectionValues(row) {
+    const values = row?.projections?.values;
+    return values !== null && typeof values === 'object' ? values : {};
+}
+function sessionRow(row) {
+    const source = row;
+    const values = projectionValues(row);
+    const preset = typeof values.agentPreset === 'string'
+        ? values.agentPreset
+        : typeof source.agentPreset === 'string' ? source.agentPreset : undefined;
+    return {
+        sessionId: String(source.sessionId ?? ''),
+        ...(typeof source.running === 'boolean' ? { running: source.running } : {}),
+        ...(typeof source.blank === 'boolean' ? { blank: source.blank } : {}),
+        ...(typeof source.cwd === 'string' ? { cwd: source.cwd } : {}),
+        ...(preset === undefined ? {} : { agentPreset: preset }),
+        ...(typeof source.parentSessionId === 'string' ? { parentSessionId: source.parentSessionId } : {}),
+        ...Object.keys(values).length === 0 ? {} : { projections: { values } },
+    };
+}
+function currentModel(row) {
+    const selection = projectionValues(row).modelSelection;
+    if (selection === null || typeof selection !== 'object')
+        return undefined;
+    const record = selection;
+    const candidate = record.next ?? record.lastUsed;
+    if (candidate === null || typeof candidate !== 'object')
+        return undefined;
+    const model = candidate;
+    if (typeof model.provider !== 'string' || typeof model.model !== 'string')
+        return undefined;
+    return {
+        provider: model.provider,
+        model: model.model,
+        ...(typeof model.reasoningEffort === 'string' ? { reasoningEffort: model.reasoningEffort } : {}),
+    };
+}
+function paginateHistory(events, beforeSeq, maxMessages) {
+    const visible = beforeSeq === undefined ? [...events] : events.filter(event => (event.seq ?? -1) < beforeSeq);
+    let count = 0;
+    let cut = 0;
+    for (let index = visible.length - 1; index >= 0; index -= 1) {
+        const type = visible[index]?.type;
+        if (type !== 'user/message' && type !== 'assistant/message')
+            continue;
+        count += 1;
+        if (count >= maxMessages) {
+            cut = index;
+            break;
+        }
+    }
+    return {
+        events: visible.slice(cut).map(event => ({ event })),
+        hasMore: cut > 0,
+    };
+}
+async function resolvedAgent(services, sessionId) {
+    const resolve = required('session.resolveAgent', services.sessionController?.resolveAgent);
+    const result = await invoke('session.resolveAgent', () => resolve.call(services.sessionController, sessionId));
+    if (result.error !== undefined) {
+        throw new RpcError('session.resolveAgent', result.error.code ?? 'internal', result.error.message ?? 'DSH alpha 无法恢复目标会话', result.error.details);
+    }
+    return required('session.resolveAgent', result.agent);
+}
+/** Probe the real alpha services instead of the adapter's always-present closures. */
+export function probeDshAlphaHost(input) {
+    const services = servicesOf(input);
+    return REQUIRED_BRIDGE_CAPABILITIES.map(method => ({
+        method,
+        available: typeof ALPHA_METHODS[method]?.(services) === 'function',
+    }));
+}
+/** Create the semantic BridgeHost over DSH v0.1.2 typed Host controllers. */
+export function createDshAlphaHost(input, signal) {
+    const services = servicesOf(input);
+    const controller = services.sessionController;
+    const abort = signal ?? new AbortController().signal;
+    const host = {
+        descriptor: Object.freeze({ id: 'dsh-typed-controllers', version: '0.1.2-alpha', transport: 'in-process' }),
+        sessions: Object.freeze({
+            list: async (request = {}) => {
+                const list = required('session.list', controller?.list);
+                const value = await invoke('session.list', () => list.call(controller, request, abort));
+                return { items: (value.items ?? []).map(sessionRow) };
+            },
+            create: async (request) => {
+                const create = required('session.create', controller?.create);
+                return await invoke('session.create', () => create.call(controller, request));
+            },
+            history: async (request) => {
+                const inspect = required('session.history', controller?.inspect);
+                const value = await invoke('session.history', () => inspect.call(controller, request.sessionId, abort));
+                return paginateHistory(value.events, request.beforeSeq, request.maxMessages ?? 60);
+            },
+            models: async ({ sessionId }) => {
+                const list = required('session.list', controller?.list);
+                const catalog = required('session.models', controller?.modelCatalog);
+                const [listed, available] = await Promise.all([
+                    invoke('session.list', () => list.call(controller, {}, abort)),
+                    invoke('session.models', () => catalog.call(controller)),
+                ]);
+                const row = (listed.items ?? []).find(item => item.sessionId === sessionId);
+                return {
+                    ...available,
+                    current: currentModel(row) ?? available.default,
+                };
+            },
+            selectModel: request => {
+                const select = required('session.selectModel', controller?.selectModel);
+                return invoke('session.selectModel', () => select.call(controller, { ...request }));
+            },
+            prompt: request => {
+                const prompt = required('session.prompt', controller?.prompt);
+                return invoke('session.prompt', () => prompt.call(controller, {
+                    ...request,
+                    requestId: `bridge-${randomUUID()}`,
+                }, abort));
+            },
+            cancel: request => {
+                const cancel = required('session.cancel', controller?.cancel);
+                return invoke('session.cancel', () => cancel.call(controller, request));
+            },
+            rename: request => {
+                const rename = required('session.rename', controller?.rename);
+                return invoke('session.rename', () => rename.call(controller, request));
+            },
+            attachment: request => {
+                const attachment = required('session.attachment', controller?.attachment);
+                return invoke('session.attachment', () => attachment.call(controller, request));
+            },
+        }),
+        workspaces: Object.freeze({
+            list: async () => {
+                const list = required('workspace.list', services.workspaceRegistry?.list);
+                const rows = await invoke('workspace.list', () => list.call(services.workspaceRegistry));
+                return {
+                    items: rows.map((item) => {
+                        const row = item;
+                        return {
+                            workspaceId: String(row.id ?? row.workspaceId ?? ''),
+                            sessionIds: Array.isArray(row.sessionIds) ? row.sessionIds.map(String) : [],
+                        };
+                    }),
+                };
+            },
+            archiveSession: request => {
+                const archive = required('workspace.archiveSession', services.workspaceController?.archiveSession);
+                return invoke('workspace.archiveSession', () => archive.call(services.workspaceController, request));
+            },
+        }),
+        presets: Object.freeze({
+            list: async () => {
+                const list = required('agentPreset.list', services.agentPresets?.remoteExportList);
+                return await invoke('agentPreset.list', () => list.call(services.agentPresets));
+            },
+        }),
+        goals: Object.freeze({
+            create: async (request) => {
+                const agent = await resolvedAgent(services, request.sessionId);
+                const create = required('goal.create', services.goals?.remoteExportCreate);
+                return await invoke('goal.create', () => create.call(services.goals, agent, {
+                    objective: request.objective,
+                    maxGoalRounds: request.maxGoalRounds,
+                }));
+            },
+            pause: async (request) => {
+                const agent = await resolvedAgent(services, request.sessionId);
+                const pause = required('goal.pause', services.goals?.pause);
+                return await invoke('goal.pause', () => pause.call(services.goals, agent, request.ref));
+            },
+            clear: async (request) => {
+                const agent = await resolvedAgent(services, request.sessionId);
+                const clear = required('goal.clear', services.goals?.clear);
+                return await invoke('goal.clear', () => clear.call(services.goals, agent, request.ref));
+            },
+        }),
+    };
+    return Object.freeze(host);
+}
+/** Prefer the stable rc.2 path when present; otherwise use alpha controllers. */
+export function resolveDshHost(input, signal) {
+    const services = servicesOf(input);
+    if (services.apiProxy !== undefined)
+        return createApiProxyHost(services.apiProxy, signal);
+    if (services.sessionController !== undefined)
+        return createDshAlphaHost(services, signal);
+    throw new RpcError('bridge.host', 'unavailable', '当前 DSH 没有可用的 apiProxy 或 typed sessionController');
+}
+/** Probe the active generation using its native surface. */
+export function probeDshHost(input) {
+    const services = servicesOf(input);
+    if (services.apiProxy !== undefined)
+        return probeApiProxy(services.apiProxy);
+    return probeDshAlphaHost(services);
+}

package/lib/host.d.ts

@@ -0,0 +1,177 @@
+/**
+ * Bridge 的宿主端口。
+ *
+ * 迁移核心只依赖这些语义能力；DSH HTTP、进程内 apiProxy，以及未来可能出现的
+ * dsh-std participant 都应在 adapter 中实现本接口。RPC 方法名与产品对象形状不应
+ * 再进入 migrate.ts。
+ */
+import { RpcError, type Rpc } from './rpc.ts';
+import type { ImageAttachmentRef, SessionEvent } from './types.ts';
+export interface BridgeHostDescriptor {
+    /** adapter 的稳定标识，例如 dsh-api-proxy、dsh-http-api 或 dsh-std。 */
+    id: string;
+    version?: string;
+    transport?: string;
+}
+export interface SessionRow {
+    sessionId: string;
+    running?: boolean;
+    blank?: boolean;
+    cwd?: string;
+    agentPreset?: string;
+    parentSessionId?: string;
+    projections?: {
+        values?: Record<string, unknown>;
+    };
+}
+export interface PresetRow {
+    id: string;
+    trust?: 'system' | 'user';
+    isDefault?: boolean;
+    name?: string;
+    description?: string;
+    broken?: string;
+}
+export interface ModelSelection {
+    provider: string;
+    model: string;
+    reasoningEffort?: string;
+}
+export interface SessionModels {
+    current?: Partial<ModelSelection>;
+    groups?: {
+        id: string;
+        models?: {
+            id: string;
+        }[];
+    }[];
+    [key: string]: unknown;
+}
+export type PromptContent = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'image';
+    mediaType: ImageAttachmentRef['mediaType'];
+    data: string;
+    name?: string;
+};
+export interface BridgeHost {
+    readonly descriptor: BridgeHostDescriptor;
+    readonly sessions: {
+        list(input?: {
+            cursor?: string;
+        }): Promise<{
+            items?: SessionRow[];
+            nextCursor?: string;
+        }>;
+        create(input: {
+            workspaceId?: string;
+            cwd?: string;
+            agentPreset?: string;
+        }): Promise<{
+            sessionId: string;
+            agentPreset?: string;
+        }>;
+        history(input: {
+            sessionId: string;
+            maxMessages?: number;
+            beforeSeq?: number;
+        }, options?: {
+            timeoutMs?: number;
+        }): Promise<{
+            events?: {
+                event: SessionEvent;
+            }[];
+            hasMore?: boolean;
+        }>;
+        models(input: {
+            sessionId: string;
+        }): Promise<SessionModels>;
+        selectModel(input: {
+            sessionId: string;
+        } & ModelSelection): Promise<unknown>;
+        prompt(input: {
+            sessionId: string;
+            mode: 'queue';
+            content: readonly PromptContent[];
+        }): Promise<unknown>;
+        cancel(input: {
+            sessionId: string;
+        }): Promise<unknown>;
+        rename(input: {
+            sessionId: string;
+            title: string;
+        }): Promise<unknown>;
+        attachment?(input: {
+            sessionId: string;
+            attachmentId: string;
+        }): Promise<{
+            attachment?: ImageAttachmentRef;
+            data?: string;
+        }>;
+    };
+    readonly workspaces: {
+        list(): Promise<{
+            items?: {
+                workspaceId: string;
+                sessionIds?: string[];
+            }[];
+        }>;
+        archiveSession(input: {
+            sessionId: string;
+        }): Promise<unknown>;
+    };
+    readonly presets: {
+        list(): Promise<{
+            presets?: PresetRow[];
+        }>;
+    };
+    readonly goals: {
+        create(input: {
+            sessionId: string;
+            objective: string;
+            maxGoalRounds: number;
+        }): Promise<{
+            ref: {
+                id: string;
+                revision: number;
+            };
+        }>;
+        pause(input: {
+            sessionId: string;
+            ref: {
+                id: string;
+                revision: number;
+            };
+        }): Promise<unknown>;
+        clear?(input: {
+            sessionId: string;
+            ref: {
+                id: string;
+                revision: number;
+            };
+        }): Promise<unknown>;
+    };
+}
+/** 0.2.x 兼容入口：现有调用者仍可传入旧的字符串 Rpc。 */
+export type BridgeHostInput = BridgeHost | Rpc;
+export declare const REQUIRED_BRIDGE_CAPABILITIES: readonly ["session.list", "session.create", "session.history", "session.models", "session.selectModel", "session.prompt", "session.cancel", "session.rename", "workspace.list", "workspace.archiveSession", "agentPreset.list", "goal.create", "goal.pause"];
+export declare const OPTIONAL_BRIDGE_CAPABILITIES: readonly ["session.attachment", "goal.clear"];
+export interface BridgeHostProbe {
+    method: string;
+    available: boolean;
+}
+/** 只检查端口形状，不执行任何宿主操作。 */
+export declare function probeBridgeHost(host: BridgeHost | undefined): BridgeHostProbe[];
+/**
+ * 把现有 DSH 字符串 RPC 包成语义端口。
+ *
+ * 这是兼容 adapter，不是迁移核心的一部分；未来的 dsh-std adapter 可以直接实现
+ * BridgeHost，而不需要复刻这些 DSH 路由名。
+ */
+export declare function createBridgeHostFromRpc(rpc: Rpc, descriptor?: BridgeHostDescriptor): BridgeHost;
+/** 将兼容输入规范化为 BridgeHost；核心入口统一调用此函数。 */
+export declare function asBridgeHost(input: BridgeHostInput): BridgeHost;
+/** 对缺失的可选能力给出与 RPC 错误一致的可分类失败。 */
+export declare function missingHostCapability(capability: string): RpcError;

package/lib/host.js

@@ -0,0 +1,102 @@
+/**
+ * Bridge 的宿主端口。
+ *
+ * 迁移核心只依赖这些语义能力；DSH HTTP、进程内 apiProxy，以及未来可能出现的
+ * dsh-std participant 都应在 adapter 中实现本接口。RPC 方法名与产品对象形状不应
+ * 再进入 migrate.ts。
+ */
+import { RpcError } from './rpc.js';
+export const REQUIRED_BRIDGE_CAPABILITIES = Object.freeze([
+    'session.list',
+    'session.create',
+    'session.history',
+    'session.models',
+    'session.selectModel',
+    'session.prompt',
+    'session.cancel',
+    'session.rename',
+    'workspace.list',
+    'workspace.archiveSession',
+    'agentPreset.list',
+    'goal.create',
+    'goal.pause',
+]);
+export const OPTIONAL_BRIDGE_CAPABILITIES = Object.freeze([
+    'session.attachment',
+    'goal.clear',
+]);
+const REQUIRED_ACCESSORS = {
+    'session.list': host => host.sessions.list,
+    'session.create': host => host.sessions.create,
+    'session.history': host => host.sessions.history,
+    'session.models': host => host.sessions.models,
+    'session.selectModel': host => host.sessions.selectModel,
+    'session.prompt': host => host.sessions.prompt,
+    'session.cancel': host => host.sessions.cancel,
+    'session.rename': host => host.sessions.rename,
+    'workspace.list': host => host.workspaces.list,
+    'workspace.archiveSession': host => host.workspaces.archiveSession,
+    'agentPreset.list': host => host.presets.list,
+    'goal.create': host => host.goals.create,
+    'goal.pause': host => host.goals.pause,
+};
+/** 只检查端口形状，不执行任何宿主操作。 */
+export function probeBridgeHost(host) {
+    return REQUIRED_BRIDGE_CAPABILITIES.map(method => {
+        let available = false;
+        try {
+            available = host !== undefined && typeof REQUIRED_ACCESSORS[method](host) === 'function';
+        }
+        catch {
+            // 外部 adapter 可能只交出部分端口；doctor 必须报告缺失，不能自己先崩。
+        }
+        return { method, available };
+    });
+}
+/**
+ * 把现有 DSH 字符串 RPC 包成语义端口。
+ *
+ * 这是兼容 adapter，不是迁移核心的一部分；未来的 dsh-std adapter 可以直接实现
+ * BridgeHost，而不需要复刻这些 DSH 路由名。
+ */
+export function createBridgeHostFromRpc(rpc, descriptor = { id: 'dsh-rpc', transport: 'rpc' }) {
+    const host = {
+        descriptor: Object.freeze({ ...descriptor }),
+        sessions: Object.freeze({
+            list: (input = {}) => rpc('session.list', input),
+            create: input => rpc('session.create', input),
+            history: (input, options) => rpc('session.history', input, options?.timeoutMs),
+            models: input => rpc('session.models', input),
+            selectModel: input => rpc('session.selectModel', input),
+            prompt: input => rpc('session.prompt', input),
+            cancel: input => rpc('session.cancel', input),
+            rename: input => rpc('session.rename', input),
+            attachment: input => rpc('session.attachment', input),
+        }),
+        workspaces: Object.freeze({
+            list: () => rpc('workspace.list', {}),
+            archiveSession: input => rpc('workspace.archiveSession', input),
+        }),
+        presets: Object.freeze({
+            list: () => rpc('agentPreset.list', {}),
+        }),
+        goals: Object.freeze({
+            create: input => rpc('goal.create', input),
+            pause: input => rpc('goal.pause', input),
+            clear: input => rpc('goal.clear', input),
+        }),
+    };
+    return Object.freeze(host);
+}
+/** 将兼容输入规范化为 BridgeHost；核心入口统一调用此函数。 */
+export function asBridgeHost(input) {
+    if (typeof input === 'function')
+        return createBridgeHostFromRpc(input);
+    if (input && typeof input === 'object' && typeof input.sessions?.list === 'function')
+        return input;
+    throw new RpcError('bridge.host', 'invalid-adapter', '宿主 adapter 没有实现 BridgeHost。');
+}
+/** 对缺失的可选能力给出与 RPC 错误一致的可分类失败。 */
+export function missingHostCapability(capability) {
+    return new RpcError('bridge.host', 'unavailable', `宿主 adapter 没有提供 ${capability}`);
+}

package/lib/index.d.ts

@@ -2,9 +2,8 @@ import type { Context } from '@deepseek-ai/cordis';
 import Schema from '@deepseek-ai/schemastery';
 export declare const name = "dsh-plugin-bridge";
 /**
- * `commands` 是入口，`apiProxy` 是引擎——两个都是硬依赖：
- * 缺哪个这个插件都无事可做，与其静默半挂，不如让 cordis 挂起等待。
- * 两者在官方 `web` profile 里都在（base 挂 commands，web-app 挂 api-gateway）。
+ * `commands` 是跨版本入口，唯一硬依赖。执行时优先使用 rc.2 的 `apiProxy`，
+ * alpha 则改走 typed controllers；doctor 探测实际选中的那一面并 fail closed。
  */
 export declare const inject: string[];
 export interface Config {

package/lib/index.js

@@ -13,16 +13,15 @@ import { mkdtempSync, readFileSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import Schema from '@deepseek-ai/schemastery';
-import { createApiProxyRpc, probeApiProxy } from './api-rpc.js';
 import { createBridgeCommand } from './command.js';
 import { SOURCE_CHAR_BUDGET, SUMMARY_CHAR_BUDGET } from './compression.js';
+import { probeDshHost, resolveDshHost } from './dsh-alpha-host.js';
 export const name = 'dsh-plugin-bridge';
 /**
- * `commands` 是入口，`apiProxy` 是引擎——两个都是硬依赖：
- * 缺哪个这个插件都无事可做，与其静默半挂，不如让 cordis 挂起等待。
- * 两者在官方 `web` profile 里都在（base 挂 commands，web-app 挂 api-gateway）。
+ * `commands` 是跨版本入口，唯一硬依赖。执行时优先使用 rc.2 的 `apiProxy`，
+ * alpha 则改走 typed controllers；doctor 探测实际选中的那一面并 fail closed。
  */
-export const inject = ['commands', 'apiProxy'];
+export const inject = ['commands'];
 /** 命令是同步返回的，等压缩工人不能等太久。 */
 const DEFAULT_PREVIEW_TIMEOUT_MS = 180_000;
 export const Config = Schema.object({
@@ -63,10 +62,9 @@ export function commandConfigOf(config = {}) {
     };
 }
 export function apply(ctx, config = {}) {
-    const apiProxyOf = () => ctx.apiProxy;
     const command = createBridgeCommand({
-        rpcFor: (signal) => createApiProxyRpc(apiProxyOf(), signal),
-        probe: () => probeApiProxy(apiProxyOf()),
+        hostFor: (signal) => resolveDshHost(ctx, signal),
+        probe: () => probeDshHost(ctx),
         config: commandConfigOf(config),
         writeSummary: writeSummaryFile,
         readSummary: (path) => readFileSync(path, 'utf8'),