@weavecode/weave 0.1.1 → 0.1.3

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

@@ -0,0 +1,277 @@
+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 都没有 → 返回
+ * false**（调用方回落 legacy `start` 起新 GUI——那是另一套流程，不在这条里猜）。
+ * 有 mux 之后的任何失败（某步 rc≠0 / 超时）一律 throw：错误经路由 400 转 toast，
+ * 绝不静默落到假成功的 legacy start。
+ */
+export declare function runInWezterm(dir: string, argv: string[]): Promise<boolean>;
+/**
+ * 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 → 前端报因）。
+ */
+export declare function weztermSpawnAndSend(socket: string, dir: string, argv: string[], split: WeztermSplitTarget | null, workspace: string | null, platform?: NodeJS.Platform): Promise<void>;
+export {};

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

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

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;

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

@@ -0,0 +1,199 @@
+import{captureCommand as i}from"./wezterm-mux.js";export async function winRaiseTerminalWindow(t){const r=(t.titles??[]).filter(n=>n&&!n.includes("|")),e=await winRaiseOnce(t,r);if(!e.ok)throw e.code===3?new Error("Could not find that terminal window \u2014 is it still open?"):e.code===4?new Error("Could not tell which window hosts that terminal \u2014 click it in the taskbar"):new Error(`Could not bring the terminal to the front: ${e.err||"unknown error"}`)}export async function winRaiseOnce(t,r){const e=await i("powershell",["-NoProfile","-NonInteractive","-ExecutionPolicy","Bypass","-EncodedCommand",winRaiseEncodedScript()],{...process.env,WEAVE_RAISE_PIDS:t.guiPid?String(t.guiPid):"",WEAVE_RAISE_PANE_PIDS:(t.panePids??[]).join(","),WEAVE_RAISE_EXE:t.exe??"",WEAVE_RAISE_TITLES:r.join("|")},15e3);if(!e)return{ok:!1,code:-1,err:"powershell is unavailable \u2014 cannot bring the terminal to the front"};if(e.ok)return{ok:!0,code:0,err:""};const n=`${e.err||""} ${e.out||""}`.trim();return{ok:!1,code:e.timedOut?-2:/status\|ambiguous/.test(e.out)?4:/status\|none/.test(e.out)?3:-3,err:n}}export function winRaiseEncodedScript(){const t=`$ErrorActionPreference = 'Stop'
+Add-Type -TypeDefinition @'
+${o}
+'@
+$exe = $env:WEAVE_RAISE_EXE
+if (-not $exe) { $exe = '' }
+$exe = $exe.ToLower()
+$pids = New-Object 'System.Collections.Generic.HashSet[uint32]'
+foreach ($p in (($env:WEAVE_RAISE_PANE_PIDS + '') -split ',')) {
+  if ($p -eq '') { continue }
+  $a = [WeaveRaise]::Ancestor([uint32]$p, $exe)
+  if ($a -ne 0) { [void]$pids.Add($a) }
+}
+foreach ($p in (($env:WEAVE_RAISE_PIDS + '') -split ',')) {
+  if ($p -eq '') { continue }
+  [void]$pids.Add([uint32]$p)
+}
+function Norm([string]$s) {
+  if (-not $s) { return '' }
+  $s = $s.Trim()
+  $s = $s -replace '^\\[\\d+/\\d+\\]\\s*', ''
+  $s = $s -replace '^[^\\p{L}\\p{N}]+', ''
+  $s = $s -replace '\\s+', ' '
+  return $s.Trim().ToLower()
+}
+$rows = [WeaveRaise]::Owned($pids, $exe)
+foreach ($r in $rows) { $r.Title = Norm $r.Title }
+$pick = $null
+if ($rows.Count -eq 1) { $pick = $rows[0] }
+else {
+  foreach ($c in ($env:WEAVE_RAISE_TITLES -split '\\|')) {
+    $c = Norm $c
+    if ($c -eq '') { continue }
+    $hit = @()
+    foreach ($r in $rows) { if ($r.Title -eq $c) { $hit += $r } }
+    if ($hit.Count -eq 1) { $pick = $hit[0]; break }
+  }
+}
+if ($pick -eq $null) {
+  foreach ($r in $rows) { '{0}|{1}|{2}' -f [int64]$r.Handle, $r.Pid, $r.Title }
+  $code = 3
+  if ($rows.Count -gt 1) { $code = 4; 'status|ambiguous' } else { 'status|none' }
+  exit $code
+}
+$res = [WeaveRaise]::Raise([int64]$pick.Handle)
+if ($res -ne 'ok') { [Console]::Error.WriteLine('raise:' + $res); exit 5 }
+'exactly ' + [int64]$pick.Handle
+exit 0
+`;return Buffer.from(t,"utf16le").toString("base64")}const o=`using System;
+using System.Text;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+public class WeaveWindow
+{
+    public IntPtr Handle;
+    public uint Pid;
+    public string Title;
+}
+
+public static class WeaveRaise
+{
+    delegate bool EnumProc(IntPtr h, IntPtr param);
+    [DllImport("user32.dll")] static extern bool EnumWindows(EnumProc cb, IntPtr param);
+    [DllImport("user32.dll", CharSet = CharSet.Unicode)] static extern int GetWindowTextW(IntPtr h, StringBuilder sb, int size);
+    [DllImport("user32.dll", CharSet = CharSet.Unicode)] static extern int GetWindowTextLengthW(IntPtr h);
+    [DllImport("user32.dll")] static extern uint GetWindowThreadProcessId(IntPtr h, out uint pid);
+    [DllImport("user32.dll")] static extern bool IsWindowVisible(IntPtr h);
+    [DllImport("user32.dll")] static extern bool ShowWindow(IntPtr h, int cmd);
+    [DllImport("user32.dll")] static extern bool SetForegroundWindow(IntPtr h);
+    [DllImport("user32.dll")] static extern bool BringWindowToTop(IntPtr h);
+    [DllImport("user32.dll")] static extern IntPtr SetFocus(IntPtr h);
+    [DllImport("user32.dll")] static extern bool IsIconic(IntPtr h);
+    [DllImport("user32.dll")] static extern IntPtr GetForegroundWindow();
+    [DllImport("user32.dll")] static extern bool AttachThreadInput(uint attach, uint attachTo, bool join);
+    [DllImport("kernel32.dll")] static extern uint GetCurrentThreadId();
+    [DllImport("kernel32.dll")] static extern IntPtr OpenProcess(uint access, bool inherit, uint pid);
+    [DllImport("kernel32.dll", CharSet = CharSet.Unicode)] static extern bool QueryFullProcessImageNameW(IntPtr h, uint flags, StringBuilder sb, ref uint size);
+    [DllImport("kernel32.dll")] static extern bool CloseHandle(IntPtr h);
+    [DllImport("kernel32.dll")] static extern IntPtr CreateToolhelp32Snapshot(uint flags, uint pid);
+    [DllImport("kernel32.dll", CharSet = CharSet.Unicode)] static extern bool Process32FirstW(IntPtr snap, ref PROCESSENTRY32W entry);
+    [DllImport("kernel32.dll", CharSet = CharSet.Unicode)] static extern bool Process32NextW(IntPtr snap, ref PROCESSENTRY32W entry);
+
+    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+    struct PROCESSENTRY32W
+    {
+        public uint dwSize;
+        public uint cntUsage;
+        public uint th32ProcessID;
+        public IntPtr th32DefaultHeapID;
+        public uint th32ModuleID;
+        public uint cntThreads;
+        public uint th32ParentProcessID;
+        public int pcPriClassBase;
+        public uint dwFlags;
+        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)] public string szExeFile;
+    }
+
+    static List<WeaveWindow> Windows()
+    {
+        List<WeaveWindow> list = new List<WeaveWindow>();
+        EnumWindows(delegate(IntPtr h, IntPtr p) {
+            int len = GetWindowTextLengthW(h);
+            if (len == 0 || !IsWindowVisible(h)) return true;
+            StringBuilder sb = new StringBuilder(len + 2);
+            GetWindowTextW(h, sb, sb.Capacity);
+            uint pid;
+            GetWindowThreadProcessId(h, out pid);
+            WeaveWindow w = new WeaveWindow();
+            w.Handle = h;
+            w.Pid = pid;
+            w.Title = sb.ToString();
+            list.Add(w);
+            return true;
+        }, IntPtr.Zero);
+        return list;
+    }
+
+    static string ExeOf(uint pid)
+    {
+        IntPtr h = OpenProcess(0x1000, false, pid);
+        if (h == IntPtr.Zero) return "";
+        try
+        {
+            StringBuilder sb = new StringBuilder(1024);
+            uint size = 1024;
+            if (!QueryFullProcessImageNameW(h, 0, sb, ref size)) return "";
+            string path = sb.ToString();
+            int slash = path.LastIndexOf('\\\\');
+            return (slash >= 0 ? path.Substring(slash + 1) : path).ToLowerInvariant();
+        }
+        finally { CloseHandle(h); }
+    }
+
+    /** pane \u91CC\u7684\u8FDB\u7A0B\u5F80\u4E0A\u627E\u7A97\u53E3\u5BBF\u4E3B\u8FDB\u7A0B\uFF08wt \u4E00\u7A97\u4E00\u8FDB\u7A0B\uFF1Bwezterm \u5168\u7A97\u53E3\u540C\u4E00\u4E2A GUI\uFF0C\u4E0D\u9002\u7528\uFF09\u3002 */
+    public static uint Ancestor(uint pid, string exeLower)
+    {
+        if (exeLower.Length == 0) return 0;
+        Dictionary<uint, uint> parents = new Dictionary<uint, uint>();
+        Dictionary<uint, string> exes = new Dictionary<uint, string>();
+        IntPtr snap = CreateToolhelp32Snapshot(0x2, 0);
+        if (snap == (IntPtr)(-1)) return 0;
+        try
+        {
+            PROCESSENTRY32W entry = new PROCESSENTRY32W();
+            entry.dwSize = (uint)Marshal.SizeOf(typeof(PROCESSENTRY32W));
+            if (Process32FirstW(snap, ref entry))
+            {
+                do {
+                    parents[entry.th32ProcessID] = entry.th32ParentProcessID;
+                    exes[entry.th32ProcessID] = entry.szExeFile == null ? "" : entry.szExeFile.ToLowerInvariant();
+                } while (Process32NextW(snap, ref entry));
+            }
+        }
+        finally { CloseHandle(snap); }
+        uint cur = pid;
+        for (int i = 0; i < 16; i++)
+        {
+            if (!parents.ContainsKey(cur)) return 0;
+            uint parent = parents[cur];
+            if (parent == 0) return 0;
+            string name;
+            exes.TryGetValue(parent, out name);
+            if (name == exeLower) return parent;
+            cur = parent;
+        }
+        return 0;
+    }
+
+    public static List<WeaveWindow> Owned(HashSet<uint> pids, string exeLower)
+    {
+        List<WeaveWindow> list = new List<WeaveWindow>();
+        foreach (WeaveWindow w in Windows())
+        {
+            if (pids.Count > 0 && !pids.Contains(w.Pid)) continue;
+            if (exeLower.Length > 0 && ExeOf(w.Pid) != exeLower) continue;
+            list.Add(w);
+        }
+        return list;
+    }
+
+    /** \u8FD8\u539F\u6700\u5C0F\u5316\u5E76\u62A2\u524D\u53F0\uFF1A\u524D\u53F0\u9501\u8981\u63A5\u5F53\u524D\u524D\u53F0\u7EBF\u7A0B\u7684\u8F93\u5165\u961F\u5217\uFF0C\u63A5\u76EE\u6807\u7A97\u53E3\u7EBF\u7A0B\u624D\u538B\u5F97\u4F4F\u5B83\u4EEC\u7684\u7126\u70B9\u3002 */
+    public static string Raise(long hwnd)
+    {
+        IntPtr h = new IntPtr(hwnd);
+        ShowWindow(h, 9);
+        IntPtr fg = GetForegroundWindow();
+        uint ignored;
+        uint me = GetCurrentThreadId();
+        uint fgThread = GetWindowThreadProcessId(fg, out ignored);
+        uint targetThread = GetWindowThreadProcessId(h, out ignored);
+        bool a = AttachThreadInput(me, fgThread, true);
+        bool b = targetThread != me && AttachThreadInput(me, targetThread, true);
+        if (!SetForegroundWindow(h)) { BringWindowToTop(h); SetFocus(h); }
+        if (b) AttachThreadInput(me, targetThread, false);
+        if (a) AttachThreadInput(me, fgThread, false);
+        return (GetForegroundWindow() == h || !IsIconic(h)) ? "ok" : "nofg";
+    }
+}`;

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

