@co0ontty/wand 1.30.3 → 1.31.1

package/dist/server-session-routes.js

@@ -144,7 +144,7 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
     });
     app.post("/api/structured-sessions", express.json(), async (req, res) => {
         const body = req.body;
-        console.log("[WAND] POST /api/structured-sessions body:", JSON.stringify({ cwd: body.cwd, mode: body.mode, runner: body.runner, provider: body.provider, worktreeEnabled: body.worktreeEnabled === true, hasPrompt: !!body.prompt, model: body.model }));
+        console.log("[WAND] POST /api/structured-sessions body:", JSON.stringify({ cwd: body.cwd, mode: body.mode, runner: body.runner, provider: body.provider, worktreeEnabled: body.worktreeEnabled === true, hasPrompt: !!body.prompt, model: body.model, thinkingEffort: body.thinkingEffort }));
         try {
             if (body.provider && body.provider !== "claude" && body.provider !== "codex") {
                 res.status(400).json({ error: "结构化会话当前仅支持 Claude 或 Codex provider。" });
@@ -158,6 +158,9 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
                 runner: body.runner ?? (provider === "codex" ? "codex-cli-exec" : "claude-cli-print"),
                 worktreeEnabled: body.worktreeEnabled === true,
                 model: typeof body.model === "string" ? body.model.trim() : undefined,
+                thinkingEffort: typeof body.thinkingEffort === "string"
+                    ? body.thinkingEffort
+                    : undefined,
             });
             console.log("[WAND] structured session created:", JSON.stringify({ id: snapshot.id, sessionKind: snapshot.sessionKind, runner: snapshot.runner, status: snapshot.status }));
             onSessionCreated?.(body.cwd ?? snapshot.cwd);
@@ -196,6 +199,29 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
             res.status(400).json({ error: getErrorMessage(error, "切换模型失败。") });
         }
     });
