@weavecode/weave 0.1.2 → 0.1.4

package/node_modules/@weavecode/server/dist/daemon/opener/backend-wt.js

@@ -0,0 +1 @@
+import{basename as c}from"node:path";import{pidAlive as f}from"../claude-liveness.js";import{countWindowsByDir as s,normalizeDirKey as l}from"./wezterm-mux.js";import{BRACKETED_PASTE_END as d,BRACKETED_PASTE_START as h,parseWtPaneId as a,parseWtTargetId as w,wtInjectKeys as p,wtPanePidFromEnv as E,wtPanesAsWindows as m,wtPanesCached as i,wtWindowSlug as u}from"./wt.js";import{winRaiseTerminalWindow as T}from"./win-raise.js";import{throughCmd as y}from"./shared.js";import{PRESET_CANDIDATES as P,TerminalBackend as g}from"./backend.js";export class WtBackend extends g{constructor(t){super("wt",t==="win32",t,t==="win32")}candidates(t,n){return P.wt(t,n,this.platform)}async countWindows(t){if(t.length===0||this.platform!=="win32")return new Map(t.map(e=>[e,0]));const n=await i();return n.length===0?new Map(t.map(e=>[e,0])):s(t,m(n))}async listTargets(t){if(this.platform!=="win32")return[];const n=await i(),e=s([t],m(n)).get(t)??0;return e===0?[]:[{id:`wt:${u(t)}`,windowId:0,tabId:0,title:c(t),matchCount:e,paneCount:e,active:!1,full:!1}]}async runAt(t,n,e){if(this.platform!=="win32")throw new Error(`Terminal preset "${this.preset}" is unavailable on this platform`);if(!w(e))throw new Error(`Invalid terminal target "${e}"`);return await this.spawnFirst([{command:"wt.exe",args:["-w",u(t),"split-pane","-d",t,...y(n,!0)??[]]}],`Terminal preset "${this.preset}" is unavailable on this platform`),null}async focusTarget(t,n){if(!w(n))throw new Error(`Invalid terminal target "${n}"`);const e=l(t,this.platform),o=(await i()).filter(r=>e!==null&&l(r.cwd,this.platform)===e).map(r=>r.pid);if(!o.length)throw new Error("That terminal is gone \u2014 reopen the list");await T({panePids:o,exe:"windowsterminal.exe"})}async locatePane(t){const n=E(t);return n==null||!f(n)?null:`wt:${n}`}ownsPaneId(t){return a(t)!==null}async sendPromptText(t,n){const e=a(t);if(e==null)throw new Error(`Invalid prompt pane "${t}"`);await p(e,`${h}${n}${d}\r`)}async sendKeys(t,n){const e=a(t);if(e==null)throw new Error(`Invalid prompt pane "${t}"`);await p(e,n)}}

package/node_modules/@weavecode/server/dist/daemon/opener/backend.d.ts

@@ -0,0 +1,115 @@
+import type { TerminalPreset, TerminalSettings } from '../settings.js';
+import type { AttachTarget, SessionTerminal } from './wezterm-mux.js';
+/**
+ * 终端后端基类与共享件：模板方法骨架（「取候选 → 按序尝试 → 全失败抛真相」）、
+ * 候选表驱动的通用后端、custom 后端、各 preset 的候选表。各终端自己的后端类在
+ * 同级 `backend-<preset>.ts`；工厂表与 `auto` 组合在 opener.ts（门面层，避免
+ * 基类 ← 子类 → 工厂的循环 import）。
+ *
+ * **能力全归后端**，一律「覆写 = 有，基类空实现 = 没有」：
+ * enumerable（能否反查已开窗口，不是调用方散写的 `preset === 'wezterm'` 白名单）、
+ * textAddressable（能否注入文本 / 裸键序）、locatePane（能否把 hook 上报的 pane env
+ * 解析回本后端的 pane 表示法——pane 表示法是后端私有知识，调用方只见不透明 id）、
+ * ownsPaneId（这个 id 是不是本后端发的——**击键/文本按 id 认领后端**，故「往哪个终端
+ * 打键」不随设置里的 preset 走）。
+ * 不支持就走基类空实现（角标不显示 / 层② 诚实置灰 / 回落标题+cwd 启发式，不谎报）。
+ */
+/** One spawn candidate: earlier entries are tried first (auto-probing). */
+export interface TerminalLaunch {
+    command: string;
+    args: string[];
+    /** Working directory for the spawned process (inherited cwd). */
+    cwd?: string;
+    /** Run through the platform shell (custom commands only). */
+    shell?: boolean;
+}
+/**
+ * prompt 层② 兜底的注入落点：后端枚举出的可打文本 pane。
+ * id 不透明、格式归各后端（wezterm = `<mux 短哈希>:<paneId>`）。
+ */
+export interface PromptPaneTarget {
+    id: string;
+    /** pane 标题（claude 的 OSC 标题）——与会话标题匹配的素材；取不到 = null。 */
+    title: string | null;
+    /** pane 实时工作目录；取不到 = null（匹配不上任何项目）。 */
+    cwd: string | null;
+}
+/**
+ * 起会话落子的起点定位（spawn 回执）：env 形状与 hook 旁路上报同构（键形归
+ * 后端、出 core 表），paneEnvSource='launch' 的 harness 据此关联会话。拿不到
+ * 回执的后端（wt 等 stdio ignore 路径）不产出——那些会话不分组，不猜。
+ */
+export interface LaunchOrigin {
+    readonly env: Record<string, string>;
+}
+/** 终端后端基类。模板方法定义骨架，子类只填候选与真正不同的流程。 */
+export declare abstract class TerminalBackend {
+    readonly preset: TerminalPreset;
+    /** 能否反查已开窗口 / 可附加目标（默认否：不是每种终端都问得到）。 */
+    readonly enumerable: boolean;
+    protected readonly platform: NodeJS.Platform;
+    /** 能否给已开 pane 注入文本（prompt 层② send-text 兜底；默认否，不谎报）。 */
+    readonly textAddressable: boolean;
+    protected constructor(preset: TerminalPreset, 
+    /** 能否反查已开窗口 / 可附加目标（默认否：不是每种终端都问得到）。 */
+    enumerable: boolean, platform?: NodeJS.Platform, 
+    /** 能否给已开 pane 注入文本（prompt 层② send-text 兜底；默认否，不谎报）。 */
+    textAddressable?: boolean);
+    /** 启动候选（按序尝试，第一个起的算成功）；空 = 本平台不支持该 preset。 */
+    abstract candidates(dir: string, run?: string[]): TerminalLaunch[];
+    /** 开一个终端（模板方法）。 */
+    open(dir: string): Promise<void>;
+    /**
+     * 开一个终端并把 `argv` 送进去（模板方法）。缺省把命令并进候选参数；wezterm
+     * 覆写为走 mux——唯一流程真正不同的 preset（legacy `start -- PROG` 绕过
+     * default_prog，且 mux 在时会挂死出无窗僵尸而 trySpawn 假成功）。返回落子的
+     * 起点（spawn 回执）；候选路径无回执 = null。
+     */
+    run(dir: string, argv: string[]): Promise<LaunchOrigin | null>;
+    /** 每目录已开终端数（单位 = 本后端的可见屏幕）；不支持的 preset 走这里（空表 = 角标不显示，不谎报）。 */
+    countWindows(_dirs: readonly string[]): Promise<Map<string, number>>;
+    /** 可附加目标（窗口内的 tab）；不支持的 preset 走这里。 */
+    listTargets(_dir: string): Promise<AttachTarget[]>;
+    /** 定点附加（多终端弹窗选定的目标）；无通道的 preset 明确拒绝，不静默忽略。 */
+    runAt(_dir: string, _argv: string[], _targetId: string): Promise<LaunchOrigin | null>;
+    /** 唤出（切到前台）已开终端；无通道的 preset 明确拒绝。 */
+    focusTarget(_dir: string, _targetId: string): Promise<void>;
+    /** prompt 层② 兜底：枚举可注入文本的 pane；无通道的后端空表（不谎报）。 */
+    listPromptPanes(): Promise<PromptPaneTarget[]>;
+    /** 层② 定位：pane env → pane id；无定位能力的后端 null（回落标题+cwd，不猜）。 */
+    locatePane(_env: Record<string, string>): Promise<string | null>;
+    /** 这个 pane id 是不是本后端发的（id 表示法归本后端）；默认不是，不抢别人的 id。 */
+    ownsPaneId(_paneId: string): boolean;
+    /** 会话 → 所在可见屏幕（会话列表分块）；无枚举能力的后端空表（不分组，不猜）。 */
+    locateScreens(_envs: Record<string, Record<string, string>>): Promise<Record<string, SessionTerminal | null>>;
+    /** prompt 层② 兜底：向枚举所得 pane 注入 prompt 原文并提交；无通道的后端明确拒绝。 */
+    sendPromptText(_paneId: string, _text: string): Promise<void>;
+    /** 阻塞问答作答：裸键序注入（模态框只吃键盘，不吃粘贴文本）；无通道的后端明确拒绝。 */
+    sendKeys(_paneId: string, _keys: string): Promise<void>;
+    /**
+     * 读 pane 可视屏文本（旁路会话读屏通道用）；无读屏能力的后端 null（不谎报）。
+     * 只回可视屏（scrollback 不取）——读屏消费方（侧问回答提取）只需要当下画面。
+     */
+    getPaneText(_paneId: string): Promise<string | null>;
+    /** 关掉这个 pane（会话生命周期收尾 / 项目关终端共用）；无通道的后端明确拒绝。 */
+    closePane(_paneId: string): Promise<void>;
+    /** 按候选顺序起一个；全失败抛真相（含试过哪些命令）。 */
+    protected spawnFirst(candidates: TerminalLaunch[], emptyReason: string): Promise<void>;
+}
+/** 候选数据驱动的后端：绝大多数 preset 只差一张候选表。 */
+export declare class CandidatesBackend extends TerminalBackend {
+    private readonly make;
+    constructor(preset: TerminalPreset, platform: NodeJS.Platform, make: (dir: string, run: string[] | undefined, platform: NodeJS.Platform) => TerminalLaunch[]);
+    candidates(dir: string, run?: string[]): TerminalLaunch[];
+}
+/** 各 preset 的候选表（纯数据）；`auto` 由这些具名条目组合，不再各抄一遍。 */
+export declare const PRESET_CANDIDATES: Record<Exclude<TerminalPreset, 'auto' | 'custom' | 'wezterm'>, (dir: string, run: string[] | undefined, platform: NodeJS.Platform) => TerminalLaunch[]>;
+/** custom：用户自撰命令模板（唯一需要读 settings 的后端）。 */
+export declare class CustomBackend extends TerminalBackend {
+    private readonly terminal;
+    constructor(terminal: TerminalSettings, platform: NodeJS.Platform);
+    candidates(dir: string, run?: string[]): TerminalLaunch[];
+}
+/** Spawn detached and forget: the child outlives the daemon, its window is
+ * its own, and I/O is dropped so a GUI process never blocks on pipes. */
+export declare function trySpawn(launch: TerminalLaunch): Promise<boolean>;

