@jingyi0605/codingns4dsh 0.1.0

package/data/build/dist/host/cli-adapters/pi-driver.d.ts

@@ -0,0 +1,43 @@
+import { spawn, spawnSync } from 'node:child_process';
+import type { CodingNsCliModelCatalog, CodingNsAgentEvent, CodingNsCliTurnInput } from '../../shared/contracts/cli-adapter.js';
+import type { CodingNsCliDriver, CodingNsCliSessionProbeInput, CodingNsCliSessionProbeResult } from './driver.js';
+export interface PiAgentDriverOptions {
+    readonly binaries?: readonly string[];
+    readonly sessionRoots?: readonly string[];
+    readonly spawnSync?: typeof spawnSync;
+    readonly spawn?: typeof spawn;
+}
+/** Pi Agent 的 --mode rpc 适配器。Pi 的长期 RPC 细节被限制在本文件和标准进程层内。 */
+export declare class PiAgentDriver implements CodingNsCliDriver {
+    readonly descriptor: {
+        readonly id: "pi";
+        readonly name: "Pi Agent";
+        readonly protocol: "json-rpc";
+        readonly capabilities: readonly ["models", "stream", "resume", "interrupt", "tool-events", "reasoning", "usage", "steer"];
+    };
+    private readonly binaries;
+    private readonly runSpawnSync;
+    private readonly runSpawn;
+    private readonly sessionRoots;
+    private cachedBinary;
+    private readonly processes;
+    private readonly sessions;
+    constructor(options?: PiAgentDriverOptions);
+    detect(): Promise<{
+        installed: boolean;
+        version: string | null;
+        command: string | null;
+    }>;
+    listModels(): Promise<CodingNsCliModelCatalog>;
+    probeSession(input: CodingNsCliSessionProbeInput): Promise<CodingNsCliSessionProbeResult>;
+    executeTurn(input: CodingNsCliTurnInput): AsyncIterable<CodingNsAgentEvent>;
+    /** 向运行中的 Pi 会话发送 steering，当前 turn 会立即改变方向。 */
+    steer(sessionId: string, prompt: string): Promise<void>;
+    /** 向运行中的 Pi 会话追加 follow-up。 */
+    followUp(sessionId: string, prompt: string): Promise<void>;
+    /** 中断当前 turn，但保留 Pi 进程供同一会话继续使用。 */
+    interrupt(sessionId: string): Promise<void>;
+    dispose(): void;
+    private getSession;
+}
+//# sourceMappingURL=pi-driver.d.ts.map

package/data/build/dist/host/cli-adapters/pi-driver.js

