@pandablessing/dsh-user-sync 0.0.0-stage → 1.0.1

package/lib/paths.js

@@ -0,0 +1,63 @@
+import { homedir } from 'node:os';
+import { join, resolve, sep } from 'node:path';
+export const DEFAULT_PROFILE = 'desktop';
+/**
+ * 解析当前运行环境的路径上下文。
+ * 主源是 profileContext（home/name），取不到时回退 DSH_HOME 与 desktop。
+ * 不读 process.env：由调用方把环境对象传进来，便于单测。
+ */
+export function resolvePaths({ profileContext = null, env = {}, userHome = homedir() } = {}) {
+    const home = profileContext?.home;
+    const name = profileContext?.name;
+    const fallbackHome = env.DSH_HOME;
+    const dshHome = home ?? fallbackHome ?? join(userHome, '.dsh');
+    const profileName = name ?? DEFAULT_PROFILE;
+    const resolvedBy = home ? 'profileContext' : fallbackHome ? 'fallback' : 'default';
+    return {
+        dshHome,
+        profileName,
+        profileDir: join(dshHome, 'profiles', profileName),
+        userHome,
+        skillsRoot: join(userHome, '.agents', 'skills'),
+        resolvedBy,
+    };
+}
+/** 统一归一化为 POSIX 路径（包内路径与哈希都用它）。 */
+export function toPosix(p) {
+    return p.replace(/\\/g, '/');
+}
+/** 把相对路径拼到根下，越出根则抛错。 */
+export function resolveInside(root, rel) {
+    const rootAbs = resolve(root);
+    const abs = resolve(rootAbs, rel);
+    if (!isInside(rootAbs, abs)) {
+        throw new Error(`路径越界: ${rel}`);
+    }
+    return abs;
+}
+/** 判断绝对路径是否落在根内（含根本身）。 */
+export function isInside(root, abs) {
+    const rootAbs = resolve(root);
+    const target = resolve(abs);
+    return target === rootAbs || target.startsWith(rootAbs + sep);
+}
+/** Windows 长路径前缀；非 Windows 原样返回。 */
+export function toLongPath(abs) {
+    if (process.platform !== 'win32')
+        return abs;
+    if (abs.startsWith('\\\\?\\'))
+        return abs;
+    if (abs.startsWith('\\\\'))
+        return `\\\\?\\UNC\\${abs.slice(2)}`;
+    return `\\\\?\\${resolve(abs)}`;
+}
+/** 包内相对路径安全检查：拒绝 `..`、空段、反斜杠与控制字符（§6.4）。 */
+export function isUnsafeRelPath(p) {
+    if (typeof p !== 'string' || p === '')
+        return true;
+    if (p.includes('\\'))
+        return true;
+    if (/[\u0000-\u001f]/.test(p))
+        return true;
+    return p.split('/').some((segment) => segment === '..' || segment === '');
+}

package/lib/plugins.js

@@ -0,0 +1,37 @@
+/**
+ * 目标机插件恢复计划（§7.8）：
+ * - `dependencies` 里缺失的包 → 逐个 `installBundle`
+ * - `link:` / `file:` 本地依赖 → 手工具清单，不自动安装
+ */
+export function planPluginRecovery({ dependencies = {}, installed = [], } = {}) {
+    const installedSet = new Set(installed);
+    const missing = [];
+    const linkDeps = [];
+    for (const [name, spec] of Object.entries(dependencies)) {
+        if (typeof spec !== 'string')
+            continue;
+        if (spec.startsWith('link:') || spec.startsWith('file:')) {
+            linkDeps.push({ name, spec, reason: 'local-path' });
+            continue;
+        }
+        if (!installedSet.has(name)) {
+            missing.push({ name, spec });
+        }
+    }
+    return { missing, linkDeps };
+}
+/** 逐个安装缺失包；单个失败不阻塞其余。 */
+export async function installMissing({ plan, installBundle, }) {
+    const results = [];
+    for (const dependency of plan.missing) {
+        const spec = dependency.spec ? `${dependency.name}@${dependency.spec}` : dependency.name;
+        try {
+            await installBundle(spec);
+            results.push({ name: dependency.name, spec, ok: true });
+        }
+        catch (error) {
+            results.push({ name: dependency.name, spec, ok: false, error: error?.message ?? String(error) });
+        }
+    }
+    return results;
+}

