dsh-model 0.0.1 → 0.15.0

package/dist/commands/uninstall.js

@@ -0,0 +1,97 @@
+// commands/uninstall.ts — 按台账逆序拆除：remote → dsh 接线 → 服务 → home。每步失败不中断，最后汇总
+import { cp, rm } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { createInterface } from 'node:readline/promises';
+import { requireRootInVps } from '../context.js';
+import { disconnectDsh } from '../dsh/connect.js';
+import { listAuthFiles } from '../engine/auth.js';
+import { L } from '../i18n.js';
+import { loadAll, saveAll } from '../ops.js';
+import { serviceFor } from '../service/index.js';
+import { exists, timestamp } from '../util/fs.js';
+import { fail, info, ok, warn } from '../util/output.js';
+import { disable as disableRemote } from './remote.js';
+import { disableWorkbuddy, removeWorkbuddyPlugin } from '../integrations/workbuddy.js';
+import { removeDshPlugin } from '../integrations/dshplugin.js';
+async function confirm(question) {
+    if (!process.stdin.isTTY)
+        return false;
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        return /^(y|yes|是)$/i.test((await rl.question(`${question} [y/N] `)).trim());
+    }
+    finally {
+        rl.close();
+    }
+}
+export async function uninstall(ctx, opts) {
+    requireRootInVps(ctx);
+    if (!(await exists(ctx.paths.home))) {
+        info(L('没有安装过 dsh-model（或已卸载）', 'dsh-model is not installed (or already removed)'));
+        return 0;
+    }
+    const all = await loadAll(ctx);
+    const authCount = (await listAuthFiles(ctx)).length;
+    if (!opts.yes) {
+        info(L('将要：关闭远程访问 → 移除 WorkBuddy bridge → 还原 dsh 配置 → 移除引擎服务 → 删除 ' + ctx.paths.home + '（含 OpenCode key 与 WorkBuddy 令牌副本）', 'This will: disable remote access → remove the WorkBuddy bridge → restore dsh config → remove the engine service → delete ' + ctx.paths.home + ' (incl. the OpenCode key and WorkBuddy token copies)'));
+        if (authCount && !opts.keepAuth)
+            info(L(`其中包括 ${authCount} 个上游登录凭据（加 --keep-auth 可先备份出来）`, `including ${authCount} upstream login credentials (add --keep-auth to back them up first)`));
+        if (!(await confirm(L('确认卸载？', 'Proceed with uninstall?')))) {
+            info(L('已取消', 'Cancelled'));
+            return 1;
+        }
+    }
+    const errors = [];
+    const step = async (name, fn) => {
+        try {
+            await fn();
+        }
+        catch (error) {
+            errors.push(`${name}: ${error.message}`);
+            fail(`${name}: ${error.message}`);
+        }
+    };
+    await step('remote', async () => {
+        if (all.state.remote && all.state.remote.mode !== 'off')
+            await disableRemote(ctx, all);
+    });
+    await step('dsh-plugin', async () => {
+        if (await removeDshPlugin(ctx, all, { force: opts.removePlugin }))
+            ok(L('已从 dsh 移除 dsh-model 插件', 'Removed the dsh-model plugin from dsh'));
+    });
+    await step('workbuddy', async () => {
+        if (await removeWorkbuddyPlugin(ctx, all))
+            ok(L('已移除上一版安装的 WorkBuddy 插件', 'Removed the WorkBuddy plugin installed by a previous version'));
+        if (await disableWorkbuddy(ctx, all))
+            ok(L('WorkBuddy bridge 服务已移除', 'WorkBuddy bridge service removed'));
+    });
+    await step('dsh', async () => {
+        if (!all.state.dsh)
+            return;
+        const r = await disconnectDsh(ctx, all.state);
+        ok(L(`dsh 配置已还原（patch：${r.patch}，凭据：${r.cred}）`, `dsh config restored (patch: ${r.patch}, credentials: ${r.cred})`));
+    });
+    await saveAll(ctx, all).catch(() => { });
+    await step('service', async () => {
+        if (ctx.serviceDisabled)
+            return;
+        await serviceFor(ctx).uninstall();
+        ok(L('系统服务已移除', 'Service removed'));
+    });
+    await step('auth-backup', async () => {
+        if (!opts.keepAuth || !authCount)
+            return;
+        const dest = join(homedir(), `dsh-model-auth-backup-${timestamp()}`);
+        await cp(ctx.paths.auth, dest, { recursive: true, filter: (src) => !src.includes('/logs') });
+        ok(L(`登录凭据已备份到 ${dest}`, `Credentials backed up to ${dest}`));
+    });
+    if (errors.length) {
+        warn(L(`有 ${errors.length} 步失败，保留了 ${ctx.paths.home} 以便重试（再次执行 uninstall）`, `${errors.length} step(s) failed; kept ${ctx.paths.home} so you can retry (run uninstall again)`));
+        return 1;
+    }
+    await rm(ctx.paths.home, { recursive: true, force: true });
+    ok(L(`已删除 ${ctx.paths.home}，卸载完成`, `Deleted ${ctx.paths.home}; uninstall complete`));
+    info(L('最后可执行：npm uninstall -g dsh-model', 'Finally you can run: npm uninstall -g dsh-model'));
+    return 0;
+}