@@ -0,0 +1,312 @@
+import { spawn, spawnSync } from 'node:child_process';
+import { homedir } from 'node:os';
+import { basename, join } from 'node:path';
+import { JsonRpcProcess } from './json-rpc-process.js';
+import { detectBinary, emptyCatalog, isRecord, textValue, usageChunk } from './rpc-driver-utils.js';
+import { PI_CATALOG, isProviderDefaultModel } from './model-catalog.js';
+import { probeStoredSession, readFirstJsonRecord } from './session-probe.js';
+import { firstToolText, isToolRecord, normalizeToolStatus, serializeToolValue } from './tool-observation.js';
+import { WINDOWS } from './process-utils.js';
+/** Pi Agent 的 --mode rpc 适配器。Pi 的长期 RPC 细节被限制在本文件和标准进程层内。 */
+export class PiAgentDriver {
+    descriptor = { id: 'pi', name: 'Pi Agent', protocol: 'json-rpc', capabilities: ['models', 'stream', 'resume', 'interrupt', 'tool-events', 'reasoning', 'usage', 'steer'] };
+    binaries;
+    runSpawnSync;
+    runSpawn;
+    sessionRoots;
+    cachedBinary = null;
+    processes = new Set();
+    sessions = new Map();
+    constructor(options = {}) {
+        this.binaries = options.binaries ?? ['pi', 'pi-agent'];
+        this.runSpawnSync = options.spawnSync ?? spawnSync;
+        this.runSpawn = options.spawn ?? spawn;
+        const configDirectory = process.env.PI_CODING_AGENT_DIR ?? join(homedir(), '.pi', 'agent');
+        this.sessionRoots = options.sessionRoots ?? [process.env.PI_CODING_AGENT_SESSION_DIR ?? join(configDirectory, 'sessions')];
+    }
+    async detect() {
+        const result = await detectBinary({ binaries: this.binaries, spawnSync: this.runSpawnSync });
+        if (result.installed)
+            this.cachedBinary = result.command;
+        return result;
+    }
+    async listModels() {
+        const detection = await this.detect();
+        if (!detection.installed)
+            return emptyCatalog();
+        // Pi 的 RPC 目录包含每个模型精确的 thinkingLevelMap；表格接口只有 yes/no，
+        // 不能用来判断具体档位，因此只能作为旧版本的降级路径。
+        const rpc = new JsonRpcProcess({ command: detection.command, args: ['--mode', 'rpc'], spawn: this.runSpawn });
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), 12_000);
+        try {
+            const response = await rpc.request('get_available_models', {}, { signal: controller.signal });
+            const catalog = parsePiCatalog(response);
+            if (catalog.groups.length > 0)
+                return catalog;
+        }
+        catch { /* 旧版 Pi 没有模型 RPC 时继续读取表格。 */ }
+        finally {
+            clearTimeout(timer);
+            rpc.dispose();
+        }
+        try {
+            const result = this.runSpawnSync(detection.command, ['--list-models'], { encoding: 'utf8', timeout: 12_000, windowsHide: true, shell: WINDOWS });
+            const catalog = parsePiCliCatalog(`${result.stdout ?? ''}\n${result.stderr ?? ''}`);
+            if (catalog.groups.length > 0)
+                return catalog;
+        }
+        catch { /* 旧版 Pi 没有 --list-models。 */ }
+        return PI_CATALOG;
+    }
+    async probeSession(input) {
+        return probeStoredSession(input, {
+            roots: this.sessionRoots,
+            matches: (path, entry, id) => entry.isFile() && basename(path).endsWith(`${id}.jsonl`),
+            validate: async (path, id) => {
+                const record = await readFirstJsonRecord(path);
+                return record?.type === 'session' && record.id === id;
+            },
+        });
+    }
+    async *executeTurn(input) {
+        const command = this.cachedBinary ?? (await this.detect()).command;
+        if (command === null)
+            throw new Error('Pi Agent 未安装');
+        const session = this.getSession(input.sessionId, command, input.cwd, input.providerSessionId);
+        const rpc = session.rpc;
+        try {
+            // 新版 Pi 接受可选模型设置；旧版会以错误响应结束，随后仍可使用默认模型。
+            if (session.needsResume && input.providerSessionId) {
+                try {
+                    await rpc.request('resume', { sessionId: input.providerSessionId }, { signal: input.signal, killOnAbort: false });
+                    session.providerSessionId = input.providerSessionId;
+                }
+                catch { /* 旧版 Pi 没有显式 resume，继续复用当前进程 */ }
+                session.needsResume = false;
+            }
+            if (!isProviderDefaultModel(input.modelId)) {
+                try {
+                    await rpc.request('set_model', { model: input.modelId }, { signal: input.signal, killOnAbort: false });
+                }
+                catch { /* 兼容旧版 */ }
+            }
+            yield { type: 'session-binding', providerSessionId: session.providerSessionId };
+            const stream = streamPiPrompt(rpc, input.prompt, input.signal);
+            let finishReason;
+            while (true) {
+                const item = await stream.next();
+                if (item.done) {
+                    finishReason = item.value;
+                    break;
+                }
+                const discoveredId = readSessionId(item.value);
+                if (discoveredId && discoveredId !== session.providerSessionId) {
+                    session.providerSessionId = discoveredId;
+                    yield { type: 'session-binding', providerSessionId: discoveredId };
+                }
+                const chunk = piMessageToChunk(item.value);
+                if (chunk !== null)
+                    yield chunk;
+            }
+            if (finishReason === 'cancel') {
+                await this.interrupt(input.sessionId);
+            }
+            yield { type: 'finish', reason: finishReason };
+        }
+        finally { /* 跨轮复用：仅 dispose() 才回收长期进程。 */ }
+    }
+    /** 向运行中的 Pi 会话发送 steering，当前 turn 会立即改变方向。 */
+    async steer(sessionId, prompt) {
+        const session = this.sessions.get(sessionId);
+        if (session === undefined)
+            throw new Error('Pi 会话不存在');
+        await session.rpc.request('steer', { message: prompt }, { killOnAbort: false });
+    }
+    /** 向运行中的 Pi 会话追加 follow-up。 */
+    async followUp(sessionId, prompt) {
+        const session = this.sessions.get(sessionId);
+        if (session === undefined)
+            throw new Error('Pi 会话不存在');
+        await session.rpc.request('follow_up', { message: prompt }, { killOnAbort: false });
+    }
+    /** 中断当前 turn，但保留 Pi 进程供同一会话继续使用。 */
+    async interrupt(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (session === undefined)
+            return;
+        try {
+            await session.rpc.request('interrupt', {}, { killOnAbort: false });
+        }
+        catch {
+            try {
+                session.rpc.notify('abort', {});
+            }
+            catch { /* 进程可能已退出 */ }
+        }
+    }
+    dispose() {
+        for (const session of this.sessions.values())
+            session.rpc.dispose();
+        this.sessions.clear();
+        this.processes.clear();
+        this.cachedBinary = null;
+    }
+    getSession(sessionId, command, cwd, providerSessionId) {
+        const previous = this.sessions.get(sessionId);
+        if (previous !== undefined && previous.cwd === cwd)
+            return previous;
+        previous?.rpc.dispose();
+        const rpc = new JsonRpcProcess({ command, args: ['--mode', 'rpc'], cwd, spawn: this.runSpawn });
+        this.processes.add(rpc);
+        const session = {
+            rpc,
+            cwd,
+            providerSessionId: providerSessionId ?? sessionId,
+            needsResume: providerSessionId !== undefined,
+        };
+        this.sessions.set(sessionId, session);
+        return session;
+    }
+}
+/**
+ * Pi 的 prompt 响应只表示已接受，不能作为轮次终态。
+ * 监听器必须先于请求注册，并一直保留到 agent_settled、失败或取消。
+ */
+async function* streamPiPrompt(rpc, prompt, signal) {
+    const queue = [];
+    let wake;
+    let promptSettled = false;
+    let terminalReason = null;
+    const notify = () => { wake?.(); wake = undefined; };
+    const listener = (message) => {
+        queue.push(message);
+        const type = piEventType(message);
+        if (type === 'agent_settled')
+            terminalReason = 'stop';
+        else if (type === 'error' || type === 'agent_error' || type === 'agent_failed')
+            terminalReason = 'error';
+        notify();
+    };
+    const removeListener = rpc.addNotificationListener(listener);
+    const onAbort = () => { terminalReason = 'cancel'; notify(); };
+    if (signal?.aborted)
+        onAbort();
+    else
+        signal?.addEventListener('abort', onAbort, { once: true });
+    void rpc.request('prompt', { message: prompt }, { signal, killOnAbort: false }).then(() => { promptSettled = true; notify(); }, () => {
+        promptSettled = true;
+        terminalReason = signal?.aborted ? 'cancel' : 'error';
+        notify();
+    });
+    try {
+        while (queue.length > 0 || !promptSettled || terminalReason === null) {
+            if (queue.length > 0) {
+                yield queue.shift();
+                continue;
+            }
+            await new Promise((resolve) => { wake = resolve; });
+        }
+        return terminalReason;
+    }
+    finally {
+        signal?.removeEventListener('abort', onAbort);
+        removeListener();
+    }
+}
+function piEventType(message) {
+    const params = isRecord(message.params) ? message.params : message;
+    return typeof params.type === 'string' ? params.type.toLowerCase() : '';
+}
+function parsePiCliCatalog(output) {
+    const models = [];
+    const levels = ['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'];
+    for (const line of output.split(/\r?\n/u)) {
+        const match = line.trim().match(/^(\S+)\s+(\S+)\s+\S+\s+\S+\s+(yes|no)(?:\s+|$)/iu);
+        if (!match)
+            continue;
+        const provider = match[1];
+        const model = match[2];
+        const id = `${provider}/${model}`;
+        if (models.some((item) => item.id === id))
+            continue;
+        models.push({ id, name: model, efforts: match[3].toLowerCase() === 'yes' ? levels : ['off'] });
+    }
+    if (models.length === 0)
+        return emptyCatalog();
+    return { groups: [{ id: 'pi', name: 'Pi', models }], currentModel: null, currentEffort: null };
+}
+function parsePiCatalog(value) {
+    const payload = isRecord(value) && isRecord(value.data) ? value.data : value;
+    const models = Array.isArray(payload) ? payload : isRecord(payload) && Array.isArray(payload.models) ? payload.models : [];
+    const items = models.flatMap((entry) => {
+        if (!isRecord(entry))
+            return [];
+        const provider = typeof entry.provider === 'string' ? entry.provider.trim() : '';
+        const id = typeof entry.id === 'string' ? entry.id.trim() : typeof entry.modelId === 'string' ? entry.modelId.trim() : '';
+        if (!id)
+            return [];
+        const modelId = provider ? `${provider}/${id}` : id;
+        const map = isRecord(entry.thinkingLevelMap) ? entry.thinkingLevelMap : null;
+        const reasoning = entry.reasoning === true;
+        const levels = !reasoning
+            ? ['off']
+            : map === null
+                ? ['off', 'minimal', 'low', 'medium', 'high']
+                : ['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'].filter((level) => typeof map[level] === 'string' && map[level].trim() !== '');
+        return [{ id: modelId, name: typeof entry.name === 'string' && entry.name.trim() ? entry.name : id, efforts: levels }];
+    });
+    if (items.length === 0)
+        return emptyCatalog();
+    return { groups: [{ id: 'pi', name: 'Pi', models: [...new Map(items.map((item) => [item.id, item])).values()] }], currentModel: null, currentEffort: null };
+}
+function piMessageToChunk(message) {
+    const params = isRecord(message.params) ? message.params : message;
+    const event = isRecord(params.item) ? params.item : params;
+    const assistantEvent = isRecord(params.assistantMessageEvent) ? params.assistantMessageEvent : null;
+    const completedMessage = isRecord(params.message) ? params.message : null;
+    const rootType = typeof event.type === 'string' ? event.type : typeof params.event === 'string' ? params.event : '';
+    if (rootType === 'agent_settled' || rootType === 'agent_end' || rootType === 'turn_end')
+        return null;
+    const type = assistantEvent !== null && typeof assistantEvent.type === 'string' ? assistantEvent.type : rootType;
+    const text = textValue(assistantEvent?.delta ?? params.delta ?? params.text ?? params.content ?? params.message);
+    if (type.includes('text_delta') || type === 'text-delta' || type === 'assistant_message_event' && text)
+        return text ? { type: 'text-delta', text } : null;
+    if (type.includes('thinking') || type.includes('reasoning'))
+        return text ? { type: 'reasoning-delta', text } : null;
+    const toolResultMessage = completedMessage?.role === 'toolResult' ? completedMessage : null;
+    const toolCall = isToolRecord(assistantEvent?.toolCall) ? assistantEvent.toolCall : null;
+    if (type.includes('tool') || type.includes('agent') || toolResultMessage !== null) {
+        const source = toolResultMessage ?? assistantEvent ?? event;
+        const toolName = firstToolText(source.toolName, source.name, toolCall?.name, params.toolName, params.name) ?? (type.includes('agent') ? 'subagent' : 'tool');
+        const callId = firstToolText(source.toolCallId, source.callId, source.id, toolCall?.id, params.toolCallId, params.callId);
+        const input = serializeToolValue(source.args ?? source.arguments ?? toolCall?.arguments ?? params.args);
+        const failed = source.isError === true || params.isError === true || type.includes('failed') || type.includes('error');
+        const resultValue = source.partialResult ?? source.result ?? (toolResultMessage === null ? source.output : source.content);
+        const result = serializeToolValue(resultValue);
+        const agentId = firstToolText(source.agentId, params.agentId, type.includes('agent') ? source.sessionId ?? params.sessionId : undefined);
+        const detail = serializeToolValue(source.detail ?? params.detail);
+        const status = normalizeToolStatus(source.status ?? source.state ?? params.status ?? params.state, failed ? 'failed' : type.includes('end') || type.includes('completed') || toolResultMessage !== null ? 'completed' : 'running');
+        return {
+            type: 'tool-event',
+            toolName,
+            status,
+            ...(callId ? { callId } : {}),
+            ...(input !== undefined ? { input } : {}),
+            ...(failed ? (result === undefined ? {} : { error: result }) : (result === undefined ? {} : { output: result })),
+            ...(!failed && result !== undefined ? { outputMode: 'snapshot' } : {}),
+            ...(agentId ? { agentId } : {}),
+            ...(detail !== undefined ? { detail } : {}),
+        };
+    }
+    const usage = usageChunk(params);
+    return usage ?? null;
+}
+function readSessionId(message) {
+    const params = isRecord(message.params) ? message.params : message;
+    for (const key of ['sessionId', 'session_id', 'providerSessionId'])
+        if (typeof params[key] === 'string' && params[key].trim())
+            return params[key].trim();
+    return null;
+}
+//# sourceMappingURL=pi-driver.js.map

