@jingyi0605/codingns4dsh 0.1.0

package/data/build/dist/host/terminal/terminal-process-store.js

@@ -0,0 +1,183 @@
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+const STORE_VERSION = 1;
+export class JsonFileTerminalProcessStorePersistence {
+    filename;
+    constructor(filename) {
+        this.filename = filename;
+    }
+    async load() {
+        try {
+            return JSON.parse(await readFile(this.filename, 'utf8'));
+        }
+        catch (error) {
+            if (isMissingFile(error))
+                return { version: STORE_VERSION, profiles: [], instances: [] };
+            throw error;
+        }
+    }
+    async save(document) {
+        const directory = dirname(this.filename);
+        const temporary = `${this.filename}.${process.pid}.tmp`;
+        await mkdir(directory, { recursive: true, mode: 0o700 });
+        await writeFile(temporary, `${JSON.stringify(document, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
+        await rename(temporary, this.filename);
+    }
+}
+export class InMemoryTerminalProcessStorePersistence {
+    document;
+    constructor(initial = { version: STORE_VERSION, profiles: [], instances: [] }) {
+        this.document = structuredClone(initial);
+    }
+    async load() { return structuredClone(this.document); }
+    async save(document) { this.document = structuredClone(document); }
+}
+export class TerminalProcessStore {
+    persistence;
+    profiles = new Map();
+    instances = new Map();
+    writeTail = Promise.resolve();
+    loaded = false;
+    constructor(persistence) {
+        this.persistence = persistence;
+    }
+    async load() {
+        if (this.loaded)
+            return;
+        const document = parseDocument(await this.persistence.load());
+        this.profiles = new Map(document.profiles.map((profile) => [profileKey(profile), cloneProfile(profile)]));
+        this.instances = new Map(document.instances.map((instance) => [instanceKey(instance), cloneInstance(instance)]));
+        this.loaded = true;
+    }
+    getProfile(workspaceId, profileId) {
+        this.requireLoaded();
+        const profile = this.profiles.get(JSON.stringify([workspaceId, profileId]));
+        return profile === undefined ? undefined : cloneProfile(profile);
+    }
+    listProfiles(workspaceId) {
+        this.requireLoaded();
+        return [...this.profiles.values()]
+            .filter((profile) => workspaceId === undefined || profile.workspaceId === workspaceId)
+            .map(cloneProfile);
+    }
+    putProfile(profile) {
+        this.requireLoaded();
+        return this.enqueue(async () => {
+            this.profiles.set(profileKey(profile), cloneProfile(profile));
+            await this.persist();
+        });
+    }
+    deleteProfile(workspaceId, profileId) {
+        this.requireLoaded();
+        return this.enqueue(async () => {
+            const deleted = this.profiles.delete(JSON.stringify([workspaceId, profileId]));
+            if (deleted)
+                await this.persist();
+            return deleted;
+        });
+    }
+    getInstance(instanceId) {
+        this.requireLoaded();
+        const instance = this.instances.get(instanceId);
+        return instance === undefined ? undefined : cloneInstance(instance);
+    }
+    listInstances(workspaceId) {
+        this.requireLoaded();
+        return [...this.instances.values()]
+            .filter((instance) => workspaceId === undefined || instance.workspaceId === workspaceId)
+            .sort((left, right) => (left.startedAt ?? '').localeCompare(right.startedAt ?? ''))
+            .map(cloneInstance);
+    }
+    putInstance(instance) {
+        this.requireLoaded();
+        return this.enqueue(async () => {
+            this.instances.set(instance.id, cloneInstance(instance));
+            await this.persist();
+        });
+    }
+    enqueue(operation) {
+        const pending = this.writeTail.then(operation, operation);
+        this.writeTail = pending.then(() => undefined, () => undefined);
+        return pending;
+    }
+    async persist() {
+        await this.persistence.save({
+            version: STORE_VERSION,
+            profiles: [...this.profiles.values()],
+            instances: [...this.instances.values()],
+        });
+    }
+    requireLoaded() {
+        if (!this.loaded)
+            throw new Error('终端进程存储尚未加载');
+    }
+}
+function parseDocument(value) {
+    if (!isRecord(value) || value.version !== STORE_VERSION || !Array.isArray(value.profiles) || !Array.isArray(value.instances)) {
+        throw new TypeError('终端进程存储格式无效');
+    }
+    return {
+        version: STORE_VERSION,
+        profiles: value.profiles.map(parseProfile),
+        instances: value.instances.map(parseInstance),
+    };
+}
+function parseProfile(value) {
+    if (!isRecord(value))
+        throw new TypeError('终端启动项必须是对象');
+    const profile = value;
+    validateProfile(profile);
+    return cloneProfile(profile);
+}
+function parseInstance(value) {
+    if (!isRecord(value))
+        throw new TypeError('终端进程实例必须是对象');
+    const instance = value;
+    validateInstance(instance);
+    return cloneInstance(instance);
+}
+export function validateProfile(profile) {
+    for (const [name, value] of [['id', profile.id], ['workspaceId', profile.workspaceId], ['name', profile.name], ['command', profile.command], ['createdAt', profile.createdAt], ['updatedAt', profile.updatedAt]]) {
+        if (typeof value !== 'string' || value.trim() === '')
+            throw new TypeError(`终端启动项字段 ${name} 无效`);
+    }
+    if (!isRelativePath(profile.cwdRelative))
+        throw new TypeError('终端启动项 cwdRelative 必须是 Workspace 内相对路径');
+    if (!Array.isArray(profile.args) || profile.args.some((value) => typeof value !== 'string'))
+        throw new TypeError('终端启动项 args 无效');
+    if (!isRecord(profile.env) || Object.entries(profile.env).some(([key, value]) => key.trim() === '' || typeof value !== 'string'))
+        throw new TypeError('终端启动项 env 无效');
+    if (Object.keys(profile.env).some(isSecretEnvironmentName))
+        throw new TypeError('终端启动项不能持久化 TOKEN、SECRET、PASSWORD 或 KEY 环境变量');
+    if (profile.runtimeMode !== 'pty')
+        throw new TypeError('当前终端启动器只支持 runtimeMode=pty');
+    if (!Number.isSafeInteger(profile.revision) || profile.revision < 1)
+        throw new TypeError('终端启动项 revision 无效');
+}
+function validateInstance(instance) {
+    for (const [name, value] of [['id', instance.id], ['workspaceId', instance.workspaceId], ['profileId', instance.profileId], ['terminalId', instance.terminalId]]) {
+        if (typeof value !== 'string' || value.trim() === '')
+            throw new TypeError(`终端进程实例字段 ${name} 无效`);
+    }
+    if (!['starting', 'running', 'stopping', 'exited', 'failed', 'lost'].includes(instance.state))
+        throw new TypeError('终端进程实例 state 无效');
+    if (instance.pid !== null && (!Number.isSafeInteger(instance.pid) || instance.pid < 1))
+        throw new TypeError('终端进程实例 pid 无效');
+    if (instance.runtimeSessionKey !== null && typeof instance.runtimeSessionKey !== 'string')
+        throw new TypeError('终端进程实例 runtimeSessionKey 无效');
+    if (!isRecord(instance.resolvedCommand) || typeof instance.resolvedCommand.command !== 'string' || !Array.isArray(instance.resolvedCommand.args) || typeof instance.resolvedCommand.cwd !== 'string')
+        throw new TypeError('终端进程实例 resolvedCommand 无效');
+}
+function cloneProfile(profile) {
+    return { ...profile, args: [...profile.args], env: { ...profile.env }, shell: { ...profile.shell, args: [...profile.shell.args] } };
+}
+function cloneInstance(instance) {
+    return { ...instance, resolvedCommand: { ...instance.resolvedCommand, args: [...instance.resolvedCommand.args] } };
+}
+function profileKey(profile) { return JSON.stringify([profile.workspaceId, profile.id]); }
+function instanceKey(instance) { return instance.id; }
+function isRelativePath(value) { return value === '.' || (value.trim() !== '' && !value.startsWith('/') && !/^[A-Za-z]:[\\/]/u.test(value) && value !== '..' && !value.startsWith('../') && !value.includes('/../') && !value.includes('\\..')); }
+function isSecretEnvironmentName(value) { return /(?:TOKEN|SECRET|PASSWORD|PRIVATE_KEY|API_KEY)/iu.test(value); }
+function isRecord(value) { return typeof value === 'object' && value !== null && !Array.isArray(value); }
+function isMissingFile(error) { return isRecord(error) && error.code === 'ENOENT'; }
+//# sourceMappingURL=terminal-process-store.js.map

package/data/build/dist/host/terminal/terminal-service.d.ts

@@ -0,0 +1,87 @@
+import type { CodingNsTerminalFrame, CodingNsTerminalRuntimeType, CodingNsTerminalShell, CodingNsWebTerminalInfo, PersistentTerminalRecord, TerminalOwnerScope, TerminalRecordIdentity } from '../../shared/contracts/terminal.js';
+import type { TerminalRuntimeManager } from './runtime-manager.js';
+import type { CodingNsTerminalStore } from './terminal-store.js';
+export interface CreatePersistentTerminalInput {
+    readonly scope: TerminalOwnerScope;
+    readonly terminalId: string;
+    readonly runtimeType: CodingNsTerminalRuntimeType;
+    readonly shell: CodingNsTerminalShell;
+    /** 可选的业务标题；普通终端未提供时使用 Shell 名称。 */
+    readonly title?: string;
+    readonly commandPath?: string;
+    readonly commandArgs?: readonly string[];
+    readonly commandEnv?: Readonly<Record<string, string>>;
+    readonly launchProfileId?: string;
+    readonly cwd: string;
+    readonly cols: number;
+    readonly rows: number;
+    /** 仅保存在当前 Host 内存中的运行时退出通知，不进入终端持久记录。 */
+    readonly onExit?: (exitCode: number | null) => void | Promise<void>;
+}
+export interface FollowPersistentTerminalInput {
+    readonly identity: TerminalRecordIdentity;
+    readonly attachmentId: string;
+    readonly generation: string;
+    readonly signal: AbortSignal;
+}
+/**
+ * 持久终端生命周期服务。
+ *
+ * store 决定“终端是什么”，runtime manager 决定“当前如何连上它”。插件停用时
+ * dispose 只释放后者；只有 close 会调用 backend.terminate。
+ */
+export declare class CodingNsTerminalService {
+    private readonly store;
+    private readonly runtimes;
+    private readonly now;
+    private readonly controllers;
+    private readonly followers;
+    private readonly operations;
+    private readonly exitCallbacks;
+    private initialized;
+    constructor(store: CodingNsTerminalStore, runtimes: TerminalRuntimeManager, now?: () => Date);
+    initialize(): Promise<void>;
+    list(scope: TerminalOwnerScope): readonly CodingNsWebTerminalInfo[];
+    /** 兼容旧调用名；真正的持久归属只按 Host + workspace 查询。 */
+    listSession(hostId: string, dshSessionId: string, workspaceId?: string): readonly CodingNsWebTerminalInfo[];
+    listWorkspace(hostId: string, workspaceId: string): readonly CodingNsWebTerminalInfo[];
+    findIdentity(hostId: string, dshSessionId: string, terminalId: string, workspaceId?: string): TerminalRecordIdentity;
+    create(input: CreatePersistentTerminalInput): Promise<CodingNsWebTerminalInfo>;
+    /** 返回 Host 侧完整记录，供进程服务读取 runtimeSessionKey 和运行身份。 */
+    getRecord(identity: TerminalRecordIdentity): PersistentTerminalRecord | undefined;
+    inspect(identity: TerminalRecordIdentity): Promise<import("./runtime-adapter.js").TerminalRuntimeIdentity>;
+    recover(): Promise<void>;
+    retain(identity: TerminalRecordIdentity, signal: AbortSignal): AsyncIterable<{
+        type: 'retained';
+    }>;
+    follow(input: FollowPersistentTerminalInput): AsyncIterable<CodingNsTerminalFrame>;
+    write(identity: TerminalRecordIdentity, attachmentId: string, data: string): Promise<void>;
+    /** Host 内部向持久终端发送一次输入，不改变浏览器 attach 控制权。 */
+    writeInitialInput(identity: TerminalRecordIdentity, data: string): Promise<void>;
+    resize(identity: TerminalRecordIdentity, attachmentId: string, cols: number, rows: number): Promise<void>;
+    rename(identity: TerminalRecordIdentity, title: string): Promise<void>;
+    close(identity: TerminalRecordIdentity): Promise<void>;
+    detachGeneration(generation: string): Promise<void>;
+    /** 插件卸载只断开 attach，持久 backend 必须继续运行。 */
+    dispose(): Promise<void>;
+    private requireController;
+    private requireAvailable;
+    private refreshRuntimeState;
+    private handleRuntimeExit;
+    private markExited;
+    private info;
+    private update;
+    private broadcastState;
+    private broadcastStateByKey;
+    private addFollower;
+    private removeFollower;
+    private finishFollowers;
+    private enqueue;
+    private requireInitialized;
+}
+export type TerminalServiceErrorCode = 'TERMINAL_UNAVAILABLE' | 'TERMINAL_CONTROL_UNAVAILABLE' | 'TERMINAL_RUNTIME_LOST';
+export declare class TerminalServiceError extends Error {
+    readonly code: TerminalServiceErrorCode;
+    constructor(code: TerminalServiceErrorCode, message: string);
+}
+//# sourceMappingURL=terminal-service.d.ts.map