@co0ontty/wand 1.72.0 → 1.74.1

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
-  "commit": "578d2224fa578f852e0fa103e5a31e161cbc3661",
-  "builtAt": "2026-06-19T00:23:42.290Z",
-  "version": "1.72.0",
+  "commit": "505999eb2201a378806a30cbcd813c16cce4cb4b",
+  "builtAt": "2026-06-19T09:43:51.607Z",
+  "version": "1.74.1",
   "channel": "stable"
 }

package/dist/claude-sdk-runner.d.ts

@@ -6,6 +6,8 @@ export declare class ClaudeRunError extends Error {
 export interface RunClaudePrintOptions {
     cwd?: string;
     timeoutMs: number;
+    /** Optional Claude model id / alias. Empty or "default" keeps Claude Code's own default. */
+    model?: string;
     /**
      * 用户偏好的回复语言（取自 config.language）。传进来时会以
      * `appendSystemPrompt` 形式灌给 Claude，保证 quick-commit / prompt-optimizer

package/dist/claude-sdk-runner.js

@@ -118,6 +118,7 @@ export async function runClaudePrint(prompt, options) {
     const timeoutHandle = setTimeout(() => abortController.abort(), options.timeoutMs);
     const sdkClaudeBinary = resolveSdkClaudeBinary();
     const languageDirective = options.language ? buildLanguageDirective(options.language) : "";
+    const model = options.model?.trim();
     const sdkOptions = {
         abortController,
         tools: [],
@@ -127,6 +128,7 @@ export async function runClaudePrint(prompt, options) {
         ...(cwd ? { cwd } : {}),
         ...(sdkClaudeBinary ? { pathToClaudeCodeExecutable: sdkClaudeBinary } : {}),
         ...(languageDirective ? { appendSystemPrompt: languageDirective } : {}),
+        ...(model && model !== "default" ? { model } : {}),
     };
     // 单条 user message → AsyncGenerator，SDK 的 streaming input 协议要求。
     async function* singleShot() {

package/dist/cli.js

@@ -1,7 +1,12 @@
 #!/usr/bin/env -S node --disable-warning=ExperimentalWarning
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { request as httpRequest } from "node:http";
+import { request as httpsRequest } from "node:https";
+import net from "node:net";
 import process from "node:process";
 import { hasConfigFile, isPreferenceKey, loadConfigWithStorage, resolveConfigPath, saveConfig, writePreferenceToStorage, } from "./config.js";
-import { readLiveInstance, removePidfile, removeSocketFile, socketPath, writePidfile, } from "./pidfile.js";
+import { isPidAlive, readLiveInstance, removePidfile, removeSocketFile, socketPath, writePidfile, } from "./pidfile.js";
 import { getErrorMessage } from "./error-utils.js";
 async function main() {
     const args = process.argv.slice(2);
@@ -17,15 +22,26 @@ async function main() {
             // web 命令下"已存在"的 ready 信息由统一的启动 banner / TUI 展示，避免重复。
             const config = await ensureRequiredFiles(configPath, { silentReady: true });
             // —— 单实例检测：如果已有 wand 主进程在跑，直接 attach 而不重启服务 ——
-            const live = readLiveInstance(configPath);
+            const live = await discoverAttachableInstance(configPath);
             if (live) {
                 await runAttach(live, configPath, useTui);
                 break;
             }
             const { ensureNodePtyHelperExecutable } = await import("./ensure-node-pty-helper.js");
             ensureNodePtyHelperExecutable();
-            const { startServer } = await import("./server.js");
-            const handle = await startServer(config, configPath);
+            const { isPortInUseError, startServer } = await import("./server.js");
+            let handle;
+            try {
+                handle = await startServer(config, configPath);
+            }
+            catch (err) {
+                if (isPortInUseError(err)) {
+                    if (await handlePortInUse(config, configPath, useTui)) {
+                        break;
+                    }
+                }
+                throw err;
+            }
             // —— 注册实例：写 pidfile + 启动 IPC 服务端（TUI / banner 模式都需要） ——
             const startedAtMs = Date.now();
             const ipcCtx = await registerInstance(handle, configPath, startedAtMs);
@@ -336,6 +352,217 @@ async function runAttach(live, configPath, useTui) {
     process.on("SIGINT", onSignal);
     process.on("SIGTERM", onSignal);
 }
+async function handlePortInUse(config, configPath, useTui) {
+    const live = await discoverAttachableInstance(configPath);
+    if (live) {
+        await runAttach(live, configPath, useTui);
+        return true;
+    }
+    const probe = await probeWandHttp(config);
+    const pid = findListeningPid(config.port);
+    if (probe?.isWand) {
+        printDetectedWandWithoutAttach(config, configPath, probe.url, pid);
+        process.exitCode = 0;
+        return true;
+    }
+    printPortInUse(config, configPath, pid);
+    process.exitCode = 1;
+    return true;
+}
+async function discoverAttachableInstance(configPath) {
+    const live = readLiveInstance(configPath);
+    if (live)
+        return live;
+    const sockPath = socketPath(configPath);
+    if (!sockPath || !existsSync(sockPath))
+        return null;
+    const snapshot = await readIpcSnapshot(sockPath);
+    if (!snapshot)
+        return null;
+    const pid = snapshot.header.pid;
+    if (!isPidAlive(pid))
+        return null;
+    return {
+        pid,
+        version: snapshot.header.version,
+        startedAt: snapshot.header.startedAtMs,
+        url: snapshot.header.url,
+        scheme: snapshot.header.scheme,
+        bindAddr: snapshot.header.bindAddr,
+        configPath: snapshot.header.configPath,
+        dbPath: snapshot.header.dbPath,
+        socket: sockPath,
+    };
+}
+function readIpcSnapshot(sockPath) {
+    return new Promise((resolve) => {
+        const sock = net.createConnection({ path: sockPath });
+        let buf = "";
+        let finished = false;
+        const finish = (value) => {
+            if (finished)
+                return;
+            finished = true;
+            clearTimeout(timer);
+            try {
+                sock.destroy();
+            }
+            catch { /* noop */ }
+            resolve(value);
+        };
+        const timer = setTimeout(() => finish(null), 800);
+        timer.unref?.();
+        sock.setEncoding("utf8");
+        sock.on("connect", () => {
+            sock.write(JSON.stringify({ id: "probe", cmd: "snapshot" }) + "\n");
+        });
+        sock.on("data", (chunk) => {
+            buf += chunk;
+            let idx;
+            while ((idx = buf.indexOf("\n")) >= 0) {
+                const line = buf.slice(0, idx).trim();
+                buf = buf.slice(idx + 1);
+                if (!line)
+                    continue;
+                let msg = null;
+                try {
+                    msg = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+                if (msg?.id !== "probe" || !msg.ok)
+                    continue;
+                const data = msg.data;
+                if (isIpcSnapshotData(data)) {
+                    finish(data);
+                    return;
+                }
+            }
+        });
+        sock.on("error", () => finish(null));
+        sock.on("close", () => finish(null));
+    });
+}
+function isIpcSnapshotData(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const snap = value;
+    const header = snap.header;
+    return !!header
+        && typeof header.pid === "number"
+        && typeof header.version === "string"
+        && typeof header.startedAtMs === "number"
+        && typeof header.url === "string"
+        && (header.scheme === "HTTP" || header.scheme === "HTTPS")
+        && typeof header.bindAddr === "string"
+        && typeof header.configPath === "string"
+        && typeof header.dbPath === "string"
+        && Array.isArray(snap.sessions);
+}
+async function probeWandHttp(config) {
+    const schemes = config.https ? ["https", "http"] : ["http", "https"];
+    for (const scheme of schemes) {
+        for (const host of probeHosts(config.host)) {
+            const baseUrl = `${scheme}://${host}:${config.port}`;
+            const sessionCheck = await requestText(`${baseUrl}/api/session-check`);
+            if (sessionCheck && looksLikeWandSessionCheck(sessionCheck.body)) {
+                return { isWand: true, url: baseUrl };
+            }
+            const home = await requestText(baseUrl);
+            if (home && home.body.includes("<title>Wand Console</title>")) {
+                return { isWand: true, url: baseUrl };
+            }
+        }
+    }
+    return null;
+}
+function probeHosts(configHost) {
+    const hosts = ["127.0.0.1", "localhost"];
+    if (configHost && configHost !== "0.0.0.0" && configHost !== "::" && !hosts.includes(configHost)) {
+        hosts.push(configHost);
+    }
+    return hosts;
+}
+function looksLikeWandSessionCheck(body) {
+    try {
+        const parsed = JSON.parse(body);
+        return typeof parsed.authed === "boolean";
+    }
+    catch {
+        return false;
+    }
+}
+function requestText(urlText) {
+    return new Promise((resolve) => {
+        let url;
+        try {
+            url = new URL(urlText);
+        }
+        catch {
+            resolve(null);
+            return;
+        }
+        const request = url.protocol === "https:" ? httpsRequest : httpRequest;
+        const req = request(url, {
+            method: "GET",
+            timeout: 800,
+            rejectUnauthorized: false,
+        }, (res) => {
+            let body = "";
+            res.setEncoding("utf8");
+            res.on("data", (chunk) => {
+                if (body.length < 64 * 1024)
+                    body += chunk;
+            });
+            res.on("end", () => resolve({ status: res.statusCode ?? 0, body }));
+        });
+        req.on("timeout", () => {
+            req.destroy();
+            resolve(null);
+        });
+        req.on("error", () => resolve(null));
+        req.end();
+    });
+}
+function findListeningPid(port) {
+    if (!Number.isInteger(port) || port <= 0)
+        return null;
+    try {
+        const result = spawnSync("lsof", ["-nP", `-iTCP:${port}`, "-sTCP:LISTEN", "-t"], { encoding: "utf8", timeout: 1000 });
+        if (result.status !== 0 && !result.stdout)
+            return null;
+        const pid = (result.stdout || "")
+            .split(/\s+/)
+            .map((part) => Number(part.trim()))
+            .find((value) => Number.isInteger(value) && value > 0 && value !== process.pid);
+        return pid ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function printDetectedWandWithoutAttach(config, configPath, url, pid) {
+    const pidLine = pid ? `       PID      ${pid}\n` : "";
+    process.stdout.write(`[wand] 检测到已有 Wand 服务正在运行：${url}\n` +
+        pidLine +
+        `       Config   ${configPath}\n` +
+        `       Port     ${config.port}\n` +
+        `       当前无法 attach：${socketPath(configPath) || "IPC socket"} 不可达。\n` +
+        `       请重启一次正在运行的服务；之后再执行 wand web 会恢复正常 attach。\n`);
+}
+function printPortInUse(config, configPath, pid) {
+    const pidHint = pid ? `\n       占用进程 PID: ${pid}` : "";
+    const killHint = pid
+        ? `kill ${pid}`
+        : `kill $(lsof -ti :${config.port})`;
+    process.stderr.write(`\n✗ [wand] 端口 ${config.port} 已被占用，但没有发现可 attach 的 Wand 实例。${pidHint}\n` +
+        `       Config: ${configPath}\n` +
+        `       Socket: ${socketPath(configPath) || "当前平台不支持 Unix socket"}\n\n` +
+        `解决方法（二选一）：\n` +
+        `1. 如果这是旧 Wand 服务，重启它后再运行 wand web\n` +
+        `2. 如果不是 Wand，占用进程可用以下命令终止：\n   ${killHint}\n\n`);
+}
 function setConfigValue(config, key, value) {
     // 偏好字段（defaultMode/defaultCwd/...）由调用方分流到 storage，password 也走 DB
     // （由 case "config:set" 直接处理），这里只剩纯 JSON 字段。

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

@@ -1,9 +1,13 @@
-import { GitStatusResult, PushResult, QuickCommitResult, TagHeadResult } from "./types.js";
+import { GitStatusResult, PushResult, QuickCommitResult, SessionProvider, SessionSnapshot, TagHeadResult } from "./types.js";
 export type QuickCommitErrorCode = "CWD_MISSING" | "NO_CWD" | "NOT_A_GIT_REPO" | "NO_COMMIT" | "NOTHING_TO_COMMIT" | "NOTHING_TO_PUSH" | "EMPTY_MESSAGE" | "EMPTY_TAG" | "EMPTY_AI_MESSAGE" | "INVALID_AI_TAG" | "TAG_EXISTS" | "GIT_ADD_FAILED" | "GIT_DIFF_FAILED" | "GIT_COMMIT_FAILED" | "GIT_TAG_FAILED" | "CLAUDE_CLI_MISSING" | "CLAUDE_CLI_FAILED" | "CLAUDE_TIMEOUT";
 export declare function getGitStatus(cwd: string): GitStatusResult;
 interface QuickCommitOptions {
     cwd: string;
     language: string;
+    provider?: SessionProvider;
+    model?: string | null;
+    thinkingEffort?: SessionSnapshot["thinkingEffort"];
+    inheritEnv?: boolean;
     autoMessage: boolean;
     customMessage?: string;
     tag?: string;
@@ -16,6 +20,12 @@ interface QuickCommitOptions {
      */
     submodule?: boolean;
 }
+interface QuickCommitAiOptions {
+    provider?: SessionProvider;
+    model?: string | null;
+    thinkingEffort?: SessionSnapshot["thinkingEffort"];
+    inheritEnv?: boolean;
+}
 export declare class QuickCommitError extends Error {
     readonly code: QuickCommitErrorCode;
     constructor(message: string, code: QuickCommitErrorCode);
@@ -25,7 +35,7 @@ export interface GenerateCommitMessageResult {
     /** AI-suggested next tag derived from the staged diff and the latest existing tag. */
     suggestedTag?: string;
 }
-export declare function generateCommitMessageOnly(cwd: string, language: string): Promise<GenerateCommitMessageResult>;
+export declare function generateCommitMessageOnly(cwd: string, language: string, ai?: QuickCommitAiOptions): Promise<GenerateCommitMessageResult>;
 interface TagHeadOptions {
     cwd: string;
     language: string;
@@ -46,5 +56,6 @@ interface PushOptions {
     tagName?: string;
 }
 export declare function runPush(opts: PushOptions): Promise<PushResult>;
+export declare function runQuickCommitWithFallback(opts: QuickCommitOptions): Promise<QuickCommitResult>;
 export declare function runQuickCommit(opts: QuickCommitOptions): Promise<QuickCommitResult>;
 export {};