package/data/build/dist/host/cli-adapters/process-utils.d.ts

@@ -0,0 +1,16 @@
+interface KillableChild {
+    readonly pid?: number | null;
+    kill(signal?: string): boolean;
+}
+/** Windows 的 npm CLI 通常是 .cmd 包装器，必须经由 shell 才能启动。 */
+export declare const WINDOWS: boolean;
+/**
+ * 结束 CLI 进程及其子进程树。
+ *
+ * Windows 没有 POSIX 进程组信号；仅调用 child.kill() 往往只结束 cmd.exe
+ * 包装器，真正的 Node/CLI 子进程仍会占用端口。taskkill /T 是系统自带的
+ * 最小进程树清理手段，失败时再回退到 Node 自身的 kill。
+ */
+export declare function terminateChildProcess(child: KillableChild, signal?: NodeJS.Signals): void;
+export {};
+//# sourceMappingURL=process-utils.d.ts.map

package/data/build/dist/host/cli-adapters/process-utils.js

@@ -0,0 +1,27 @@
+import { spawnSync } from 'node:child_process';
+/** Windows 的 npm CLI 通常是 .cmd 包装器，必须经由 shell 才能启动。 */
+export const WINDOWS = process.platform === 'win32';
+/**
+ * 结束 CLI 进程及其子进程树。
+ *
+ * Windows 没有 POSIX 进程组信号；仅调用 child.kill() 往往只结束 cmd.exe
+ * 包装器，真正的 Node/CLI 子进程仍会占用端口。taskkill /T 是系统自带的
+ * 最小进程树清理手段，失败时再回退到 Node 自身的 kill。
+ */
+export function terminateChildProcess(child, signal = 'SIGTERM') {
+    if (WINDOWS && typeof child.pid === 'number' && child.pid > 0) {
+        try {
+            spawnSync('taskkill', ['/PID', String(child.pid), '/T', '/F'], {
+                windowsHide: true,
+            });
+        }
+        catch {
+            // taskkill 不可用时继续尝试 Node 的兼容终止路径。
+        }
+    }
+    try {
+        child.kill(signal);
+    }
+    catch { /* 进程可能已经退出 */ }
+}
+//# sourceMappingURL=process-utils.js.map