package/dist/commands/workbuddy.js

@@ -0,0 +1,117 @@
+// commands/workbuddy.ts — dsh-model workbuddy [status|login|logout|enable|refresh|disable]
+import { requireRootInVps } from '../context.js';
+import { availableVariants, loadCatalogs } from '../bridge/runtime.js';
+import { DshModelError } from '../errors.js';
+import { L } from '../i18n.js';
+import { disableWorkbuddy, enableWorkbuddy, refreshBridge, riskNotice } from '../integrations/workbuddy.js';
+import { workbuddyLogin, workbuddyLogout } from '../bridge/login.js';
+import { WORKBUDDY_VARIANTS } from '../bridge/workbuddy/variants.js';
+import { bold } from '../util/output.js';
+import { loadAll, saveAll, syncAll } from '../ops.js';
+import { withLock } from '../state.js';
+import { info, isJsonMode, ok, printJson, skip, warn } from '../util/output.js';
+/** cn / ai（也认 workbuddy / workbuddy-ai），默认国内版 */
+function pickVariant(arg) {
+    const a = (arg ?? 'cn').toLowerCase();
+    const id = a === 'ai' || a === 'workbuddy-ai' || a === 'global' ? 'workbuddy-ai' : a === 'cn' || a === 'workbuddy' ? 'workbuddy' : '';
+    const v = WORKBUDDY_VARIANTS.find((x) => x.id === id);
+    if (!v)
+        throw new DshModelError('unknown_workbuddy_product', L(`不认识的产品：${arg}（cn 或 ai）`, `Unknown product: ${arg} (cn or ai)`));
+    return v;
+}
+export async function workbuddy(ctx, sub, arg) {
+    if (sub === 'login')
+        return login(ctx, pickVariant(arg));
+    if (sub === 'logout')
+        return logout(ctx, pickVariant(arg));
+    if (!sub || sub === 'status') {
+        const [apps, cats] = await Promise.all([availableVariants(ctx.paths.home), loadCatalogs(ctx.paths.home)]);
+        if (isJsonMode()) {
+            printJson({ apps: apps.map((v) => v.displayName), catalogs: cats.map(({ models, ...c }) => ({ ...c, models: models.length })) });
+            return 0;
+        }
+        info(L(`App：${apps.length ? apps.map((v) => v.displayName).join('、') : '未检测到'}`, `App: ${apps.length ? apps.map((v) => v.displayName).join(', ') : 'not found'}`));
+        for (const c of cats) {
+            info(`  ${c.label}: ${c.signedIn ? L(`已登录${c.nickname ? `（${c.nickname}）` : ''}，${c.models.length} 个模型`, `signed in${c.nickname ? ` (${c.nickname})` : ''}, ${c.models.length} models`) : L('未登录', 'not signed in')}${c.error ? `  — ${c.error}` : ''}`);
+        }
+        return 0;
+    }
+    requireRootInVps(ctx);
+    if (sub === 'refresh') {
+        if (await refreshBridge(ctx))
+            ok(L('bridge 已重读 WorkBuddy 登录态与目录，并同步到引擎和 dsh', 'bridge re-read WorkBuddy sign-in and catalog and synced the engine and dsh'));
+        else
+            warn(L('bridge 没在运行（dsh-model workbuddy enable）', 'bridge is not running (dsh-model workbuddy enable)'));
+        return 0;
+    }
+    return withLock(ctx, async () => {
+        const all = await loadAll(ctx);
+        if (sub === 'enable') {
+            await enableWorkbuddy(ctx, all);
+            await saveAll(ctx, all);
+            await syncAll(ctx, all);
+            return 0;
+        }
+        if (sub === 'disable') {
+            if (!(await disableWorkbuddy(ctx, all))) {
+                skip(L('WorkBuddy 本来就没启用', 'WorkBuddy was not enabled'));
+                return 0;
+            }
+            delete all.config.bridge;
+            await saveAll(ctx, all);
+            // bridge 不在了，目录文件也作废：删掉后重新生成引擎配置
+            const { rm } = await import('node:fs/promises');
+            const { bridgeDir, bridgeConfigPath } = await import('../bridge/runtime.js');
+            await rm(bridgeDir(ctx.paths.home), { recursive: true, force: true });
+            await rm(bridgeConfigPath(ctx.paths.home), { force: true });
+            await syncAll(ctx, all, { quiet: true });
+            ok(L('已停用 WorkBuddy（bridge 服务、目录与登录副本已移除）', 'WorkBuddy disabled (bridge service, catalogs and token copies removed)'));
+            return 0;
+        }
+        throw new DshModelError('unknown_command', L(`未知子命令：workbuddy ${sub}`, `Unknown subcommand: workbuddy ${sub}`));
+    });
+}
+/**
+ * 登录：轮询期间不持锁（最长 10 分钟），拿到令牌后再持锁启用 / 重启 bridge 并同步。
+ */
+async function login(ctx, variant) {
+    requireRootInVps(ctx);
+    const all = await loadAll(ctx);
+    if (!all.config.bridge?.riskNoticeAt)
+        warn(riskNotice());
+    info(L(`正在向 ${variant.displayName} 申请授权链接…`, `Requesting an authorization link from ${variant.displayName}…`));
+    const credential = await workbuddyLogin(variant, ctx.paths.home, {
+        proxy: all.config.proxy,
+        owner: ctx.owner,
+        onUrl: (url) => {
+            info('');
+            info(bold(L('在任意设备的浏览器里打开下面的链接并授权（服务器上不需要浏览器）：', 'Open this link in a browser on any device and approve (no browser needed on the server):')));
+            info(`\n  ${url}\n`);
+            info(L('等待授权中（最长 10 分钟，Ctrl+C 取消）…', 'Waiting for approval (up to 10 minutes, Ctrl+C to cancel)…'));
+        },
+    });
+    ok(L(`${variant.displayName} 已登录${credential.nickname ? `（${credential.nickname}）` : ''}；令牌只存在 dsh-model 自己的目录（0600）`, `${variant.displayName} signed in${credential.nickname ? ` (${credential.nickname})` : ''}; the token is kept only in dsh-model's own directory (0600)`));
+    return withLock(ctx, async () => {
+        const fresh = await loadAll(ctx);
+        await enableWorkbuddy(ctx, fresh);
+        await saveAll(ctx, fresh);
+        await syncAll(ctx, fresh);
+        return 0;
+    });
+}
+async function logout(ctx, variant) {
+    requireRootInVps(ctx);
+    if (!(await workbuddyLogout(variant, ctx.paths.home))) {
+        skip(L(`${variant.displayName} 没有用 dsh-model 登录过（桌面 App 的登录请在 App 里退出）`, `${variant.displayName} was not signed in through dsh-model (sign out of the desktop app in the app itself)`));
+        return 0;
+    }
+    ok(L(`已删除 dsh-model 保存的 ${variant.displayName} 令牌`, `Deleted the ${variant.displayName} token saved by dsh-model`));
+    return withLock(ctx, async () => {
+        const all = await loadAll(ctx);
+        if (all.state.bridgeService)
+            await enableWorkbuddy(ctx, all); // 重启 bridge，让它不再服务这个产品
+        await saveAll(ctx, all);
+        await syncAll(ctx, all, { quiet: true });
+        return 0;
+    });
+}