package/node_modules/@weavecode/server/dist/daemon/opener/backend.js

@@ -0,0 +1 @@
+import{spawn as m}from"node:child_process";import{joinCmd as s,quotePath as i,throughCmd as l}from"./shared.js";import{wtWindowSlug as p}from"./wt.js";export class TerminalBackend{preset;enumerable;platform;textAddressable;constructor(e,t,r=process.platform,a=!1){this.preset=e,this.enumerable=t,this.platform=r,this.textAddressable=a}async open(e){await this.spawnFirst(this.candidates(e),`Terminal preset "${this.preset}" is unavailable on this platform`)}async run(e,t){return await this.spawnFirst(this.candidates(e,t),`Terminal preset "${this.preset}" cannot run a command here \u2014 pick another preset in settings`),null}async countWindows(e){return new Map}async listTargets(e){return[]}async runAt(e,t,r){throw new Error(`Terminal preset "${this.preset}" cannot attach to a chosen pane \u2014 pick wezterm, wt or Terminal.app in settings`)}async focusTarget(e,t){throw new Error(`Terminal preset "${this.preset}" cannot bring an open terminal to the front \u2014 pick wezterm or wt in settings`)}async listPromptPanes(){return[]}async locatePane(e){return null}ownsPaneId(e){return!1}async locateScreens(e){return{}}async sendPromptText(e,t){throw new Error(`Terminal preset "${this.preset}" cannot send text into an open pane \u2014 pick a preset with text injection in settings`)}async sendKeys(e,t){throw new Error(`Terminal preset "${this.preset}" cannot send keys to an open pane \u2014 pick a preset with key injection in settings`)}async getPaneText(e){return null}async closePane(e){throw new Error(`Terminal preset "${this.preset}" cannot close an open pane \u2014 pick wezterm in settings`)}async spawnFirst(e,t){for(const r of e)if(await trySpawn(r))return;throw new Error(e.length===0?t:"No usable terminal found (tried: "+e.map(r=>r.command).join(", ")+")")}}export class CandidatesBackend extends TerminalBackend{make;constructor(e,t,r){super(e,!1,t),this.make=r}candidates(e,t){return this.make(e,t,this.platform)}}export const PRESET_CANDIDATES={wt:(n,e,t)=>t==="win32"?[{command:"wt.exe",args:["-w",p(n),"-d",n,...l(e,!0)??[]]}]:[],powershell:(n,e,t)=>t==="win32"?[e?{command:"powershell.exe",args:["-NoExit","-Command",s(e,"win32")],cwd:n}:{command:"powershell.exe",args:["-NoExit"],cwd:n}]:[],cmd:(n,e,t)=>t==="win32"?[e?{command:"cmd.exe",args:["/K",s(e,"win32")],cwd:n}:{command:"cmd.exe",args:["/K"],cwd:n}]:[],terminal:(n,e,t)=>t!=="darwin"?[]:e?[{command:"osascript",args:c("Terminal",n,e)}]:[{command:"open",args:["-a","Terminal",n]}],iterm:(n,e,t)=>t!=="darwin"?[]:e?[{command:"osascript",args:c("iTerm",n,e)}]:[{command:"open",args:["-a","iTerm",n]}],gnome:(n,e)=>[{command:"gnome-terminal",args:[`--working-directory=${n}`,...e?["--",...e]:[]]}],konsole:(n,e)=>[{command:"konsole",args:["--workdir",n,...e?["-e",...e]:[]]}],ghostty:(n,e,t)=>t==="win32"?[]:t==="darwin"?e?[]:[{command:"open",args:["-a","Ghostty",n]}]:[{command:"ghostty",args:[`--working-directory=${n}`,...e?["-e",...e]:[]]}]};function c(n,e,t){const a=`cd ${i(e,"darwin")} && ${s(t,"darwin")}`.replace(/\\/g,"\\\\").replace(/"/g,'\\"');return n==="Terminal"?["-e",`tell application "Terminal" to do script "${a}"`,"-e",'tell application "Terminal" to activate']:["-e",'tell application "iTerm" to create window with default profile',"-e",`tell application "iTerm" to tell current window to write text "${a}"`]}export class CustomBackend extends TerminalBackend{terminal;constructor(e,t){super("custom",!1,t),this.terminal=e}candidates(e,t){const r=this.terminal.customCommand.trim();if(!r)return[];let a=r.replace(/\{path\}/g,i(e,this.platform));const o=t?s(t,this.platform):"";return a=a.includes("{command}")?a.replace(/\{command\}/g,o):t?`${a} ${o}`:a,[{command:a,args:[],shell:!0}]}}export function trySpawn(n){return new Promise(e=>{let t;try{t=m(n.command,n.args,{cwd:n.cwd,shell:n.shell,detached:!0,stdio:"ignore"})}catch{e(!1);return}t.on("error",()=>e(!1)),t.on("spawn",()=>{t.unref(),e(!0)})})}

package/node_modules/@weavecode/server/dist/daemon/opener/launch.d.ts

@@ -0,0 +1,20 @@
+import type { TerminalSettings, TerminalLaunch } from '../opener.js';
+/**
+ * Resolve the spawn candidates that would open a terminal at `dir`. 兼容入口：
+ * 候选解析已归后端（`TerminalBackend.candidates`），这里只做分发。
+ *
+ * `run` = argv of a command to execute inside the new terminal (e.g.
+ * `['claude', '--resume', id]`); omitted = just open the directory.
+ */
+export declare function resolveTerminalLaunch(dir: string, terminal: TerminalSettings, platform?: NodeJS.Platform, run?: string[]): TerminalLaunch[];
+/** File-manager command that opens `dir` (per platform). */
+export declare function resolveExplorerLaunch(dir: string, platform?: NodeJS.Platform): TerminalLaunch;
+/** Spawn detached and forget: the child outlives the daemon, its window is
+ * its own, and I/O is dropped so a GUI process never blocks on pipes. */
+export declare function trySpawn(launch: TerminalLaunch): Promise<boolean>;
+/** Try candidates in order until one launches (auto-probe fallback). */
+/** Open the OS file manager at `dir`. */
+export declare function openInExplorer(dir: string): Promise<void>;
+/** Open a terminal at `dir` following the configured preset. `auto` tries the
+ * platform candidates in order until one launches. */
+export declare function openInTerminal(dir: string, terminal: TerminalSettings): Promise<void>;

package/node_modules/@weavecode/server/dist/daemon/opener/launch.js

@@ -0,0 +1 @@
+import{spawn as a}from"node:child_process";export function resolveTerminalLaunch(n,e,r=process.platform,o){return terminalBackendFor(e,r).candidates(n,o)}export function resolveExplorerLaunch(n,e=process.platform){return e==="win32"?{command:"explorer.exe",args:[n]}:e==="darwin"?{command:"open",args:[n]}:{command:"xdg-open",args:[n]}}export function trySpawn(n){return new Promise(e=>{let r;try{r=a(n.command,n.args,{cwd:n.cwd,shell:n.shell,detached:!0,stdio:"ignore"})}catch{e(!1);return}r.on("error",()=>e(!1)),r.on("spawn",()=>{r.unref(),e(!0)})})}export async function openInExplorer(n){const e=resolveExplorerLaunch(n);if(!await trySpawn(e))throw new Error(`Failed to open file manager (${e.command})`)}export async function openInTerminal(n,e){await terminalBackendFor(e).open(n)}

package/node_modules/@weavecode/server/dist/daemon/opener/pty-terminals.d.ts

@@ -0,0 +1,52 @@
+import type { AttachTarget } from './wezterm-mux.js';
+/** Terminal.app 一个 tab（整面）：窗口/序号/tty + 窗口是否最前/tab 是否聚焦。 */
+export interface TerminalAppSurface {
+    /** AppleScript window id——会话期稳定，不受窗口顺序/焦点变化影响。 */
+    windowId: number;
+    /** 窗口内 tab 序号（1 起）。 */
+    tabIndex: number;
+    /** tty 设备路径（/dev/ttysNNN）——cwd 桥接键。 */
+    tty: string;
+    selected: boolean;
+    frontmost: boolean;
+    /** 根进程 cwd；取不到 = null（tab 在但不进任何目录匹配）。 */
+    cwd: string | null;
+}
+/** dump 文本 → surface 列表（cwd 另行桥接）；坏行跳过，不整体失败。 */
+export declare function parseTerminalAppDump(text: string): Omit<TerminalAppSurface, 'cwd'>[];
+/**
+ * `ps -axo pid=,ppid=,tty=` → tty（ps 形如 ttys004，无 /dev/ 前缀）→ 进程树
+ * 根 pid。根 = 父进程不在同一 tty 上的那个（shell 的父是 launchd，claude 的
+ * 父是 shell）；被 exec 替换成 claude 时根就是 claude，cwd 口径不变。
+ */
+export declare function parsePsRootPids(psText: string): Map<string, number>;
+/** `lsof -Fn` 输出 → pid → cwd（`p<pid>` 行后随 `n<路径>` 行）。 */
+export declare function parseLsofCwds(lsofText: string): Map<number, string>;
+/** 实时枚举（不吃缓存——落点决策必须看实时世界，同 wezterm 口径）。 */
+export declare function listTerminalAppSurfaces(platform: NodeJS.Platform): Promise<TerminalAppSurface[]>;
+export declare function terminalAppSurfacesCached(platform: NodeJS.Platform): Promise<TerminalAppSurface[]>;
+export declare function terminalAppTargetId(windowId: number, tabIndex: number): string;
+/** 目标 id ↔ (window, tab) 解码；坏 id → null。 */
+export declare function parseTerminalAppTargetId(id: string): {
+    windowId: number;
+    tabIndex: number;
+} | null;
+export declare function terminalAppMatches(surfaces: readonly TerminalAppSurface[], dir: string, platform: NodeJS.Platform): TerminalAppSurface[];
+/**
+ * 目标列表（纯函数）：只列本项目名下的 tab。排序（最近活跃从上往下）：
+ * ① 最前窗口的 tab 在前（Terminal.app 无 mux idle 信号，frontmost 是最近
+ * 活跃的最佳代理）；② 窗口内聚焦 tab 在前；③ 其余按 tabIndex 降序（越晚开
+ * 越可能更近用过）。matchCount/paneCount 恒 1/1——一个 tab 就一个面。
+ */
+export declare function terminalAppTargets(dir: string, surfaces: readonly TerminalAppSurface[], platform?: NodeJS.Platform): AttachTarget[];
+/** run 的落点：同项目已开的窗口（frontmost 优先，否则最大 windowId——越晚
+ * 创建越可能更近用过）；tab 只用于定位窗口（do script 落点本来就是窗口级
+ * 新 tab，tab 顺序变动无害）。没有 → null（走新窗）。 */
+export declare function pickTerminalAppWindow(surfaces: readonly TerminalAppSurface[], dir: string, platform?: NodeJS.Platform): {
+    windowId: number;
+    tabIndex: number;
+} | null;
+/** 目标列表（实时枚举入口）。 */
+export declare function listTerminalAppTargets(dir: string, platform: NodeJS.Platform): Promise<AttachTarget[]>;
+/** 在指定窗口开新 tab 跑命令；false = AppleScript 失败（窗口没了/无授权）。 */
+export declare function doScriptInTerminalWindow(dir: string, argv: string[], windowId: number): Promise<boolean>;

package/node_modules/@weavecode/server/dist/daemon/opener/pty-terminals.js

@@ -0,0 +1,5 @@
+import{captureCommand as p,normalizeDirKey as d}from"./wezterm-mux.js";import{joinCmd as l,quotePath as f}from"./shared.js";const m=['if application "Terminal" is not running then return ""','tell application "Terminal"','  set out to ""',"  repeat with w in windows","    set wid to id of w","    set fm to frontmost of w as text","    repeat with t in tabs of w",'      set out to out & wid & "\\t" & (index of t) & "\\t" & tty of t & "\\t" & (selected of t as text) & "\\t" & fm & linefeed',"    end repeat","  end repeat","  return out","end tell"].join(`
+`);export function parseTerminalAppDump(o){const t=[];for(const r of o.split(`
+`)){const e=r.trim().split("	");if(e.length!==5)continue;const n=Number(e[0]),i=Number(e[1]);!Number.isInteger(n)||!Number.isInteger(i)||t.push({windowId:n,tabIndex:i,tty:e[2],selected:e[3]==="true",frontmost:e[4]==="true"})}return t}export function parsePsRootPids(o){const t=new Map,r=new Map;for(const n of o.split(`
+`)){const i=/^\s*(\d+)\s+(\d+)\s+(\S+)/.exec(n);if(!i)continue;const a=Number(i[1]),c=i[3];if(c==="??")continue;const s=t.get(c)??new Set;s.add(a),t.set(c,s),r.set(a,Number(i[2]))}const e=new Map;for(const[n,i]of t)for(const a of i)if(!i.has(r.get(a)??-1)){e.set(n,a);break}return e}export function parseLsofCwds(o){const t=new Map;let r=-1;for(const e of o.split(`
+`))e.startsWith("p")&&/^\d+$/.test(e.slice(1))?r=Number(e.slice(1)):e.startsWith("n")&&r!==-1&&(t.set(r,e.slice(1)),r=-1);return t}export async function listTerminalAppSurfaces(o){if(o!=="darwin")return[];const t=await p("osascript",["-e",m]);if(!t?.ok)return[];const r=parseTerminalAppDump(t.out);if(r.length===0)return[];const e=await p("ps",["-axo","pid=,ppid=,tty="]);if(!e?.ok)return r.map(s=>({...s,cwd:null}));const n=parsePsRootPids(e.out),i=[...new Set(r.map(s=>n.get(s.tty.replace(/^\/dev\//,""))??-1))].filter(s=>s!==-1),a=i.length>0?await p("lsof",["-a","-p",i.join(","),"-d","cwd","-Fn"]):null,c=parseLsofCwds(a?.out??"");return r.map(s=>({...s,cwd:c.get(n.get(s.tty.replace(/^\/dev\//,""))??-1)??null}))}let u=null;export async function terminalAppSurfacesCached(o){if(u&&Date.now()-u.at<1e4)return u.surfaces;const t=await listTerminalAppSurfaces(o);return u={at:Date.now(),surfaces:t},t}export function terminalAppTargetId(o,t){return`terminal:${o}:${t}`}export function parseTerminalAppTargetId(o){const t=/^terminal:(\d+):(\d+)$/.exec(o);return t?{windowId:Number(t[1]),tabIndex:Number(t[2])}:null}export function terminalAppMatches(o,t,r){const e=d(t,r);return e?o.filter(n=>n.cwd!==null&&d(n.cwd,r)===e):[]}export function terminalAppTargets(o,t,r=process.platform){const e=terminalAppMatches(t,o,r);return e.sort((n,i)=>Number(i.frontmost)-Number(n.frontmost)||Number(i.selected)-Number(n.selected)||i.tabIndex-n.tabIndex),e.map(n=>({id:terminalAppTargetId(n.windowId,n.tabIndex),windowId:n.windowId,tabId:n.tabIndex,title:null,matchCount:1,paneCount:1,active:n.frontmost&&n.selected,full:!1}))}export function pickTerminalAppWindow(o,t,r=process.platform){const e=terminalAppMatches(o,t,r);return e.length===0?null:(e.sort((n,i)=>Number(i.frontmost)-Number(n.frontmost)||i.windowId-n.windowId),{windowId:e[0].windowId,tabIndex:e[0].tabIndex})}export async function listTerminalAppTargets(o,t){return terminalAppTargets(o,await listTerminalAppSurfaces(t),t)}export async function doScriptInTerminalWindow(o,t,r){const n=`cd ${f(o,"darwin")} && ${l(t,"darwin")}`.replace(/\\/g,"\\\\").replace(/"/g,'\\"');return(await p("osascript",["-e",`tell application "Terminal" to do script "${n}" in window id ${r}`]))?.ok===!0}

package/node_modules/@weavecode/server/dist/daemon/opener/shared.d.ts

@@ -0,0 +1,18 @@
+/**
+ * shell 引用工具域：路径/参数引用与 argv 拼接（custom 命令模板与 win32 转发共用）。
+ * 启动恒走参数数组 spawn（绝不拼 shell 串），目录名无法注入命令；唯一的例外是
+ * `custom` preset——用户自己写的命令模板，刻意经 shell（daemon 只听本机且有令牌）。
+ */
+/** Quote a path for interpolation into a custom shell command. */
+export declare function quotePath(dir: string, platform: NodeJS.Platform): string;
+/** Quote one argv entry for a shell command line (win32: cmd/PowerShell; posix: sh). */
+export declare function quoteArg(arg: string, platform: NodeJS.Platform): string;
+/** Join argv into one shell command line for presets that take a command string. */
+export declare function joinCmd(argv: string[], platform: NodeJS.Platform): string;
+/**
+ * win32：`wt.exe` / `wezterm` 是直接 CreateProcess 派发，**不做 PATHEXT 解析** ——
+ * 裸 `claude`（Windows 上只有 .cmd/.ps1 shim，没有同名 .exe）会报
+ * `0x80070002 找不到文件`。统一经 cmd.exe 转发（cmd/powershell 预设本来就经 shell，
+ * 所以只有这几个直发的预设需要）。`/k` 保留窗口：启动失败时用户看得见原因。
+ */
+export declare function throughCmd(run: string[] | undefined, win: boolean): string[] | undefined;

package/node_modules/@weavecode/server/dist/daemon/opener/shared.js

@@ -0,0 +1 @@
+export function quotePath(e,t){return t==="win32"?`"${e}"`:`'${e.replace(/'/g,"'\\''")}'`}export function quoteArg(e,t){return t==="win32"?e!==""&&!/[\s"&|<>^%]/.test(e)?e:`"${e.replace(/"/g,'\\"')}"`:/^[A-Za-z0-9_@%+=:,./-]+$/.test(e)?e:`'${e.replace(/'/g,"'\\''")}'`}export function joinCmd(e,t){return e.map(n=>quoteArg(n,t)).join(" ")}export function throughCmd(e,t){return!t||!e||e.length===0?e:["cmd.exe","/k",joinCmd(e,"win32")]}

package/node_modules/@weavecode/server/dist/daemon/opener/wezterm-mux.d.ts

@@ -0,0 +1,280 @@
+import type { LaunchOrigin } from '../opener.js';
+export interface WeztermPaneInfo {
+    windowId: number;
+    tabId: number;
+    paneId: number;
+    cwd: string | null;
+    left: number;
+    top: number;
+    /** 该 pane 是否当前聚焦（多终端弹窗的排序信号之一）。 */
+    isActive: boolean;
+    /** pane 标题（claude 的 OSC 标题）——弹窗标签的素材，缺省回落窗口/Tab 号。 */
+    title: string | null;
+}
+export type WeztermDirection = 'right' | 'bottom';
+/** 分屏落点：把哪个 pane 往哪个方向切。 */
+export interface WeztermSplitTarget {
+    paneId: number;
+    direction: WeztermDirection;
+}
+/** 解析 `cli list --format json`；坏输入安全落空（上层转新窗口/回退）。 */
+export declare function parseWeztermPanes(jsonText: string | null): WeztermPaneInfo[];
+/** file:/// URL/本地路径 → 规范比较键：统一斜杠、去尾斜杠，win 下压大小写。 */
+export declare function normalizeDirKey(raw: string | null, platform: NodeJS.Platform): string | null;
+/** 跨 mux 摊平的 pane 行：计数只需 (mux 判别键, windowId, tabId, cwd)。 */
+export interface WeztermMuxPane {
+    muxKey: string;
+    windowId: number;
+    /** tab 号（可见屏幕）；不给 = 该后端没有 tab 概念，按窗口计。 */
+    tabId?: number;
+    cwd: string | null;
+}
+/**
+ * 已打开终端计数，单位 = 各后端的**可见屏幕**（与会话终端选择弹窗的选项同一
+ * 口径）：distinct (mux, windowId, tabId)、任一 pane cwd 命中即计——不是分屏
+ * pane 数、也不是会话数。同一屏多个 pane 同属一目录只计 1。
+ */
+export declare function countWindowsByDir(dirs: readonly string[], panes: readonly WeztermMuxPane[], platform?: NodeJS.Platform): Map<string, number>;
+/**
+ * 单个终端（一个**可见屏幕** = wezterm 的一个 tab）的 pane 上限：网格 1 2 /
+ * 3 4 / 5 6 长满即停，再要新会话就只能新开窗口。各终端后端的「可见屏幕」定义
+ * 不同——不支持分屏的后端（Terminal.app / 纯 shell preset）没有「挤在同一个
+ * 可见屏幕里」这回事，不设限：每个会话各占一个窗口/tab。
+ */
+export declare const MAX_PANES_PER_SCREEN = 6;
+/**
+ * 一个 tab 内的网格生长：网格按 1 2 / 3 4 / 5 6 生长 —— 首个分屏向右开列，
+ * 之后矮列的底格向下延伸，等高取左列。坐标用 `cli list` 报的 left_col/top_row，
+ * 用户手工增删 pane 后依旧推导得出，不落持久状态。长满 `MAX_PANES_PER_SCREEN`
+ * 即无落点（null）——调用方据此新开窗口。
+ */
+export declare function planWeztermGrid(tabPanes: WeztermPaneInfo[]): WeztermSplitTarget | null;
+/**
+ * 同项目复用布局：挑「cwd 匹配该项目的 pane 最多、且有空间」的 tab（平手取最早
+ * tab），再按 tab 内网格生长推导落点；匹配的 tab 全满 = 无落点（null → 新窗口）。
+ */
+export declare function planWeztermReuse(dir: string, panes: WeztermPaneInfo[], platform?: NodeJS.Platform): WeztermSplitTarget | null;
+/** 新项目窗：最近活跃 client 的 workspace（拿不到就省略，进 mux 默认 workspace）。 */
+export declare function planWeztermNewWindow(dir: string, workspace: string | null): string[];
+/**
+ * 会话终端可附加目标（多终端弹窗的选项）：一个终端窗口内的一个 tab（wezterm
+ * 的 tab 含分屏 pane，即一个可见屏幕；Terminal.app 的 tab 即整面）。id 不透明、
+ * 格式归各后端（wezterm `<mux 短哈希>:<windowId>:<tabId>`，Terminal.app
+ * `terminal:<win>:<tab>`）。
+ */
+export interface AttachTarget {
+    id: string;
+    windowId: number;
+    tabId: number;
+    /** tab 聚焦 pane 的标题（claude 的 OSC 标题）；null 由前端回落「窗口 W · Tab T」文案。 */
+    title: string | null;
+    /** cwd 命中请求目录的 pane 数 / 该 tab 总 pane 数。 */
+    matchCount: number;
+    paneCount: number;
+    /** 该 tab 内含聚焦 pane（窗口正看着它）。 */
+    active: boolean;
+    /** 这个可见屏幕已长满（pane 数到上限）：前端置灰，后端定点附加明确拒绝。 */
+    full: boolean;
+    /** 本卡片上 cwd 命中本项目的 pane（可关的那几个，表示法同 prompt pane id）；
+     *  给不出 = 该后端关不了远程 pane，前端不摆关闭键。 */
+    paneIds?: string[];
+}
+/**
+ * mux socket → 不透明短标识（不回传本机路径）。**按比较键取哈希**：同一 socket
+ * 有两种形态（wezterm 注进 pane env 的是混合分隔符，目录拼出来的是全反斜杠），
+ * 裸串哈希会给同一实例发两个 id，投递时按 id 反查就落空。
+ */
+export declare function weztermMuxKey(socket: string): string;
+/**
+ * 层② 定位（纯函数）：hook 上报的 pane env × 活 mux 表 → prompt pane id。
+ * 键缺、socket 对不上活 mux、pane 号已不在 = null（宁可回落，不猜）。
+ */
+export declare function weztermPaneFromEnv(env: Record<string, string>, muxes: readonly {
+    socket: string;
+    panes: readonly {
+        paneId: number;
+    }[];
+}[], platform: NodeJS.Platform): string | null;
+/**
+ * 会话所在的**可见屏幕**（终端里的一块屏 = wezterm 一个 tab）：会话列表按它分块
+ * ——同一块屏上的会话聚在一起。id 不透明、格式归后端，只作分组键；窗口/Tab 号
+ * 与同窗口 tab 数供块头文案（Tab 号只在同窗口多 tab 时有意义）。
+ */
+export interface SessionTerminal {
+    id: string;
+    windowId: number;
+    tabId: number;
+    tabsInWindow: number;
+}
+/**
+ * 会话 → 可见屏幕（纯函数）：hook 上报的 pane env × 活 mux 表 × 这轮的候选清单。
+ * 三态各司其职——屏幕 = 反查到了；`null` = **确认不在了**（pane 已关 / 换了 mux /
+ * 整个 GUI 没了）；**缺键 = 这轮没探到但实例还活着**（探活闸跳过、冷却、超时），
+ * web 据此保留上次分块。探活闸的冷却窗与偶发失败都会让 mux 短暂不在枚举表里，
+ * 把它们写成 null 就是「同一个终端的会话莫名掉出分块」的成因——分不清「没查」
+ * 与「查了没有」。
+ */
+export declare function sessionScreensFromEnvs(envs: Record<string, Record<string, string>>, muxes: readonly {
+    socket: string;
+    panes: readonly WeztermPaneInfo[];
+}[], 
+/** 这轮认定还活着的 socket（`weztermSocketCandidates` 口径 = 枚举成功 ∪ 探活
+ *  失败/被闸跳过）：不在枚举表里却在这里面 = 只是这轮没探到。 */
+candidates: readonly string[], platform?: NodeJS.Platform): Record<string, SessionTerminal | null>;
+/** 目标 id ↔ (mux, window, tab) 解码；坏 id → null。 */
+export declare function parseAttachTargetId(id: string): {
+    muxKey: string;
+    windowId: number;
+    tabId: number;
+} | null;
+/**
+ * 目标列表（纯函数）：**只列本项目名下的 tab**（至少一个 pane 的 cwd 命中该目录）
+ * ——别的项目的终端不进来，用户不必在一堆无关窗口里挑。空表语义 = 该项目没有
+ * 终端开着（调用方据此直接开新窗，而不是弹一个空选择框）。
+ *
+ * 排序（最近活跃从上往下）：① 整个 wezterm 实例更近活跃（mux 的 client idle
+ * 更小）在前；② 同实例内含聚焦 pane 的 tab 在前；③ 其余按 tabId 降序（tab 越晚
+ * 创建越可能更近用过）。`cli list` 不报任何时间戳，这是可得信号下的最佳近似。
+ */
+export declare function attachTargetsFromMuxes(dir: string, muxes: readonly {
+    socket: string;
+    idleMs: number;
+    panes: WeztermPaneInfo[];
+}[], platform?: NodeJS.Platform): AttachTarget[];
+/** 目标列表（实时枚举，不吃探活缓存——用户手一划就可能关掉窗）。 */
+export declare function listAttachTargets(dir: string, platform?: NodeJS.Platform): Promise<AttachTarget[]>;
+/** 活跃 client：workspace + idle 毫秒（idle 还用来在多个 mux 之间选最活跃的）。 */
+interface WeztermActiveClient {
+    workspace: string;
+    idleMs: number;
+}
+/** list-clients JSON → idle 最小的 client；坏输入/无有效 client → null。 */
+export declare function weztermActiveClient(jsonText: string | null): WeztermActiveClient | null;
+/** list-clients JSON → 最近活跃（idle 最小）client 的 workspace；坏输入 null。 */
+export declare function weztermActiveWorkspaceOf(jsonText: string | null): string | null;
+/** 捕获型子调用结果：ok=rc0 且未超时；out/err 供上层拼错误文案。 */
+export interface CaptureResult {
+    ok: boolean;
+    out: string;
+    err: string;
+    timedOut: boolean;
+}
+/**
+ * 捕获型子调用（与 fire-and-forget 的 trySpawn 相对）：null = 进程起不来
+ * （ENOENT 等）；其余带 rc/stdout/stderr。daemon 侧查世界的通道都走它
+ * （wezterm cli / osascript / ps / lsof / wt 进程表）。
+ */
+export declare function captureCommand(command: string, args: string[], env?: NodeJS.ProcessEnv, timeoutMs?: number): Promise<CaptureResult | null>;
+/**
+ * wezterm cli 子调用：null = 进程起不来（ENOENT 等）；其余带 rc/stdout/stderr。
+ * socket 非空时经 WEZTERM_UNIX_SOCKET 指定 mux——daemon 不在 pane 里，没有
+ * wezterm 注入的这个 env，不显式点名就会去连默认 sock/残留 socket 而误判。
+ *
+ * 恒带 `--no-auto-start`：cli 缺省「连不上 socket 就原地拉起 wezterm-mux-server
+ * --daemonize」——该进程永不退出、还继承调用方的 stdio 管道把探活挂到超时，对着
+ * 陈旧/失联 socket 探一次就泄一个（实测攒过 16 个，复盘见 docs/DECISIONS.md）。
+ * 带上后连不上是干净的 rc≠0，probeGate 据此判永久死。
+ */
+export declare function weztermCli(args: string[], socket: string): Promise<CaptureResult | null>;
+/** cli 子命令参数 → 补上 `--no-auto-start`（须落在 `cli` 与子命令之间）。 */
+export declare function weztermCliArgs(args: readonly string[]): string[];
+/** cli 步骤失败的诊断文案：socket + 命令 + stderr/超时，经路由 400 → 前端 toast。 */
+export declare function weztermStepError(args: string[], socket: string, r: CaptureResult | null): string;
+/**
+ * `gui-sock-<pid>` 那个 pid 是否**真是它的 GUI**。pid 会被复用，`weztermPidAlive`
+ * 只答「有进程占着这个号」——死 socket 因此能一直冒充活实例（实测 GUI 50172 死后，
+ * daemon 仍每隔一分钟对着它的 socket spawn 一次 `wezterm cli`）。
+ * 只在该 socket 探活已经失败后调用：这时多花一枪 tasklist 不算什么。
+ */
+export declare function weztermGuiAlive(pid: number): Promise<boolean>;
+/**
+ * socket 路径 → 它绑定的 GUI 进程 pid（`gui-sock-<pid>`）；非该形态返回 null——
+ * 判死无据时宁可只冷却，也不永久拉黑。
+ */
+export declare function weztermGuiPidOf(socket: string): number | null;
+/**
+ * 候选 mux socket：进程 env 显式指定的最优先（daemon 一般没有，pane 内才有），
+ * 其次存活 GUI 的 gui-sock-*（新的在前 ≈ 最近开的 wezterm 实例）。
+ * 跳过裸 `sock`：默认 socket 不按 GUI pid 命名、判活无据——历史教训是 cli 对它
+ * 原地拉起幽灵 server 后 rc=0 返回空世界、假成功一轮接一轮（见 DECISIONS）；
+ * wezterm 注进 pane env 的恒是 gui-sock-<pid>，跳过它不丢发现面。
+ */
+export declare function weztermSocketCandidates(platform: NodeJS.Platform): string[];
+/** 一个探活通过的 mux：socket + pane 世界 + 活跃 client（workspace 与 idle）。 */
+export interface WeztermMux {
+    socket: string;
+    panes: WeztermPaneInfo[];
+    workspace: string | null;
+    idleMs: number;
+}
+/**
+ * 探活失败的 socket 记忆——避免对已知坏 socket 反复 spawn `wezterm cli`。
+ *
+ * 为什么需要：陈旧的 `gui-sock-<pid>` 不会自己消失（wezterm 退出不清理，实测
+ * 攒到过 48 个），对它们反复 spawn 纯属浪费（`--no-auto-start` 后死 socket
+ * 是快速 rc≠0，不再是当年「原地拉起幽灵 mux-server、探活 >250s 不返回」的
+ * 自伤——复盘见 docs/DECISIONS.md）。
+ *
+ * 判据的分寸：socket 路径与 GUI 的 pid 绑定，**进程死则该路径永久失效**（新 GUI
+ * 必然是新 pid → 新路径），所以「干净的非零退出 + 这个 GUI 进程真没了」可以永久
+ * 记住；而**超时/起不来/进程还活着却答不上来只算可疑**（本机 GUI 常年在 4~6 核，
+ * 5s 内答不上来是可能的），只短期回避，免得把活着的 GUI 误判死。
+ */
+export declare class SocketProbeGate {
+    private readonly dead;
+    private readonly cooling;
+    /** 这一轮要不要探它。 */
+    shouldProbe(socket: string, now?: number): boolean;
+    /** 探活成功：它活着，清掉回避态。 */
+    succeeded(socket: string): void;
+    /** 干净的非零退出（socket 层失败）→ 该路径永久失效。 */
+    failed(socket: string): void;
+    /** 超时 / 可执行起不来 → 只回避一段时间。 */
+    cooledDown(socket: string, now?: number): void;
+}
+/** 进程内的探活失败记忆（见 SocketProbeGate）。 */
+export declare const probeGate: SocketProbeGate;
+/**
+ * 逐候选探活（单次 5s 超时兜底挂死的 GUI）；返回活 mux 与候选清单（报错用）。
+ * light = 只取计数要的字段（socket+panes）：跳过 `list-clients`（每 socket 省
+ * 一半 spawn），workspace/idleMs 留空——仅供 `weztermLiveMuxesCached`（计数）用，
+ * run/落点决策恒走全量。候选**并行**探：串行时 N 个 mux 的墙钟是 N×，
+ * 事件循环饱和窗口里被排队放大成秒级。
+ */
+export declare function weztermLiveMuxes(light?: boolean, force?: string | null): Promise<{
+    muxes: WeztermMux[];
+    candidates: string[];
+}>;
+/**
+ * pane id 里的 mux 短标识 → 那个 mux。**只探它那一个 socket**（绕过探活闸）：
+ * 击键/投递已知目标，全量扫是白花 spawn，且冷却期会把「实例还在」误判成
+ * 「实例没了」→ 停止键静默失败。
+ */
+export declare function weztermMuxForId(muxKey: string): Promise<WeztermMux | null>;
+/**
+ * 开终端（不带命令）的 mux 通道：有活实例 → 最活跃那个开新窗口；一个都没有
+ * → false（调用方回落 legacy `start` 起新 GUI）。某步失败一律 throw——跟着
+ * `run` 的口径，不静默落到另起一个 GUI 进程。
+ */
+export declare function openInWezterm(dir: string): Promise<boolean>;
+/**
+ * wezterm run 主通道：同项目 → 分屏复用（复用目标长满 = 没有可复用落点）；
+ * 否则 → 最活跃 mux 开新窗口；命令一律 send-text。**一个活 mux 都没有 → 返回
+ * null**（调用方回落 legacy `start` 起新 GUI——那是另一套流程，不在这条里猜）。
+ * 有 mux 之后的任何失败（某步 rc≠0 / 超时）一律 throw：错误经路由 400 转 toast，
+ * 绝不静默落到假成功的 legacy start。成功带回落子的起点 pane（spawn 回执），
+ * paneEnvSource='launch' 的 harness 据此定位会话。
+ */
+export declare function runInWezterm(dir: string, argv: string[]): Promise<LaunchOrigin | null>;
+/**
+ * spawn 落 pane（分屏 / 新窗）：runInWezterm、开终端、定点附加共用的前半步。
+ * split = null → 开新窗口。返回新 pane id；任何一步失败一律 throw。
+ */
+export declare function weztermSpawnPane(socket: string, dir: string, split: WeztermSplitTarget | null, workspace: string | null): Promise<string>;
+/**
+ * spawn + send-text 投递：runInWezterm 与定点附加共用的尾部。任何一步失败一律
+ * throw（路由 400 → 前端报因）。成功回起点 pane 的定位 env（键形出 core 表，
+ * paneEnvSource='launch' 的 harness 据此反查这块屏）。
+ */
+export declare function weztermSpawnAndSend(socket: string, dir: string, argv: string[], split: WeztermSplitTarget | null, workspace: string | null, platform?: NodeJS.Platform): Promise<LaunchOrigin>;
+export {};

package/node_modules/@weavecode/server/dist/daemon/opener/wezterm-mux.js

@@ -0,0 +1 @@
+import{spawn as $}from"node:child_process";import{createHash as z}from"node:crypto";import{readdirSync as M}from"node:fs";import{basename as y,join as I}from"node:path";import{TERMINAL_LOCATOR_ENV as h}from"@weavecode/core";import{joinCmd as k}from"./shared.js";export function parseWeztermPanes(t){if(!t)return[];let n;try{n=JSON.parse(t)}catch{return[]}if(!Array.isArray(n))return[];const r=[];for(const s of n){const e=s;typeof e?.pane_id!="number"||typeof e?.tab_id!="number"||r.push({windowId:typeof e.window_id=="number"?e.window_id:0,tabId:e.tab_id,paneId:e.pane_id,cwd:typeof e.cwd=="string"?e.cwd:null,left:typeof e.left_col=="number"?e.left_col:0,top:typeof e.top_row=="number"?e.top_row:0,isActive:e.is_active===!0,title:typeof e.title=="string"&&e.title?e.title:null})}return r}export function normalizeDirKey(t,n){if(!t)return null;let r=t;if(r.startsWith("file://")){r=r.slice(7);try{r=decodeURIComponent(r)}catch{return null}n==="win32"&&(r=r.replace(/^\//,""))}return r=r.replace(/\\/g,"/").replace(/\/+$/,""),r?n==="win32"?r.toLowerCase():r:null}export function countWindowsByDir(t,n,r=process.platform){const s=t.map(o=>normalizeDirKey(o,r)),e=t.map(()=>new Set);for(const o of n){const i=normalizeDirKey(o.cwd,r);if(!i)continue;const c=o.tabId==null?`${o.muxKey}#${o.windowId}`:`${o.muxKey}#${o.windowId}#${o.tabId}`;for(let u=0;u<t.length;u++)s[u]!==null&&s[u]===i&&e[u].add(c)}return new Map(t.map((o,i)=>[o,e[i].size]))}export const MAX_PANES_PER_SCREEN=6;function _(t,n,r){const s=new Map,e=new Map;for(const c of n)e.set(c.tabId,(e.get(c.tabId)??0)+1),normalizeDirKey(c.cwd,r)===t&&s.set(c.tabId,(s.get(c.tabId)??0)+1);let o=null,i=0;for(const[c,u]of s)(e.get(c)??0)>=MAX_PANES_PER_SCREEN||(o===null||u>i||u===i&&c<o)&&(o=c,i=u);return o}export function planWeztermGrid(t){if(t.length===0||t.length>=MAX_PANES_PER_SCREEN)return null;if(t.length===1)return{paneId:t[0].paneId,direction:"right"};const n=new Map;for(const e of t){const o=n.get(e.left)??[];o.push(e),n.set(e.left,o)}const r=[...n.entries()].sort(([e],[o])=>e-o).map(([,e])=>[...e].sort((o,i)=>i.top-o.top));if(r.length===1)return{paneId:r[0][0].paneId,direction:"right"};let s=r[0];for(const e of r)e.length<s.length&&(s=e);return{paneId:s[0].paneId,direction:"bottom"}}export function planWeztermReuse(t,n,r=process.platform){const s=normalizeDirKey(t,r);if(!s)return null;const e=_(s,n,r);return e===null?null:planWeztermGrid(n.filter(o=>o.tabId===e))}export function planWeztermNewWindow(t,n){const r=["cli","spawn","--new-window","--cwd",t];return n&&r.push("--workspace",n),r}export function weztermMuxKey(t){return z("sha256").update(normalizeDirKey(t,process.platform)??t).digest("hex").slice(0,8)}export function weztermPaneFromEnv(t,n,r){const[s,e]=h.wezterm,o=t[s],i=t[e];if(!o||!i)return null;const c=normalizeDirKey(i,r),u=n.find(l=>normalizeDirKey(l.socket,r)===c);return!u||!u.panes.some(l=>String(l.paneId)===o)?null:`${weztermMuxKey(u.socket)}:${o}`}export function sessionScreensFromEnvs(t,n,r,s=process.platform){const[e,o]=h.wezterm,i=new Set(r.map(u=>normalizeDirKey(u,s))),c={};for(const[u,l]of Object.entries(t)){const a=l[e],d=l[o],w=d?n.find(f=>normalizeDirKey(f.socket,s)===normalizeDirKey(d,s)):void 0,p=w?.panes.find(f=>String(f.paneId)===a);if(w){c[u]=p?{id:`${weztermMuxKey(w.socket)}:${p.windowId}:${p.tabId}`,windowId:p.windowId,tabId:p.tabId,tabsInWindow:new Set(w.panes.filter(f=>f.windowId===p.windowId).map(f=>f.tabId)).size}:null;continue}d&&i.has(normalizeDirKey(d,s))||(c[u]=null)}return c}export function parseAttachTargetId(t){const n=/^([0-9a-f]{8}):(\d+):(\d+)$/.exec(t);return n?{muxKey:n[1],windowId:Number(n[2]),tabId:Number(n[3])}:null}export function attachTargetsFromMuxes(t,n,r=process.platform){const s=normalizeDirKey(t,r);if(!s)return[];const e=[];for(const o of[...n].sort((i,c)=>i.idleMs-c.idleMs)){const i=weztermMuxKey(o.socket),c=new Map;for(const l of o.panes){const a=`${l.windowId}:${l.tabId}`,d=c.get(a)??[];d.push(l),c.set(a,d)}const u=[];for(const[l,a]of c){const d=a.filter(m=>normalizeDirKey(m.cwd,r)===s);if(d.length===0)continue;const w=Number(l.slice(0,l.indexOf(":"))),p=Number(l.slice(l.indexOf(":")+1)),f=a.find(m=>m.isActive)??a[0];u.push({id:`${i}:${w}:${p}`,windowId:w,tabId:p,title:f.title,matchCount:d.length,paneCount:a.length,active:a.some(m=>m.isActive),full:a.length>=MAX_PANES_PER_SCREEN,paneIds:d.map(m=>`${i}:${m.paneId}`)})}u.sort((l,a)=>Number(a.active)-Number(l.active)||a.tabId-l.tabId),e.push(...u)}return e}export async function listAttachTargets(t,n=process.platform){const{muxes:r}=await weztermLiveMuxes();return attachTargetsFromMuxes(t,r,n)}export function weztermActiveClient(t){if(!t)return null;let n;try{n=JSON.parse(t)}catch{return null}if(!Array.isArray(n))return null;let r=null;for(const s of n){const e=s;if(typeof e?.workspace!="string"||!e.workspace)continue;const o=e.idle_time,i=(typeof o?.secs=="number"?o.secs*1e3:0)+(typeof o?.nanos=="number"?o.nanos/1e6:0);(r===null||i<r.idleMs)&&(r={workspace:e.workspace,idleMs:i})}return r}export function weztermActiveWorkspaceOf(t){return weztermActiveClient(t)?.workspace??null}const g=5e3;export function captureCommand(t,n,r,s=g){return new Promise(e=>{let o;try{o=$(t,n,{windowsHide:!0,env:r??process.env})}catch{e(null);return}let i="",c="",u=!1;const l=d=>{u||(u=!0,clearTimeout(a),e(d))};o.stdout.on("data",d=>{i+=d.toString()}),o.stderr?.on("data",d=>{c+=d.toString()});const a=setTimeout(()=>{o.stdout.destroy(),o.stderr?.destroy(),o.unref(),o.kill(),l({ok:!1,out:i,err:c.trim(),timedOut:!0})},s);a.unref(),o.on("error",()=>l(null)),o.on("close",d=>{l({ok:d===0,out:i,err:c.trim(),timedOut:!1})})})}export function weztermCli(t,n){return captureCommand("wezterm",weztermCliArgs(t),{...process.env,WEZTERM_UNIX_SOCKET:n})}export function weztermCliArgs(t){return t[0]==="cli"?["cli","--no-auto-start",...t.slice(1)]:[...t]}export function weztermStepError(t,n,r){const s=`wezterm[${y(n)}] ${t.join(" ")}`;return r===null?`${s}: executable not found`:r.timedOut?`${s}: timed out after ${g}ms`:r.err?`${s}: ${r.err}`:`${s}: exited with failure`}function x(t){try{return process.kill(t,0),!0}catch{return!1}}export async function weztermGuiAlive(t){if(!x(t))return!1;if(process.platform!=="win32")return!0;const n=await captureCommand("tasklist",["/FI",`PID eq ${t}`,"/FO","CSV","/NH"],void 0,2e3);return n?.ok===!0&&/wezterm-gui\.exe/i.test(n.out)}export function weztermGuiPidOf(t){const n=/gui-sock-(\d+)$/.exec(t.replace(/\\/g,"/"));return n?Number(n[1]):null}function b(t){let n;try{n=M(t)}catch{return[]}const r=[];for(const s of n){const e=/^gui-sock-(\d+)$/.exec(s);if(!e)continue;const o=Number(e[1]);x(o)&&r.push({path:I(t,s),pid:o})}return r.sort((s,e)=>e.pid-s.pid).map(s=>s.path)}function S(t,n){const r=t.replace(/\\/g,"/");return n==="win32"?r.toLowerCase():r}export function weztermSocketCandidates(t){const n=[],r=new Set,s=i=>{const c=S(i,t);r.has(c)||(r.add(c),n.push(i))},e=process.env.WEZTERM_UNIX_SOCKET;if(e){const i=weztermGuiPidOf(e);(i===null||x(i))&&s(e)}const o=t==="win32"?process.env.USERPROFILE:process.env.HOME;return o&&b(I(o,".local","share","wezterm")).forEach(s),t!=="win32"&&process.env.XDG_RUNTIME_DIR&&b(I(process.env.XDG_RUNTIME_DIR,"wezterm")).forEach(s),n}const E=6e4;export class SocketProbeGate{dead=new Set;cooling=new Map;shouldProbe(n,r=Date.now()){if(this.dead.has(n))return!1;const s=this.cooling.get(n);return s===void 0||r>=s}succeeded(n){this.cooling.delete(n)}failed(n){this.dead.add(n),this.cooling.delete(n)}cooledDown(n,r=Date.now()){this.dead.has(n)||this.cooling.set(n,r+E)}}export const probeGate=new SocketProbeGate;export async function weztermLiveMuxes(t=!1,n=null){const r=n?[n]:weztermSocketCandidates(process.platform);return{muxes:(await Promise.all(r.map(async e=>{if(!n&&!probeGate.shouldProbe(e))return null;const o=await weztermCli(["cli","list","--format","json"],e);if(!o?.ok){const l=weztermGuiPidOf(e);return o&&!o.timedOut&&l!==null&&!await weztermGuiAlive(l)?probeGate.failed(e):probeGate.cooledDown(e),null}probeGate.succeeded(e);const i=parseWeztermPanes(o.out);if(t)return{socket:e,panes:i,workspace:null,idleMs:Number.POSITIVE_INFINITY};const c=await weztermCli(["cli","list-clients","--format","json"],e),u=weztermActiveClient(c?.ok?c.out:null);return{socket:e,panes:i,workspace:u?.workspace??null,idleMs:u?.idleMs??Number.POSITIVE_INFINITY}}))).filter(e=>e!==null),candidates:r}}export async function weztermMuxForId(t){const n=weztermSocketCandidates(process.platform).find(s=>weztermMuxKey(s)===t);if(!n)return null;const{muxes:r}=await weztermLiveMuxes(!0,n);return r.find(s=>weztermMuxKey(s.socket)===t)??null}export async function openInWezterm(t){const{muxes:n}=await weztermLiveMuxes();if(n.length===0)return!1;const r=n.reduce((s,e)=>e.idleMs<s.idleMs?e:s);return await weztermSpawnPane(r.socket,t,null,r.workspace),!0}export async function runInWezterm(t,n){const r=process.platform,{muxes:s}=await weztermLiveMuxes();if(s.length===0)return null;let e=null,o=null;for(const i of s){const c=planWeztermReuse(t,i.panes,r);c&&(e===null||i.idleMs<e.idleMs)&&(e=i,o=c)}return e??=s.reduce((i,c)=>c.idleMs<i.idleMs?c:i),weztermSpawnAndSend(e.socket,t,n,o,e.workspace)}export async function weztermSpawnPane(t,n,r,s){const e=r?["cli","split-pane","--pane-id",String(r.paneId),`--${r.direction}`,"--cwd",n]:planWeztermNewWindow(n,s),o=await weztermCli(e,t);if(!o?.ok)throw new Error(weztermStepError(e,t,o));const i=o.out.trim();if(!/^\d+$/.test(i))throw new Error(`wezterm[${y(t)}] ${e.join(" ")}: unexpected pane id "${i}"`);return i}export async function weztermSpawnAndSend(t,n,r,s,e,o=process.platform){const i=await weztermSpawnPane(t,n,s,e),c=["cli","send-text","--pane-id",i,"--no-paste",`${k(r,o)}\r`],u=await weztermCli(c,t);if(!u?.ok)throw new Error(weztermStepError(c,t,u));const[l,a]=h.wezterm;return{env:{[l]:i,[a]:t}}}

package/node_modules/@weavecode/server/dist/daemon/opener/win-raise.d.ts

@@ -0,0 +1,33 @@
+/** 一次唤出要向 Win32 问的三件事：窗口属于谁、标题叫什么、抬哪一个。 */
+export interface WinRaiseRequest {
+    /** 窗口属主 pid（wezterm：一个 GUI 进程装多个窗口）。 */
+    guiPid?: number;
+    /** 或者给 pane 里的进程，由脚本往上找 exe 命中的那个进程（wt：一窗一进程）。 */
+    panePids?: readonly number[];
+    /** 窗口所属进程 exe（小写，如 `windowsterminal.exe`）。 */
+    exe?: string;
+    /** 认窗口用的标题候选，**按可信度排序**（OS 窗口标题 = 该窗口某个 pane 的标题）。 */
+    titles?: readonly string[];
+}
+/**
+ * 唤出已开终端的 Windows 抓手 = 抬 HWND。终端都不给 CLI 窗口号：`wezterm cli
+ * activate-pane` 只切 mux 内部焦点，实测既不抬窗口也不解最小化（`set-tab-title`
+ * / `set-window-title` 也不落到 OS 标题上）；wt 更是只有 stdin 通道。能用的对应
+ * 关系只有一条——**OS 窗口标题 = 该窗口某个 pane 的标题**（ConPTY 把 pane 的标题
+ * 当终端标题上报），所以先按进程/exe 收窄到那家的窗口，再用标题消歧。
+ *
+ * 标题匹配必须**先归一**（脚本里做）：claude 的 title 带头部 spinner 字（`✳`/`◐`），
+ * OS 标题停在 pane 上一次上报的那一帧、常常比此刻的 pane 标题差一格；wezterm 还会
+ * 给多 tab 窗口的标题前缀 `[活动 tab/总数]`。
+ *
+ * 另一条实测约束写在脚本里：`SetForegroundWindow` 会被 Windows 的前台锁吞掉，抬之前
+ * 必须把输入队列接到当前前台线程上。
+ */
+export declare function winRaiseTerminalWindow(req: WinRaiseRequest): Promise<void>;
+export declare function winRaiseOnce(req: WinRaiseRequest, titles: readonly string[]): Promise<{
+    ok: boolean;
+    code: number;
+    err: string;
+}>;
+/** PowerShell 脚本（base64/UTF-16，`-EncodedCommand` 免引号转义）；纯函数，单测覆盖。 */
+export declare function winRaiseEncodedScript(): string;