lark-remote 0.1.7 → 0.1.9

package/dist/runner/dsh/fake-dsh-server.js

@@ -0,0 +1,156 @@
+/**
+ * Fake DSH Web Host HTTP server for agent-dsh tests.
+ *
+ * Mimics the real DSH wire protocol (deepseek-harness apiproxy handler.ts):
+ *   - POST /api/<method>: body {type:'client-request',rpcId,method,payload},
+ *     response {type:'server-response',rpcId,result:{ok:true,value}|{ok:false,error}}.
+ *   - SSE GET /api/events.mux: frames `data: {type:'server-request',rpcId,
+ *     method:<frame.type>, payload:<frame>}\n\n`.
+ *
+ * The mux frame queue is consumed ACROSS connections (shared pointer): the
+ * first connection drains a prefix then closes; a reconnect drains the rest —
+ * which is exactly how a server that drops mid-turn is modelled. Unary
+ * handlers and the history value are registered by the test.
+ */
+import { createServer } from 'node:http';
+import { randomUUID } from 'node:crypto';
+export class FakeDshServer {
+    server;
+    unaryHandlers = new Map();
+    muxFrames = [];
+    historyValue = { events: [] };
+    port = 0;
+    closedConnections = 0;
+    requests = [];
+    constructor() {
+        this.server = createServer((req, res) => {
+            const url = req.url ?? '';
+            const path = url.split('?')[0];
+            if (req.method === 'GET' && path === '/api/events.mux') {
+                this.closedConnections++;
+                this.handleMux(res);
+                return;
+            }
+            if (req.method !== 'POST' || !path.startsWith('/api/')) {
+                res.writeHead(404);
+                res.end('not found');
+                return;
+            }
+            let raw = '';
+            req.on('data', (c) => (raw += c));
+            req.on('end', () => {
+                let body = {};
+                try {
+                    body = JSON.parse(raw);
+                }
+                catch {
+                    res.writeHead(400);
+                    res.end('bad request');
+                    return;
+                }
+                const method = path.slice('/api/'.length);
+                if (body.type !== 'client-request' || !body.rpcId || body.method !== method) {
+                    res.writeHead(400);
+                    res.end('bad request');
+                    return;
+                }
+                const rpcId = body.rpcId;
+                this.requests.push({ method, rpcId, payload: body.payload });
+                const handler = this.unaryHandlers.get(method);
+                let result;
+                if (handler) {
+                    result = handler(body.payload, rpcId);
+                }
+                else if (method === 'session.history') {
+                    result = { ok: true, value: this.historyValue };
+                }
+                else if (method === 'session.list') {
+                    result = { ok: true, value: { items: [] } };
+                }
+                else {
+                    result = { ok: true, value: {} };
+                }
+                res.writeHead(200, { 'content-type': 'application/json' });
+                res.end(JSON.stringify({ type: 'server-response', rpcId, result }));
+            });
+        });
+    }
+    get baseUrl() {
+        return `http://127.0.0.1:${this.port}`;
+    }
+    get connectionCount() {
+        return this.closedConnections;
+    }
+    async start() {
+        await new Promise((resolve) => this.server.listen(0, '127.0.0.1', resolve));
+        const addr = this.server.address();
+        this.port = addr.port;
+    }
+    async stop() {
+        await new Promise((resolve) => this.server.close(() => resolve()));
+    }
+    register(method, handler) {
+        this.unaryHandlers.set(method, handler);
+    }
+    setMuxFrames(frames) {
+        this.muxFrames = frames;
+    }
+    setHistoryValue(value) {
+        this.historyValue = value;
+    }
+    /** Synchronous unary dispatch (no HTTP) — used by tests that inject the
+     *  reader's sync transport to avoid the spawnSync-in-process deadlock. */
+    dispatchSync(method, payload, rpcId = `rpc-${randomUUID()}`) {
+        this.requests.push({ method, rpcId, payload });
+        const handler = this.unaryHandlers.get(method);
+        let result;
+        if (handler) {
+            result = handler(payload, rpcId);
+        }
+        else if (method === 'session.history') {
+            result = { ok: true, value: this.historyValue };
+        }
+        else if (method === 'session.list') {
+            result = { ok: true, value: { items: [] } };
+        }
+        else {
+            result = { ok: true, value: {} };
+        }
+        return { type: 'server-response', rpcId, result };
+    }
+    handleMux(res) {
+        res.writeHead(200, {
+            'content-type': 'text/event-stream',
+            'cache-control': 'no-cache',
+            connection: 'keep-alive',
+        });
+        // Drain the SHARED script (shift): the first connection consumes a prefix
+        // then closes (a {close:true} marker or an exhausted queue); a reconnect
+        // continues from where it left off — the natural model of a mid-turn drop.
+        const timer = setInterval(() => {
+            const item = this.muxFrames.shift();
+            if (item === undefined) {
+                clearInterval(timer);
+                res.end();
+                return;
+            }
+            if ('close' in item && item.close === true) {
+                clearInterval(timer);
+                res.end();
+                return;
+            }
+            const frame = item;
+            res.write(`data: ${JSON.stringify({
+                type: 'server-request',
+                rpcId: `mux-${randomUUID()}`,
+                method: frame.type,
+                payload: frame,
+            })}\n\n`);
+        }, 5);
+        reqClose(res, timer);
+    }
+}
+function reqClose(res, timer) {
+    res.on('close', () => clearInterval(timer));
+}
+//# sourceMappingURL=fake-dsh-server.js.map