@@ -0,0 +1,73 @@
+import { type WeztermMuxPane } from './wezterm-mux.js';
+/** wt 进程表一行（name 已归一小写）。 */
+export interface WtProcRow {
+    pid: number;
+    parentPid: number;
+    name: string;
+    created: string;
+    cwd: string | null;
+}
+export declare function parseWtProcDump(text: string): WtProcRow[];
+/**
+ * pane 反查（纯函数）：pane 根 = WindowsTerminal 直接子进程里非 OpenConsole
+ * 的那些（shell 启动器 / cmd 包装 / claude 直跑……）。cwd 取「最深 shell 链
+ * 尾」：Git Bash 的 bin/bash 只是启动器（cwd 停在启动目录），真正交互的
+ * usr/bin/bash 是它的子进程；非 shell 根（如 claude）取根自己的 cwd——
+ * 它的工具子进程不是 pane，不该跟。
+ */
+export declare function wtPanes(rows: readonly WtProcRow[]): {
+    pid: number;
+    cwd: string | null;
+}[];
+/** 计数口径：每 pane 一个独立窗口键（wt 归属不到窗口；前端文案「N 个终端
+ * 已打开」对 pane 数成立，窗口级的 wezterm 也落在同一文案下）。 */
+export declare function wtPanesAsWindows(panes: readonly {
+    pid: number;
+    cwd: string | null;
+}[]): WeztermMuxPane[];
+export declare function wtPanesCached(): Promise<{
+    pid: number;
+    cwd: string | null;
+}[]>;
+/**
+ * 项目命名窗口名：路径归一键 → 净化 + 短哈希（同路径稳定；净化后撞名的
+ * 两个目录靠哈希区分）。wt 窗口名在窗口切换器里用户可见，保留可读前缀。
+ */
+export declare function wtWindowSlug(dir: string): string;
+/** 定点目标 id ↔ 命名窗口名；坏 id → null。落点窗口由 dir 重derive（picker
+ * 条目可能陈旧，dir 才是会话真身）。 */
+export declare function parseWtTargetId(id: string): string | null;
+/** wt 的 pane id ↔ 会话进程号；坏 id → null。 */
+export declare function parseWtPaneId(id: string): number | null;
+/**
+ * 上报的 pane env → wt 要打键的那个 pid；不是 wt 会话（缺世界标记或 pid）→ null。
+ * 纯函数：环境判定与取值一处写，投递路径只做存在性校验。
+ */
+export declare function wtPanePidFromEnv(env: Record<string, string>): number | null;
+export declare const BRACKETED_PASTE_START = "\u001B[200~";
+export declare const BRACKETED_PASTE_END = "\u001B[201~";
+/**
+ * wt 的击键通道：**附着到会话进程的 console 写输入记录**（AttachConsole +
+ * WriteConsoleInput）——WT 不给 per-pane 写入口，而它的每个 pane 都是一个
+ * ConPTY，输入记录写进去与真按键等价（实测：ESC/Tab/CR/方向键/文本字节级到达，
+ * 且**不需要窗口在前台**，不抢焦点）。
+ *
+ * 落地方式：daemon 侧没有可直接调 Win32 的运行时，故起一个 PowerShell 把同一段
+ * C# 现编现用（`Add-Type`，~1s；这是每次击键一条的一次性子进程，不进循环）。
+ * 键串与 pid 走 env 传递（键串 base64）——不拼进脚本文本，免引号注入。
+ *
+ * 失败一律 throw（消息/作答转可见失败，不静默丢）——console 附着不上通常意味着
+ * 目标进程已不是那个 pane 的客户端（换了终端/已退出），正是该让用户看见的真相。
+ */
+export declare function wtInjectKeys(pid: number, keys: string): Promise<void>;
+/** PowerShell 脚本（base64/UTF-16，`-EncodedCommand` 免引号转义）；纯函数，单测覆盖。 */
+export declare function wtInjectEncodedScript(): string;
+/**
+ * Konsole（KDE，Linux）：每个会话自带一条 D-Bus 路径（`KONSOLE_DBUS_SERVICE` +
+ * `KONSOLE_DBUS_SESSION`，hook 子进程天然继承），会话对象自己就有 `sendText`
+ * 与 `sendKey`——不抢焦点、不依赖窗口在前台，与 wt 那条 console 通道同级别。
+ * pane id = `konsole:<服务名>|<会话路径>`。
+ *
+ * **本机（Windows）无法实机验证**：按 Konsole 公开的 D-Bus 接口写（见
+ * docs/DECISIONS.md），调用失败一律抛真相，不静默降级成「送到了」。
+ */