package/lib/scan.js

@@ -0,0 +1,335 @@
+import { lstatSync, readdirSync, readFileSync, readlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import { toPosix } from './paths.js';
+export const DEFAULT_MODULES = ['skills', 'plugins', 'config', 'userMemory'];
+export const ALL_MODULES = ['skills', 'plugins', 'config', 'userMemory', 'projectMemory', 'sessions'];
+/** 单文件超过 8 MiB 拒绝打包。 */
+export const MAX_FILE_BYTES = 8 * 1024 * 1024;
+/** 包总量超过 10 MiB 拒绝打包。 */
+export const MAX_TOTAL_BYTES = 10 * 1024 * 1024;
+const IGNORE_DIRS = new Set(['node_modules', '.git']);
+const IGNORE_FILES = new Set(['.DS_Store', 'Thumbs.db', 'desktop.ini']);
+const IGNORE_NAMES = ['.credentials.yaml', '.credentials.yml', 'credentials.json', '.anonymous-user-id'];
+/** Windows 保留名（不区分大小写，`CON.txt` 也算）。 */
+const RESERVED = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(\..*)?$/i;
+export function isReservedName(name) {
+    const base = name.split(/[\\/]/).pop() ?? name;
+    return RESERVED.test(base) || /[. ]$/.test(base);
+}
+function shouldIgnore(name, rel) {
+    if (IGNORE_DIRS.has(name) || IGNORE_FILES.has(name))
+        return true;
+    if (name.endsWith('.map') || name.includes('.bak-'))
+        return true;
+    if (IGNORE_NAMES.includes(name))
+        return true;
+    if (toPosix(rel).split('/').includes('storages'))
+        return true;
+    return false;
+}
+function globToRegExp(glob) {
+    const escaped = glob.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*').replace(/\?/g, '.');
+    return new RegExp(`^${escaped}$`);
+}
+/** 判断一个包内路径是否命中排除模式。 */
+export function isExcluded(rel, globs) {
+    if (!globs || globs.length === 0)
+        return false;
+    return globs.some((glob) => globToRegExp(glob).test(rel) || globToRegExp(glob).test(rel.split('/').pop() ?? rel));
+}
+function walk(root, prefix, module, ctx) {
+    let dirents;
+    try {
+        dirents = readdirSync(root, { withFileTypes: true });
+    }
+    catch (error) {
+        const code = error.code ?? String(error);
+        ctx.skipped.push({ path: toPosix(prefix || root), reason: `unreadable: ${code}` });
+        return;
+    }
+    for (const dirent of dirents) {
+        const name = dirent.name;
+        const abs = join(root, name);
+        const rel = prefix ? `${prefix}/${name}` : name;
+        if (shouldIgnore(name, rel)) {
+            ctx.skipped.push({ path: rel, reason: 'ignored' });
+            continue;
+        }
+        if (isReservedName(name)) {
+            ctx.errors.push({ code: 'E_RESERVED_NAME', path: rel });
+            continue;
+        }
+        if (dirent.isSymbolicLink()) {
+            let target;
+            try {
+                target = readlinkSync(abs);
+            }
+            catch {
+                target = '';
+            }
+            if (isExcluded(rel, ctx.excludeGlobs)) {
+                ctx.skipped.push({ path: rel, reason: 'excluded' });
+                continue;
+            }
+            ctx.out.push({ module, path: toPosix(rel), absPath: abs, size: 0, mode: '120000', linkTarget: target });
+            continue;
+        }
+        if (dirent.isDirectory()) {
+            walk(abs, rel, module, ctx);
+            continue;
+        }
+        if (!dirent.isFile())
+            continue;
+        if (isExcluded(rel, ctx.excludeGlobs)) {
+            ctx.skipped.push({ path: rel, reason: 'excluded' });
+            continue;
+        }
+        const stat = lstatSync(abs);
+        if (stat.size > MAX_FILE_BYTES) {
+            ctx.errors.push({ code: 'E_FILE_TOO_LARGE', path: rel, size: stat.size });
+            continue;
+        }
+        ctx.out.push({
+            module,
+            path: toPosix(rel),
+            absPath: abs,
+            size: stat.size,
+            mode: (stat.mode & 0o111) !== 0 ? '100755' : '100644',
+        });
+    }
+}
+function collectSkills({ userHome, ctx }) {
+    const skillsRoot = join(userHome, '.agents', 'skills');
+    let dirents;
+    try {
+        dirents = readdirSync(skillsRoot, { withFileTypes: true });
+    }
+    catch {
+        return; // 技能根不存在：正常空态
+    }
+    for (const dirent of dirents) {
+        if (!dirent.isDirectory() || dirent.name.startsWith('.'))
+            continue;
+        const skillDir = join(skillsRoot, dirent.name);
+        const hasManifest = (() => {
+            try {
+                return readdirSync(skillDir).includes('SKILL.md');
+            }
+            catch {
+                return false;
+            }
+        })();
+        if (!hasManifest) {
+            ctx.skipped.push({ path: `skills/${dirent.name}`, reason: 'no SKILL.md' });
+            continue;
+        }
+        walk(skillDir, `skills/${dirent.name}`, 'skills', ctx);
+    }
+}
+function collectProfileFiles({ dshHome, profileName, modules, ctx, }) {
+    const profileDir = join(dshHome, 'profiles', profileName);
+    const read = (name) => {
+        try {
+            const stat = lstatSync(join(profileDir, name));
+            return stat.isFile() ? stat.size : null;
+        }
+        catch {
+            return null;
+        }
+    };
+    const push = (name, module) => {
+        const size = read(name);
+        if (size === null)
+            return;
+        const rel = `profiles/${profileName}/${name}`;
+        if (isExcluded(rel, ctx.excludeGlobs)) {
+            ctx.skipped.push({ path: rel, reason: 'excluded' });
+            return;
+        }
+        if (size > MAX_FILE_BYTES) {
+            ctx.errors.push({ code: 'E_FILE_TOO_LARGE', path: rel, size });
+            return;
+        }
+        ctx.out.push({ module, path: rel, absPath: join(profileDir, name), size, mode: '100644' });
+    };
+    if (modules.includes('plugins')) {
+        for (const name of ['package.json', 'pnpm-lock.yaml', 'pnpm-workspace.yaml', 'cordis.yml'])
+            push(name, 'plugins');
+    }
+    if (modules.includes('config')) {
+        push('cordis.patch.yml', 'config');
+    }
+}
+function collectUserMemory({ dshHome, ctx }) {
+    // 用户级记忆主文件：AGENTS.md 放在 DSH 主目录根
+    const agents = join(dshHome, 'AGENTS.md');
+    try {
+        const stat = lstatSync(agents);
+        if (stat.isFile() && !isExcluded('AGENTS.md', ctx.excludeGlobs)) {
+            if (stat.size > MAX_FILE_BYTES)
+                ctx.errors.push({ code: 'E_FILE_TOO_LARGE', path: 'AGENTS.md', size: stat.size });
+            else
+                ctx.out.push({ module: 'userMemory', path: 'AGENTS.md', absPath: agents, size: stat.size, mode: '100644' });
+        }
+    }
+    catch {
+        // 没有 AGENTS.md 不算错误
+    }
+    const root = join(dshHome, 'memories');
+    let dirents;
+    try {
+        dirents = readdirSync(root, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const dirent of dirents) {
+        if (!dirent.isFile())
+            continue;
+        if (!['MEMORY.md', 'USER.md', 'KEY.md'].includes(dirent.name)) {
+            ctx.skipped.push({ path: `memories/${dirent.name}`, reason: 'not user-memory whitelist' });
+            continue;
+        }
+        const rel = `memories/${dirent.name}`;
+        if (isExcluded(rel, ctx.excludeGlobs)) {
+            ctx.skipped.push({ path: rel, reason: 'excluded' });
+            continue;
+        }
+        const stat = lstatSync(join(root, dirent.name));
+        if (stat.size > MAX_FILE_BYTES) {
+            ctx.errors.push({ code: 'E_FILE_TOO_LARGE', path: rel, size: stat.size });
+            continue;
+        }
+        ctx.out.push({ module: 'userMemory', path: rel, absPath: join(root, dirent.name), size: stat.size, mode: '100644' });
+    }
+}
+function collectProjectMemory({ dshHome, ctx }) {
+    const root = join(dshHome, 'memories');
+    for (const sub of ['projects', 'daily']) {
+        let dirents;
+        try {
+            dirents = readdirSync(join(root, sub), { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const dirent of dirents) {
+            const abs = join(root, sub, dirent.name);
+            const rel = `memories/${sub}/${dirent.name}`;
+            if (dirent.isFile()) {
+                if (isExcluded(rel, ctx.excludeGlobs))
+                    continue;
+                const stat = lstatSync(abs);
+                if (stat.size > MAX_FILE_BYTES) {
+                    ctx.errors.push({ code: 'E_FILE_TOO_LARGE', path: rel, size: stat.size });
+                    continue;
+                }
+                ctx.out.push({ module: 'projectMemory', path: rel, absPath: abs, size: stat.size, mode: '100644' });
+            }
+            else if (dirent.isDirectory()) {
+                walk(abs, rel, 'projectMemory', ctx);
+            }
+        }
+    }
+}
+function collectSessions({ dshHome, ctx }) {
+    const sessionsRoot = join(dshHome, 'sessions');
+    // 工作区注册表：归档会话列表 + 会话归属工作区
+    const archived = new Set();
+    const workspaceTitles = new Map();
+    try {
+        const registry = JSON.parse(lstatSync(join(dshHome, 'storages', 'workspace.json')).isFile()
+            ? readFileSync(join(dshHome, 'storages', 'workspace.json'), 'utf8')
+            : '{}');
+        for (const id of registry.global?.archivedSessionIds ?? [])
+            archived.add(id);
+        for (const ws of Object.values(registry.tables?.workspaces ?? {})) {
+            for (const sid of ws.sessionIds ?? [])
+                workspaceTitles.set(sid, ws.title ?? '');
+        }
+    }
+    catch {
+        // 没有注册表时按未归档处理
+    }
+    let wsDirs;
+    try {
+        wsDirs = readdirSync(sessionsRoot, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const wsDir of wsDirs) {
+        if (!wsDir.isDirectory())
+            continue;
+        let sessionDirs;
+        try {
+            sessionDirs = readdirSync(join(sessionsRoot, wsDir.name), { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const sessionDir of sessionDirs) {
+            if (!sessionDir.isDirectory())
+                continue;
+            const sid = sessionDir.name;
+            const rel = `sessions/${wsDir.name}/${sid}`;
+            if (archived.has(sid)) {
+                ctx.skipped.push({ path: rel, reason: 'archived' });
+                continue;
+            }
+            // 空会话（只有元数据行、UI 不显示）不纳入同步：主日志小于 2 KiB 视为空会话
+            const sessionDirAbs = join(sessionsRoot, wsDir.name, sid);
+            let payloadBytes = 0;
+            try {
+                for (const entry of readdirSync(sessionDirAbs, { withFileTypes: true })) {
+                    if (entry.isFile())
+                        payloadBytes += lstatSync(join(sessionDirAbs, entry.name)).size;
+                }
+            }
+            catch {
+                payloadBytes = 0;
+            }
+            if (payloadBytes < 2048) {
+                ctx.skipped.push({ path: rel, reason: 'empty-session' });
+                continue;
+            }
+            let title = null;
+            try {
+                const cache = JSON.parse(lstatSync(join(dshHome, 'storages', 'session_projcache', 'sessions', `${sid}.json`)).isFile()
+                    ? readFileSync(join(dshHome, 'storages', 'session_projcache', 'sessions', `${sid}.json`), 'utf8')
+                    : '{}');
+                title = cache.record?.rows?.title?.val ?? null;
+            }
+            catch {
+                title = null;
+            }
+            const before = ctx.out.length;
+            walk(join(sessionsRoot, wsDir.name, sid), rel, 'sessions', ctx);
+            const workspaceTitle = workspaceTitles.get(sid) ?? wsDir.name;
+            for (let i = before; i < ctx.out.length; i++) {
+                ctx.out[i].title = title ?? `（无标题）${workspaceTitle}`;
+            }
+        }
+    }
+}
+/** 扫描用户级资产。 */
+export function scanAssets({ dshHome, userHome, profileName = 'desktop', modules = DEFAULT_MODULES, excludeGlobs = [], }) {
+    const ctx = { out: [], errors: [], skipped: [], excludeGlobs };
+    if (modules.includes('skills'))
+        collectSkills({ userHome, ctx });
+    if (modules.some((m) => ['plugins', 'config'].includes(m))) {
+        collectProfileFiles({ dshHome, profileName, modules, ctx });
+    }
+    if (modules.includes('userMemory'))
+        collectUserMemory({ dshHome, ctx });
+    if (modules.includes('projectMemory'))
+        collectProjectMemory({ dshHome, ctx });
+    if (modules.includes('sessions'))
+        collectSessions({ dshHome, ctx });
+    const entries = ctx.out.sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
+    const totalBytes = entries.reduce((sum, entry) => sum + entry.size, 0);
+    if (totalBytes > MAX_TOTAL_BYTES) {
+        ctx.errors.push({ code: 'E_TOTAL_TOO_LARGE', total: totalBytes, limit: MAX_TOTAL_BYTES });
+    }
+    return { entries, errors: ctx.errors, skipped: ctx.skipped, totalBytes };
+}

package/lib/scheduler.js

@@ -0,0 +1,80 @@
+import { loadState, saveState } from './state.js';
+/**
+ * 自动检查调度器：启动后检查一次，之后按间隔检查远端**元数据**（list + meta），
+ * 不下载、不写盘（只把检查时间与判定记进 state.json）。
+ * 失败不无限重试：下一次到点照常。
+ */
+export function createScheduler({ sync, statePath, intervalHours = 6, tickMs = 60_000, now = () => Date.now(), }) {
+    let timer = null;
+    let checking = false;
+    function settings() {
+        const state = loadState(statePath);
+        return {
+            autoCheck: state.autoCheck !== false,
+            intervalHours: Number(state.intervalHours) > 0 ? Number(state.intervalHours) : intervalHours,
+            lastCheckAt: state.lastCheckAt ?? null,
+            lastDecision: state.lastDecision ?? null,
+            lastCheckError: state.lastCheckError ?? null,
+        };
+    }
+    function isDue(at = now()) {
+        const current = settings();
+        if (!current.autoCheck)
+            return false;
+        if (!current.lastCheckAt)
+            return true;
+        const last = Date.parse(current.lastCheckAt);
+        if (!Number.isFinite(last))
+            return true;
+        return at - last >= current.intervalHours * 3_600_000;
+    }
+    async function runOnce() {
+        if (checking)
+            return null;
+        checking = true;
+        try {
+            const result = await sync.check();
+            const state = loadState(statePath);
+            state.lastCheckAt = new Date().toISOString();
+            state.lastDecision = {
+                action: result.decision?.action ?? null,
+                reason: result.decision?.reason ?? null,
+                packageId: result.latest?.name ?? null,
+                createdAt: result.meta?.createdAt ?? result.latest?.modifiedAt ?? null,
+            };
+            delete state.lastCheckError;
+            saveState(statePath, state);
+            return result;
+        }
+        catch (error) {
+            const state = loadState(statePath);
+            state.lastCheckAt = new Date().toISOString();
+            state.lastCheckError = error?.message ?? String(error);
+            saveState(statePath, state);
+            return { decision: null, error: state.lastCheckError };
+        }
+        finally {
+            checking = false;
+        }
+    }
+    function tick() {
+        if (isDue()) {
+            // 后台检查：不阻塞调用方，错误已记录在 state
+            void runOnce();
+        }
+    }
+    function start() {
+        if (timer)
+            return;
+        tick();
+        timer = setInterval(tick, tickMs);
+        // 不阻止 Node 进程退出（测试与无界面场景都靠它）
+        timer.unref?.();
+    }
+    function stop() {
+        if (timer)
+            clearInterval(timer);
+        timer = null;
+    }
+    return { start, stop, runOnce, tick, isDue, settings };
+}

package/lib/secret.js

@@ -0,0 +1,62 @@
+/**
+ * 敏感数据扫描：文件名黑名单 + 内容模式。
+ * 设计 §5.4：命中即**整包拒绝**（不是警告、不是跳过）。
+ * 本模块只做检测，不决定动作；调用方根据结果拒绝打包/应用。
+ */
+export const BLOCKED_NAMES = [
+    /^\.credentials\.ya?ml$/i,
+    /^credentials\.json$/i,
+    /\.token$/i,
+    /\.key$/i,
+    /^cloud-credentials\.json$/i,
+    /^github\.token$/i,
+    /^\.npmrc\.auth$/i,
+    /^\.netrc$/i,
+    /^id_rsa$/i,
+    /^id_ed25519$/i,
+];
+export const CONTENT_PATTERNS = [
+    { name: 'sk-密钥', re: /sk-[A-Za-z0-9]{16,}/g },
+    { name: '通用密钥字段', re: /(api[_-]?key|token|secret|password|passwd)["'\s:=-]+[A-Za-z0-9_-]{20,}/gi },
+    { name: 'Bearer', re: /Bearer\s+[A-Za-z0-9._-]{20,}/g },
+    { name: 'GitHub token', re: /gh[pousr]_[A-Za-z0-9]{30,}|github_pat_[A-Za-z0-9_]{30,}/g },
+    { name: '云厂商 AK', re: /LTAI[A-Za-z0-9]{12,}|AKIA[0-9A-Z]{16}/g },
+    { name: '私钥', re: /-----BEGIN [A-Z ]*PRIVATE KEY-----/g },
+    { name: 'npm 凭据', re: /_authToken\s*=|_auth\s*=/g },
+];
+/** 单文件超过此大小进入抽样扫描。 */
+export const SAMPLE_THRESHOLD = 1024 * 1024;
+/** 抽样时前后各取多少字节。 */
+export const SAMPLE_BYTES = 64 * 1024;
+/** 文件名是否命中黑名单（只看 basename）。 */
+export function isBlockedName(name) {
+    const base = name.replace(/\\/g, '/').split('/').pop() ?? name;
+    return BLOCKED_NAMES.some((re) => re.test(base));
+}
+/**
+ * 扫描文本内容，返回命中位置。
+ * 只返回「文件 + 行号 + 模式名」，不返回命中的值本身（§5.4 日志与 UI 不显示值）。
+ */
+export function scanText(text, filePath = '') {
+    const hits = [];
+    const lines = text.split('\n');
+    for (const { name, re } of CONTENT_PATTERNS) {
+        for (let i = 0; i < lines.length; i++) {
+            re.lastIndex = 0;
+            if (re.test(lines[i])) {
+                hits.push({ file: filePath, line: i + 1, pattern: name });
+            }
+        }
+    }
+    return hits;
+}
+/** 扫描缓冲区。超过阈值时只扫前后各 SAMPLE_BYTES，并标记 sampled。 */
+export function scanBuffer(buf, filePath = '') {
+    const sampled = buf.length > SAMPLE_THRESHOLD;
+    if (!sampled) {
+        return { hits: scanText(buf.toString('utf8'), filePath), sampled };
+    }
+    const head = buf.subarray(0, SAMPLE_BYTES).toString('utf8');
+    const tail = buf.subarray(buf.length - SAMPLE_BYTES).toString('utf8');
+    return { hits: [...scanText(head, filePath), ...scanText(tail, filePath)], sampled };
+}