@co0ontty/wand 1.18.12 → 1.20.4

package/dist/tui/index.js

@@ -0,0 +1,138 @@
+import { buildLayout } from "./layout.js";
+import { installLogBus, restoreLogBus } from "./log-bus.js";
+import { formatSession, sortRows } from "./session-formatter.js";
+/** 触发 sessions 列表重渲的事件类型。output 太频繁，不订阅。 */
+const SESSIONS_REFRESH_EVENTS = new Set(["status", "started", "ended", "task"]);
+const RELATIVE_TIME_TICK_MS = 5_000;
+export function startTui(deps) {
+    const layout = buildLayout();
+    let active = true;
+    let stopping = false;
+    const handle = {
+        get isActive() { return active; },
+        stop,
+    };
+    // 让 server 端的 wandError/wandWarn 能感知 TUI 在线。
+    globalThis.__wandTui = handle;
+    installLogBus((record) => {
+        if (!active)
+            return;
+        layout.appendLog(record);
+    });
+    const headerInfo = () => {
+        const all = collectSessions();
+        const counts = countSessions(all);
+        const primary = deps.urls[0];
+        return {
+            version: deps.version,
+            url: primary ? primary.url : `${deps.httpsEnabled ? "https" : "http"}://${deps.bindAddr}`,
+            scheme: primary ? primary.scheme : (deps.httpsEnabled ? "HTTPS" : "HTTP"),
+            bindAddr: deps.bindAddr,
+            configPath: deps.configPath,
+            dbPath: deps.dbPath,
+            orphanRecoveredCount: deps.orphanRecoveredCount,
+            sessionCounts: counts,
+        };
+    };
+    function collectSessions() {
+        const ptyList = deps.processManager.listSlim();
+        const structuredList = safeStructuredList(deps.structuredSessions);
+        // 同 id 去重，PTY 优先（PM 是主路径）
+        const seen = new Set();
+        const merged = [];
+        for (const s of ptyList) {
+            seen.add(s.id);
+            merged.push(s);
+        }
+        for (const s of structuredList) {
+            if (!seen.has(s.id))
+                merged.push(s);
+        }
+        return sortRows(merged);
+    }
+    function countSessions(all) {
+        let act = 0, arch = 0;
+        for (const s of all) {
+            if (s.archived)
+                arch += 1;
+            else if (s.status === "running")
+                act += 1;
+        }
+        return { active: act, archived: arch, total: all.length };
+    }
+    function refreshAll() {
+        if (!active)
+            return;
+        const all = collectSessions();
+        layout.refreshHeader(headerInfo());
+        layout.refreshSessions(all.map((s) => formatSession(s)));
+    }
+    // —— 数据订阅 ——
+    const onPmEvent = (ev) => {
+        if (!active)
+            return;
+        if (SESSIONS_REFRESH_EVENTS.has(ev.type)) {
+            scheduleSessionsRefresh();
+        }
+    };
+    deps.processManager.on("process", onPmEvent);
+    // structuredSessions 当前没有公开 EventEmitter 接口；本版本仅靠定时刷新覆盖其变化。
+    // 若后续暴露 .on("process", ...) 可以在此追加监听。
+    let pendingRefresh = false;
+    function scheduleSessionsRefresh() {
+        if (pendingRefresh)
+            return;
+        pendingRefresh = true;
+        setImmediate(() => {
+            pendingRefresh = false;
+            if (active)
+                refreshAll();
+        });
+    }
+    const tickTimer = setInterval(() => {
+        if (active)
+            refreshAll();
+    }, RELATIVE_TIME_TICK_MS);
+    tickTimer.unref?.();
+    // —— 键位 ——
+    layout.screen.key(["q", "Q"], () => { void stop("user"); });
+    layout.screen.key(["C-c"], () => { void stop("user"); });
+    layout.screen.key(["r", "R"], () => { refreshAll(); });
+    // 首次渲染
+    refreshAll();
+    async function stop(reason) {
+        if (stopping || !active)
+            return;
+        stopping = true;
+        active = false;
+        clearInterval(tickTimer);
+        try {
+            deps.processManager.off("process", onPmEvent);
+        }
+        catch { /* noop */ }
+        try {
+            layout.destroy();
+        }
+        catch { /* destroyed */ }
+        restoreLogBus();
+        if (globalThis.__wandTui === handle) {
+            delete globalThis.__wandTui;
+        }
+        try {
+            await deps.onExit(reason);
+        }
+        catch (err) {
+            // 此时 stderr 已经还原，安全打印。
+            process.stderr.write(`[wand] TUI 退出回调失败: ${String(err)}\n`);
+        }
+    }
+    return handle;
+}
+function safeStructuredList(mgr) {
+    try {
+        return mgr.listSlim();
+    }
+    catch {
+        return [];
+    }
+}

