evolcore 0.0.1 → 0.0.2

package/dist/cli/trigger-command.js

@@ -0,0 +1,505 @@
+import fs from 'fs';
+import path from 'path';
+import { resolvePaths } from '../paths.js';
+import { ipcQuery } from '../ipc.js';
+import { isHelpFlag } from './help.js';
+import { AGENT_DELEGATION_TOKEN_ENV } from '../core/auth/agent-delegation.js';
+import { readTaskRuntimeContextFromEnv } from './task-context.js';
+import { normalizeTriggerDefinition, resolveScriptPath, } from '../trigger/validation.js';
+export async function cmdTrigger(args) {
+    const sub = args[0];
+    if (!sub || isHelpFlag(sub)) {
+        printHelp();
+        return;
+    }
+    if (sub === 'template') {
+        handleTemplate(args.slice(1));
+        return;
+    }
+    const rest = args.slice(1);
+    const json = hasFlag(rest, '--json') || flagValue(rest, '--format') === 'json';
+    try {
+        switch (sub) {
+            case 'list':
+                await listTriggers(rest, json);
+                return;
+            case 'show':
+                await showTrigger(rest, json);
+                return;
+            case 'history':
+                await showHistory(rest, json);
+                return;
+            case 'create':
+                await createTrigger(rest, json);
+                return;
+            case 'update':
+                await updateTrigger(rest, json);
+                return;
+            case 'enable':
+            case 'disable':
+                await setEnabled(rest, sub === 'enable', json);
+                return;
+            case 'cancel':
+                await cancelTrigger(rest, json);
+                return;
+            case 'delete':
+            case 'remove':
+            case 'rm':
+                await deleteTrigger(rest, json);
+                return;
+            case 'run':
+                await runTrigger(rest, json);
+                return;
+            default:
+                throw new Error(`unknown trigger subcommand: ${sub}`);
+        }
+    }
+    catch (err) {
+        if (json)
+            console.log(JSON.stringify({ ok: false, error: err?.message || String(err) }, null, 2));
+        else
+            console.error(err?.message || String(err));
+        process.exit(1);
+    }
+}
+function printHelp() {
+    console.log(`用法: ec trigger <subcommand>
+
+命令:
+  list [--agent <aid>] [--all] [--json]
+  show [--agent <aid>] <triggerId> [--json]
+  history [--agent <aid>] [triggerId] [--limit <n>] [--json]
+  create --file <trigger.json|trigger-dir> [--enable] [--json]
+    OR
+  create [--agent <aid>] --cron <expr>|--event <pattern> --prompt <text> [--enable] [其他flag]
+  update [--agent <aid>] <triggerId> <参数...> [--if-revision <sha256:...>] [--json]
+  enable [--agent <aid>] <triggerId>
+  disable [--agent <aid>] <triggerId>
+  cancel [--agent <aid>] <triggerId>  (disable 的兼容别名)
+  delete [--agent <aid>] <triggerId>
+  run [--agent <aid>] <triggerId> [--dry-run] [--json]
+  template list|show <name> [--json]
+
+Create 参数模式支持:
+  --once | --delay <时长> | --at <ISO时间> | --cron <表达式> | --every <时长> | --event <事件模式>
+  --exec <script|trigger-session|target-session>
+  --prompt <文本>
+  --script-path <路径> --script-runtime <node|python|bash>
+  --feedback <target|origin|silent> (create 参数模式仅支持 target)
+  --model <模型>  --effort <low|medium|high|xhigh|max>
+  --max-runs <次数>  --max-duration <时长: 30s|15m|2h|1d>
+  --permission <readonly|auto|request|bypass>（省略则继承当前身份配置）
+  --tz <时区> (仅 cron)
+  --target-channel <channelKey> --target-channel-id <ID>  (AUN 可简写为 aun)
+  --target-session <main|thread> [--target-thread-id <threadId>]
+  --trigger-thread <per-run|by-trigger>
+  --name <名称>
+
+Update 仅支持常用字段:
+  --once | --delay | --at | --cron | --every | --event [--tz]
+  --prompt <文本>  --name <名称>
+  --model <模型>  --effort <强度>  --permission <权限模式|inherit>（inherit 清除覆盖）
+  --max-runs <次数>  --max-duration <时长>
+  --concurrency <forbid|replace|allow>  --missed-policy <skip|run-once|run-all>
+
+省略 --agent 时使用当前 agent AID；仅在跨身份操作或无会话上下文时需要显式指定。`);
+}
+async function listTriggers(args, json) {
+    const agentAid = resolveAgentAid(args);
+    const res = await request({ type: 'trigger.list', agentAid, all: hasFlag(args, '--all') });
+    if (json)
+        return printJson(res);
+    const triggers = res.triggers;
+    if (triggers.length === 0) {
+        console.log('(无 trigger)');
+        return;
+    }
+    for (const t of triggers) {
+        console.log(`${t.enabled ? 'on ' : 'off'}  ${t.id}  ${t.name}  ${sourceLabel(t)}`);
+    }
+}
+async function showTrigger(args, json) {
+    const agentAid = resolveAgentAid(args);
+    const triggerId = positional(args, 0, ['--agent']);
+    const res = await request({ type: 'trigger.show', agentAid, triggerId });
+    if (json)
+        return printJson(res);
+    const t = res.definition;
+    console.log(`${t.name} (${t.id})`);
+    console.log(`agent: ${t.agentAid}`);
+    console.log(`enabled: ${t.enabled}`);
+    console.log(`source: ${sourceLabel(t)}`);
+    if (t.limits?.maxRuns !== undefined || t.limits?.maxDuration !== undefined) {
+        console.log(`limits: ${[
+            t.limits.maxRuns !== undefined ? `maxRuns=${t.limits.maxRuns}` : undefined,
+            t.limits.maxDuration !== undefined ? `maxDuration=${t.limits.maxDuration}` : undefined,
+        ].filter(Boolean).join(', ')}`);
+    }
+    const limitState = res.limitState;
+    if (limitState) {
+        const parts = [
+            `runCount=${limitState.runCount}`,
+            `startedAt=${new Date(limitState.startedAt).toISOString()}`,
+            limitState.disabledReason ? `disabledReason=${limitState.disabledReason}` : undefined,
+        ].filter(Boolean);
+        if (t.limits?.maxDuration) {
+            const expiresAt = limitState.startedAt + limitDurationMs(t.limits.maxDuration);
+            parts.push(`expiresAt=${new Date(expiresAt).toISOString()}`);
+        }
+        console.log(`limit state: ${parts.join(', ')}`);
+    }
+    console.log(`execution: ${t.execution.type}`);
+    if (t.execution.type === 'script')
+        console.log(`script: ${scriptCommandLabel(t.execution.script)}`);
+    console.log(`model: ${t.execution.model ?? 'inherit'}`);
+    console.log(`effort: ${t.execution.effort ?? 'inherit'}`);
+    console.log(`permission: ${t.execution.permissionMode ?? 'inherit'}`);
+    console.log(`feedback: ${t.feedback.strategy}${t.feedback.target ? ` -> ${t.feedback.target.channelKey}/${t.feedback.target.channelId}/${t.feedback.target.session}` : ''}`);
+    const active = Array.isArray(res.active) ? res.active : [];
+    console.log(`active runs: ${active.length}`);
+    const recent = Array.isArray(res.recentRuns) ? res.recentRuns : [];
+    if (recent.length > 0) {
+        console.log('recent:');
+        for (const r of recent.slice(0, 5)) {
+            console.log(`  ${r.status.padEnd(9)} ${r.reason ?? ''} ${new Date(r.finishedAt).toISOString()} ${r.runId}`);
+        }
+    }
+}
+async function showHistory(args, json) {
+    const agentAid = resolveAgentAid(args);
+    const triggerId = optionalPositional(args, 0, ['--agent', '--limit', '--format']);
+    const rawLimit = flagValue(args, '--limit');
+    const limit = rawLimit === undefined ? 100 : Number(rawLimit);
+    if (!Number.isInteger(limit) || limit <= 0 || limit > 10_000) {
+        throw new Error('--limit 必须是 1 到 10000 的整数');
+    }
+    const res = await request({ type: 'trigger.history', agentAid, triggerId, limit });
+    if (json)
+        return printJson(res);
+    const events = Array.isArray(res.events) ? res.events : [];
+    if (events.length === 0) {
+        console.log('(无 trigger history)');
+        return;
+    }
+    for (const event of events) {
+        const timestamp = new Date(event.timestamp).toISOString();
+        const detail = event.audit
+            ? `${event.audit.status} ${event.audit.runId}`
+            : event.legacyRecord
+                ? `${event.legacyRecord.name ?? ''} ${event.legacyRecord.doneReason ?? ''}`.trim()
+                : `${event.definition?.name ?? ''} ${event.revision ?? ''}`.trim();
+        console.log(`${timestamp}  ${event.type.padEnd(18)}  ${event.triggerId}  ${detail}`);
+    }
+}
+async function createTrigger(args, json) {
+    // Support two modes: --file (full JSON) or flags (parser-based)
+    if (hasFlag(args, '--file')) {
+        const file = requireFlag(args, '--file');
+        const { definition, files } = loadDefinitionWithFiles(file);
+        const res = await request({
+            type: 'trigger.create',
+            definition,
+            files,
+            enable: hasFlag(args, '--enable') ? true : undefined,
+        }, 30_000);
+        if (json)
+            return printJson(res);
+        console.log(`✓ created ${res.trigger.id} (${res.trigger.name})`);
+        return;
+    }
+    // Flag mode: use parser
+    const { parseTriggerSet } = await import('../trigger/parser.js');
+    const flagStr = args.filter(a => a !== '--enable' && a !== '--json' && !a.startsWith('--format')).join(' ');
+    const parseResult = parseTriggerSet(flagStr);
+    if (!parseResult.ok) {
+        throw new Error(parseResult.error);
+    }
+    const parsed = parseResult.value;
+    const agentAid = parsed.agentId ?? resolveAgentAid(args);
+    if (parsed.feedbackStrategy !== 'target') {
+        throw new Error('CLI flag 模式仅支持 --feedback target；origin/silent 请使用 /trigger 或 --file 导入 Trigger V3 第二阶段 JSON');
+    }
+    if (!parsed.targetChannel || !parsed.targetChannelId) {
+        throw new Error('CLI flag 模式需要显式指定 --target-channel <channelKey> --target-channel-id <id>');
+    }
+    const now = Date.now();
+    if (parsed.targetSession === 'thread' && !parsed.targetThreadId) {
+        throw new Error('--target-session thread 需要 --target-thread-id');
+    }
+    const script = parsed.scriptPath ? {
+        path: parsed.scriptPath,
+        runtime: parsed.scriptRuntime,
+        args: parsed.scriptArgs,
+        timeoutMs: parsed.scriptTimeoutMs ?? 30_000,
+    } : undefined;
+    const definition = {
+        $schema_version: 3.1,
+        agentAid,
+        name: parsed.name || `trigger-${now.toString(36)}`,
+        enabled: hasFlag(args, '--enable'),
+        createdAt: now,
+        updatedAt: now,
+        source: sourceFromParsed(parsed),
+        execution: {
+            type: parsed.executionType,
+            ...(script ? { script } : { prompt: parsed.prompt }),
+            ...(parsed.model ? { model: parsed.model } : {}),
+            ...(parsed.effort ? { effort: parsed.effort } : {}),
+            ...(parsed.permissionMode ? { permissionMode: parsed.permissionMode } : {}),
+            ...(parsed.executionType === 'trigger_session' ? { thread: parsed.triggerThread ?? 'by_trigger' } : {}),
+            onError: 'retry',
+            noopSentinel: '[[NOOP]]',
+        },
+        feedback: {
+            strategy: 'target',
+            target: {
+                channelKey: parsed.targetChannel,
+                channelId: parsed.targetChannelId,
+                session: parsed.targetSession,
+                ...(parsed.targetSession === 'thread' ? { threadId: parsed.targetThreadId } : {}),
+            },
+        },
+        reliability: { concurrency: 'forbid', missedPolicy: 'run_once', retry: { maxAttempts: 0, backoffMs: 30_000 } },
+        limits: limitsFromParsed(parsed),
+    };
+    const res = await request({
+        type: 'trigger.create',
+        definition,
+        files: [],
+        enable: hasFlag(args, '--enable') ? true : undefined,
+    }, 30_000);
+    if (json)
+        return printJson(res);
+    console.log(`✓ created ${res.trigger.id} (${res.trigger.name})`);
+}
+function sourceFromParsed(parsed) {
+    if (parsed.scheduleType === 'once')
+        return { type: 'once' };
+    if (parsed.scheduleType === 'delay')
+        return { type: 'delay', afterMs: Number(parsed.scheduleValue) };
+    if (parsed.scheduleType === 'at')
+        return { type: 'at', at: parsed.scheduleValue };
+    if (parsed.scheduleType === 'cron') {
+        const src = { type: 'cron', expression: parsed.scheduleValue };
+        if (parsed.timezone)
+            src.timezone = parsed.timezone;
+        return src;
+    }
+    if (parsed.scheduleType === 'interval')
+        return { type: 'interval', everyMs: Number(parsed.scheduleValue) };
+    if (parsed.scheduleType === 'event')
+        return { type: 'event', eventPattern: parsed.scheduleValue };
+    throw new Error(`unsupported scheduleType: ${parsed.scheduleType}`);
+}
+function limitsFromParsed(parsed) {
+    const limits = {};
+    if (parsed.maxRuns !== undefined)
+        limits.maxRuns = parsed.maxRuns;
+    if (parsed.maxDuration !== undefined)
+        limits.maxDuration = parsed.maxDuration;
+    return Object.keys(limits).length > 0 ? limits : undefined;
+}
+function limitDurationMs(value) {
+    const amount = Number(value.slice(0, -1));
+    const unit = value.slice(-1);
+    if (unit === 'd')
+        return amount * 86_400_000;
+    if (unit === 'h')
+        return amount * 3_600_000;
+    if (unit === 'm')
+        return amount * 60_000;
+    return amount * 1_000;
+}
+function scriptCommandLabel(script) {
+    const args = Array.isArray(script.args) ? script.args.map(arg => shellQuoteArg(String(arg))).join(' ') : '';
+    const command = shellQuoteArg(script.path);
+    return `${script.runtime} ${command}${args ? ` ${args}` : ''}`;
+}
+function shellQuoteArg(value) {
+    if (!value)
+        return "''";
+    return /[\s"'\\]/.test(value) ? `"${value.replace(/(["\\$`])/g, '\\$1')}"` : value;
+}
+async function updateTrigger(args, json) {
+    const agentAid = resolveAgentAid(args);
+    const triggerId = positional(args, 0, ['--agent', '--format', '--if-revision']);
+    const { parseTriggerUpdateArgv } = await import('../trigger/parser.js');
+    const parsed = parseTriggerUpdateArgv(triggerId, triggerUpdateArgs(args));
+    if (!parsed.ok)
+        throw new Error(parsed.error);
+    const expectedRevision = flagValue(args, '--if-revision');
+    const res = await request({
+        type: 'trigger.update',
+        agentAid,
+        triggerId,
+        patch: parsed.value,
+        ...(expectedRevision ? { expectedRevision } : {}),
+    }, 30_000);
+    if (json)
+        return printJson(res);
+    console.log(`✓ updated ${res.trigger.id} (${res.trigger.name})`);
+}
+function triggerUpdateArgs(args) {
+    const out = [];
+    let skippedTriggerId = false;
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--json')
+            continue;
+        if (arg.startsWith('--format=') || arg.startsWith('--agent=') || arg.startsWith('--if-revision='))
+            continue;
+        if (arg === '--format' || arg === '--agent' || arg === '--if-revision') {
+            i += 1;
+            continue;
+        }
+        if (!skippedTriggerId && !arg.startsWith('-')) {
+            skippedTriggerId = true;
+            continue;
+        }
+        out.push(arg);
+    }
+    return out;
+}
+async function setEnabled(args, enabled, json) {
+    const agentAid = resolveAgentAid(args);
+    const triggerId = positional(args, 0, ['--agent']);
+    const res = await request({ type: 'trigger.setEnabled', agentAid, triggerId, enabled });
+    if (json)
+        return printJson(res);
+    console.log(`✓ ${enabled ? 'enabled' : 'disabled'} ${res.trigger.id}`);
+}
+async function cancelTrigger(args, json) {
+    const agentAid = resolveAgentAid(args);
+    const triggerId = positional(args, 0, ['--agent']);
+    const res = await request({ type: 'trigger.cancel', agentAid, triggerId });
+    if (json)
+        return printJson(res);
+    console.log(`✓ disabled ${res.trigger.id}`);
+}
+async function deleteTrigger(args, json) {
+    const agentAid = resolveAgentAid(args);
+    const triggerId = positional(args, 0, ['--agent']);
+    const res = await request({ type: 'trigger.delete', agentAid, triggerId });
+    if (json)
+        return printJson(res);
+    console.log(`✓ deleted ${res.trigger.id}`);
+}
+async function runTrigger(args, json) {
+    const agentAid = resolveAgentAid(args);
+    const triggerId = positional(args, 0, ['--agent']);
+    const res = await request({ type: 'trigger.run', agentAid, triggerId, dryRun: hasFlag(args, '--dry-run') }, 120_000);
+    if (json)
+        return printJson(res);
+    const result = res.result;
+    console.log(`${result.status}${result.reason ? ` (${result.reason})` : ''}: ${result.runId}`);
+    if (result.error)
+        console.log(result.error);
+}
+function handleTemplate(args) {
+    const sub = args[0] || 'list';
+    const json = hasFlag(args, '--json') || flagValue(args, '--format') === 'json';
+    if (sub === 'list') {
+        if (json)
+            printJson({ ok: true, templates: [] });
+        else
+            console.log('(无内置 trigger template)');
+        return;
+    }
+    if (sub === 'show') {
+        const name = args.find(a => !a.startsWith('-') && a !== 'show');
+        if (!name)
+            throw new Error('missing template name');
+        if (json)
+            printJson({ ok: false, error: `template not found: ${name}` });
+        else
+            console.log(`template not found: ${name}`);
+        return;
+    }
+    throw new Error(`unknown template subcommand: ${sub}`);
+}
+async function request(cmd, timeoutMs = 10_000) {
+    const actorSessionId = process.env.EVOLCORE_SESSION_ID;
+    const delegationToken = process.env[AGENT_DELEGATION_TOKEN_ENV];
+    let controlToken;
+    if (!actorSessionId) {
+        try {
+            controlToken = fs.readFileSync(resolvePaths().controlToken, 'utf8').trim() || undefined;
+        }
+        catch { }
+    }
+    const res = await ipcQuery(resolvePaths().socket, actorSessionId ? { ...cmd, actorSessionId, delegationToken } : { ...cmd, controlToken }, timeoutMs);
+    if (!res)
+        throw new Error('错误: 无法连接 evolcore 服务');
+    if (res.ok === false || res.error)
+        throw new Error(res.error || 'trigger command failed');
+    return res;
+}
+function loadDefinitionWithFiles(inputPath) {
+    const stat = fs.statSync(inputPath);
+    const baseDir = stat.isDirectory() ? inputPath : path.dirname(inputPath);
+    const jsonPath = stat.isDirectory() ? path.join(inputPath, 'trigger.json') : inputPath;
+    const definition = normalizeTriggerDefinition(JSON.parse(fs.readFileSync(jsonPath, 'utf-8')));
+    const files = [];
+    if (definition.execution.type === 'script') {
+        const scriptAbs = resolveScriptPath(baseDir, definition.execution.script.path);
+        const relativePath = path.relative(baseDir, scriptAbs).replace(/\\/g, '/');
+        files.push({ relativePath, contentBase64: fs.readFileSync(scriptAbs).toString('base64') });
+    }
+    return { definition, files };
+}
+function sourceLabel(t) {
+    switch (t.source.type) {
+        case 'once': return 'once';
+        case 'delay': return `delay ${t.source.afterMs}ms`;
+        case 'at': return `at ${t.source.at}`;
+        case 'cron': return `cron ${t.source.expression}${t.source.timezone ? ` (${t.source.timezone})` : ''}`;
+        case 'interval': return `interval ${t.source.everyMs}ms`;
+        case 'event': return `event ${t.source.eventPattern}`;
+    }
+}
+function resolveAgentAid(args) {
+    const aid = (flagValue(args, '--agent')
+        ?? process.env.EVOLCORE_SELF_AID
+        ?? readTaskRuntimeContextFromEnv()?.selfAid)?.trim();
+    if (!aid) {
+        throw new Error('missing --agent and no current agent context');
+    }
+    return aid;
+}
+function requireFlag(args, name) {
+    const value = flagValue(args, name);
+    if (!value)
+        throw new Error(`missing ${name}`);
+    return value;
+}
+function flagValue(args, name) {
+    const idx = args.indexOf(name);
+    if (idx >= 0 && idx + 1 < args.length)
+        return args[idx + 1];
+    const prefixed = args.find(a => a.startsWith(`${name}=`));
+    return prefixed ? prefixed.slice(name.length + 1) : undefined;
+}
+function hasFlag(args, name) {
+    return args.includes(name);
+}
+function positional(args, index, flagsWithValue) {
+    const value = optionalPositional(args, index, flagsWithValue);
+    if (!value)
+        throw new Error('missing triggerId');
+    return value;
+}
+function optionalPositional(args, index, flagsWithValue) {
+    const skip = new Set();
+    for (const flag of flagsWithValue) {
+        const idx = args.indexOf(flag);
+        if (idx >= 0) {
+            skip.add(idx);
+            skip.add(idx + 1);
+        }
+    }
+    const values = args.filter((a, i) => !skip.has(i) && !a.startsWith('-'));
+    return values[index];
+}
+function printJson(value) {
+    console.log(JSON.stringify(value, null, 2));
+}

package/dist/cli/version.js

@@ -0,0 +1,88 @@
+/**
+ * ec version — 显示所有组件版本和构建时间戳，便于诊断。
+ */
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { MAIN_PACKAGE_NAME, PRODUCT_DISPLAY_NAME, WEB_PACKAGE_NAME } from '../product.js';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PACKAGE_ROOT = path.resolve(__dirname, '../..');
+const RESET = '\x1b[0m';
+const BOLD = '\x1b[1m';
+const DIM = '\x1b[2m';
+const GREEN = '\x1b[32m';
+const CYAN = '\x1b[36m';
+function readPkgJson(dir) {
+    const f = path.join(dir, 'package.json');
+    if (!fs.existsSync(f))
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(f, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+function getFileModTime(filePath) {
+    try {
+        const stat = fs.statSync(filePath);
+        return stat.mtime.toISOString().replace('T', ' ').slice(0, 19);
+    }
+    catch {
+        return null;
+    }
+}
+function findInstalledVersion(pkgName) {
+    // 从 PACKAGE_ROOT/node_modules 查找
+    const dir = path.join(PACKAGE_ROOT, 'node_modules', ...pkgName.split('/'));
+    const pkg = readPkgJson(dir);
+    if (!pkg)
+        return null;
+    // 取 dist/index.js 修改时间作为构建时间戳参考
+    const mainFile = path.join(dir, 'dist', 'index.js');
+    const ts = getFileModTime(mainFile) || getFileModTime(path.join(dir, 'index.js'));
+    return { name: pkg.name || pkgName, version: pkg.version || '?', buildTs: ts || undefined, path: dir };
+}
+export function handleVersion(args) {
+    const isJson = args.includes('--format') && args.includes('json') || args.includes('--json');
+    // 主包
+    const mainPkg = readPkgJson(PACKAGE_ROOT);
+    const mainEntry = path.join(PACKAGE_ROOT, 'dist', 'cli', 'index.js');
+    const mainTs = getFileModTime(mainEntry);
+    // ecweb 包
+    const ecwebDir = path.join(PACKAGE_ROOT, 'ecweb');
+    const ecwebPkg = readPkgJson(ecwebDir);
+    const ecwebEntry = path.join(ecwebDir, 'dist', 'index.js');
+    const ecwebTs = getFileModTime(ecwebEntry);
+    const ecwebStaticTs = getFileModTime(path.join(ecwebDir, 'dist', 'static', 'index.html'));
+    // 关键依赖
+    const deps = [
+        '@agentunion/fastaun',
+        'ws',
+    ];
+    const components = [
+        { name: MAIN_PACKAGE_NAME, version: mainPkg?.version || '?', built: mainTs || undefined, note: 'main package' },
+        { name: WEB_PACKAGE_NAME, version: ecwebPkg?.version || '?', built: ecwebTs || undefined, note: `static: ${ecwebStaticTs || '?'}` },
+    ];
+    for (const dep of deps) {
+        const info = findInstalledVersion(dep);
+        if (info) {
+            components.push({ name: info.name, version: info.version, built: info.buildTs || undefined });
+        }
+    }
+    // Node.js 版本
+    components.push({ name: 'node', version: process.version, note: process.platform + '/' + process.arch });
+    if (isJson) {
+        console.log(JSON.stringify(components, null, 2));
+        return;
+    }
+    console.log(`\n${BOLD}🔧 ${PRODUCT_DISPLAY_NAME} Component Versions${RESET}\n`);
+    const nameW = Math.max(...components.map(c => c.name.length), 8);
+    const verW = Math.max(...components.map(c => c.version.length), 7);
+    for (const c of components) {
+        const builtStr = c.built ? `${DIM}built: ${c.built}${RESET}` : '';
+        const noteStr = c.note ? `${DIM}(${c.note})${RESET}` : '';
+        console.log(`  ${CYAN}${c.name.padEnd(nameW)}${RESET}  ${GREEN}${c.version.padEnd(verW)}${RESET}  ${builtStr} ${noteStr}`);
+    }
+    console.log();
+}

package/dist/cli/watch-logs.js

@@ -0,0 +1,33 @@
+import path from 'path';
+/** 去掉轮转后缀（"daemon-20260518-21.log" → "daemon"；"ts-sdk-2026-05-27.log" → "ts-sdk"）。入参可为文件名或绝对路径。 */
+export function shortLogName(file) {
+    return path.basename(file, '.log')
+        .replace(/-\d{8}-\d{2}$/, '') // -YYYYMMDD-HH（按小时轮转）
+        .replace(/-\d{4}-\d{2}-\d{2}$/, ''); // -YYYY-MM-DD（按日轮转，如 ts-sdk）
+}
+/** 从 .log 文件名列表推导去重、字母序的类型列表。 */
+export function deriveLogTypes(files) {
+    const set = new Set();
+    for (const f of files) {
+        if (!f.endsWith('.log'))
+            continue;
+        set.add(shortLogName(f));
+    }
+    return [...set].sort();
+}
+/** 计算预勾集合：saved 为 undefined → 全勾；否则只勾命中 saved 的类型（新类型不勾）。 */
+export function computePreChecked(types, saved) {
+    if (saved === undefined)
+        return new Set(types);
+    const savedSet = new Set(saved);
+    return new Set(types.filter(t => savedSet.has(t)));
+}
+/** 返回 requested 中不在 available 里的无效类型。 */
+export function validateLogTypes(requested, available) {
+    const set = new Set(available);
+    return requested.filter(t => !set.has(t));
+}
+/** 只保留类型命中 filterTypes 的文件路径。 */
+export function filterLogFiles(files, filterTypes) {
+    return files.filter(f => filterTypes.has(shortLogName(f)));
+}