@jingyi0605/codingns4dsh 0.1.0

package/data/build/dist/features/resource-scope/index.js

@@ -0,0 +1,161 @@
+import { ResourceScopeStaleError, } from '../../shared/contracts/peer-host.js';
+export { ResourceScopeStaleError, } from '../../shared/contracts/peer-host.js';
+/**
+ * 管理当前 Host/Workspace/PeerHost 资源作用域。
+ *
+ * 这是纯状态协调器：它不发请求、不创建连接，也不理解具体资源类型。
+ * 作用域切换会立即让旧 generation 失效，然后清理旧 disposer，最后保留新快照。
+ */
+export class ResourceScopeManager {
+    activeScope = null;
+    nextGeneration = 0;
+    transitionTail = Promise.resolve();
+    constructor(initialScope) {
+        if (initialScope) {
+            this.activeScope = {
+                ref: Object.freeze({
+                    ...validateScopeInput(initialScope),
+                    scopeGeneration: 1,
+                }),
+                disposers: [],
+            };
+            this.nextGeneration = 1;
+        }
+    }
+    /** 返回当前快照；返回值不可用于修改管理器内部状态。 */
+    getCurrent() {
+        return this.activeScope?.ref ?? null;
+    }
+    /**
+     * 切换作用域。并发切换会按调用顺序串行化，避免旧 disposer 交叉执行。
+     * 相同作用域不会制造无意义的新 generation，但仍可附加 disposer。
+     */
+    switchTo(input, disposer) {
+        const validatedInput = validateScopeInput(input);
+        let result;
+        const operation = this.transitionTail.then(async () => {
+            const current = this.activeScope;
+            if (current && sameScope(current.ref, validatedInput)) {
+                if (disposer)
+                    this.addDisposer(disposer);
+                result = current.ref;
+                return;
+            }
+            const previous = this.activeScope;
+            const next = Object.freeze({
+                ...validatedInput,
+                scopeGeneration: ++this.nextGeneration,
+            });
+            // 先撤销旧快照，旧异步回调从这一刻起就会被 isCurrent 拒绝。
+            // 清理完成后才提交新快照，避免新作用域与旧连接同时被观察到。
+            this.activeScope = null;
+            let disposeError;
+            try {
+                await disposeScope(previous);
+            }
+            catch (error) {
+                disposeError = error;
+            }
+            this.activeScope = { ref: next, disposers: [] };
+            if (disposer)
+                this.addDisposer(disposer);
+            result = next;
+            if (disposeError)
+                throw disposeError;
+        });
+        this.transitionTail = operation.then(() => undefined, () => undefined);
+        return operation.then(() => result);
+    }
+    /**
+     * 为当前作用域注册清理函数。传入旧快照会直接失败，防止资源归属错乱。
+     */
+    addDisposer(disposer) {
+        if (!this.activeScope)
+            throw new ResourceScopeStaleError('No active resource scope');
+        const entry = { dispose: disposer, active: true };
+        this.activeScope.disposers.push(entry);
+        return () => {
+            entry.active = false;
+        };
+    }
+    /**
+     * 按快照注册清理函数。异步初始化完成后应优先使用此方法，避免旧作用域
+     * 的初始化结果把 disposer 错挂到新作用域。
+     */
+    registerDisposer(scope, disposer) {
+        this.assertCurrent(scope);
+        return this.addDisposer(disposer);
+    }
+    /** 判断快照是否仍然代表当前作用域。 */
+    isCurrent(scope) {
+        return Boolean(scope && this.activeScope && sameRef(this.activeScope.ref, scope));
+    }
+    /** 旧请求回写前调用；作用域不匹配时抛出稳定错误。 */
+    assertCurrent(scope) {
+        if (!this.isCurrent(scope))
+            throw new ResourceScopeStaleError();
+    }
+    /** 只有当前作用域才能执行写入，避免旧请求污染新作用域。 */
+    commitIfCurrent(scope, write) {
+        this.assertCurrent(scope);
+        return write();
+    }
+    /** 清理当前作用域并使其失效。后续可重新 switchTo。 */
+    async clear() {
+        const operation = this.transitionTail.then(async () => {
+            const previous = this.activeScope;
+            this.activeScope = null;
+            await disposeScope(previous);
+        });
+        this.transitionTail = operation.then(() => undefined, () => undefined);
+        await operation;
+    }
+}
+function validateScopeInput(input) {
+    if (!input || !nonEmpty(input.hostId) || !nonEmpty(input.workspaceId)) {
+        throw new TypeError('Resource scope hostId and workspaceId must be non-empty');
+    }
+    if (input.targetHostId !== null && !nonEmpty(input.targetHostId)) {
+        throw new TypeError('Resource scope targetHostId must be null or non-empty');
+    }
+    return {
+        hostId: input.hostId,
+        workspaceId: input.workspaceId,
+        targetHostId: input.targetHostId,
+    };
+}
+function nonEmpty(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+function sameScope(ref, input) {
+    return ref.hostId === input.hostId
+        && ref.workspaceId === input.workspaceId
+        && ref.targetHostId === input.targetHostId;
+}
+function sameRef(left, right) {
+    return left.hostId === right.hostId
+        && left.workspaceId === right.workspaceId
+        && left.targetHostId === right.targetHostId
+        && left.scopeGeneration === right.scopeGeneration;
+}
+async function disposeScope(scope) {
+    if (!scope)
+        return;
+    const errors = [];
+    for (const entry of [...scope.disposers].reverse()) {
+        if (!entry.active)
+            continue;
+        entry.active = false;
+        try {
+            await entry.dispose();
+        }
+        catch (error) {
+            errors.push(error);
+        }
+    }
+    if (errors.length === 1)
+        throw errors[0];
+    if (errors.length > 1)
+        throw new AggregateError(errors, 'Failed to dispose resource scope');
+}
+//# sourceMappingURL=index.js.map

package/data/build/dist/host/auth-session.d.ts

@@ -0,0 +1,42 @@
+import type { AuthDeviceManagementSnapshotDto, CodingNsAuthLoginResult, CodingNsAuthSessionSnapshot, HostBindRequest, LoginByEmailRequest, TunnelBindingSummary } from '../shared/contracts/auth.js';
+import type { CodingNsControlApiClient } from './control-api-client.js';
+import type { RelaySignalingTicketResponse } from '../shared/contracts/signaling.js';
+import type { CodingNsCredentialStore } from './credential-store.js';
+/**
+ * Host 侧认证协调器。
+ * 只管理状态和依赖边界，不创建 HTTP、计时器或 WebRTC 资源。
+ */
+export declare class CodingNsAuthSession {
+    private readonly client;
+    private readonly credentials;
+    private readonly controlBaseUrl;
+    private state;
+    private accessToken;
+    private credential;
+    constructor(client: CodingNsControlApiClient, credentials: CodingNsCredentialStore, controlBaseUrl: string);
+    snapshot(): CodingNsAuthSessionSnapshot;
+    /**
+     * 供 Host 侧 Control API/信令适配器临时取用 access token。
+     * 调用方不得把返回值写入快照、日志或发送给 Client。
+     */
+    getAccessToken(): string | null;
+    /** 仅供 Host 内部设备运行时调用，Client 不会拿到控制面客户端。 */
+    getControlClient(): CodingNsControlApiClient;
+    /** 使用保存的 refresh token 恢复会话；没有凭据时保持 logged_out。 */
+    restore(): Promise<CodingNsAuthSessionSnapshot>;
+    login(request: LoginByEmailRequest): Promise<CodingNsAuthLoginResult>;
+    refresh(): Promise<CodingNsAuthSessionSnapshot>;
+    logout(): Promise<void>;
+    getDevices(): Promise<AuthDeviceManagementSnapshotDto>;
+    listHostBindings(): Promise<TunnelBindingSummary[]>;
+    bindHost(request: HostBindRequest): Promise<TunnelBindingSummary>;
+    unbindHost(bindingId: string): Promise<TunnelBindingSummary>;
+    /** 为浏览器 Client 申请短期票据；access/refresh token 永远不离开 Host。 */
+    createClientSignalingTicket(tunnelDomain?: string): Promise<RelaySignalingTicketResponse>;
+    private saveResponse;
+    private refreshDeviceAndBinding;
+    private loginResult;
+    private requireAccessToken;
+    private reset;
+}
+//# sourceMappingURL=auth-session.d.ts.map

package/data/build/dist/host/auth-session.js

@@ -0,0 +1,186 @@
+/**
+ * Host 侧认证协调器。
+ * 只管理状态和依赖边界，不创建 HTTP、计时器或 WebRTC 资源。
+ */
+export class CodingNsAuthSession {
+    client;
+    credentials;
+    controlBaseUrl;
+    state = {
+        status: 'logged_out',
+        account: null,
+        currentDevice: null,
+        binding: null,
+        expiresAt: null,
+        errorCode: null,
+    };
+    accessToken = null;
+    credential = null;
+    constructor(client, credentials, controlBaseUrl) {
+        this.client = client;
+        this.credentials = credentials;
+        this.controlBaseUrl = controlBaseUrl;
+        if (controlBaseUrl.trim() === '') {
+            throw new TypeError('controlBaseUrl 不能为空');
+        }
+    }
+    snapshot() {
+        return {
+            ...this.state,
+            account: this.state.account ? { ...this.state.account } : null,
+            currentDevice: this.state.currentDevice ? { ...this.state.currentDevice } : null,
+            binding: this.state.binding ? { ...this.state.binding } : null,
+        };
+    }
+    /**
+     * 供 Host 侧 Control API/信令适配器临时取用 access token。
+     * 调用方不得把返回值写入快照、日志或发送给 Client。
+     */
+    getAccessToken() {
+        return this.accessToken;
+    }
+    /** 仅供 Host 内部设备运行时调用，Client 不会拿到控制面客户端。 */
+    getControlClient() {
+        return this.client;
+    }
+    /** 使用保存的 refresh token 恢复会话；没有凭据时保持 logged_out。 */
+    async restore() {
+        const credential = await this.credentials.read();
+        if (!credential) {
+            this.reset('logged_out');
+            return this.snapshot();
+        }
+        this.credential = credential;
+        return this.refresh();
+    }
+    async login(request) {
+        this.state = { ...this.state, status: 'logging_in', errorCode: null };
+        try {
+            const response = await this.client.login(request);
+            await this.saveResponse(response);
+            await this.refreshDeviceAndBinding();
+            this.state = { ...this.state, status: 'authenticated', errorCode: null };
+            return this.loginResult();
+        }
+        catch (error) {
+            this.state = { ...this.state, status: 'failed', errorCode: errorCode(error) };
+            throw error;
+        }
+    }
+    async refresh() {
+        const credential = this.credential ?? await this.credentials.read();
+        if (!credential) {
+            this.reset('logged_out');
+            return this.snapshot();
+        }
+        this.state = { ...this.state, status: 'refreshing', errorCode: null };
+        try {
+            const response = await this.client.refresh({ refreshToken: credential.refreshToken });
+            await this.saveResponse(response);
+            await this.refreshDeviceAndBinding();
+            this.state = { ...this.state, status: 'authenticated', errorCode: null };
+            return this.snapshot();
+        }
+        catch (error) {
+            this.accessToken = null;
+            this.state = { ...this.state, status: 'revoked', errorCode: errorCode(error) };
+            throw error;
+        }
+    }
+    async logout() {
+        this.accessToken = null;
+        this.credential = null;
+        await this.credentials.clear();
+        this.reset('logged_out');
+    }
+    async getDevices() {
+        const token = this.requireAccessToken();
+        const devices = await this.client.getDevices(token);
+        this.state = { ...this.state, currentDevice: devices.currentDevice };
+        return devices;
+    }
+    async listHostBindings() {
+        const response = await this.client.listHostBindings(this.requireAccessToken());
+        const binding = response.bindings[0] ?? null;
+        this.state = { ...this.state, binding };
+        return response.bindings;
+    }
+    async bindHost(request) {
+        const response = await this.client.bindHost(this.requireAccessToken(), request);
+        this.state = { ...this.state, binding: response.binding };
+        return response.binding;
+    }
+    async unbindHost(bindingId) {
+        const response = await this.client.unbindHost(this.requireAccessToken(), bindingId);
+        if (this.state.binding?.bindingId === response.binding.bindingId) {
+            this.state = { ...this.state, binding: null };
+        }
+        return response.binding;
+    }
+    /** 为浏览器 Client 申请短期票据；access/refresh token 永远不离开 Host。 */
+    async createClientSignalingTicket(tunnelDomain) {
+        const domain = tunnelDomain?.trim() || this.state.binding?.tunnelDomain;
+        if (!domain)
+            throw new Error('Codingns4DSH 尚未绑定 Host');
+        return this.client.createSignalingTicket(this.requireAccessToken(), { tunnelDomain: domain });
+    }
+    async saveResponse(response) {
+        this.accessToken = response.accessToken;
+        this.credential = {
+            controlBaseUrl: this.controlBaseUrl,
+            accountId: response.account?.accountId ?? '',
+            refreshToken: response.refreshToken,
+            refreshTokenExpiresAt: response.refreshTokenExpiresAt,
+            deviceId: this.state.currentDevice?.deviceId ?? null,
+            savedAt: new Date().toISOString(),
+        };
+        await this.credentials.write(this.credential);
+        this.state = {
+            ...this.state,
+            account: response.account,
+            expiresAt: response.expiresAt,
+        };
+    }
+    async refreshDeviceAndBinding() {
+        const devices = await this.client.getDevices(this.requireAccessToken());
+        const bindings = await this.client.listHostBindings(this.requireAccessToken());
+        this.state = {
+            ...this.state,
+            currentDevice: devices.currentDevice,
+            binding: bindings.bindings[0] ?? null,
+        };
+    }
+    loginResult() {
+        if (!this.state.account)
+            throw new Error('认证响应缺少 account');
+        return {
+            account: this.state.account,
+            expiresAt: this.state.expiresAt ?? '',
+            currentDevice: this.state.currentDevice,
+            binding: this.state.binding,
+        };
+    }
+    requireAccessToken() {
+        if (!this.accessToken)
+            throw new Error('Codingns4DSH 会话未认证');
+        return this.accessToken;
+    }
+    reset(status) {
+        this.accessToken = null;
+        this.credential = null;
+        this.state = {
+            status,
+            account: null,
+            currentDevice: null,
+            binding: null,
+            expiresAt: null,
+            errorCode: null,
+        };
+    }
+}
+function errorCode(error) {
+    if (error instanceof Error && error.name)
+        return error.name;
+    return 'AUTH_REQUEST_FAILED';
+}
+//# sourceMappingURL=auth-session.js.map

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

@@ -0,0 +1,14 @@
+import type { CodingNsAgentEvent, CodingNsCliTurnInput } from '../../shared/contracts/cli-adapter.js';
+import type { CodingNsCliSessionProbeInput, CodingNsCliSessionProbeResult } from './driver.js';
+import { StandardStreamDriver, type StandardStreamDriverOptions } from './standard-stream-driver.js';
+export declare class ClaudeCodeDriver extends StandardStreamDriver {
+    private readonly sessionRoots;
+    constructor(options?: StandardStreamDriverOptions);
+    listModels(): Promise<import("../../shared/contracts/cli-adapter.js").CodingNsCliModelCatalog>;
+    probeSession(input: CodingNsCliSessionProbeInput): Promise<CodingNsCliSessionProbeResult>;
+    protected buildArgs(input: CodingNsCliTurnInput): readonly string[];
+    protected parseEvent(value: Record<string, unknown>, input: CodingNsCliTurnInput): readonly CodingNsAgentEvent[];
+}
+/** 简短别名，便于按适配器名称装配。 */
+export { ClaudeCodeDriver as ClaudeDriver };
+//# sourceMappingURL=claude-driver.d.ts.map

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

@@ -0,0 +1,103 @@
+import { homedir } from 'node:os';
+import { basename, join } from 'node:path';
+import { StandardStreamDriver, emptyCatalog } from './standard-stream-driver.js';
+import { CLAUDE_CATALOG, enrichEfforts, isProviderDefaultModel } from './model-catalog.js';
+import { probeStoredSession, readFirstJsonRecord } from './session-probe.js';
+import { firstToolText, isToolRecord, serializeToolValue } from './tool-observation.js';
+export class ClaudeCodeDriver extends StandardStreamDriver {
+    sessionRoots;
+    constructor(options = {}) {
+        super({ id: 'claude-code', name: 'Claude Code', protocol: 'stream-json', capabilities: ['models', 'stream', 'resume', 'interrupt', 'tool-events', 'reasoning', 'usage'] }, { binaries: ['claude'] }, options);
+        this.sessionRoots = options.sessionRoots ?? [join(process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), '.claude'), 'projects')];
+    }
+    async listModels() {
+        if (!(await this.detect()).installed)
+            return emptyCatalog();
+        const catalog = await super.listModels();
+        return catalog.groups.length > 0 ? enrichEfforts(catalog, CLAUDE_CATALOG) : CLAUDE_CATALOG;
+    }
+    async probeSession(input) {
+        return probeStoredSession(input, {
+            roots: this.sessionRoots,
+            matches: (path, entry, id) => entry.isFile() && basename(path) === `${id}.jsonl`,
+            validate: async (path, id) => (await readFirstJsonRecord(path))?.sessionId === id,
+        });
+    }
+    buildArgs(input) {
+        const args = ['-p', input.prompt, '--output-format', 'stream-json', '--verbose', '--permission-mode', 'bypassPermissions'];
+        if (input.providerSessionId)
+            args.push('--resume', input.providerSessionId);
+        if (input.modelId && !isProviderDefaultModel(input.modelId))
+            args.push('--model', input.modelId);
+        return args;
+    }
+    parseEvent(value, input) {
+        const event = value.type === 'stream_event' && typeof value.event === 'object' && value.event !== null ? value.event : value;
+        const delta = typeof event.delta === 'object' && event.delta !== null ? event.delta : null;
+        if (event.type === 'content_block_delta' && delta?.type === 'text_delta' && typeof delta.text === 'string')
+            return [{ type: 'text-delta', text: delta.text }];
+        if (event.type === 'content_block_start' && isToolRecord(event.content_block) && event.content_block.type === 'tool_use') {
+            const tool = claudeToolUse(event.content_block);
+            return tool === null ? [] : [tool];
+        }
+        if ((value.type === 'assistant' || value.type === 'user') && typeof value.message === 'object' && value.message !== null) {
+            const message = value.message;
+            const content = Array.isArray(message.content) ? message.content : [];
+            return content.flatMap((part) => {
+                if (!part || typeof part !== 'object')
+                    return [];
+                const item = part;
+                if (item.type === 'tool_use') {
+                    const tool = claudeToolUse(item);
+                    return tool === null ? [] : [tool];
+                }
+                if (item.type === 'tool_result') {
+                    const tool = claudeToolResult(item);
+                    return tool === null ? [] : [tool];
+                }
+                return typeof item.text === 'string' ? [{ type: 'text-delta', text: item.text }] : [];
+            });
+        }
+        return super.parseEvent(value, input);
+    }
+}
+function claudeToolUse(item) {
+    const toolName = firstToolText(item.name, item.toolName);
+    if (toolName === undefined)
+        return null;
+    const callId = firstToolText(item.id, item.tool_use_id, item.toolUseId);
+    const input = serializeToolValue(item.input ?? item.arguments);
+    const agentId = firstToolText(item.agentId, item.agent_id);
+    const detail = serializeToolValue(item.detail);
+    return {
+        type: 'tool-event',
+        toolName,
+        status: 'running',
+        ...(callId ? { callId } : {}),
+        ...(input !== undefined ? { input } : {}),
+        ...(agentId ? { agentId } : {}),
+        ...(detail !== undefined ? { detail } : {}),
+    };
+}
+function claudeToolResult(item) {
+    const callId = firstToolText(item.tool_use_id, item.toolUseId, item.callId);
+    if (callId === undefined)
+        return null;
+    const failed = item.is_error === true || item.isError === true;
+    const content = serializeToolValue(item.content ?? item.output ?? item.result);
+    const agentId = firstToolText(item.agentId, item.agent_id);
+    const detail = serializeToolValue(item.detail);
+    return {
+        type: 'tool-event',
+        toolName: firstToolText(item.name, item.toolName) ?? 'tool',
+        callId,
+        status: failed ? 'failed' : 'completed',
+        ...(failed ? (content === undefined ? {} : { error: content }) : (content === undefined ? {} : { output: content })),
+        ...(!failed && content !== undefined ? { outputMode: 'snapshot' } : {}),
+        ...(agentId ? { agentId } : {}),
+        ...(detail !== undefined ? { detail } : {}),
+    };
+}
+/** 简短别名，便于按适配器名称装配。 */
+export { ClaudeCodeDriver as ClaudeDriver };
+//# sourceMappingURL=claude-driver.js.map

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