package/dist/tui/layout.d.ts

@@ -0,0 +1,25 @@
+import { LogRecord } from "./log-bus.js";
+import { SessionRow } from "./session-formatter.js";
+export interface HeaderInfo {
+    version: string;
+    url: string;
+    scheme: "HTTP" | "HTTPS";
+    bindAddr: string;
+    configPath: string;
+    dbPath: string;
+    orphanRecoveredCount: number;
+    sessionCounts: {
+        active: number;
+        archived: number;
+        total: number;
+    };
+}
+export interface LayoutHandle {
+    screen: any;
+    refreshHeader(info: HeaderInfo): void;
+    refreshSessions(rows: SessionRow[]): void;
+    appendLog(record: LogRecord): void;
+    setSelectionListener(listener: (index: number) => void): void;
+    destroy(): void;
+}
+export declare function buildLayout(): LayoutHandle;

package/dist/tui/layout.js

@@ -0,0 +1,198 @@
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+// neo-blessed 是 CJS，没有匹配 @types/blessed 的 default export，统一当 any 用。
+const blessed = require("neo-blessed");
+const HEADER_HEIGHT = 6;
+const SESSIONS_HEIGHT = 12;
+const LOG_TOP = HEADER_HEIGHT + SESSIONS_HEIGHT;
+const LOG_BUFFER_LIMIT = 1000;
+const RENDER_THROTTLE_MS = 50;
+export function buildLayout() {
+    const screen = blessed.screen({
+        smartCSR: true,
+        fullUnicode: true,
+        title: "wand",
+        autoPadding: true,
+        warnings: false,
+    });
+    const header = blessed.box({
+        parent: screen,
+        top: 0,
+        left: 0,
+        width: "100%",
+        height: HEADER_HEIGHT,
+        border: { type: "line" },
+        label: " wand ",
+        tags: true,
+        style: {
+            border: { fg: "cyan" },
+            label: { fg: "cyan", bold: true },
+        },
+    });
+    const sessions = blessed.list({
+        parent: screen,
+        top: HEADER_HEIGHT,
+        left: 0,
+        width: "100%",
+        height: SESSIONS_HEIGHT,
+        border: { type: "line" },
+        label: " Sessions ",
+        keys: true,
+        mouse: false,
+        vi: false,
+        tags: true,
+        scrollable: true,
+        scrollbar: { ch: " ", style: { bg: "gray" } },
+        style: {
+            border: { fg: "gray" },
+            label: { fg: "cyan", bold: true },
+            selected: { bg: "blue", fg: "white" },
+            item: { fg: "white" },
+        },
+        items: [],
+    });
+    // 日志面板故意关掉 tags：用户日志可能含 `{...}`，开 tags 会被误解析。
+    // 颜色通过 ANSI 转义码注入，blessed.log 能正确渲染 ANSI。
+    const logbox = blessed.log({
+        parent: screen,
+        top: LOG_TOP,
+        left: 0,
+        width: "100%",
+        bottom: 1,
+        border: { type: "line" },
+        label: " Logs ",
+        tags: false,
+        scrollable: true,
+        scrollback: LOG_BUFFER_LIMIT,
+        scrollbar: { ch: " ", style: { bg: "gray" } },
+        style: {
+            border: { fg: "gray" },
+            label: { fg: "cyan", bold: true },
+        },
+    });
+    const hint = blessed.box({
+        parent: screen,
+        bottom: 0,
+        left: 0,
+        width: "100%",
+        height: 1,
+        tags: true,
+        content: "{gray-fg}[q]uit  [r]efresh  [↑↓] navigate{/}",
+    });
+    // 让 sessions 默认获得焦点以接收键盘事件
+    sessions.focus();
+    let renderPending = false;
+    let renderTimer = null;
+    function scheduleRender() {
+        if (renderPending)
+            return;
+        renderPending = true;
+        renderTimer = setTimeout(() => {
+            renderPending = false;
+            renderTimer = null;
+            try {
+                screen.render();
+            }
+            catch { /* destroyed */ }
+        }, RENDER_THROTTLE_MS);
+        renderTimer.unref?.();
+    }
+    function refreshHeader(info) {
+        const orphan = info.orphanRecoveredCount > 0
+            ? `  {gray-fg}(${info.orphanRecoveredCount} orphan PTYs cleaned){/}`
+            : "";
+        const counts = info.sessionCounts;
+        const sess = `${counts.active} active · ${counts.archived} archived · ${counts.total} total`;
+        const lines = [
+            `{cyan-fg}Version{/}    ${info.version}`,
+            `{cyan-fg}URL{/}        ${info.url} {gray-fg}(${info.scheme}, bind ${info.bindAddr}){/}`,
+            `{cyan-fg}Config{/}     ${info.configPath}`,
+            `{cyan-fg}Database{/}   ${info.dbPath}`,
+            `{cyan-fg}Sessions{/}   ${sess}${orphan}`,
+        ];
+        header.setContent(lines.join("\n"));
+        scheduleRender();
+    }
+    function refreshSessions(rows) {
+        if (rows.length === 0) {
+            sessions.setItems(["{gray-fg}— 暂无会话 —{/}"]);
+        }
+        else {
+            sessions.setItems(rows.map(formatRow));
+        }
+        scheduleRender();
+    }
+    function appendLog(record) {
+        const ts = formatTs(record.ts);
+        const tsAnsi = `\x1b[90m${ts}\x1b[39m`;
+        const lineAnsi = ansiColorize(record.level, record.line);
+        logbox.log(`${tsAnsi} ${lineAnsi}`);
+        scheduleRender();
+    }
+    function setSelectionListener(listener) {
+        sessions.on("select item", (_item, index) => listener(index));
+    }
+    function destroy() {
+        if (renderTimer) {
+            clearTimeout(renderTimer);
+            renderTimer = null;
+        }
+        try {
+            screen.destroy();
+        }
+        catch { /* already destroyed */ }
+    }
+    return {
+        screen,
+        refreshHeader,
+        refreshSessions,
+        appendLog,
+        setSelectionListener,
+        destroy,
+    };
+}
+function formatRow(row) {
+    const glyphColor = toneColor(row.tone);
+    const glyph = `{${glyphColor}-fg}${row.glyph}{/}`;
+    const runner = pad(row.runner, 12);
+    const cwd = pad(row.cwd, 30);
+    const state = `{${toneColor(row.tone)}-fg}${pad(row.state, 9)}{/}`;
+    const dur = row.duration ? `{gray-fg}${row.duration}{/}` : "";
+    return `${glyph}  ${runner}  ${cwd}  ${state}  ${dur}`;
+}
+function pad(str, width) {
+    if (str.length >= width)
+        return str.slice(0, width);
+    return str + " ".repeat(width - str.length);
+}
+function toneColor(tone) {
+    switch (tone) {
+        case "running": return "green";
+        case "idle": return "white";
+        case "failed": return "red";
+        case "stopped": return "yellow";
+        case "exited": return "gray";
+        case "archived": return "gray";
+        default: return "white";
+    }
+}
+function ansiColorize(level, line) {
+    // 把 line 内本身的颜色重置消掉（避免覆盖我们的颜色），再加上 level 颜色。
+    const cleaned = stripAnsi(line);
+    if (level === "error")
+        return `\x1b[31m${cleaned}\x1b[39m`;
+    if (level === "warn")
+        return `\x1b[33m${cleaned}\x1b[39m`;
+    return cleaned;
+}
+function stripAnsi(line) {
+    // eslint-disable-next-line no-control-regex
+    return line.replace(/\x1b\[[0-9;]*m/g, "");
+}
+function formatTs(ms) {
+    const d = new Date(ms);
+    const hh = String(d.getHours()).padStart(2, "0");
+    const mm = String(d.getMinutes()).padStart(2, "0");
+    const ss = String(d.getSeconds()).padStart(2, "0");
+    return `${hh}:${mm}:${ss}`;
+}

package/dist/tui/log-bus.d.ts

@@ -0,0 +1,23 @@
+/**
+ * TUI 日志总线：当 TUI 运行时，劫持 console.* 与 process.stderr.write，
+ * 把所有运行期日志路由到 TUI 的 log 面板。
+ *
+ * 故意不劫持 process.stdout.write —— blessed 自身的渲染走 stdout，
+ * 劫持会形成自循环。所有"启动期"经过 stdout 的写入都发生在 TUI 启动之前，
+ * 不需要捕获。
+ */
+export type LogLevel = "info" | "warn" | "error";
+export interface LogRecord {
+    level: LogLevel;
+    line: string;
+    ts: number;
+}
+export type LogSink = (record: LogRecord) => void;
+/** 安装日志拦截。重复安装会先恢复再重装。 */
+export declare function installLogBus(sink: LogSink): void;
+/** 还原 console.* 与 stderr.write。多次调用安全。 */
+export declare function restoreLogBus(): void;
+/** 主动写入 TUI 日志面板（用于 wandError/wandWarn 等已识别路径）。
+ *  非活跃时不做任何事，调用方应自行判断是否回退到原 stderr。 */
+export declare function wandTuiLog(level: LogLevel, line: string): void;
+export declare function isLogBusActive(): boolean;

package/dist/tui/log-bus.js

@@ -0,0 +1,111 @@
+/**
+ * TUI 日志总线：当 TUI 运行时，劫持 console.* 与 process.stderr.write，
+ * 把所有运行期日志路由到 TUI 的 log 面板。
+ *
+ * 故意不劫持 process.stdout.write —— blessed 自身的渲染走 stdout，
+ * 劫持会形成自循环。所有"启动期"经过 stdout 的写入都发生在 TUI 启动之前，
+ * 不需要捕获。
+ */
+let original = null;
+let activeSink = null;
+let inSink = false;
+function emit(level, args) {
+    if (!activeSink)
+        return;
+    if (inSink) {
+        // 防止 sink 内部异常或日志再触发劫持函数导致雪崩。
+        if (original) {
+            const text = stringifyArgs(args);
+            original.stderrWrite.call(process.stderr, text + "\n");
+        }
+        return;
+    }
+    const text = stringifyArgs(args);
+    for (const line of splitLines(text)) {
+        if (line.length === 0)
+            continue;
+        inSink = true;
+        try {
+            activeSink({ level, line, ts: Date.now() });
+        }
+        catch (err) {
+            if (original) {
+                original.stderrWrite.call(process.stderr, `[log-bus] sink threw: ${String(err)}\n`);
+            }
+        }
+        finally {
+            inSink = false;
+        }
+    }
+}
+function stringifyArgs(args) {
+    return args
+        .map((a) => {
+        if (typeof a === "string")
+            return a;
+        if (a instanceof Error)
+            return a.stack || a.message;
+        try {
+            return JSON.stringify(a);
+        }
+        catch {
+            return String(a);
+        }
+    })
+        .join(" ");
+}
+function splitLines(text) {
+    return text.replace(/\r\n/g, "\n").split("\n").map((s) => s.replace(/\s+$/, ""));
+}
+/** 安装日志拦截。重复安装会先恢复再重装。 */
+export function installLogBus(sink) {
+    if (original)
+        restoreLogBus();
+    original = {
+        consoleLog: console.log,
+        consoleInfo: console.info,
+        consoleWarn: console.warn,
+        consoleError: console.error,
+        stderrWrite: process.stderr.write.bind(process.stderr),
+    };
+    activeSink = sink;
+    console.log = (...args) => emit("info", args);
+    console.info = (...args) => emit("info", args);
+    console.warn = (...args) => emit("warn", args);
+    console.error = (...args) => emit("error", args);
+    process.stderr.write = ((chunk, encodingOrCb, cb) => {
+        const text = typeof chunk === "string"
+            ? chunk
+            : Buffer.isBuffer(chunk)
+                ? chunk.toString(typeof encodingOrCb === "string" ? encodingOrCb : "utf8")
+                : String(chunk);
+        emit("error", [text]);
+        if (typeof encodingOrCb === "function")
+            encodingOrCb();
+        else if (typeof cb === "function")
+            cb();
+        return true;
+    });
+}
+/** 还原 console.* 与 stderr.write。多次调用安全。 */
+export function restoreLogBus() {
+    if (!original)
+        return;
+    console.log = original.consoleLog;
+    console.info = original.consoleInfo;
+    console.warn = original.consoleWarn;
+    console.error = original.consoleError;
+    process.stderr.write = original.stderrWrite;
+    original = null;
+    activeSink = null;
+}
+/** 主动写入 TUI 日志面板（用于 wandError/wandWarn 等已识别路径）。
+ *  非活跃时不做任何事，调用方应自行判断是否回退到原 stderr。 */
+export function wandTuiLog(level, line) {
+    if (!activeSink)
+        return;
+    emit(level, [line]);
+}
+export function isLogBusActive() {
+    return activeSink !== null;
+}

package/dist/tui/relative-time.d.ts

@@ -0,0 +1,4 @@
+/** 把绝对时间字符串（ISO）转为简短的相对时长，例：`2m`、`10m`、`1h`、`3d`。 */
+export declare function relativeAge(fromIso: string, nowMs?: number): string;
+/** 计算两个时间点之间的相对时长（结束 - 开始）。 */
+export declare function durationBetween(startIso: string, endIso: string | null): string;

package/dist/tui/relative-time.js

@@ -0,0 +1,27 @@
+/** 把绝对时间字符串（ISO）转为简短的相对时长，例：`2m`、`10m`、`1h`、`3d`。 */
+export function relativeAge(fromIso, nowMs = Date.now()) {
+    const t = Date.parse(fromIso);
+    if (!Number.isFinite(t))
+        return "—";
+    const seconds = Math.max(0, Math.floor((nowMs - t) / 1000));
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h`;
+    const days = Math.floor(hours / 24);
+    return `${days}d`;
+}
+/** 计算两个时间点之间的相对时长（结束 - 开始）。 */
+export function durationBetween(startIso, endIso) {
+    if (!endIso)
+        return relativeAge(startIso);
+    const start = Date.parse(startIso);
+    const end = Date.parse(endIso);
+    if (!Number.isFinite(start) || !Number.isFinite(end) || end < start)
+        return "—";
+    return relativeAge(startIso, end);
+}

package/dist/tui/session-formatter.d.ts

@@ -0,0 +1,17 @@
+import { SessionSnapshot } from "../types.js";
+export interface SessionRow {
+    id: string;
+    glyph: string;
+    runner: string;
+    cwd: string;
+    state: string;
+    duration: string;
+    /** 用于上色的语义级别（blessed tag 由调用方决定）。 */
+    tone: "running" | "idle" | "archived" | "exited" | "failed" | "stopped";
+}
+/** 把绝对路径压缩为友好显示：`~/foo` 或者长路径只保留尾部。 */
+export declare function shortenCwd(cwd: string, max?: number): string;
+/** 从 SessionSnapshot 推导出一行表格数据。状态规则见 plan。 */
+export declare function formatSession(snap: SessionSnapshot, now?: number): SessionRow;
+/** 把行集按"活跃优先 → idle → 已结束 → archived"排序，再按开始时间倒序。 */
+export declare function sortRows(snaps: SessionSnapshot[]): SessionSnapshot[];

package/dist/tui/session-formatter.js

@@ -0,0 +1,111 @@
+import path from "node:path";
+import os from "node:os";
+import { durationBetween, relativeAge } from "./relative-time.js";
+/** 把绝对路径压缩为友好显示：`~/foo` 或者长路径只保留尾部。 */
+export function shortenCwd(cwd, max = 28) {
+    const home = os.homedir();
+    let out = cwd;
+    if (home && cwd.startsWith(home))
+        out = "~" + cwd.slice(home.length);
+    if (out.length <= max)
+        return out;
+    // 保留头部 1 段 + 尾部尽可能多
+    const parts = out.split(path.sep).filter(Boolean);
+    if (parts.length <= 2)
+        return "…" + out.slice(out.length - max + 1);
+    const head = parts[0].startsWith("~") ? parts[0] : "";
+    const tail = parts.slice(-2).join(path.sep);
+    const candidate = (head ? head + path.sep : "/") + "…" + path.sep + tail;
+    return candidate.length <= max ? candidate : "…" + tail.slice(tail.length - max + 1);
+}
+/** 从 SessionSnapshot 推导出一行表格数据。状态规则见 plan。 */
+export function formatSession(snap, now = Date.now()) {
+    const runner = (snap.runner || snap.provider || "pty").toString();
+    const cwd = shortenCwd(snap.cwd);
+    if (snap.archived) {
+        return {
+            id: snap.id,
+            glyph: "○",
+            runner,
+            cwd,
+            state: "archived",
+            duration: "",
+            tone: "archived",
+        };
+    }
+    switch (snap.status) {
+        case "running": {
+            const hasTask = typeof snap.currentTaskTitle === "string" && snap.currentTaskTitle.length > 0;
+            return {
+                id: snap.id,
+                glyph: "●",
+                runner,
+                cwd,
+                state: hasTask ? "running" : "idle",
+                duration: relativeAge(snap.startedAt, now),
+                tone: hasTask ? "running" : "idle",
+            };
+        }
+        case "failed":
+            return {
+                id: snap.id,
+                glyph: "○",
+                runner,
+                cwd,
+                state: "failed",
+                duration: durationBetween(snap.startedAt, snap.endedAt),
+                tone: "failed",
+            };
+        case "stopped":
+            return {
+                id: snap.id,
+                glyph: "○",
+                runner,
+                cwd,
+                state: "stopped",
+                duration: durationBetween(snap.startedAt, snap.endedAt),
+                tone: "stopped",
+            };
+        case "exited":
+        default:
+            return {
+                id: snap.id,
+                glyph: "○",
+                runner,
+                cwd,
+                state: "exited",
+                duration: durationBetween(snap.startedAt, snap.endedAt),
+                tone: "exited",
+            };
+    }
+}
+/** 把行集按"活跃优先 → idle → 已结束 → archived"排序，再按开始时间倒序。 */
+export function sortRows(snaps) {
+    const rank = {
+        running: 0,
+        idle: 1,
+        failed: 2,
+        stopped: 3,
+        exited: 4,
+        archived: 5,
+    };
+    return [...snaps].sort((a, b) => {
+        const ra = a.archived
+            ? rank.archived
+            : a.status === "running"
+                ? a.currentTaskTitle
+                    ? rank.running
+                    : rank.idle
+                : rank[a.status] ?? 99;
+        const rb = b.archived
+            ? rank.archived
+            : b.status === "running"
+                ? b.currentTaskTitle
+                    ? rank.running
+                    : rank.idle
+                : rank[b.status] ?? 99;
+        if (ra !== rb)
+            return ra - rb;
+        return b.startedAt.localeCompare(a.startedAt);
+    });
+}