package/dist/context.js

@@ -0,0 +1,86 @@
+// context.ts — 运行模式与所有路径
+//
+// local：普通用户在 Mac / Linux 上自用，状态在 ~/.dsh-model，服务是用户级的
+// vps  ：检测到 dsh-vps（/opt/dsh-vps），需要 root；引擎以 dsh 用户运行，状态在 /home/dsh/.dsh-model
+//
+// 测试与特殊场景可用环境变量覆盖：DSH_MODEL_MODE、DSH_MODEL_HOME、DSH_HOME、DSH_MODEL_SERVICE=none
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { DshModelError } from './errors.js';
+import { L } from './i18n.js';
+import { run } from './util/exec.js';
+export const VPS_ROOT = '/opt/dsh-vps';
+export const VPS_USER = 'dsh';
+export const VPS_USER_HOME = '/home/dsh';
+export function detectMode(env = process.env, platform = process.platform) {
+    const forced = env.DSH_MODEL_MODE;
+    if (forced === 'local' || forced === 'vps')
+        return forced;
+    return platform === 'linux' && existsSync(VPS_ROOT) ? 'vps' : 'local';
+}
+export function makePaths(home) {
+    const engineDir = join(home, 'engine');
+    const auth = join(home, 'auth');
+    return {
+        home,
+        config: join(home, 'config.json'),
+        state: join(home, 'state.json'),
+        keys: join(home, 'keys.json'),
+        engineYaml: join(home, 'engine.yaml'),
+        engineDir,
+        versionsDir: join(engineDir, 'versions'),
+        current: join(engineDir, 'current'),
+        auth,
+        replaced: join(auth, '.replaced'),
+        backups: join(home, 'backups'),
+        logs: join(auth, 'logs'), // 引擎把日志写在 auth-dir/logs 下（实测 v8.0.13）
+        tmp: join(home, 'tmp'),
+        lock: join(home, '.lock'),
+    };
+}
+export async function createContext(env = process.env) {
+    const platform = process.platform;
+    if (platform !== 'darwin' && platform !== 'linux') {
+        throw new DshModelError('unsupported_platform', L(`暂不支持这个平台：${platform}（只支持 macOS 和 Linux）`, `Unsupported platform: ${platform} (macOS and Linux only)`));
+    }
+    const mode = detectMode(env, platform);
+    const isRoot = typeof process.getuid === 'function' && process.getuid() === 0;
+    const serviceDisabled = env.DSH_MODEL_SERVICE === 'none';
+    if (mode === 'vps') {
+        const home = env.DSH_MODEL_HOME ? resolve(env.DSH_MODEL_HOME) : join(VPS_USER_HOME, '.dsh-model');
+        return {
+            mode,
+            platform,
+            paths: makePaths(home),
+            owner: await lookupOwner(VPS_USER),
+            runAs: VPS_USER,
+            dshHome: env.DSH_HOME ? resolve(env.DSH_HOME) : join(VPS_USER_HOME, '.dsh'),
+            isRoot,
+            serviceDisabled,
+            env,
+        };
+    }
+    const home = env.DSH_MODEL_HOME ? resolve(env.DSH_MODEL_HOME) : join(homedir(), '.dsh-model');
+    return {
+        mode,
+        platform,
+        paths: makePaths(home),
+        dshHome: env.DSH_HOME ? resolve(env.DSH_HOME) : join(homedir(), '.dsh'),
+        isRoot,
+        serviceDisabled,
+        env,
+    };
+}
+/** vps 模式下要改系统服务 / Caddy，必须 root */
+export function requireRootInVps(ctx) {
+    if (ctx.mode === 'vps' && !ctx.isRoot && !ctx.serviceDisabled) {
+        throw new DshModelError('need_root', L('检测到 dsh-vps，这台机器按 VPS 模式运行，需要 root。', 'dsh-vps detected: running in VPS mode, which needs root.'), L('请用 sudo 重新执行，例如：sudo dsh-model setup', 'Re-run with sudo, e.g. sudo dsh-model setup'));
+    }
+}
+async function lookupOwner(user) {
+    const [u, g] = await Promise.all([run('id', ['-u', user]), run('id', ['-g', user])]);
+    if (u.code !== 0 || g.code !== 0)
+        return undefined;
+    return { uid: Number(u.stdout.trim()), gid: Number(g.stdout.trim()) };
+}