package/dist/runner/dsh/index.d.ts

@@ -0,0 +1,3 @@
+export { DshRunner, type DshRunnerOptions } from './runner.js';
+export { DshClient, DshError } from './client.js';
+export { DshTranslator, mapUsage } from './translator.js';

package/dist/runner/dsh/index.js

@@ -0,0 +1,4 @@
+export { DshRunner } from './runner.js';
+export { DshClient, DshError } from './client.js';
+export { DshTranslator, mapUsage } from './translator.js';
+//# sourceMappingURL=index.js.map

package/dist/runner/dsh/runner.d.ts

@@ -0,0 +1,57 @@
+/**
+ * DshRunner — workspace-lifetime runner bridging to the DSH Web Host
+ * (DeepSeek Harness) over plain HTTP. No local subprocess is spawned.
+ *
+ * Flow per run: session.create(cwd) (when no sessionId) → synthetic system/init
+ * (DSH has no init event) → open per-session mux subscription → session.prompt
+ * (mode:'queue') → consume subscription until turn/end → result event.
+ *
+ * stop() → session.cancel + abort the mux subscription. killOrphan /
+ * registerExitHandlers are no-ops (no local process). approval/requested is
+ * surfaced as a WARN log + an assistant text prompt pointing to the DSH Web UI
+ * (never silently parked — the turn stays live until the user resolves it in
+ * the UI or the turn is cancelled/times out).
+ */
+import type { AgentEvent, AgentSessionReader, AgentStatusInfo, SpawnOptions } from '../types.js';
+import type { AgentRunner } from '../types.js';
+import { DshClient, type WebSocketFactory } from './client.js';
+/** DSH selectModel provider（deepseek-official 是 rc.7 模型目录的 provider）。 */
+export declare const DSH_MODEL_PROVIDER = "deepseek-official";
+export interface DshRunnerOptions {
+    kind: 'dsh';
+    sessionReader: AgentSessionReader;
+    /** DSH Web Host base URL, e.g. http://127.0.0.1:3080. */
+    host?: string;
+    /** Session preset（agentPreset）固定于 session 创建时；undefined = 服务端默认。 */
+    agentPreset?: string;
+    /** Display model name. */
+    model?: string;
+    /** 推理强度（off/low/high/max）；undefined = 服务端默认。 */
+    reasoningEffort?: string;
+    /** Injectable fetch for tests. */
+    fetchImpl?: typeof fetch;
+    /** Injectable WebSocket factory (defaults to global WebSocket). */
+    webSocketImpl?: WebSocketFactory;
+}
+export declare class DshRunner implements AgentRunner {
+    readonly kind: "dsh";
+    readonly sessionReader: AgentSessionReader;
+    readonly client: DshClient;
+    /** 用户配置的模型 ID（run 前 selectModel 对齐用）；undefined = 服务端默认。 */
+    private readonly configuredModel;
+    private readonly agentPreset;
+    private readonly reasoningEffort;
+    private activeAbort;
+    private activeSessionId;
+    private running;
+    constructor(opts: DshRunnerOptions);
+    get isRunning(): boolean;
+    getStatusInfo(): AgentStatusInfo;
+    run(message: string, opts: SpawnOptions): AsyncGenerator<AgentEvent>;
+    stop(_opts?: {
+        immediate?: boolean;
+    }): Promise<void>;
+    killOrphan(): void;
+    registerExitHandlers(): void;
+    unregisterExitHandlers(): void;
+}

package/dist/runner/dsh/runner.js