+    // 思考深度切换：与 /model 路由对称。结构化会话立即影响下一条 prompt（CLI/SDK 各自接入
+    // applyThinkingEffortToPrompt / thinking budget），PTY 会话仅影响通过 chat 视图发送的输入。
+    app.post("/api/sessions/:id/thinking-effort", express.json(), (req, res) => {
+        const body = req.body;
+        const raw = typeof body?.thinkingEffort === "string" ? body.thinkingEffort : null;
+        const id = req.params.id;
+        try {
+            if (structured.get(id)) {
+                const updated = structured.setSessionThinkingEffort(id, raw);
+                res.json(updated);
+                return;
+            }
+            if (!processes.get(id)) {
+                res.status(404).json({ error: "未找到该会话。" });
+                return;
+            }
+            const updated = processes.setSessionThinkingEffort(id, raw);
+            res.json(updated);
+        }
+        catch (error) {
+            res.status(400).json({ error: getErrorMessage(error, "切换思考深度失败。") });
+        }
+    });
     app.get("/api/structured-sessions/:id/messages", (req, res) => {
         const snapshot = structured.get(req.params.id);
         if (!snapshot) {
@@ -207,10 +233,13 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
     app.post("/api/structured-sessions/:id/messages", express.json(), async (req, res) => {
         const input = String(req.body?.input ?? "");
         const interrupt = !!req.body?.interrupt;
+        // preserveQueue: 仅在 interrupt 路径有意义。排队条「立即」会带这个 flag，
+        // 让退出 handler 不要把剩余 queuedMessages 清空（默认行为是清空）。
+        const preserveQueue = !!req.body?.preserveQueue;
         const idempotencyKey = typeof req.body?.idempotencyKey === "string" ? req.body.idempotencyKey : undefined;
-        console.log("[WAND] POST /api/structured-sessions/:id/messages id:", req.params.id, "input:", input.substring(0, 50), "interrupt:", interrupt, "idempotencyKey:", idempotencyKey);
+        console.log("[WAND] POST /api/structured-sessions/:id/messages id:", req.params.id, "input:", input.substring(0, 50), "interrupt:", interrupt, "preserveQueue:", preserveQueue, "idempotencyKey:", idempotencyKey);
         try {
-            const snapshot = await structured.sendMessage(req.params.id, input, { interrupt, idempotencyKey });
+            const snapshot = await structured.sendMessage(req.params.id, input, { interrupt, preserveQueue, idempotencyKey });
             res.json(snapshot);
         }
         catch (error) {
@@ -222,6 +251,46 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
             });
         }
     });
+    // ── Structured queued-messages management ──
+    // 三个端点构成"排队消息条"的后端操作面：reorder（拖拽换序）、单条删除、全部清空。
+    // 全部走乐观更新模型，失败时前端会回滚到上一次 WS 推送的 queuedMessages。
+    app.patch("/api/structured-sessions/:id/queued", express.json(), (req, res) => {
+        const rawOrder = req.body?.order;
+        if (!Array.isArray(rawOrder)) {
+            res.status(400).json({ error: "缺少 order 数组。" });
+            return;
+        }
+        try {
+            const snapshot = structured.reorderQueuedMessages(req.params.id, rawOrder.map((v) => Number(v)));
+            res.json(snapshot);
+        }
+        catch (error) {
+            res.status(400).json({ error: getErrorMessage(error, "无法调整排队顺序。") });
+        }
+    });
+    app.delete("/api/structured-sessions/:id/queued/:index", (req, res) => {
+        const index = Number(req.params.index);
+        if (!Number.isFinite(index)) {
+            res.status(400).json({ error: "下标无效。" });
+            return;
+        }
+        try {
+            const snapshot = structured.deleteQueuedMessage(req.params.id, index);
+            res.json(snapshot);
+        }
+        catch (error) {
+            res.status(400).json({ error: getErrorMessage(error, "无法删除排队消息。") });
+        }
+    });
+    app.delete("/api/structured-sessions/:id/queued", (req, res) => {
+        try {
+            const snapshot = structured.clearQueuedMessages(req.params.id);
+            res.json(snapshot);
+        }
+        catch (error) {
+            res.status(400).json({ error: getErrorMessage(error, "无法清空排队消息。") });
+        }
+    });
     // ── Tool content lazy-load endpoint ──
     app.get("/api/sessions/:id/tool-content/:toolUseId", (req, res) => {
         const snapshot = getSessionById(processes, structured, req.params.id);

package/dist/server.js

@@ -1813,6 +1813,7 @@ export async function startServer(config, configPath) {
                 model: effectiveModel,
                 cols: reqCols,
                 rows: reqRows,
+                thinkingEffort: body.thinkingEffort ?? undefined,
             });
             recordRecentPath(storage, body.cwd ?? snapshot.cwd);
             res.status(201).json(snapshot);

package/dist/structured-session-manager.d.ts

@@ -10,6 +10,8 @@ interface CreateStructuredSessionOptions {
     worktreeEnabled?: boolean;
     /** 用户指定的 Claude 模型（别名或完整 ID）。留空则 spawn 时不加 --model。 */
     model?: string;
+    /** 用户预设的思考深度。留空 / null 视为 off。 */
+    thinkingEffort?: SessionSnapshot["thinkingEffort"];
 }
 /**
  * 把任意外部输入收敛到合法的 thinkingEffort 枚举值。`null` / 非法值都视为
@@ -39,6 +41,14 @@ export declare class StructuredSessionManager {
      */
     private readonly pendingSdkQueries;
     private readonly interruptedWith;
+    /**
+     * Sessions where the current interrupt is a "queue promote" (用户从排队条点了「立即」
+     * 把队首插队到 now)。退出处理三个分支默认会把 queuedMessages 清空——因为常规的
+     * interrupt 语义是"算了，做这个"，把队列也作废。但 queue-promote 的语义是
+     * "先做这条，剩下的队列还要继续"，所以这里打个标记，让退出 handler 保留 queue。
+     * 收到后必须 delete 掉，避免下一次普通 interrupt 误带 flag。
+     */
+    private readonly preserveQueueOnInterrupt;
     /** Last wall-clock time (ms) we did a full saveSession for a streaming session. */
     private readonly lastStreamSaveAt;
     /**
@@ -69,11 +79,25 @@ export declare class StructuredSessionManager {
     sendMessage(id: string, input: string, opts?: {
         interrupt?: boolean;
         idempotencyKey?: string;
+        preserveQueue?: boolean;
     }): Promise<SessionSnapshot>;
     /** Approve a pending permission request. */
     approvePermission(sessionId: string): SessionSnapshot;
     /** Deny a pending permission request. */
     denyPermission(sessionId: string): SessionSnapshot;
+    /**
+     * Reorder the pending queued messages. `order` is a permutation of the current
+     * indices, e.g. `[2, 0, 1]` means "move the third queued message to the front,
+     * push the original first to position #2". Throws if the permutation is
+     * malformed (length mismatch / duplicate / out-of-range). 不允许在 inFlight
+     * 期间改"已经被 flushNextQueuedMessage 拿走的队首"，但本方法只动 queue 数组
+     * 本身，flushNext 在另一段时序里读 sessions.get(...) 当前快照，已经天然安全。
+     */
+    reorderQueuedMessages(sessionId: string, order: number[]): SessionSnapshot;
+    /** Remove a single queued message by index. */
+    deleteQueuedMessage(sessionId: string, index: number): SessionSnapshot;
+    /** Clear all queued messages. No-op when queue is already empty. */
+    clearQueuedMessages(sessionId: string): SessionSnapshot;
     /** Update the selected model for a structured session. Takes effect on the next spawn. */
     setSessionModel(sessionId: string, model: string | null): SessionSnapshot;
     /**

package/dist/structured-session-manager.js

@@ -390,8 +390,8 @@ function buildAppendSystemPromptParts(language, mode) {
     }
     if (trimmedLanguage) {
         parts.push(isChinese
-            ? "请使用中文回复。所有解释、注释和对话文本都使用中文。"
-            : `Please respond in ${trimmedLanguage}. Use ${trimmedLanguage} for all your explanations, comments, and conversational text.`);
+            ? "请使用中文回复。所有解释、注释和对话文本都使用中文。当你通过 Task 工具派发子代理（subagent）时，必须在传给子代理的 prompt 里明确要求它也使用中文回复，确保所有子代理的输出同样遵循该语言偏好。"
+            : `Please respond in ${trimmedLanguage}. Use ${trimmedLanguage} for all your explanations, comments, and conversational text. When you dispatch a subagent via the Task tool, you MUST explicitly instruct the subagent in its prompt to also respond in ${trimmedLanguage}, so every subagent's output follows the same language preference.`);
     }
     return parts;
 }
@@ -434,6 +434,14 @@ export class StructuredSessionManager {
      */
     pendingSdkQueries = new Map();
     interruptedWith = new Map();
+    /**
+     * Sessions where the current interrupt is a "queue promote" (用户从排队条点了「立即」
+     * 把队首插队到 now)。退出处理三个分支默认会把 queuedMessages 清空——因为常规的
+     * interrupt 语义是"算了，做这个"，把队列也作废。但 queue-promote 的语义是
+     * "先做这条，剩下的队列还要继续"，所以这里打个标记，让退出 handler 保留 queue。
+     * 收到后必须 delete 掉，避免下一次普通 interrupt 误带 flag。
+     */
+    preserveQueueOnInterrupt = new Set();
     /** Last wall-clock time (ms) we did a full saveSession for a streaming session. */
     lastStreamSaveAt = new Map();
     /**
@@ -549,6 +557,7 @@ export class StructuredSessionManager {
             ? prepareSessionWorktree({ cwd: options.cwd, sessionId: id })
             : null;
         const selectedModel = options.model?.trim() || null;
+        const initialThinkingEffort = normalizeThinkingEffort(options.thinkingEffort);
         const snapshot = {
             id,
             sessionKind: "structured",
@@ -585,6 +594,7 @@ export class StructuredSessionManager {
             autoApprovePermissions: shouldAutoApproveForMode(options.mode),
             approvalStats: { tool: 0, command: 0, file: 0, total: 0 },
             selectedModel,
+            thinkingEffort: initialThinkingEffort,
         };
         this.sessions.set(id, snapshot);
         this.storage.saveSession(snapshot);
@@ -635,6 +645,12 @@ export class StructuredSessionManager {
             }
             else if (opts?.interrupt) {
                 this.interruptedWith.set(id, prompt);
+                if (opts.preserveQueue) {
+                    this.preserveQueueOnInterrupt.add(id);
+                }
+                else {
+                    this.preserveQueueOnInterrupt.delete(id);
+                }
                 try {
                     child.kill("SIGTERM");
                 }
@@ -767,6 +783,60 @@ export class StructuredSessionManager {
     denyPermission(sessionId) {
         return this.resolvePermission(sessionId, false);
     }
+    /**
+     * Reorder the pending queued messages. `order` is a permutation of the current
+     * indices, e.g. `[2, 0, 1]` means "move the third queued message to the front,
+     * push the original first to position #2". Throws if the permutation is
+     * malformed (length mismatch / duplicate / out-of-range). 不允许在 inFlight
+     * 期间改"已经被 flushNextQueuedMessage 拿走的队首"，但本方法只动 queue 数组
+     * 本身，flushNext 在另一段时序里读 sessions.get(...) 当前快照，已经天然安全。
+     */
+    reorderQueuedMessages(sessionId, order) {
+        const session = this.requireSession(sessionId);
+        const queue = session.queuedMessages ?? [];
+        if (!Array.isArray(order) || order.length !== queue.length) {
+            throw new Error("排序长度与当前队列不一致，请刷新后重试。");
+        }
+        const seen = new Set();
+        for (const idx of order) {
+            if (!Number.isInteger(idx) || idx < 0 || idx >= queue.length || seen.has(idx)) {
+                throw new Error("排序参数无效。");
+            }
+            seen.add(idx);
+        }
+        const reordered = order.map((idx) => queue[idx]);
+        const updated = { ...session, queuedMessages: reordered };
+        this.sessions.set(sessionId, updated);
+        this.storage.saveSession(updated);
+        this.emitStructuredSnapshot(updated);
+        return updated;
+    }
+    /** Remove a single queued message by index. */
+    deleteQueuedMessage(sessionId, index) {
+        const session = this.requireSession(sessionId);
+        const queue = session.queuedMessages ?? [];
+        if (!Number.isInteger(index) || index < 0 || index >= queue.length) {
+            throw new Error("队列中没有该条消息（可能已被处理）。");
+        }
+        const next = queue.slice(0, index).concat(queue.slice(index + 1));
+        const updated = { ...session, queuedMessages: next };
+        this.sessions.set(sessionId, updated);
+        this.storage.saveSession(updated);
+        this.emitStructuredSnapshot(updated);
+        return updated;
+    }
+    /** Clear all queued messages. No-op when queue is already empty. */
+    clearQueuedMessages(sessionId) {
+        const session = this.requireSession(sessionId);
+        if (!session.queuedMessages || session.queuedMessages.length === 0) {
+            return session;
+        }
+        const updated = { ...session, queuedMessages: [] };
+        this.sessions.set(sessionId, updated);
+        this.storage.saveSession(updated);
+        this.emitStructuredSnapshot(updated);
+        return updated;
+    }
     /** Update the selected model for a structured session. Takes effect on the next spawn. */
     setSessionModel(sessionId, model) {
         const session = this.requireSession(sessionId);
@@ -848,6 +918,7 @@ export class StructuredSessionManager {
     stop(id) {
         const session = this.requireSession(id);
         this.interruptedWith.delete(id);
+        this.preserveQueueOnInterrupt.delete(id);
         const child = this.pendingChildren.get(id);
         if (child) {
             child.kill();
@@ -900,6 +971,8 @@ export class StructuredSessionManager {
         }
         this.sessions.delete(id);
         this.lastStreamSaveAt.delete(id);
+        this.interruptedWith.delete(id);
+        this.preserveQueueOnInterrupt.delete(id);
         this.storage.deleteSession(id);
         this.logger?.deleteSession(id);
     }
@@ -1043,6 +1116,11 @@ export class StructuredSessionManager {
         if (modelChoice && modelChoice !== "default") {
             args.push("--model", modelChoice);
         }
+        // 思考深度 → --reasoning-effort（off → minimal，standard → low，deep → medium，max → high）
+        const reasoningFlag = thinkingEffortToCodexFlag(session.thinkingEffort);
+        if (reasoningFlag) {
+            args.push("--reasoning-effort", reasoningFlag);
+        }
         if (session.claudeSessionId) {
             args.push("resume", session.claudeSessionId, "-");
         }
@@ -1285,7 +1363,7 @@ export class StructuredSessionManager {
                     output: turnState.result,
                     claudeSessionId: turnState.sessionId ?? current.claudeSessionId,
                     messages: msgs,
-                    queuedMessages: interruptPrompt ? [] : current.queuedMessages,
+                    queuedMessages: interruptPrompt && !this.preserveQueueOnInterrupt.has(sessionId) ? [] : current.queuedMessages,
                     pendingEscalation: null,
                     permissionBlocked: false,
                     structuredState: {
@@ -1304,6 +1382,11 @@ export class StructuredSessionManager {
                 }
                 if (interruptPrompt) {
                     this.interruptedWith.delete(sessionId);
+                    // 把"保留队列"标记一并清掉——不属于本次 interrupt 的后续轮次会按
+                    // 默认（清空 queue）行为走，避免 stale flag 影响下一次普通 interrupt。
+                    // 注意：被保留的 queuedMessages 不需要在这里主动 flush，重发的
+                    // interruptPrompt 跑完会自然触发 flushNextQueuedMessage。
+                    this.preserveQueueOnInterrupt.delete(sessionId);
                     resolve();
                     setImmediate(() => {
                         this.sendMessage(sessionId, interruptPrompt).catch((err) => {
@@ -1384,6 +1467,10 @@ export class StructuredSessionManager {
             // variadic 参数贪婪吞掉（commander 的 <tools...> 会一直吃 positional 直到
             // 下一个 flag）。表现为 claude 报 "Input must be provided either through
             // stdin or as a prompt argument when using --print"。
+            //
+            // 思考深度通过给 prompt 前置魔法词触发（think / think hard / ultrathink）。
+            // applyThinkingEffortToPrompt 自身已经做了"用户已写过就不重复加"的保护。
+            const effectivePrompt = applyThinkingEffortToPrompt(prompt, session.thinkingEffort);
             const spawnedAt = new Date().toISOString();
             const child = spawn("claude", args, {
                 cwd: session.cwd,
@@ -1396,13 +1483,13 @@ export class StructuredSessionManager {
                 pid: child.pid ?? null,
                 cwd: session.cwd,
                 args,
-                prompt: prompt.slice(0, 2048),
-                promptLength: prompt.length,
+                prompt: effectivePrompt.slice(0, 2048),
+                promptLength: effectivePrompt.length,
                 claudeSessionId: session.claudeSessionId,
                 spawnedAt,
             });
             this.pendingChildren.set(sessionId, child);
-            child.stdin?.end(prompt);
+            child.stdin?.end(effectivePrompt);
             const turnState = {
                 blocks: [],
                 result: "",
@@ -1792,7 +1879,7 @@ export class StructuredSessionManager {
                     output: turnState.result,
                     claudeSessionId: turnState.sessionId ?? current.claudeSessionId,
                     messages: msgs,
-                    queuedMessages: interruptPrompt ? [] : current.queuedMessages,
+                    queuedMessages: interruptPrompt && !this.preserveQueueOnInterrupt.has(sessionId) ? [] : current.queuedMessages,
                     pendingEscalation: null,
                     permissionBlocked: false,
                     structuredState: {
@@ -1817,6 +1904,11 @@ export class StructuredSessionManager {
                 // 用户中断当前回复：保存部分回复后立即发送新消息。
                 if (interruptPrompt) {
                     this.interruptedWith.delete(sessionId);
+                    // 把"保留队列"标记一并清掉——不属于本次 interrupt 的后续轮次会按
+                    // 默认（清空 queue）行为走，避免 stale flag 影响下一次普通 interrupt。
+                    // 注意：被保留的 queuedMessages 不需要在这里主动 flush，重发的
+                    // interruptPrompt 跑完会自然触发 flushNextQueuedMessage。
+                    this.preserveQueueOnInterrupt.delete(sessionId);
                     resolve();
                     setImmediate(() => {
                         this.sendMessage(sessionId, interruptPrompt).catch((err) => {
@@ -1889,6 +1981,12 @@ export class StructuredSessionManager {
         // SDK 默认会把整个 process.env 透传给 claude 子进程；这里显式按 inheritEnv 配置组装，
         // 否则关闭"继承环境变量"开关时 SDK 路径会被静默忽略。
         const sdkEnv = buildChildEnv(this.config.inheritEnv !== false);
+        // 思考深度：off → 显式禁用 thinking，其他 → 给一个固定 budget。
+        // SDK 类型用驼峰 budgetTokens（API 层是 budget_tokens，SDK 内部已做转换）。
+        const sdkThinkingBudget = thinkingEffortToSdkBudget(session.thinkingEffort);
+        const sdkThinking = sdkThinkingBudget > 0
+            ? { type: "enabled", budgetTokens: sdkThinkingBudget }
+            : { type: "disabled" };
         const sdkOptions = {
             cwd: session.cwd,
             abortController,
@@ -1897,6 +1995,7 @@ export class StructuredSessionManager {
             ...(permPolicy.permissionMode === "bypassPermissions" ? { allowDangerouslySkipPermissions: true } : {}),
             ...(permPolicy.allowedTools ? { allowedTools: permPolicy.allowedTools } : {}),
             ...(isManaged ? { disallowedTools: ["AskUserQuestion"] } : {}),
+            thinking: sdkThinking,
             includePartialMessages: true,
             // 把子 agent 的 text/thinking 也转发回来，UI 才能把"被 Task 召唤来的协作者"
             // 渲染成独立角色的群聊消息。关掉这个开关时只会收到子 agent 的 tool_use/tool_result，

package/dist/tui/attach.js

@@ -230,14 +230,13 @@ export function startAttachTui(deps) {
             layout.showToast("服务已安装，按 Shift+S 卸载", "warn", 2500);
             return;
         }
-        const ok = await layout.confirm({
-            title: "注册为系统服务",
-            body: process.platform === "linux"
-                ? "将写入 ~/.config/systemd/user/wand.service。"
-                : process.platform === "darwin"
-                    ? "将写入 ~/Library/LaunchAgents/com.wand.web.plist。"
-                    : "当前平台暂不支持。",
-        });
+        const isRoot = typeof process.getuid === "function" ? process.getuid() === 0 : false;
+        const body = process.platform === "linux"
+            ? `将写入 /etc/systemd/system/wand.service，systemctl enable --now，开机自启。\n${isRoot ? "当前是 root，可以直接装。" : "⚠ 需要 root,可以 Ctrl+C 退出 TUI 后跑 sudo wand service:install。"}`
+            : process.platform === "darwin"
+                ? `将写入 /Library/LaunchDaemons/com.wand.web.plist，launchctl load，开机自启。\n${isRoot ? "当前是 root,可以直接装。" : "⚠ 需要 root,退出 TUI 跑 sudo wand service:install。"}`
+                : "当前平台暂不支持。";
+        const ok = await layout.confirm({ title: "注册为系统服务", body });
         if (!ok)
             return;
         const r = await runOffMicrotask(() => installService({ configPath: deps.configPath }));

package/dist/tui/commands.d.ts

@@ -36,12 +36,29 @@ export declare function checkUpdate(currentVersion: string): UpdateInfo;
 export declare function installUpdate(): CommandResult;
 export declare function openInBrowser(url: string): CommandResult;
 export declare function copyToClipboard(text: string): CommandResult;
+/**
+ * 服务安装的作用域：
+ *   - "system" = Linux 写 /etc/systemd/system/wand.service；macOS 写 /Library/LaunchDaemons/
+ *                需要 root，开机自启，所有用户可用，不依赖 login session。
+ *   - "user"   = Linux 写 ~/.config/systemd/user/wand.service；macOS 写 ~/Library/LaunchAgents/
+ *                不要 root，登出会被回收（除非 loginctl enable-linger）。
+ *
+ * 默认 system。
+ */
+export type ServiceScope = "system" | "user";
+export declare const DEFAULT_SERVICE_SCOPE: ServiceScope;
 export interface ServiceContext {
     configPath: string;
     /** wand 可执行文件路径。优先使用 process.argv[1]，回退到 which wand。 */
     wandBin?: string;
+    /** 显式指定作用域。不传走 DEFAULT_SERVICE_SCOPE。 */
+    scope?: ServiceScope;
+}
+export interface ServiceOpts {
+    /** 不传 = 自动检测已装的那个；都没装就用 default。 */
+    scope?: ServiceScope;
 }
-export declare function isServiceInstalled(): boolean;
+export declare function isServiceInstalled(scope?: ServiceScope): boolean;
 export interface ServiceStatus {
     /** 是否已安装服务文件。 */
     installed: boolean;
@@ -54,11 +71,11 @@ export interface ServiceStatus {
     /** 平台。 */
     platform: NodeJS.Platform;
 }
-export declare function serviceStatus(): ServiceStatus;
-export declare function serviceStart(): CommandResult;
-export declare function serviceStop(): CommandResult;
-export declare function serviceRestart(): CommandResult;
+export declare function serviceStatus(opts?: ServiceOpts): ServiceStatus;
+export declare function serviceStart(opts?: ServiceOpts): CommandResult;
+export declare function serviceStop(opts?: ServiceOpts): CommandResult;
+export declare function serviceRestart(opts?: ServiceOpts): CommandResult;
 /** 取最近 N 行服务日志。 */
-export declare function serviceLogs(lines?: number): CommandResult;
+export declare function serviceLogs(lines?: number, opts?: ServiceOpts): CommandResult;
 export declare function installService(ctx: ServiceContext): CommandResult;
-export declare function uninstallService(): CommandResult;
+export declare function uninstallService(opts?: ServiceOpts): CommandResult;