package/dist/daemon/client.js

@@ -0,0 +1,27 @@
+// daemon/client.ts — 调守护进程 /control/*（CLI 用；dsh 插件宿主端也照这个格式调）
+import { loadBridgeConfig } from '../bridge/runtime.js';
+import { DshModelError } from '../errors.js';
+import { L, lang } from '../i18n.js';
+export async function control(ctx, method, path, body, timeoutMs = 60_000) {
+    const cfg = await loadBridgeConfig(ctx.paths.home);
+    if (!cfg)
+        throw new DshModelError('daemon_not_configured', L('守护进程未配置（dsh-model setup）', 'Daemon not configured (dsh-model setup)'));
+    let res;
+    try {
+        res = await fetch(`http://127.0.0.1:${cfg.port}/control${path}`, {
+            method,
+            headers: { Authorization: `Bearer ${cfg.secret}`, 'x-dsh-model-lang': lang(), ...(body !== undefined ? { 'Content-Type': 'application/json' } : {}) },
+            body: body !== undefined ? JSON.stringify(body) : undefined,
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+    }
+    catch {
+        throw new DshModelError('daemon_unreachable', L(`守护进程没在 127.0.0.1:${cfg.port} 上运行`, `Daemon is not running on 127.0.0.1:${cfg.port}`), L('执行 dsh-model repair', 'Run dsh-model repair'));
+    }
+    const data = (await res.json().catch(() => ({})));
+    if (!res.ok || data.error) {
+        const e = data.error ?? { code: 'daemon_error', message: `HTTP ${res.status}` };
+        throw new DshModelError(e.code, e.message, e.hint);
+    }
+    return data;
+}