@@ -0,0 +1,211 @@
+/**
+ * DshRunner — workspace-lifetime runner bridging to the DSH Web Host
+ * (DeepSeek Harness) over plain HTTP. No local subprocess is spawned.
+ *
+ * Flow per run: session.create(cwd) (when no sessionId) → synthetic system/init
+ * (DSH has no init event) → open per-session mux subscription → session.prompt
+ * (mode:'queue') → consume subscription until turn/end → result event.
+ *
+ * stop() → session.cancel + abort the mux subscription. killOrphan /
+ * registerExitHandlers are no-ops (no local process). approval/requested is
+ * surfaced as a WARN log + an assistant text prompt pointing to the DSH Web UI
+ * (never silently parked — the turn stays live until the user resolves it in
+ * the UI or the turn is cancelled/times out).
+ */
+import { DshClient } from './client.js';
+import { DshTranslator } from './translator.js';
+import { getLogger } from '../../logger/index.js';
+/** DSH selectModel provider（deepseek-official 是 rc.7 模型目录的 provider）。 */
+export const DSH_MODEL_PROVIDER = 'deepseek-official';
+export class DshRunner {
+    kind = 'dsh';
+    sessionReader;
+    client;
+    /** 用户配置的模型 ID（run 前 selectModel 对齐用）；undefined = 服务端默认。 */
+    configuredModel;
+    agentPreset;
+    reasoningEffort;
+    activeAbort = null;
+    activeSessionId = null;
+    running = false;
+    constructor(opts) {
+        this.sessionReader = opts.sessionReader;
+        this.configuredModel = opts.model;
+        this.agentPreset = opts.agentPreset;
+        this.reasoningEffort = opts.reasoningEffort;
+        this.client = new DshClient(opts.host ?? 'http://127.0.0.1:3080', opts.fetchImpl, opts.webSocketImpl);
+    }
+    get isRunning() {
+        return this.running;
+    }
+    getStatusInfo() {
+        const extras = { host: this.client.baseUrl };
+        if (this.agentPreset)
+            extras.preset = this.agentPreset;
+        if (this.reasoningEffort)
+            extras.reasoning = this.reasoningEffort;
+        return {
+            kind: this.kind,
+            model: this.configuredModel ?? 'DSH',
+            extras,
+        };
+    }
+    async *run(message, opts) {
+        if (this.running) {
+            throw new Error('DshRunner is already running');
+        }
+        const abort = new AbortController();
+        this.activeAbort = abort;
+        this.running = true;
+        let sessionId = opts.sessionId;
+        let terminalEmitted = false;
+        try {
+            // CC-03: session.create 必须包进同一 try/finally，否则创建失败（服务端不可达/报错）
+            // 会在进入旧 try 之前抛异常，finally 不执行 → running 恒 true、activeAbort 残留。
+            if (!sessionId) {
+                const created = await this.client.createSession({
+                    cwd: opts.cwd,
+                    ...(this.agentPreset ? { agentPreset: this.agentPreset } : {}),
+                });
+                sessionId = created.sessionId;
+            }
+            this.activeSessionId = sessionId;
+            // 模型/推理强度变更 = 保留 session，每次 run 前对齐（§4.3）：
+            // 该调用同时会写服务端全局默认；失败仅告警不阻断 run（模型校验由 DSH 负责）。
+            if (this.configuredModel) {
+                try {
+                    await this.client.selectModel({
+                        sessionId,
+                        provider: DSH_MODEL_PROVIDER,
+                        model: this.configuredModel,
+                        ...(this.reasoningEffort ? { reasoningEffort: this.reasoningEffort } : {}),
+                    });
+                }
+                catch (err) {
+                    getLogger().warn(`[dsh] selectModel failed for session ${sessionId} (run continues): ${err.message}`);
+                }
+            }
+            yield {
+                type: 'system',
+                subtype: 'init',
+                session_id: sessionId,
+                cwd: opts.cwd,
+                model: this.configuredModel ?? 'DSH',
+            };
+            try {
+                // Snapshot the pre-prompt high-water mark before mutating the session.
+                // DSH session.history returns the whole session, so starting from seq 0
+                // would replay the first completed turn on every follow-up prompt.
+                const prePromptSeq = await this.client.latestEventSeq(sessionId);
+                await this.client.unary('session.prompt', {
+                    sessionId,
+                    mode: 'queue',
+                    content: [{ type: 'text', text: message }],
+                });
+                const translator = new DshTranslator();
+                try {
+                    for await (const item of this.client.sessionEvents(sessionId, opts.cwd, abort.signal, prePromptSeq)) {
+                        if (abort.signal.aborted)
+                            break;
+                        if (item.kind === 'approval') {
+                            getLogger().warn(`[dsh] approval requested approvalId=${item.approvalId} tool=${item.toolName} — resolve in DSH Web UI`);
+                            yield {
+                                type: 'assistant',
+                                message: {
+                                    content: [
+                                        {
+                                            type: 'text',
+                                            text: `⚠️ 需要授权（${item.toolName}）：请在 DSH Web UI 处理 ${this.client.baseUrl}`,
+                                        },
+                                    ],
+                                },
+                            };
+                            continue;
+                        }
+                        for (const ev of translator.eventToAgentEvents(item.event, sessionId)) {
+                            yield ev;
+                            if (ev.type === 'result') {
+                                terminalEmitted = true;
+                                return;
+                            }
+                        }
+                    }
+                }
+                catch (err) {
+                    if (abort.signal.aborted)
+                        throw err;
+                    getLogger().error(`[dsh] run consume error: ${err.message}`);
+                    yield {
+                        type: 'result',
+                        subtype: 'error',
+                        session_id: sessionId,
+                        errorMessage: `DSH stream error: ${err.message}`,
+                    };
+                    terminalEmitted = true;
+                }
+            }
+            catch (err) {
+                if (!abort.signal.aborted) {
+                    yield {
+                        type: 'result',
+                        subtype: 'error',
+                        session_id: sessionId,
+                        errorMessage: `DSH run failed: ${err.message}`,
+                    };
+                    terminalEmitted = true;
+                }
+            }
+        }
+        catch (err) {
+            // CC-03: createSession 等启动期失败也产出 error result（而非抛异常），
+            // 由本 catch 统一转 error result；state 清理在 finally。
+            if (!abort.signal.aborted) {
+                yield {
+                    type: 'result',
+                    subtype: 'error',
+                    session_id: sessionId ?? '',
+                    errorMessage: `DSH run failed: ${err.message}`,
+                };
+                terminalEmitted = true;
+            }
+        }
+        finally {
+            this.running = false;
+            this.activeSessionId = null;
+            this.activeAbort = null;
+        }
+        if (!terminalEmitted) {
+            yield {
+                type: 'result',
+                subtype: abort.signal.aborted ? 'interrupted' : 'error',
+                session_id: sessionId ?? '',
+                errorMessage: abort.signal.aborted ? 'run stopped' : 'turn ended without a terminal event',
+            };
+        }
+    }
+    async stop(_opts) {
+        const sessionId = this.activeSessionId;
+        const abort = this.activeAbort;
+        if (abort && !abort.signal.aborted)
+            abort.abort();
+        if (sessionId) {
+            try {
+                await this.client.unary('session.cancel', { sessionId });
+                getLogger().info(`[dsh] cancelled session ${sessionId}`);
+            }
+            catch (err) {
+                getLogger().warn(`[dsh] session.cancel failed: ${err.message}`);
+            }
+        }
+    }
+    killOrphan() {
+        // No local subprocess for DSH — nothing to reap.
+    }
+    registerExitHandlers() {
+        // No local subprocess for DSH — nothing to register.
+    }
+    unregisterExitHandlers() {
+        // No-op (see registerExitHandlers).
+    }
+}
+//# sourceMappingURL=runner.js.map