package/data/build/dist/host/cli-adapters/provider-subscription.d.ts

@@ -0,0 +1,82 @@
+import { spawn, spawnSync } from 'node:child_process';
+import type { CliSubscriptionUsage } from '../../shared/contracts/subscription.js';
+type FetchLike = typeof fetch;
+/** 统一读取 Codex、Claude Code、OpenCode 订阅摘要。所有原始凭据都留在 Host。 */
+export declare class ProviderSubscriptionService {
+    readonly commandCode: SubscriptionReader | undefined;
+    readonly codex: CodexSubscriptionService;
+    readonly claudeCode: ClaudeCodeSubscriptionService;
+    readonly opencode: OpenCodeSubscriptionService;
+    readonly sub2api: Sub2ApiUsageService;
+    constructor(options?: ProviderSubscriptionOptions);
+    read(adapterId: string): Promise<CliSubscriptionUsage | null>;
+    private readSub2ApiFirst;
+}
+export interface ProviderSubscriptionOptions {
+    readonly commandCode?: SubscriptionReader;
+    readonly codex?: CodexSubscriptionOptions;
+    readonly claudeCode?: ClaudeCodeSubscriptionOptions;
+    readonly opencode?: OpenCodeSubscriptionOptions;
+    readonly sub2api?: Sub2ApiUsageOptions;
+}
+export interface SubscriptionReader {
+    read(): Promise<CliSubscriptionUsage | null>;
+}
+export interface Sub2ApiSource {
+    readonly baseUrl: string;
+    readonly apiKey: string;
+}
+export interface Sub2ApiUsageOptions {
+    readonly fetch?: FetchLike;
+    readonly timeoutMs?: number;
+    readonly sources?: Partial<Record<'codex' | 'claude-code' | 'dsh' | 'grok' | 'opencode', Sub2ApiSource | readonly Sub2ApiSource[]>>;
+}
+/** 通过 Provider 的上游 base URL 检测 Sub2API；只返回脱敏后的统计摘要。 */
+export declare class Sub2ApiUsageService {
+    private readonly request;
+    private readonly timeoutMs;
+    private readonly configuredSources;
+    constructor(options?: Sub2ApiUsageOptions);
+    hasSource(adapterId: string): boolean;
+    read(adapterId: string): Promise<CliSubscriptionUsage | null>;
+    private readSource;
+}
+export interface CodexSubscriptionOptions {
+    readonly homeDirectory?: string;
+    readonly binaries?: readonly string[];
+    readonly spawnSync?: typeof spawnSync;
+    readonly spawn?: typeof spawn;
+    readonly timeoutMs?: number;
+}
+export declare class CodexSubscriptionService implements SubscriptionReader {
+    private readonly binaries;
+    private readonly runSpawnSync;
+    private readonly runSpawn;
+    private readonly timeoutMs;
+    private readonly homeDirectory;
+    private command;
+    constructor(options?: CodexSubscriptionOptions);
+    read(): Promise<CliSubscriptionUsage | null>;
+}
+export interface ClaudeCodeSubscriptionOptions {
+    readonly homeDirectory?: string;
+    readonly fetch?: FetchLike;
+    readonly timeoutMs?: number;
+}
+export declare class ClaudeCodeSubscriptionService implements SubscriptionReader {
+    private readonly homeDirectory;
+    private readonly request;
+    private readonly timeoutMs;
+    constructor(options?: ClaudeCodeSubscriptionOptions);
+    read(): Promise<CliSubscriptionUsage | null>;
+}
+export interface OpenCodeSubscriptionOptions {
+    readonly homeDirectory?: string;
+}
+export declare class OpenCodeSubscriptionService implements SubscriptionReader {
+    private readonly homeDirectory;
+    constructor(options?: OpenCodeSubscriptionOptions);
+    read(): Promise<CliSubscriptionUsage | null>;
+}
+export {};
+//# sourceMappingURL=provider-subscription.d.ts.map