@dsh-cove/dsh-web-all 0.0.0-stage → 0.4.4

package/lib/types/host/services/ssh/store.js

@@ -0,0 +1,330 @@
+/**
+ * ssh host 服务域 —— 主机配置存储（全新实现；行为契约参考旧包）。
+ *
+ * 持久化 $DSH_HOME/dsh-ssh.json；~/.ssh/config 只读导入（解析 Host 块）。
+ * 机密（密码/key path/passphrase）仅在文件内，不进入任何投影。
+ */
+import { closeSync, existsSync, fchmodSync, fstatSync, lstatSync, mkdirSync, openSync, readFileSync, renameSync, unlinkSync, writeFileSync, writeSync, readSync } from 'node:fs';
+import { randomBytes } from 'node:crypto';
+import { isHostKeyFingerprint } from "../../../core/ssh/protocol.js";
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+export function storePath(dshHome) {
+    return join(dshHome ?? (process.env.DSH_HOME ?? join(homedir(), '.dsh')), 'dsh-ssh.json');
+}
+export function sshConfigPath() {
+    return join(homedir(), '.ssh', 'config');
+}
+const SCHEMA_VERSION = 1;
+const ALIAS_RE = /^[A-Za-z0-9._-]+$/;
+function validateEntry(payload) {
+    if (typeof payload !== 'object' || payload === null)
+        return 'body must be a JSON object';
+    const p = payload;
+    if (typeof p.host !== 'string' || p.host.trim() === '')
+        return 'host is required';
+    if (typeof p.user !== 'string' || p.user.trim() === '')
+        return 'user is required';
+    if (p.auth !== undefined) {
+        const auth = p.auth;
+        if (typeof auth !== 'object' || auth === null)
+            return 'auth must be an object';
+        if (auth.kind !== 'key' && auth.kind !== 'password' && auth.kind !== 'agent')
+            return 'auth.kind must be key, password or agent';
+        if (auth.kind === 'key' && (typeof auth.keyPath !== 'string' || auth.keyPath.trim() === ''))
+            return 'auth.keyPath is required for key auth';
+    }
+    if (p.hostKeyFingerprint !== undefined && !isHostKeyFingerprint(p.hostKeyFingerprint))
+        return 'hostKeyFingerprint must be a canonical SHA256 fingerprint';
+    if (p.port !== undefined && (typeof p.port !== 'number' || !Number.isInteger(p.port) || p.port < 1 || p.port > 65535))
+        return 'invalid port';
+    if (p.proxyJump !== undefined && (!Array.isArray(p.proxyJump) || p.proxyJump.some(x => typeof x !== 'string' || x === '')))
+        return 'proxyJump must be a string array';
+    const alias = p.alias;
+    if (typeof alias !== 'string' || !ALIAS_RE.test(alias))
+        return 'alias must be letters, digits, dots, hyphens or underscores';
+    return null;
+}
+export class HostStoreBusyError extends Error {
+    code = 'SSH_HOST_STORE_BUSY';
+    constructor() { super('SSH host store is busy; retry later or inspect its orphan lock with all writers stopped'); this.name = 'HostStoreBusyError'; }
+}
+/** 主机配置存储。 Locks cover the whole read-modify-save, not just rename. */
+export class HostStore {
+    path;
+    sshConfigOverride;
+    lockPath;
+    lockTimeoutMs;
+    constructor(path, sshConfigOverride, options = {}) {
+        this.path = resolve(path ?? storePath());
+        this.sshConfigOverride = sshConfigOverride;
+        this.lockPath = `${this.path}.lock`;
+        const timeout = options.lockTimeoutMs ?? 2000;
+        if (!Number.isFinite(timeout) || timeout < 0 || timeout > 10_000)
+            throw new Error('invalid SSH host store lock timeout');
+        this.lockTimeoutMs = timeout;
+    }
+    mutate(operation) {
+        mkdirSync(resolve(this.path, '..'), { recursive: true });
+        const lock = resolve(this.lockPath);
+        if (lock !== `${this.path}.lock`)
+            throw new Error('unexpected SSH host store lock path');
+        const token = randomBytes(32).toString('hex');
+        const owner = JSON.stringify({ token, pid: process.pid, createdAt: Date.now() });
+        const deadline = performance.now() + this.lockTimeoutMs;
+        const wait = new Int32Array(new SharedArrayBuffer(4));
+        let fd;
+        while (true) {
+            try {
+                fd = openSync(lock, 'wx+', 0o600);
+                break;
+            }
+            catch (error) {
+                if (error.code !== 'EEXIST')
+                    throw error;
+                const remaining = deadline - performance.now();
+                if (remaining <= 0)
+                    throw new HostStoreBusyError();
+                Atomics.wait(wait, 0, 0, Math.min(10, remaining));
+            }
+        }
+        const identity = fstatSync(fd);
+        let initialized = false;
+        const assertOwned = () => {
+            const named = lstatSync(lock);
+            const actual = fstatSync(fd);
+            if (!named.isFile() || named.dev !== identity.dev || named.ino !== identity.ino || actual.size !== Buffer.byteLength(owner)) {
+                throw new Error('SSH host store lock ownership changed; refusing mutation or lock removal');
+            }
+            const bytes = Buffer.alloc(Buffer.byteLength(owner));
+            if (readSync(fd, bytes, 0, bytes.length, 0) !== bytes.length || bytes.toString('utf8') !== owner) {
+                throw new Error('SSH host store lock ownership changed; refusing mutation or lock removal');
+            }
+        };
+        try {
+            fchmodSync(fd, 0o600);
+            const bytes = Buffer.from(owner);
+            let written = 0;
+            while (written < bytes.length) {
+                const count = writeSync(fd, bytes, written, bytes.length - written);
+                if (count <= 0)
+                    throw new Error('SSH host store lock owner could not be written');
+                written += count;
+            }
+            initialized = true;
+            assertOwned();
+            return operation(this.load(), assertOwned);
+        }
+        finally {
+            try {
+                if (initialized) {
+                    assertOwned();
+                    // Only this exact resolved path, inode and random owner token may be
+                    // removed. Crash/orphan locks are deliberately left for an operator;
+                    // PID reuse and timestamps are not safe proof that a writer is dead.
+                    if (resolve(lock) !== this.lockPath)
+                        throw new Error('unexpected SSH host store lock removal path');
+                    unlinkSync(lock);
+                }
+                else {
+                    const named = lstatSync(lock);
+                    if (named.isFile() && named.dev === identity.dev && named.ino === identity.ino && named.size === 0)
+                        unlinkSync(lock);
+                }
+            }
+            finally {
+                closeSync(fd);
+            }
+        }
+    }
+    load() {
+        let text;
+        try {
+            text = readFileSync(this.path, 'utf8');
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return { version: SCHEMA_VERSION, hosts: [] };
+            throw new Error('SSH host store cannot be read; refusing to replace it', { cause: error });
+        }
+        try {
+            const parsed = JSON.parse(text);
+            if (typeof parsed !== 'object' || parsed === null)
+                throw new Error('invalid store object');
+            const file = parsed;
+            if (file.version !== SCHEMA_VERSION || !Array.isArray(file.hosts))
+                throw new Error('unsupported SSH host store schema');
+            const aliases = new Set();
+            for (const host of file.hosts) {
+                if (validateEntry(host) !== null || host.auth === undefined || !Array.isArray(host.tags) || host.tags.some(tag => typeof tag !== 'string')
+                    || !Array.isArray(host.proxyJump) || !Number.isFinite(host.createdAt) || !Number.isFinite(host.updatedAt) || aliases.has(host.alias))
+                    throw new Error('invalid SSH host store entry');
+                aliases.add(host.alias);
+            }
+            return file;
+        }
+        catch (error) {
+            throw new Error('SSH host store is corrupt or unsupported; refusing to replace it', { cause: error });
+        }
+    }
+    save(file, assertOwned) {
+        assertOwned();
+        const dir = resolve(this.path, '..');
+        mkdirSync(dir, { recursive: true });
+        // Atomic replacement also repairs legacy permissive store modes. Never
+        // create secrets through a predictable path, regardless of process umask.
+        const temp = `${this.path}.${randomBytes(16).toString('hex')}.tmp`;
+        if (resolve(temp) !== temp || resolve(temp, '..') !== dir || !temp.startsWith(`${this.path}.`) || !temp.endsWith('.tmp'))
+            throw new Error('unexpected SSH host store temporary path');
+        const removeTemp = () => {
+            if (resolve(temp) !== temp || resolve(temp, '..') !== dir || !temp.startsWith(`${this.path}.`) || !temp.endsWith('.tmp'))
+                throw new Error('unexpected SSH host store temporary removal path');
+            unlinkSync(temp);
+        };
+        const fd = openSync(temp, 'wx', 0o600);
+        try {
+            fchmodSync(fd, 0o600);
+            writeFileSync(fd, JSON.stringify(file, null, 2), 'utf8');
+            closeSync(fd);
+        }
+        catch (error) {
+            try {
+                closeSync(fd);
+            }
+            catch { /* already closed */ }
+            removeTemp();
+            throw error;
+        }
+        try {
+            assertOwned();
+            renameSync(temp, this.path);
+        }
+        catch (error) {
+            removeTemp();
+            throw error;
+        }
+    }
+    list() {
+        return this.load().hosts;
+    }
+    find(alias) {
+        return this.list().find(entry => entry.alias === alias);
+    }
+    /** 安全投影（不含机密）。 */
+    summarize(entry) {
+        const keyReady = entry.auth.kind === 'key' && entry.auth.keyPath !== undefined
+            ? existsSync(entry.auth.keyPath)
+            : false;
+        return {
+            alias: entry.alias,
+            host: entry.host,
+            hostKeyFingerprint: entry.hostKeyFingerprint,
+            port: entry.port,
+            user: entry.user,
+            auth: entry.auth.kind,
+            keyReady,
+            proxyJump: entry.proxyJump,
+            description: entry.description,
+            environment: entry.environment,
+            tags: entry.tags,
+            location: entry.location,
+            createdAt: entry.createdAt,
+            updatedAt: entry.updatedAt,
+        };
+    }
+    upsert(input) {
+        const invalid = validateEntry(input);
+        if (invalid !== null)
+            throw new Error(invalid);
+        return this.mutate((file, assertOwned) => this.upsertOwned(file, input, assertOwned));
+    }
+    upsertOwned(file, input, assertOwned) {
+        const now = Date.now();
+        const existing = file.hosts.find(h => h.alias === input.alias);
+        const entry = existing === undefined
+            ? { ...input, createdAt: now, updatedAt: now }
+            : { ...existing, ...input, updatedAt: now };
+        if (existing === undefined)
+            file.hosts.push(entry);
+        else
+            file.hosts = file.hosts.map(h => h.alias === input.alias ? entry : h);
+        this.save(file, assertOwned);
+        return { entry, created: existing === undefined };
+    }
+    remove(alias) {
+        return this.mutate((file, assertOwned) => {
+            const before = file.hosts.length;
+            file.hosts = file.hosts.filter(h => h.alias !== alias);
+            if (file.hosts.length === before)
+                return false;
+            this.save(file, assertOwned);
+            return true;
+        });
+    }
+    /** 从 ~/.ssh/config 导入 Host 块（只读解析，不写回）。 */
+    importSshConfig() {
+        const configPath = this.sshConfigOverride ?? sshConfigPath();
+        if (!existsSync(configPath))
+            return { imported: [], skipped: [] };
+        const text = readFileSync(configPath, 'utf8');
+        const imported = [];
+        const skipped = [];
+        let currentHost;
+        let current = {};
+        const flush = () => {
+            if (currentHost === undefined || currentHost === '*' || !ALIAS_RE.test(currentHost)) {
+                if (currentHost !== undefined && currentHost !== '*')
+                    skipped.push(currentHost);
+                return;
+            }
+            const host = current['HostName'] ?? currentHost;
+            const port = Number(current['Port'] ?? 22);
+            const user = current['User'] ?? process.env.USER ?? 'root';
+            const auth = current['IdentityFile'] !== undefined
+                ? { kind: 'key', keyPath: current['IdentityFile'] }
+                : { kind: 'agent' };
+            imported.push({
+                alias: currentHost,
+                host,
+                port: Number.isInteger(port) && port > 0 && port <= 65535 ? port : 22,
+                user,
+                auth,
+                proxyJump: current['ProxyJump'] !== undefined ? current['ProxyJump'].split(/[\s,]+/).filter(Boolean) : [],
+                tags: [],
+                createdAt: Date.now(),
+                updatedAt: Date.now(),
+            });
+        };
+        for (const rawLine of text.split(/\r?\n/)) {
+            const line = rawLine.trim();
+            if (line === '' || line.startsWith('#'))
+                continue;
+            const m = /^Host\s+(.+)$/i.exec(line);
+            if (m !== null) {
+                flush();
+                currentHost = m[1].trim();
+                current = {};
+                continue;
+            }
+            const kv = /^(\w+)\s+(.+)$/.exec(line);
+            if (kv !== null && currentHost !== undefined) {
+                current[kv[1]] = kv[2].trim();
+            }
+        }
+        flush();
+        const committed = [];
+        for (const entry of imported) {
+            this.mutate((file, assertOwned) => {
+                // The existence check belongs to the same lock as the write. Another
+                // process may add this alias while config parsing is still in flight.
+                if (file.hosts.some(host => host.alias === entry.alias))
+                    return;
+                const invalid = validateEntry(entry);
+                if (invalid !== null)
+                    throw new Error(invalid);
+                committed.push(this.upsertOwned(file, entry, assertOwned).entry);
+            });
+        }
+        return { imported: committed, skipped };
+    }
+}