package/dist/runner/dsh/translator.d.ts

@@ -0,0 +1,28 @@
+/**
+ * DshTranslator — maps DSH SessionEvents to AgentEvents.
+ *
+ * Per-turn stateful: accumulates usage from assistant/message.usage records and
+ * converts assistant/chunk deltas to assistant text/thinking events.
+ *
+ * Mapping (task spec + DSH SessionEventMap):
+ *   assistant/chunk {chunk:{type:'text-delta',text}}     → assistant text (incremental)
+ *   assistant/chunk {chunk:{type:'reasoning-delta',text}} → assistant thinking (incremental)
+ *   assistant/message {usage?}                            → records usage (no event)
+ *   turn/end {reason.kind}                                → result:
+ *       completed → success; aborted/interrupted → interrupted;
+ *       blocked/error/max-tokens → error (errorMessage carries the reason)
+ *
+ * DSH TokenUsage: {inputTokens, outputTokens, cacheReadTokens?, cacheWriteTokens?}
+ *   → ResultEvent.usage: input_tokens/output_tokens/cache_read_tokens/
+ *     cache_creation_tokens (cacheWrite = cache creation) + total_tokens sum.
+ */
+import type { AgentEvent, ResultEvent } from '../types.js';
+import type { DshSessionEvent, DshTokenUsage } from './types.js';
+export declare class DshTranslator {
+    private liveUsage?;
+    private hasUsage;
+    /** Translate one session event into AgentEvents (may be empty). */
+    eventToAgentEvents(ev: DshSessionEvent, sessionId: string): AgentEvent[];
+}
+/** Map DSH TokenUsage → ResultEvent.usage (cacheWrite = cache creation). */
+export declare function mapUsage(u: DshTokenUsage): NonNullable<ResultEvent['usage']>;

