@co0ontty/wand 1.22.0 → 1.24.0

package/dist/tui/index.js

@@ -1,6 +1,8 @@
+import { checkUpdate, copyToClipboard, installService, installUpdate, isServiceInstalled, openInBrowser, restartSelf, uninstallService, } from "./commands.js";
 import { buildLayout } from "./layout.js";
 import { installLogBus, restoreLogBus } from "./log-bus.js";
 import { formatSession, sortRows } from "./session-formatter.js";
+import { openServicePanel } from "./service-panel.js";
 /** 触发 sessions 列表重渲的事件类型。output 太频繁，不订阅。 */
 const SESSIONS_REFRESH_EVENTS = new Set(["status", "started", "ended", "task"]);
 const RELATIVE_TIME_TICK_MS = 5_000;
@@ -8,6 +10,7 @@ export function startTui(deps) {
     const layout = buildLayout();
     let active = true;
     let stopping = false;
+    const startedAtMs = Date.now();
     const handle = {
         get isActive() { return active; },
         stop,
@@ -32,6 +35,9 @@ export function startTui(deps) {
             dbPath: deps.dbPath,
             orphanRecoveredCount: deps.orphanRecoveredCount,
             sessionCounts: counts,
+            startedAtMs,
+            rssBytes: safeRss(),
+            serviceInstalled: safeServiceInstalled(),
         };
     };
     function collectSessions() {
@@ -94,12 +100,145 @@ export function startTui(deps) {
             refreshAll();
     }, RELATIVE_TIME_TICK_MS);
     tickTimer.unref?.();
-    // —— 键位 ——
-    layout.screen.key(["q", "Q"], () => { void stop("user"); });
+    // 服务面板打开时，屏幕级快捷键全部让位给面板自身按键。
+    const idle = () => !layout.isServicePanelOpen();
+    // —— 基本键位 ——
+    layout.screen.key(["q", "Q"], () => { if (idle())
+        void stop("user"); });
     layout.screen.key(["C-c"], () => { void stop("user"); });
-    layout.screen.key(["r", "R"], () => { refreshAll(); });
+    layout.screen.key(["r"], () => {
+        if (!idle())
+            return;
+        refreshAll();
+        layout.showToast("已刷新", "info", 1500);
+    });
+    layout.screen.key(["l", "L"], () => {
+        if (!idle())
+            return;
+        layout.clearLogs();
+        layout.showToast("日志已清空", "info", 1500);
+    });
+    layout.screen.key(["?", "h", "H"], () => {
+        if (!idle())
+            return;
+        const visible = layout.toggleHelp();
+        if (!visible)
+            refreshAll();
+    });
+    // —— 运维快捷键 ——
+    layout.screen.key(["g", "G"], () => { if (idle())
+        openServicePanel({ layout, configPath: deps.configPath }); });
+    layout.screen.key(["S-r"], () => { if (idle())
+        void handleRestart(); });
+    layout.screen.key(["u", "U"], () => { if (idle())
+        void handleUpdate(); });
+    layout.screen.key(["o", "O"], () => { if (idle())
+        handleOpenBrowser(); });
+    layout.screen.key(["c", "C"], () => { if (idle())
+        handleCopyUrl(); });
+    layout.screen.key(["s"], () => { if (idle())
+        void handleInstallService(); });
+    layout.screen.key(["S-s"], () => { if (idle())
+        void handleUninstallService(); });
     // 首次渲染
     refreshAll();
+    // —— 操作处理函数 ——
+    async function handleRestart() {
+        const ok = await layout.confirm({
+            title: "重启 wand",
+            body: "将派生新进程并退出当前进程，活跃会话会因 PTY 中断而中止，是否继续？",
+        });
+        if (!ok)
+            return;
+        layout.showToast("正在重启…", "info", 5000);
+        // 让 toast 有时间渲染，再触发 restart
+        setTimeout(() => {
+            const r = restartSelf();
+            if (!r.ok)
+                layout.showToast(r.message, "error", 4000);
+        }, 200);
+    }
+    async function handleUpdate() {
+        layout.showToast("正在检查更新…", "info", 2000);
+        const info = await runOffMicrotask(() => checkUpdate(deps.version));
+        if (!info.latest) {
+            layout.showToast("无法连接到 npm registry", "error", 3500);
+            return;
+        }
+        if (!info.hasUpdate) {
+            layout.showToast(`已是最新版本 (v${info.current})`, "success", 3000);
+            return;
+        }
+        const go = await layout.confirm({
+            title: "发现新版本",
+            body: `当前 v${info.current} → 最新 v${info.latest}，是否立即升级？`,
+            yes: "回车 / y 安装",
+            no: "Esc / n 取消",
+        });
+        if (!go)
+            return;
+        layout.showToast("正在执行 npm install -g …", "info", 5000);
+        const r = await runOffMicrotask(() => installUpdate());
+        layout.showToast(r.message, r.ok ? "success" : "error", 5000);
+        if (r.detail)
+            layout.showDetail(r.ok ? "更新输出" : "更新失败", r.detail);
+    }
+    function handleOpenBrowser() {
+        const url = deps.urls[0]?.url;
+        if (!url) {
+            layout.showToast("没有可用 URL", "warn", 2000);
+            return;
+        }
+        const r = openInBrowser(url);
+        layout.showToast(r.message, r.ok ? "success" : "error", 2500);
+    }
+    function handleCopyUrl() {
+        const url = deps.urls[0]?.url;
+        if (!url) {
+            layout.showToast("没有可用 URL", "warn", 2000);
+            return;
+        }
+        const r = copyToClipboard(url);
+        layout.showToast(r.message, r.ok ? "success" : "error", 2500);
+    }
+    async function handleInstallService() {
+        if (isServiceInstalled()) {
+            layout.showToast("服务已安装，按 Shift+S 卸载", "warn", 2500);
+            return;
+        }
+        const ok = await layout.confirm({
+            title: "注册为系统服务",
+            body: process.platform === "linux"
+                ? "将写入 ~/.config/systemd/user/wand.service 并 systemctl --user enable --now。"
+                : process.platform === "darwin"
+                    ? "将写入 ~/Library/LaunchAgents/com.wand.web.plist 并 launchctl load。"
+                    : "当前平台暂不支持。",
+        });
+        if (!ok)
+            return;
+        const r = await runOffMicrotask(() => installService({ configPath: deps.configPath }));
+        layout.showToast(r.message, r.ok ? "success" : "error", 5000);
+        if (r.detail)
+            layout.showDetail(r.ok ? "服务安装详情" : "服务安装失败", r.detail);
+        refreshAll();
+    }
+    async function handleUninstallService() {
+        if (!isServiceInstalled()) {
+            layout.showToast("当前未安装系统服务", "warn", 2500);
+            return;
+        }
+        const ok = await layout.confirm({
+            title: "卸载系统服务",
+            body: "将禁用并删除 wand 的 systemd / launchd 配置，确认继续？",
+        });
+        if (!ok)
+            return;
+        const r = await runOffMicrotask(() => uninstallService());
+        layout.showToast(r.message, r.ok ? "success" : "error", 4000);
+        if (r.detail)
+            layout.showDetail(r.ok ? "服务卸载详情" : "服务卸载失败", r.detail);
+        refreshAll();
+    }
     async function stop(reason) {
         if (stopping || !active)
             return;
@@ -136,3 +275,32 @@ function safeStructuredList(mgr) {
         return [];
     }
 }
+function safeRss() {
+    try {
+        return process.memoryUsage().rss;
+    }
+    catch {
+        return 0;
+    }
+}
+function safeServiceInstalled() {
+    try {
+        return isServiceInstalled();
+    }
+    catch {
+        return false;
+    }
+}
+/** 把同步阻塞操作放到下一 microtask，给 TUI 留出一帧把 toast 画出来。 */
+function runOffMicrotask(fn) {
+    return new Promise((resolve, reject) => {
+        setImmediate(() => {
+            try {
+                resolve(fn());
+            }
+            catch (err) {
+                reject(err);
+            }
+        });
+    });
+}

package/dist/tui/ipc-client.d.ts

@@ -0,0 +1,27 @@
+/**
+ * IPC 客户端：连接主进程的 wand.sock，发送 snapshot/ping，等待行内 JSON 应答。
+ *
+ * 极简实现：单连接、并发请求按 id 路由、断线自动重连（指数退避）。
+ */
+import { EventEmitter } from "node:events";
+import { IpcSnapshotData } from "./ipc-protocol.js";
+export declare class IpcClient extends EventEmitter {
+    private readonly socketPath;
+    private socket;
+    private buf;
+    private pending;
+    private nextId;
+    private closed;
+    private reconnectMs;
+    private connected;
+    constructor(socketPath: string);
+    start(): void;
+    isConnected(): boolean;
+    close(): void;
+    snapshot(): Promise<IpcSnapshotData>;
+    ping(): Promise<boolean>;
+    shutdownDaemon(): Promise<boolean>;
+    private connect;
+    private handleLine;
+    private request;
+}

package/dist/tui/ipc-client.js

@@ -0,0 +1,153 @@
+/**
+ * IPC 客户端：连接主进程的 wand.sock，发送 snapshot/ping，等待行内 JSON 应答。
+ *
+ * 极简实现：单连接、并发请求按 id 路由、断线自动重连（指数退避）。
+ */
+import net from "node:net";
+import { EventEmitter } from "node:events";
+const REQ_TIMEOUT_MS = 5_000;
+const RECONNECT_INITIAL_MS = 250;
+const RECONNECT_MAX_MS = 5_000;
+export class IpcClient extends EventEmitter {
+    socketPath;
+    socket = null;
+    buf = "";
+    pending = new Map();
+    nextId = 1;
+    closed = false;
+    reconnectMs = RECONNECT_INITIAL_MS;
+    connected = false;
+    constructor(socketPath) {
+        super();
+        this.socketPath = socketPath;
+    }
+    start() {
+        this.connect();
+    }
+    isConnected() {
+        return this.connected;
+    }
+    close() {
+        this.closed = true;
+        for (const [, p] of this.pending) {
+            clearTimeout(p.timer);
+            p.reject(new Error("client closed"));
+        }
+        this.pending.clear();
+        try {
+            this.socket?.destroy();
+        }
+        catch { /* noop */ }
+        this.socket = null;
+    }
+    async snapshot() {
+        const resp = await this.request({ cmd: "snapshot" });
+        if (!resp.ok)
+            throw new Error(resp.error);
+        return resp.data;
+    }
+    async ping() {
+        try {
+            const resp = await this.request({ cmd: "ping" });
+            if (!resp.ok)
+                return false;
+            return resp.data.pong === true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async shutdownDaemon() {
+        try {
+            const resp = await this.request({ cmd: "shutdown" });
+            return resp.ok === true;
+        }
+        catch {
+            return false;
+        }
+    }
+    // ─── 内部 ────────────────────────────────────────────────────────────
+    connect() {
+        if (this.closed)
+            return;
+        const sock = net.createConnection({ path: this.socketPath });
+        this.socket = sock;
+        sock.setEncoding("utf8");
+        sock.on("connect", () => {
+            this.connected = true;
+            this.reconnectMs = RECONNECT_INITIAL_MS;
+            this.emit("connect");
+        });
+        sock.on("data", (chunk) => {
+            this.buf += chunk;
+            let idx;
+            while ((idx = this.buf.indexOf("\n")) >= 0) {
+                const line = this.buf.slice(0, idx).trim();
+                this.buf = this.buf.slice(idx + 1);
+                if (line)
+                    this.handleLine(line);
+            }
+        });
+        const onClose = () => {
+            this.connected = false;
+            this.emit("disconnect");
+            // 把还没完成的请求拒掉，避免永远卡住
+            for (const [, p] of this.pending) {
+                clearTimeout(p.timer);
+                p.reject(new Error("ipc disconnected"));
+            }
+            this.pending.clear();
+            if (this.closed)
+                return;
+            const delay = this.reconnectMs;
+            this.reconnectMs = Math.min(this.reconnectMs * 2, RECONNECT_MAX_MS);
+            const timer = setTimeout(() => this.connect(), delay);
+            timer.unref?.();
+        };
+        sock.on("close", onClose);
+        sock.on("error", (err) => {
+            this.emit("error", err);
+        });
+    }
+    handleLine(line) {
+        let msg = null;
+        try {
+            msg = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        if (!msg || typeof msg.id !== "string")
+            return;
+        const p = this.pending.get(msg.id);
+        if (!p)
+            return;
+        this.pending.delete(msg.id);
+        clearTimeout(p.timer);
+        p.resolve(msg);
+    }
+    request(payload) {
+        return new Promise((resolve, reject) => {
+            if (!this.socket || !this.connected) {
+                reject(new Error("ipc not connected"));
+                return;
+            }
+            const id = String(this.nextId++);
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error("ipc request timeout"));
+            }, REQ_TIMEOUT_MS);
+            timer.unref?.();
+            this.pending.set(id, { resolve, reject, timer });
+            const req = { id, cmd: payload.cmd };
+            try {
+                this.socket.write(JSON.stringify(req) + "\n");
+            }
+            catch (err) {
+                this.pending.delete(id);
+                clearTimeout(timer);
+                reject(err);
+            }
+        });
+    }
+}

package/dist/tui/ipc-protocol.d.ts

@@ -0,0 +1,50 @@
+/**
+ * 主进程 ↔ attach 客户端的控制平面 IPC 协议。
+ *
+ * 帧格式：单行 JSON，以 `\n` 分割。客户端按行读，服务端按行解析。
+ * 不做长度前缀，因为单条 message 受 snapshot 大小限制，远低于 socket 缓冲区。
+ */
+import { SessionRow } from "./session-formatter.js";
+export interface IpcSnapshotHeader {
+    version: string;
+    url: string;
+    scheme: "HTTP" | "HTTPS";
+    bindAddr: string;
+    configPath: string;
+    dbPath: string;
+    orphanRecoveredCount: number;
+    sessionCounts: {
+        active: number;
+        archived: number;
+        total: number;
+    };
+    /** 主进程启动时间 (ms epoch)。 */
+    startedAtMs: number;
+    /** 主进程 RSS。 */
+    rssBytes: number;
+    /** 主进程 PID。 */
+    pid: number;
+}
+export interface IpcSnapshotData {
+    header: IpcSnapshotHeader;
+    sessions: SessionRow[];
+}
+export interface IpcRequest {
+    id: string;
+    cmd: "snapshot" | "ping" | "shutdown";
+}
+export interface IpcResponseOk<T = unknown> {
+    id: string;
+    ok: true;
+    data: T;
+}
+export interface IpcResponseErr {
+    id: string;
+    ok: false;
+    error: string;
+}
+export type IpcResponse<T = unknown> = IpcResponseOk<T> | IpcResponseErr;
+export type SnapshotResponse = IpcResponseOk<IpcSnapshotData>;
+export type PingResponse = IpcResponseOk<{
+    pong: true;
+}>;

package/dist/tui/ipc-protocol.js

@@ -0,0 +1,7 @@
+/**
+ * 主进程 ↔ attach 客户端的控制平面 IPC 协议。
+ *
+ * 帧格式：单行 JSON，以 `\n` 分割。客户端按行读，服务端按行解析。
+ * 不做长度前缀，因为单条 message 受 snapshot 大小限制，远低于 socket 缓冲区。
+ */
+export {};

package/dist/tui/ipc-server.d.ts

@@ -0,0 +1,17 @@
+/**
+ * IPC 服务端：监听 Unix socket，处理 attach 客户端发来的 snapshot/ping 请求。
+ *
+ * Windows 不支持（socketPath 返回空字符串），调用方应跳过 startIpcServer。
+ */
+import { IpcSnapshotData } from "./ipc-protocol.js";
+export interface IpcServerDeps {
+    socketPath: string;
+    /** 由 TUI 上层组装。同步函数，避免在 socket callback 里做异步阻塞。 */
+    snapshotProvider: () => IpcSnapshotData;
+    /** attach 客户端发起 shutdown 时调用；返回 promise，resolve 后服务端退出。 */
+    onShutdown?: () => void | Promise<void>;
+}
+export interface IpcServerHandle {
+    close(): Promise<void>;
+}
+export declare function startIpcServer(deps: IpcServerDeps): IpcServerHandle | null;

package/dist/tui/ipc-server.js

@@ -0,0 +1,100 @@
+/**
+ * IPC 服务端：监听 Unix socket，处理 attach 客户端发来的 snapshot/ping 请求。
+ *
+ * Windows 不支持（socketPath 返回空字符串），调用方应跳过 startIpcServer。
+ */
+import net from "node:net";
+import { existsSync, unlinkSync } from "node:fs";
+export function startIpcServer(deps) {
+    if (!deps.socketPath)
+        return null;
+    // 残留 socket 文件可能让 net.listen 直接报 EADDRINUSE。先尝试清理。
+    if (existsSync(deps.socketPath)) {
+        try {
+            unlinkSync(deps.socketPath);
+        }
+        catch { /* noop */ }
+    }
+    const server = net.createServer((conn) => {
+        let buf = "";
+        conn.on("data", (chunk) => {
+            buf += chunk.toString("utf8");
+            let idx;
+            while ((idx = buf.indexOf("\n")) >= 0) {
+                const line = buf.slice(0, idx).trim();
+                buf = buf.slice(idx + 1);
+                if (!line)
+                    continue;
+                handleLine(line, conn);
+            }
+        });
+        conn.on("error", () => { });
+    });
+    function handleLine(line, conn) {
+        let req = null;
+        try {
+            req = JSON.parse(line);
+        }
+        catch {
+            return; // 直接丢弃损坏帧
+        }
+        if (!req || typeof req.id !== "string" || typeof req.cmd !== "string")
+            return;
+        try {
+            switch (req.cmd) {
+                case "ping": {
+                    const resp = { id: req.id, ok: true, data: { pong: true } };
+                    conn.write(JSON.stringify(resp) + "\n");
+                    return;
+                }
+                case "snapshot": {
+                    const data = deps.snapshotProvider();
+                    const resp = { id: req.id, ok: true, data };
+                    conn.write(JSON.stringify(resp) + "\n");
+                    return;
+                }
+                case "shutdown": {
+                    const ack = { id: req.id, ok: true, data: { accepted: true } };
+                    conn.write(JSON.stringify(ack) + "\n");
+                    // 给客户端一个 tick 把 ack 拿到再触发 shutdown
+                    setImmediate(() => { void deps.onShutdown?.(); });
+                    return;
+                }
+                default: {
+                    const err = { id: req.id, ok: false, error: `unknown cmd: ${req.cmd}` };
+                    conn.write(JSON.stringify(err) + "\n");
+                }
+            }
+        }
+        catch (e) {
+            const err = {
+                id: req.id,
+                ok: false,
+                error: e instanceof Error ? e.message : String(e),
+            };
+            try {
+                conn.write(JSON.stringify(err) + "\n");
+            }
+            catch { /* peer 走了 */ }
+        }
+    }
+    server.on("error", (err) => {
+        // 不要崩进程；attach 模式不可用也不影响主功能。
+        process.stderr.write(`[wand] IPC server error: ${err.message}\n`);
+    });
+    server.listen(deps.socketPath);
+    return {
+        close: async () => {
+            await new Promise((resolve) => {
+                server.close(() => resolve());
+                // 兜底：1s 内强制 resolve
+                setTimeout(() => resolve(), 1000).unref?.();
+            });
+            try {
+                if (existsSync(deps.socketPath))
+                    unlinkSync(deps.socketPath);
+            }
+            catch { /* noop */ }
+        },
+    };
+}

package/dist/tui/layout.d.ts

@@ -13,6 +13,39 @@ export interface HeaderInfo {
         archived: number;
         total: number;
     };
+    /** 服务启动时间（ms epoch），用于计算 uptime。 */
+    startedAtMs: number;
+    /** 当前进程 RSS 内存（字节），由调用方传入。 */
+    rssBytes: number;
+    /** 是否已注册系统服务（systemd / launchd），用于在 header 显示标签。 */
+    serviceInstalled: boolean;
+}
+export type ToastLevel = "info" | "warn" | "error" | "success";
+export interface ConfirmOptions {
+    title: string;
+    body: string;
+    yes?: string;
+    no?: string;
+}
+export interface ServicePanelView {
+    /** 第一行状态描述，例如 "active (running) since ..." */
+    statusLine: string;
+    /** active / inactive / failed / unsupported / unknown / loaded。决定状态行颜色。 */
+    state: "active" | "inactive" | "failed" | "loaded" | "unknown" | "unsupported";
+    installed: boolean;
+    platform: NodeJS.Platform;
+    /** 用于"上次操作"提示行，可为空。 */
+    lastAction?: string;
+}
+export interface ServicePanelHandlers {
+    onStart: () => void | Promise<void>;
+    onStop: () => void | Promise<void>;
+    onRestart: () => void | Promise<void>;
+    onInstall: () => void | Promise<void>;
+    onUninstall: () => void | Promise<void>;
+    onLogs: () => void | Promise<void>;
+    onRefresh: () => void | Promise<void>;
+    onClose: () => void;
 }
 export interface LayoutHandle {
     screen: any;
@@ -20,6 +53,17 @@ export interface LayoutHandle {
     refreshSessions(rows: SessionRow[]): void;
     appendLog(record: LogRecord): void;
     setSelectionListener(listener: (index: number) => void): void;
+    showHelp(visible: boolean): void;
+    toggleHelp(): boolean;
+    showToast(message: string, level?: ToastLevel, ttlMs?: number): void;
+    confirm(opts: ConfirmOptions): Promise<boolean>;
+    showDetail(title: string, body: string): void;
+    hideDetail(): void;
+    clearLogs(): void;
+    openServicePanel(handlers: ServicePanelHandlers, initial: ServicePanelView): void;
+    updateServicePanel(view: ServicePanelView): void;
+    closeServicePanel(): void;
+    isServicePanelOpen(): boolean;
     destroy(): void;
 }
 export declare function buildLayout(): LayoutHandle;