@co0ontty/wand 1.18.1 → 1.20.4

package/dist/cli.js

@@ -11,9 +11,38 @@ async function main() {
             break;
         }
         case "web": {
-            const config = await ensureRequiredFiles(configPath);
+            const useTui = shouldUseTui();
+            // web 命令下"已存在"的 ready 信息由统一的启动 banner / TUI 展示，避免重复。
+            // "Created..." 这种首次创建事件仍会输出（ensureRequiredFiles 内部判断）。
+            const config = await ensureRequiredFiles(configPath, { silentReady: true });
+            const { ensureNodePtyHelperExecutable } = await import("./ensure-node-pty-helper.js");
+            ensureNodePtyHelperExecutable();
             const { startServer } = await import("./server.js");
-            await startServer(config, configPath);
+            const handle = await startServer(config, configPath);
+            if (useTui) {
+                const { startTui } = await import("./tui/index.js");
+                const tui = startTui({
+                    processManager: handle.processManager,
+                    structuredSessions: handle.structuredSessions,
+                    version: handle.version,
+                    configPath: handle.configPath,
+                    dbPath: handle.dbPath,
+                    bindAddr: handle.bindAddr,
+                    httpsEnabled: handle.httpsEnabled,
+                    urls: handle.urls,
+                    orphanRecoveredCount: handle.orphanRecoveredCount,
+                    onExit: async () => {
+                        await handle.close();
+                        process.exit(0);
+                    },
+                });
+                const onSignal = () => { void tui.stop("signal"); };
+                process.on("SIGINT", onSignal);
+                process.on("SIGTERM", onSignal);
+            }
+            else {
+                printStartupBanner(handle);
+            }
             break;
         }
         case "config:path": {
@@ -65,26 +94,64 @@ Options:
   -c, --config <path>       Use a custom config file (default: ~/.wand/config.json)
 `);
 }
-async function ensureRequiredFiles(configPath) {
+async function ensureRequiredFiles(configPath, opts = {}) {
     const { ensureDatabaseFile, resolveDatabasePath } = await import("./storage.js");
     const dbPath = resolveDatabasePath(configPath);
     const hadConfig = hasConfigFile(configPath);
     const config = await ensureConfig(configPath);
     const createdDb = ensureDatabaseFile(dbPath);
+    // 已存在的 ready 信息在 TUI 模式下由启动 banner 统一展示，此处静默；
+    // 但 created 是首次创建事件，无论 TUI 与否都值得提示。
     if (!hadConfig) {
         process.stdout.write(`[wand] Created default config at ${configPath}\n`);
     }
-    else {
+    else if (!opts.silentReady) {
         process.stdout.write(`[wand] Config ready at ${configPath}\n`);
     }
     if (createdDb) {
         process.stdout.write(`[wand] Created SQLite database at ${dbPath}\n`);
     }
-    else {
+    else if (!opts.silentReady) {
         process.stdout.write(`[wand] SQLite database ready at ${dbPath}\n`);
     }
     return config;
 }
+function shouldUseTui() {
+    if (process.env.WAND_NO_TUI)
+        return false;
+    if (!process.stdout.isTTY || !process.stderr.isTTY)
+        return false;
+    // Windows conhost 旧版渲染 box-drawing 不可靠；仅 Windows Terminal (WT_SESSION) 启用
+    if (process.platform === "win32" && !process.env.WT_SESSION)
+        return false;
+    return true;
+}
+function printStartupBanner(handle) {
+    const all = [...handle.processManager.listSlim(), ...handle.structuredSessions.listSlim()];
+    let active = 0, archived = 0;
+    for (const s of all) {
+        if (s.archived)
+            archived += 1;
+        else if (s.status === "running")
+            active += 1;
+    }
+    const scheme = handle.httpsEnabled ? "HTTPS" : "HTTP";
+    const primary = handle.urls[0]?.url ?? `${handle.httpsEnabled ? "https" : "http"}://${handle.bindAddr}`;
+    const orphan = handle.orphanRecoveredCount > 0
+        ? ` (${handle.orphanRecoveredCount} orphan PTYs cleaned)`
+        : "";
+    const lines = [
+        `[wand] wand v${handle.version} ready · ${primary} (${scheme})`,
+        `       Bind     ${handle.bindAddr}`,
+        `       Config   ${handle.configPath}`,
+        `       Database ${handle.dbPath}`,
+        `       Sessions ${active} active · ${archived} archived · ${all.length} total${orphan}`,
+    ];
+    for (const extra of handle.urls.slice(1)) {
+        lines.splice(1, 0, `       URL      ${extra.url} (${extra.scheme})`);
+    }
+    process.stdout.write(lines.join("\n") + "\n");
+}
 function setConfigValue(config, key, value) {
     switch (key) {
         case "host":

package/dist/ensure-node-pty-helper.d.ts

@@ -0,0 +1 @@
+export declare function ensureNodePtyHelperExecutable(): void;

package/dist/ensure-node-pty-helper.js

@@ -0,0 +1,51 @@
+// node-pty's prebuilt `spawn-helper` ships in node_modules without the
+// executable bit on some npm/tar combinations (npm/cli#8131). On macOS,
+// posix_spawn against a non-executable file returns EACCES and node-pty
+// throws "posix_spawnp failed." — every PTY session fails before it starts.
+//
+// Run once on server startup. Locates node-pty wherever it actually lives
+// (dev repo, hoisted global, pnpm store …) via require.resolve, finds the
+// per-arch prebuilds dir the loaded binary is in, and ensures the helper
+// next to it is +x. Idempotent and best-effort: silent on the happy path,
+// warns on failure but never blocks startup.
+import { chmodSync, existsSync, statSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import process from "node:process";
+const requireFromHere = createRequire(import.meta.url);
+export function ensureNodePtyHelperExecutable() {
+    // spawn-helper is only used on Unix-likes. Windows uses winpty / conpty.
+    if (process.platform === "win32")
+        return;
+    let nodePtyEntry;
+    try {
+        nodePtyEntry = requireFromHere.resolve("node-pty");
+    }
+    catch {
+        return;
+    }
+    // node-pty's lib/index.js sits at <pkg>/lib/index.js; helper lives at
+    // <pkg>/prebuilds/<platform>-<arch>/spawn-helper.
+    const pkgRoot = path.resolve(path.dirname(nodePtyEntry), "..");
+    const arch = `${process.platform}-${process.arch}`;
+    const helper = path.join(pkgRoot, "prebuilds", arch, "spawn-helper");
+    if (!existsSync(helper))
+        return;
+    let mode;
+    try {
+        mode = statSync(helper).mode & 0o777;
+    }
+    catch {
+        return;
+    }
+    if ((mode & 0o111) === 0o111)
+        return;
+    try {
+        chmodSync(helper, mode | 0o755);
+        process.stderr.write(`[wand] Restored +x on ${helper} (npm dropped the bit on install)\n`);
+    }
+    catch (err) {
+        process.stderr.write(`[wand] Warning: could not chmod +x ${helper}: ${err instanceof Error ? err.message : String(err)}\n`
+            + `[wand] PTY sessions may fail to start. Run: chmod +x ${JSON.stringify(helper)}\n`);
+    }
+}

package/dist/git-quick-commit.d.ts

@@ -0,0 +1,18 @@
+import { GitStatusResult, QuickCommitResult } from "./types.js";
+export declare function getGitStatus(cwd: string): GitStatusResult;
+interface QuickCommitOptions {
+    cwd: string;
+    language: string;
+    autoMessage: boolean;
+    customMessage?: string;
+    tag?: string;
+    autoTag?: boolean;
+    push?: boolean;
+}
+export declare class QuickCommitError extends Error {
+    readonly code: string;
+    constructor(message: string, code: string);
+}
+export declare function generateCommitMessageOnly(cwd: string, language: string): Promise<string>;
+export declare function runQuickCommit(opts: QuickCommitOptions): Promise<QuickCommitResult>;
+export {};

package/dist/git-quick-commit.js

@@ -0,0 +1,373 @@
+import { execFile, execFileSync } from "node:child_process";
+import { existsSync } from "node:fs";
+const GIT_TIMEOUT_MS = 1500;
+const GIT_PUSH_TIMEOUT_MS = 30_000;
+const MAX_FILE_ENTRIES = 200;
+const CLAUDE_MESSAGE_TIMEOUT_MS = 30_000;
+const MAX_DIFF_FOR_AI = 100_000;
+function runGit(args, cwd, timeoutMs = GIT_TIMEOUT_MS) {
+    return execFileSync("git", args, {
+        cwd,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+        timeout: timeoutMs,
+        maxBuffer: 16 * 1024 * 1024,
+    }).trim();
+}
+function runGitAllowEmpty(args, cwd, timeoutMs = GIT_TIMEOUT_MS) {
+    return execFileSync("git", args, {
+        cwd,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+        timeout: timeoutMs,
+        maxBuffer: 16 * 1024 * 1024,
+    });
+}
+function getGitErrorMessage(error) {
+    const e = error;
+    if (e?.stderr && typeof e.stderr === "string")
+        return e.stderr.trim() || e.message || "git 命令失败";
+    if (e?.message)
+        return e.message;
+    return String(error);
+}
+function unquotePath(raw) {
+    if (raw.startsWith("\"") && raw.endsWith("\"")) {
+        return raw.slice(1, -1).replace(/\\"/g, "\"").replace(/\\\\/g, "\\");
+    }
+    return raw;
+}
+function makeEntry(path, status, sub) {
+    if (sub && sub.length === 4 && sub[0] === "S") {
+        return {
+            path,
+            status,
+            isSubmodule: true,
+            submoduleState: {
+                commitChanged: sub[1] === "C",
+                hasTrackedChanges: sub[2] === "M",
+                hasUntracked: sub[3] === "U",
+            },
+        };
+    }
+    return { path, status };
+}
+function parsePorcelainV2(raw) {
+    const out = [];
+    const lines = raw.split(/\r?\n/);
+    for (const line of lines) {
+        if (!line)
+            continue;
+        const head = line[0];
+        if (head === "1") {
+            const parts = line.split(" ");
+            if (parts.length < 9)
+                continue;
+            const status = parts[1];
+            const sub = parts[2];
+            const path = unquotePath(parts.slice(8).join(" "));
+            out.push(makeEntry(path, status, sub));
+        }
+        else if (head === "2") {
+            const parts = line.split(" ");
+            if (parts.length < 10)
+                continue;
+            const status = parts[1];
+            const sub = parts[2];
+            const rest = parts.slice(9).join(" ");
+            const tabIdx = rest.indexOf("\t");
+            const newPath = unquotePath(tabIdx === -1 ? rest : rest.slice(0, tabIdx));
+            out.push(makeEntry(newPath, status, sub));
+        }
+        else if (head === "?") {
+            out.push({ path: unquotePath(line.slice(2)), status: "??" });
+        }
+        else if (head === "!") {
+            out.push({ path: unquotePath(line.slice(2)), status: "!!" });
+        }
+    }
+    return out;
+}
+export function getGitStatus(cwd) {
+    if (!cwd || !existsSync(cwd)) {
+        return { isGit: false, error: "工作目录不存在。" };
+    }
+    let isInside;
+    try {
+        isInside = runGit(["rev-parse", "--is-inside-work-tree"], cwd);
+    }
+    catch {
+        return { isGit: false };
+    }
+    if (isInside !== "true") {
+        return { isGit: false };
+    }
+    let repoRoot;
+    try {
+        repoRoot = runGit(["rev-parse", "--show-toplevel"], cwd);
+    }
+    catch {
+        repoRoot = undefined;
+    }
+    let branch;
+    try {
+        branch = runGit(["branch", "--show-current"], cwd);
+    }
+    catch (error) {
+        return { isGit: true, repoRoot, error: getGitErrorMessage(error) };
+    }
+    if (!branch) {
+        try {
+            branch = `HEAD (${runGit(["rev-parse", "--short", "HEAD"], cwd)})`;
+        }
+        catch {
+            branch = "HEAD";
+        }
+    }
+    let head;
+    let initialCommit = false;
+    try {
+        head = runGit(["rev-parse", "HEAD"], cwd);
+    }
+    catch {
+        initialCommit = true;
+    }
+    let porcelain;
+    try {
+        porcelain = runGitAllowEmpty(["status", "--porcelain=v2", "--untracked-files=all"], cwd);
+    }
+    catch (error) {
+        return { isGit: true, branch, repoRoot, head, initialCommit, error: getGitErrorMessage(error) };
+    }
+    const allEntries = parsePorcelainV2(porcelain);
+    const files = allEntries.slice(0, MAX_FILE_ENTRIES);
+    let latestTag;
+    let suggestedNextTag;
+    try {
+        latestTag = runGit(["describe", "--tags", "--abbrev=0"], cwd);
+    }
+    catch {
+        latestTag = undefined;
+    }
+    if (latestTag) {
+        suggestedNextTag = bumpPatchTag(latestTag);
+    }
+    return {
+        isGit: true,
+        branch,
+        modifiedCount: allEntries.length,
+        files,
+        head,
+        repoRoot,
+        initialCommit,
+        latestTag,
+        suggestedNextTag,
+    };
+}
+function bumpPatchTag(tag) {
+    const m = tag.match(/^(v?)(\d+)\.(\d+)\.(\d+)(.*)/);
+    if (!m)
+        return "";
+    const prefix = m[1];
+    const major = m[2];
+    const minor = m[3];
+    const patch = parseInt(m[4], 10) + 1;
+    return `${prefix}${major}.${minor}.${patch}`;
+}
+export class QuickCommitError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = "QuickCommitError";
+    }
+}
+// ── AI commit message generation ──
+function callClaudeText(prompt, cwd) {
+    return new Promise((resolve, reject) => {
+        const child = execFile("claude", ["-p", "--output-format", "text"], {
+            cwd,
+            encoding: "utf8",
+            maxBuffer: 4 * 1024 * 1024,
+            timeout: CLAUDE_MESSAGE_TIMEOUT_MS,
+        }, (error, stdout, stderr) => {
+            if (error) {
+                const e = error;
+                if (e.code === "ENOENT") {
+                    reject(new QuickCommitError("未找到 claude CLI。", "CLAUDE_CLI_MISSING"));
+                    return;
+                }
+                if (e.code === "ETIMEDOUT") {
+                    reject(new QuickCommitError("Claude 生成超时，请手动填写 commit message。", "CLAUDE_TIMEOUT"));
+                    return;
+                }
+                const msg = (stderr || "").trim() || e.message || "claude 调用失败";
+                reject(new QuickCommitError(`Claude CLI 失败：${msg}`, "CLAUDE_CLI_FAILED"));
+                return;
+            }
+            resolve((stdout || "").trim());
+        });
+        child.stdin?.end(prompt);
+    });
+}
+async function generateCommitMessage(cwd, language) {
+    let diff;
+    try {
+        diff = runGit(["diff", "--cached", "--submodule=log"], cwd, 5000);
+    }
+    catch {
+        diff = "";
+    }
+    if (!diff) {
+        try {
+            diff = runGit(["diff", "--cached", "--name-only"], cwd, 3000);
+        }
+        catch {
+            diff = "(no diff available)";
+        }
+    }
+    if (diff.length > MAX_DIFF_FOR_AI) {
+        diff = diff.slice(0, MAX_DIFF_FOR_AI) + "\n\n... (diff truncated) ...";
+    }
+    const lang = language.trim() || "中文";
+    const prompt = `阅读以下 git diff，用${lang}写一条简洁的 commit message。要求：祈使句，不超过 50 字，描述「做了什么」。只输出 message 本身，不要引号、不要 Markdown 格式、不要任何额外说明。\n\n${diff}`;
+    const raw = await callClaudeText(prompt, cwd);
+    const message = raw.replace(/^["'`]+|["'`]+$/g, "").trim();
+    if (!message) {
+        throw new QuickCommitError("Claude 返回了空的 commit message。", "EMPTY_AI_MESSAGE");
+    }
+    return message;
+}
+export async function generateCommitMessageOnly(cwd, language) {
+    if (!cwd || !existsSync(cwd)) {
+        throw new QuickCommitError("工作目录不存在。", "CWD_MISSING");
+    }
+    try {
+        runGit(["add", "-A"], cwd, 5000);
+    }
+    catch {
+        // best-effort staging so the diff is complete
+    }
+    return generateCommitMessage(cwd, language);
+}
+// ── Direct git operations ──
+export async function runQuickCommit(opts) {
+    const { cwd, language, autoMessage, customMessage, tag, autoTag, push } = opts;
+    if (!cwd || !existsSync(cwd)) {
+        throw new QuickCommitError("工作目录不存在。", "CWD_MISSING");
+    }
+    let isInside;
+    try {
+        isInside = runGit(["rev-parse", "--is-inside-work-tree"], cwd);
+    }
+    catch (error) {
+        throw new QuickCommitError(getGitErrorMessage(error), "NOT_A_GIT_REPO");
+    }
+    if (isInside !== "true") {
+        throw new QuickCommitError("当前目录不在 git 仓库内。", "NOT_A_GIT_REPO");
+    }
+    // Step 1: stage all
+    try {
+        runGit(["add", "-A"], cwd, 5000);
+    }
+    catch (error) {
+        throw new QuickCommitError(`git add 失败：${getGitErrorMessage(error)}`, "GIT_ADD_FAILED");
+    }
+    // Step 2: check if anything to commit
+    let stagedFiles;
+    try {
+        stagedFiles = runGitAllowEmpty(["diff", "--cached", "--name-only"], cwd).trim();
+    }
+    catch (error) {
+        throw new QuickCommitError(getGitErrorMessage(error), "GIT_DIFF_FAILED");
+    }
+    if (!stagedFiles) {
+        throw new QuickCommitError("没有任何改动可以提交。", "NOTHING_TO_COMMIT");
+    }
+    // Step 3: get commit message
+    let message;
+    if (autoMessage) {
+        message = await generateCommitMessage(cwd, language);
+    }
+    else {
+        message = (customMessage || "").trim();
+        if (!message) {
+            throw new QuickCommitError("commit message 不能为空。", "EMPTY_MESSAGE");
+        }
+    }
+    // Step 4: commit
+    try {
+        runGit(["commit", "-m", message], cwd, 10_000);
+    }
+    catch (error) {
+        throw new QuickCommitError(`git commit 失败：${getGitErrorMessage(error)}`, "GIT_COMMIT_FAILED");
+    }
+    let commitHash;
+    try {
+        commitHash = runGit(["rev-parse", "--short", "HEAD"], cwd);
+    }
+    catch {
+        commitHash = "";
+    }
+    // Step 5: tag
+    const makeTag = !!(autoTag || (tag && tag.trim()));
+    let tagName = "";
+    if (makeTag) {
+        if (tag && tag.trim()) {
+            tagName = tag.trim();
+        }
+        else {
+            let latestTag;
+            try {
+                latestTag = runGit(["describe", "--tags", "--abbrev=0"], cwd);
+            }
+            catch {
+                latestTag = undefined;
+            }
+            tagName = bumpPatchTag(latestTag || "v0.0.0");
+        }
+        if (tagName) {
+            try {
+                runGit(["tag", tagName], cwd);
+            }
+            catch (error) {
+                throw new QuickCommitError(`git tag 失败：${getGitErrorMessage(error)}`, "GIT_TAG_FAILED");
+            }
+        }
+    }
+    // Step 6: push
+    let pushed = false;
+    let pushError;
+    if (push) {
+        try {
+            let hasUpstream = false;
+            try {
+                runGit(["rev-parse", "--abbrev-ref", "@{upstream}"], cwd);
+                hasUpstream = true;
+            }
+            catch {
+                hasUpstream = false;
+            }
+            if (hasUpstream) {
+                runGit(["push", "--recurse-submodules=on-demand"], cwd, GIT_PUSH_TIMEOUT_MS);
+            }
+            else {
+                runGit(["push", "-u", "--recurse-submodules=on-demand", "origin", "HEAD"], cwd, GIT_PUSH_TIMEOUT_MS);
+            }
+            if (tagName) {
+                runGit(["push", "origin", `refs/tags/${tagName}`], cwd, GIT_PUSH_TIMEOUT_MS);
+            }
+            pushed = true;
+        }
+        catch (error) {
+            pushError = getGitErrorMessage(error);
+        }
+    }
+    return {
+        ok: true,
+        commit: { hash: commitHash, message },
+        tag: tagName ? { name: tagName } : undefined,
+        pushed,
+        pushError,
+    };
+}

package/dist/process-manager.d.ts

@@ -29,13 +29,18 @@ export declare class ProcessManager extends EventEmitter {
     private readonly storage;
     private readonly sessions;
     private readonly logger;
-    private readonly lifecycleManager;
+    /** 24h archive scan timer */
+    private archiveTimer;
     /** Per-session debounce timers for throttled persist calls */
     private readonly persistDebounceTimers;
     /** Last persisted message state per session — used to skip redundant message writes */
     private readonly lastPersistedMessageState;
+    /** 启动时被识别为孤儿 PTY 并标记为 exited 的旧会话数（旧服务器进程已死） */
+    private orphanRecoveredCount;
     constructor(config: WandConfig, storage: WandStorage, configDir?: string);
     on(event: "process", listener: ProcessEventHandler): this;
+    /** 启动时被识别为孤儿 PTY 并标记为 exited 的旧会话数量（仅用于启动摘要展示）。 */
+    getOrphanRecoveredCount(): number;
     private emitEvent;
     private cleanupOldSessions;
     start(command: string, cwd: string | undefined, mode: ExecutionMode, initialInput?: string, opts?: {
@@ -102,14 +107,6 @@ export declare class ProcessManager extends EventEmitter {
      * Use this at critical points (exit, stop, delete) to ensure no data loss.
      */
     private flushPersist;
-    private backfillExitedClaudeSessionIds;
-    /**
-     * Auto-recover the most recent exited session that has a Claude session ID.
-     * Only resumes one session per server start, using the most recent eligible
-     * session. Reuses the original session ID (in-place resume) and sets
-     * `autoRecovered: true`.
-     */
-    private autoRecoverExitedSessions;
     private archiveExpiredSessions;
     private assertCommandAllowed;
     /**