package/dist/runner/dsh/translator.js

@@ -0,0 +1,98 @@
+/**
+ * DshTranslator — maps DSH SessionEvents to AgentEvents.
+ *
+ * Per-turn stateful: accumulates usage from assistant/message.usage records and
+ * converts assistant/chunk deltas to assistant text/thinking events.
+ *
+ * Mapping (task spec + DSH SessionEventMap):
+ *   assistant/chunk {chunk:{type:'text-delta',text}}     → assistant text (incremental)
+ *   assistant/chunk {chunk:{type:'reasoning-delta',text}} → assistant thinking (incremental)
+ *   assistant/message {usage?}                            → records usage (no event)
+ *   turn/end {reason.kind}                                → result:
+ *       completed → success; aborted/interrupted → interrupted;
+ *       blocked/error/max-tokens → error (errorMessage carries the reason)
+ *
+ * DSH TokenUsage: {inputTokens, outputTokens, cacheReadTokens?, cacheWriteTokens?}
+ *   → ResultEvent.usage: input_tokens/output_tokens/cache_read_tokens/
+ *     cache_creation_tokens (cacheWrite = cache creation) + total_tokens sum.
+ */
+export class DshTranslator {
+    liveUsage;
+    hasUsage = false;
+    /** Translate one session event into AgentEvents (may be empty). */
+    eventToAgentEvents(ev, sessionId) {
+        switch (ev.type) {
+            case 'assistant/chunk': {
+                const chunk = ev.data.chunk;
+                if (!chunk)
+                    return [];
+                const ts = new Date(ev.time).toISOString();
+                if (chunk.type === 'text-delta' && chunk.text) {
+                    return [
+                        {
+                            type: 'assistant',
+                            message: { content: [{ type: 'text', text: chunk.text }] },
+                            timestamp: ts,
+                        },
+                    ];
+                }
+                if (chunk.type === 'reasoning-delta' && chunk.text) {
+                    return [
+                        {
+                            type: 'assistant',
+                            message: { content: [{ type: 'thinking', thinking: chunk.text }] },
+                            timestamp: ts,
+                        },
+                    ];
+                }
+                return [];
+            }
+            case 'assistant/message': {
+                const raw = ev.data.usage;
+                if (raw && typeof raw === 'object') {
+                    this.liveUsage = raw;
+                    this.hasUsage = true;
+                }
+                return [];
+            }
+            case 'turn/end': {
+                const reason = ev.data.reason?.kind;
+                const subtype = reason === 'completed'
+                    ? 'success'
+                    : reason === 'aborted' || reason === 'interrupted'
+                        ? 'interrupted'
+                        : 'error';
+                const result = {
+                    type: 'result',
+                    subtype,
+                    session_id: sessionId,
+                    timestamp: new Date(ev.time).toISOString(),
+                };
+                if (this.hasUsage && this.liveUsage) {
+                    result.usage = mapUsage(this.liveUsage);
+                }
+                if (subtype === 'error') {
+                    result.errorMessage = `turn ended with reason: ${reason}`;
+                }
+                return [result];
+            }
+            default:
+                return [];
+        }
+    }
+}
+/** Map DSH TokenUsage → ResultEvent.usage (cacheWrite = cache creation). */
+export function mapUsage(u) {
+    const input = u.inputTokens ?? 0;
+    const output = u.outputTokens ?? 0;
+    const cacheRead = u.cacheReadTokens ?? 0;
+    const cacheWrite = u.cacheWriteTokens ?? 0;
+    return {
+        input_tokens: input,
+        output_tokens: output,
+        cache_read_tokens: cacheRead,
+        cache_creation_tokens: cacheWrite,
+        total_tokens: input + output + cacheRead + cacheWrite,
+    };
+}
+//# sourceMappingURL=translator.js.map