package/lib/types/host/services/ssh/terminal-ws.d.ts

@@ -0,0 +1,9 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { SshEngine } from './engine.ts';
+import type { HostStore } from './store.ts';
+/** 注册 /api/dsh-ssh/terminal 的 WS 升级处理。 */
+export declare function registerTerminalUpgrade(ctx: Context, deps: {
+    engine: SshEngine;
+    store: HostStore;
+}): () => void;
+//# sourceMappingURL=terminal-ws.d.ts.map

package/lib/types/host/services/ssh/terminal-ws.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"terminal-ws.d.ts","sourceRoot":"","sources":["../../../../../src/host/services/ssh/terminal-ws.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAGlD,OAAO,KAAK,EAAE,SAAS,EAA4C,MAAM,aAAa,CAAA;AACtF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAY3C,0CAA0C;AAC1C,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,SAAS,CAAA;CAAE,GAAG,MAAM,IAAI,CA8B/G"}

package/lib/types/host/services/ssh/terminal-ws.js

@@ -0,0 +1,142 @@
+import { WebSocket, WebSocketServer } from 'ws';
+import { SSH_API } from "../../../core/ssh/protocol.js";
+import { accessTrustOf } from "../access-trust/index.js";
+/** 发送缓冲背压阈值。 */
+const BACKPRESSURE_HIGH_WATER = 1024 * 1024;
+const BACKPRESSURE_LOW_WATER = 512 * 1024;
+function queryParam(url, name) {
+    const value = url.searchParams.get(name);
+    return value === null ? undefined : value;
+}
+/** 注册 /api/dsh-ssh/terminal 的 WS 升级处理。 */
+export function registerTerminalUpgrade(ctx, deps) {
+    const { engine, store } = deps;
+    const wss = new WebSocketServer({ noServer: true });
+    const isTrusted = accessTrustOf(ctx).isTrusted;
+    const dispose = ctx.webServer.registerUpgrade({
+        path: SSH_API.terminal,
+        handler: (req, socket, head) => {
+            if (!isTrusted(req)) {
+                socket.write('HTTP/1.1 403 Forbidden\r\nConnection: close\r\n\r\n');
+                socket.destroy();
+                return;
+            }
+            const url = new URL(req.url ?? '/', 'http://localhost');
+            const alias = queryParam(url, 'alias');
+            if (alias === undefined) {
+                socket.write('HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n');
+                socket.destroy();
+                return;
+            }
+            const cols = Number.parseInt(queryParam(url, 'cols') ?? '80', 10);
+            const rows = Number.parseInt(queryParam(url, 'rows') ?? '24', 10);
+            wss.handleUpgrade(req, socket, head, (ws) => {
+                attach(ctx, { engine, store }, ws, alias, Number.isFinite(cols) ? cols : 80, Number.isFinite(rows) ? rows : 24);
+            });
+        },
+    });
+    return () => {
+        dispose();
+        wss.close();
+    };
+}
+function attach(ctx, deps, ws, alias, cols, rows) {
+    const { engine, store } = deps;
+    let session;
+    let closed = false;
+    let paused = false;
+    let pendingAuthFinish;
+    const resume = () => {
+        if (paused && ws.bufferedAmount < BACKPRESSURE_LOW_WATER) {
+            paused = false;
+            session?.resume();
+        }
+    };
+    const sendFrame = (frame) => {
+        if (closed || ws.readyState !== WebSocket.OPEN)
+            return;
+        ws.send(JSON.stringify(frame), resume);
+        if (!paused && ws.bufferedAmount > BACKPRESSURE_HIGH_WATER) {
+            paused = true;
+            session?.pause();
+        }
+    };
+    const closeSession = () => {
+        if (pendingAuthFinish !== undefined) {
+            const finish = pendingAuthFinish;
+            pendingAuthFinish = undefined;
+            try {
+                finish([]);
+            }
+            catch { /* ignore */ }
+        }
+        const opened = session;
+        session = undefined;
+        if (opened !== undefined)
+            opened.close();
+    };
+    const onKeyboardInteractive = (name, instructions, _lang, prompts, finish) => {
+        const entry = store.find(alias);
+        if (entry?.auth.kind === 'password' && entry.auth.password !== undefined && prompts.length > 0 && prompts.every(p => /password/i.test(p.prompt))) {
+            const password = entry.auth.password;
+            finish(prompts.map(() => password));
+            return;
+        }
+        pendingAuthFinish = finish;
+        sendFrame({ type: 'auth_prompt', name, instructions, prompts: prompts.map(p => ({ prompt: p.prompt, echo: p.echo })) });
+    };
+    void engine.openShell(alias, { cols, rows }, onKeyboardInteractive).then((opened) => {
+        if (ws.readyState !== WebSocket.OPEN) {
+            opened.close();
+            return;
+        }
+        session = opened;
+        sendFrame({ type: 'ready', alias });
+        opened.onData = (data) => sendFrame({ type: 'output', data: data.toString('utf8') });
+        opened.onExit = (code, error) => {
+            sendFrame({ type: 'exit', code, error });
+            closed = true;
+            try {
+                ws.close(1000);
+            }
+            catch { /* already closed */ }
+        };
+    }).catch((error) => {
+        sendFrame({ type: 'exit', code: null, error: error instanceof Error ? error.message : String(error) });
+        closed = true;
+        try {
+            ws.close(1000);
+        }
+        catch { /* already closed */ }
+    });
+    ws.on('message', (data) => {
+        let frame;
+        try {
+            frame = JSON.parse(String(data));
+        }
+        catch {
+            return;
+        }
+        if (frame.type === 'input') {
+            session?.send(frame.data);
+        }
+        else if (frame.type === 'resize') {
+            session?.resize(frame.cols, frame.rows);
+        }
+        else if (frame.type === 'auth_response') {
+            if (pendingAuthFinish !== undefined) {
+                const finish = pendingAuthFinish;
+                pendingAuthFinish = undefined;
+                finish(frame.responses);
+            }
+        }
+    });
+    ws.on('close', () => {
+        closed = true;
+        closeSession();
+    });
+    ws.on('error', () => {
+        closed = true;
+        closeSession();
+    });
+}