@@ -0,0 +1,45 @@
+import { spawn, spawnSync } from 'node:child_process';
+import type { CodingNsAgentEvent, CodingNsAgentQuestionResponse, CodingNsCliModelCatalog, CodingNsAgentPermissionResponse, CodingNsCliTurnInput } from '../../shared/contracts/cli-adapter.js';
+import type { CodingNsCliDriver, CodingNsCliSessionProbeInput, CodingNsCliSessionProbeResult } from './driver.js';
+export interface CodexAppServerDriverOptions {
+    readonly binaries?: readonly string[];
+    readonly sessionRoots?: readonly string[];
+    readonly spawnSync?: typeof spawnSync;
+    readonly spawn?: typeof spawn;
+}
+/** Codex app-server 的 JSON-RPC 驱动，Host 只暴露统一文本流，不暴露线程和 token。 */
+export declare class CodexAppServerDriver implements CodingNsCliDriver {
+    readonly descriptor: {
+        readonly id: "codex";
+        readonly name: "Codex";
+        readonly protocol: "json-rpc";
+        readonly capabilities: readonly ["models", "stream", "resume", "interrupt", "tool-events", "reasoning", "usage", "permission", "questions", "steer"];
+    };
+    private readonly binaries;
+    private readonly runSpawnSync;
+    private readonly runSpawn;
+    private readonly sessionRoots;
+    private cachedBinary;
+    private readonly processes;
+    private readonly sessions;
+    constructor(options?: CodexAppServerDriverOptions);
+    detect(): Promise<{
+        installed: boolean;
+        version: string | null;
+        command: string | null;
+    }>;
+    listModels(): Promise<CodingNsCliModelCatalog>;
+    probeSession(input: CodingNsCliSessionProbeInput): Promise<CodingNsCliSessionProbeResult>;
+    executeTurn(input: CodingNsCliTurnInput): AsyncIterable<CodingNsAgentEvent>;
+    /** 将新输入 steer 到当前 Codex turn。 */
+    steer(sessionId: string, prompt: string): Promise<void>;
+    /** 中断当前 Codex turn，但保留 app-server 线程。 */
+    interrupt(sessionId: string): Promise<void>;
+    /** 回传原生权限请求；审批值只在 Host 进程中流转。 */
+    respondPermission(sessionId: string, response: CodingNsAgentPermissionResponse): void;
+    /** 回传 requestUserInput 的结构化回答。 */
+    respondQuestion(sessionId: string, response: CodingNsAgentQuestionResponse): void;
+    dispose(): void;
+    private getSession;
+}
+//# sourceMappingURL=codex-driver.d.ts.map