package/lib/types/host/services/ssh/tools.d.ts

@@ -0,0 +1,11 @@
+import type { SshEngine } from './engine.ts';
+import type { HostStore } from './store.ts';
+export declare function sshListTool(engine: SshEngine): import("@deepseek-ai/dsh-tools").ToolDefinition;
+export declare function sshExecTool(engine: SshEngine): import("@deepseek-ai/dsh-tools").ToolDefinition;
+export declare function sshUploadTool(engine: SshEngine): import("@deepseek-ai/dsh-tools").ToolDefinition;
+export declare function sshDownloadTool(engine: SshEngine): import("@deepseek-ai/dsh-tools").ToolDefinition;
+export declare function sshTunnelTool(engine: SshEngine): import("@deepseek-ai/dsh-tools").ToolDefinition;
+export declare function sshClusterTool(engine: SshEngine): import("@deepseek-ai/dsh-tools").ToolDefinition;
+/** 全部 ssh agent 工具。 */
+export declare function makeSshTools(engine: SshEngine, _store: HostStore): Array<ReturnType<typeof sshListTool>>;
+//# sourceMappingURL=tools.d.ts.map

package/lib/types/host/services/ssh/tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../../../../src/host/services/ssh/tools.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAC5C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AA6B3C,wBAAgB,WAAW,CAAC,MAAM,EAAE,SAAS,mDA2C5C;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,SAAS,mDAgC5C;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,SAAS,mDA0B9C;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,mDAwChD;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,SAAS,mDA6B9C;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,SAAS,mDA+C/C;AAED,uBAAuB;AACvB,wBAAgB,YAAY,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,GAAG,KAAK,CAAC,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC,CASxG"}