@weavecode/weave 0.0.0-stage → 0.1.0

package/node_modules/@weavecode/server/dist/hooks/handlers/webhook.d.ts

@@ -0,0 +1,26 @@
+import type { HookRule } from '@weavecode/core';
+/** 事件摘要——出站 webhook body 只带这些字段（不透传全量 toolResponse，收窄外泄面）。 */
+export interface EventSummary {
+    ruleId: string;
+    ruleName: string;
+    projectId: number;
+    sessionId: string | null;
+    event: string;
+    toolName: string | null;
+    /** toolInput.file_path（若事件携带）。 */
+    filePath: string | null;
+    cwd: string | null;
+    at: string;
+}
+export interface WebhookResult {
+    ok: boolean;
+    status: 'succeeded' | 'failed' | 'timeout';
+    output?: string;
+    error?: string;
+}
+/**
+ * 出站 webhook 处理器：POST 事件摘要到外部系统。
+ * 边界：仅 http/https、5s 超时、响应体截断 4KB、可选 HMAC-SHA256 签名头
+ * `X-Weave-Signature: sha256=<hex>`（secret 即签名密钥）。
+ */
+export declare function runWebhook(rule: HookRule, summary: EventSummary, fetchImpl?: typeof fetch): Promise<WebhookResult>;

package/node_modules/@weavecode/server/dist/hooks/handlers/webhook.js

@@ -0,0 +1 @@
+import{createHmac as l}from"node:crypto";const u=5e3,d=4096;export async function runWebhook(a,i,c=fetch){const e=a.handler;if(e.type!=="webhook")return{ok:!1,status:"failed",error:`rule ${a.id} is not a webhook handler`};let r;try{r=new URL(e.url)}catch{return{ok:!1,status:"failed",error:`invalid url: ${e.url}`}}if(r.protocol!=="http:"&&r.protocol!=="https:")return{ok:!1,status:"failed",error:`unsupported protocol: ${r.protocol}`};const s=JSON.stringify(i),n={"content-type":"application/json","user-agent":"weave-daemon",...e.headers??{}};e.secret&&(n["x-weave-signature"]=`sha256=${l("sha256",e.secret).update(s).digest("hex")}`);try{const t=await c(r,{method:"POST",headers:n,body:s,signal:AbortSignal.timeout(u)}),o=(await t.text()).slice(0,d);return t.ok?{ok:!0,status:"succeeded",output:o||`HTTP ${t.status}`}:{ok:!1,status:"failed",error:`HTTP ${t.status}`,output:o}}catch(t){const o=t instanceof Error&&(t.name==="TimeoutError"||t.name==="AbortError");return{ok:!1,status:o?"timeout":"failed",error:o?`webhook timed out after ${u}ms`:String(t)}}}

package/node_modules/@weavecode/server/dist/hooks/headless-runner.d.ts

@@ -0,0 +1,91 @@
+import { type SpawnOptions } from 'node:child_process';
+import type { ResumeCommandSpec } from '@weavecode/harness';
+/**
+ * 无头回合执行核心（session-orchestration 批 1 自 resume-runner 抽出）：
+ * spawn `spec.args(sessionId, prompt)`、输出收集、超时强杀、**跨域共享的同会话
+ * 并发闸**——指令池派发（ResumeRunner）与点对点消息（MessageDeliverer）用同一
+ * 实例，两个 claude --resume 进程绝不落在同一会话上。
+ *
+ * run() 同步返回（「已启动」语义）；等待退出、超时、onSettle 回调全走后台，
+ * 任何异常内部消化为 failed 终态，绝不 throw。
+ */
+/** 子进程句柄的最小结构：真实 ChildProcess 与测试的 EventEmitter fake 都满足。 */
+export interface SpawnChild {
+    pid?: number;
+    /** listener 用 `(...args: never[]) => void`：never 可赋给任意具体参数类型，
+     *  调用方得以直接写 `(code: number | null) => …` 而无需类型断言。 */
+    on(event: string, listener: (...args: never[]) => void): unknown;
+    stdin?: {
+        on(event: string, listener: (...args: never[]) => void): unknown;
+        write(chunk: string): unknown;
+        end(): unknown;
+    } | null;
+    stdout?: {
+        on(event: string, listener: (...args: never[]) => void): unknown;
+    } | null;
+    stderr?: {
+        on(event: string, listener: (...args: never[]) => void): unknown;
+    } | null;
+}
+/** 测试注入的 spawn 签名；缺省用 node:child_process.spawn。 */
+export type SpawnLike = (command: string, args: readonly string[], options: SpawnOptions) => SpawnChild;
+export interface HeadlessSettleResult {
+    status: 'succeeded' | 'failed' | 'timeout';
+    output: string | null;
+    error: string | null;
+}
+export interface HeadlessRunInput {
+    sessionId: string;
+    cwd: string;
+    prompt: string;
+    spec: ResumeCommandSpec;
+    bin: string;
+    /** 单次超时（毫秒），超时强杀 → timeout；**0 = 不设看门狗**（投递等待发生在
+     *  目标会话内的场景，如 prompt 中继——设上限只会把正常投递误判成 timeout）。 */
+    timeoutMs?: number;
+    /**
+     * 是否自成进程组（POSIX `detached`）。缺省 true——headless 回合跑得长、可整组
+     * 强杀。**中继传 false**：它是本轮次的一次性子进程，应当跟 daemon 同进程组、
+     * 随 daemon 退出被回收，不留独立进程占资源。win32 shell 模式恒 false（实测
+     * shell+detached 管道输出全丢）。
+     */
+    detached?: boolean;
+    onSettle: (result: HeadlessSettleResult) => void;
+}
+export interface HeadlessRunnerDeps {
+    /** 测试注入的 spawn 实现；缺省用 node:child_process.spawn。 */
+    spawnImpl?: SpawnLike;
+    /** 测试注入的强杀实现（缺省：Windows 下 taskkill，POSIX 杀进程组）。 */
+    killImpl?: (pid: number) => void;
+}
+export declare class HeadlessRunner {
+    private readonly spawnImpl;
+    private readonly killImpl;
+    /** sessionId → 进行中的回合（并发闸）；终态落定后清除。 */
+    private readonly active;
+    /** sessionId → 在飞子进程 pid（daemon 退出时统一回收；终态/退出后清除）。 */
+    private readonly livePids;
+    constructor(deps?: HeadlessRunnerDeps);
+    /** 该会话是否已有无头回合在跑（跨 dispatch/message 域共享）。 */
+    isBusy(sessionId: string): boolean;
+    /**
+     * 回收全部在飞子进程（daemon 退出时调用）：这些进程是 daemon 的子进程，
+     * 不该比 daemon 活得久。win32 → taskkill /T /F（整棵进程树）；POSIX →
+     * 先杀进程组（detached 子进程自成组）再回退单进程（非 detached 的子进程，
+     * 如中继）——三平台同一入口，无平台分支。返回强杀尝试数。
+     */
+    killAll(): number;
+    /**
+     * 启动一次无头回合：同会话已占用返回 false（调用方映射 409）。
+     * 通过后立即返回 true；终态经 onSettle 后台送达。
+     */
+    run(input: HeadlessRunInput): boolean;
+    /** spawn 并挂上输出收集 / 退出 / 超时监听；同步完成，不等待退出。 */
+    private watch;
+    /** 终态落定（**按次**幂等）：守卫是本次 run 的 state 标志而非共享闸——同会话
+     * 前一回合的迟到事件不得吞掉后一回合的 settle。清闸 → 回调 onSettle；回调
+     * 异常只吞（后台回调不冒泡）。 */
+    private settle;
+}
+/** 默认强杀：Windows 用 taskkill 杀进程树；POSIX 杀 detached 进程组，失败回退单进程。 */
+export declare function defaultKill(pid: number): void;

package/node_modules/@weavecode/server/dist/hooks/headless-runner.js

@@ -0,0 +1,2 @@
+import{spawn as k}from"node:child_process";const L=3e5,y=32*1024,E=2e3;export class HeadlessRunner{spawnImpl;killImpl;active=new Set;livePids=new Map;constructor(t={}){this.spawnImpl=t.spawnImpl??k,this.killImpl=t.killImpl??defaultKill}isBusy(t){return this.active.has(t)}killAll(){let t=0;for(const s of this.livePids.values())try{this.killImpl(s),t++}catch{}return this.livePids.clear(),t}run(t){if(this.active.has(t.sessionId))return!1;this.active.add(t.sessionId);const s={settled:!1};try{this.watch(t,s)}catch(n){this.settle(t,s,{status:"failed",output:null,error:P(n)})}return!0}watch(t,s){const n=t.timeoutMs??L,a=t.spec.promptStdin===!0,f=t.spec.args(t.sessionId,a?"":t.prompt),d=a&&process.platform==="win32"&&!/[\s"\\/]/.test(t.bin),T=(t.detached??!0)&&!d,m={cwd:t.cwd,detached:T,windowsHide:!0,shell:d,stdio:[a?"pipe":"ignore","pipe","pipe"],env:(()=>{const e={...process.env,WEAVE_HOOK_DISPATCH:"1"};return delete e.CLAUDE_CODE_CHILD_SESSION,e})()},i=d?this.spawnImpl([t.bin,...f].join(" "),[],m):this.spawnImpl(t.bin,f,m);if(i.pid!==void 0&&this.livePids.set(t.sessionId,i.pid),a){i.stdin?.on("error",()=>{});try{i.stdin?.write(t.prompt),i.stdin?.end()}catch{}}const I=[],p=[];let w=0,v=0;const S=(e,o,l)=>{if(o>=y)return o;const c=y-o;return e.push(l.length>c?l.subarray(0,c):l),o+Math.min(l.length,c)},h=()=>Buffer.concat([...I,...p]).toString("utf8"),H=()=>{const e=Buffer.concat(p).toString("utf8");return e.length>E?e.slice(-E):e};i.stdout?.on("data",e=>{w=S(I,w,e)}),i.stderr?.on("data",e=>{v=S(p,v,e)});const u=n>0?setTimeout(()=>{if(i.pid!==void 0)try{this.killImpl(i.pid)}catch{}this.settle(t,s,{status:"timeout",output:h(),error:`Timeout after ${n}ms`})},n):null;i.on("error",e=>{u!==null&&clearTimeout(u),this.settle(t,s,{status:"failed",output:h(),error:P(e)})}),i.on("exit",(e,o)=>{u!==null&&clearTimeout(u);const l=h();if(e===0){this.settle(t,s,{status:"succeeded",output:l,error:null});return}const c=e!==null?`exit ${e}`:`exit signal ${o??"unknown"}`,g=H();this.settle(t,s,{status:"failed",output:l,error:g?`${c}
+${g}`:c})})}settle(t,s,n){if(!s.settled){s.settled=!0,this.active.delete(t.sessionId),this.livePids.delete(t.sessionId);try{t.onSettle(n)}catch{}}}}export function defaultKill(r){if(process.platform==="win32"){try{k("taskkill",["/PID",String(r),"/T","/F"],{windowsHide:!0,stdio:"ignore"}).on("error",()=>{})}catch{}return}try{process.kill(-r,"SIGKILL")}catch{try{process.kill(r,"SIGKILL")}catch{}}}function P(r){return r instanceof Error?r.message:String(r)}

package/node_modules/@weavecode/server/dist/hooks/inbox-socket.d.ts

@@ -0,0 +1,39 @@
+import type { PromptInboxSpec } from '@weavecode/harness';
+/**
+ * 会话本地收件箱「通用传输」：连上 harness 给的地址 → 写 harness 组好的帧 → 关。
+ *
+ * **协议不在本模块**：帧格式、键名、平台认证要求全归 harness 的 `PromptInboxSpec`
+ * （claude 的 inbox socket 规格见 weave-harness/src/claude/prompt-inbox.ts）——本模块
+ * 只做「连、写、关、超时」这类与 harness 无关的机械动作，其他 harness 有同类机制时
+ * 只需声明自己的 spec。
+ *
+ * 成功 = 已写进地址并关闭连接（**不等于**对方已读：接收侧可能 Held/Refused）。
+ * 失败（连不上/超时/该平台缺凭据）→ reject，调用方回落中继/终端/队列。
+ */
+export interface InboxTarget {
+    /** 会话自己的直投地址（hook 旁路上报；`uds:` 前缀可有可无）。 */
+    socket: string;
+    /** 会话自己的凭据（无 = null，能否投由 spec 的平台要求决定）。 */
+    token: string | null;
+}
+export interface InboxDeliveryOptions {
+    /** 连接 + 写入总超时；缺省 3000ms（接收侧自有关闭上限 30s，我们更严，防挂死）。 */
+    timeoutMs?: number;
+    platform?: string;
+}
+/** `/status` 的 Peer address 带 `uds:` 前缀；env 里不带。两种都接受。 */
+export declare function inboxSocketPathOf(socket: string): string;
+export declare function deliverViaInboxSocket(spec: PromptInboxSpec, target: InboxTarget, text: string, options?: InboxDeliveryOptions): Promise<void>;
+/**
+ * sessionId → 该会话的 inbox 目标（内存态，**凭据不落库、不进 UI、不写日志**）：
+ * 由 hook 事件旁路上报（hook 进程是会话自己的 child，继承会话导出的 env）。
+ * 凭据**每会话进程一份**（resume 后 socket 名重生成、旧值即废），所以不持久化；
+ * 会话删除/归档时 forget。
+ */
+export declare class InboxSocketRegistry {
+    private readonly bySession;
+    /** 上报/刷新（hook 每次事件都会带，覆盖写即最新）。socket 为空 = 该会话没有可用 inbox。 */
+    set(sessionId: string, target: InboxTarget | null): void;
+    get(sessionId: string): InboxTarget | undefined;
+    forget(sessionId: string): void;
+}

package/node_modules/@weavecode/server/dist/hooks/inbox-socket.js

@@ -0,0 +1 @@
+import k from"node:net";export function inboxSocketPathOf(o){return o.startsWith("uds:")?o.slice(4):o}export function deliverViaInboxSocket(o,e,r,c={}){const u=c.platform??process.platform,m=c.timeoutMs??3e3,l=inboxSocketPathOf(e.socket);return o.requiresAuthOn(u)&&!e.token?Promise.reject(new Error(`inbox delivery requires a token on platform "${u}"`)):new Promise((a,b)=>{const f=o.frame({token:e.token,text:r});let n=!1;const i=s=>{n||(n=!0,t.destroy(),b(s))},t=k.connect(l);t.setTimeout(m),t.on("timeout",()=>i(new Error(`inbox socket timeout after ${m}ms`))),t.on("error",s=>i(s)),t.on("connect",()=>{t.write(f,s=>{s?i(s):t.end()})}),t.on("close",()=>{n||(n=!0,a())})})}export class InboxSocketRegistry{bySession=new Map;set(e,r){r?.socket?this.bySession.set(e,r):this.bySession.delete(e)}get(e){return this.bySession.get(e)}forget(e){this.bySession.delete(e)}}

package/node_modules/@weavecode/server/dist/hooks/inbox-worker.d.ts

@@ -0,0 +1,113 @@
+import { Worker } from 'node:worker_threads';
+import { type EventSource } from '@weavecode/harness';
+import { HookEventRepository, type HookEventInput } from '../repositories/hook-events.js';
+import { ProjectRepository } from '../repositories/projects.js';
+import { SessionRepository } from '../repositories/sessions.js';
+import type { HookEventBus } from './bus.js';
+import type { HookDispatcher } from './dispatcher.js';
+import type { WatchEngine } from './watch-engine.js';
+import type { SequenceEngine } from './sequence-engine.js';
+import type { MessageDeliverer } from './message-deliverer.js';
+import type { QuestionTracker } from './question-tracker.js';
+/**
+ * inbox 消费线程（hook 文件化管道的 daemon 侧）：hook-handler.cjs 把事件追加到
+ * `<dataDir>/hooks/inbox/<shard>.jsonl`（行形 `{v, token, report}`，纯传输缓冲、
+ * 入库即删）；本模块在 worker_threads 里认领→入库，主线程收 postMessage 后补
+ * SSE/dispatcher/outbox。
+ *
+ * 竞争协议（复用 spool 的 rename-claim）：rename 原子先到先得，输家 ENOENT 空手；
+ * 崩在半途留下 `.claim.jsonl` 下轮先清。入库失败的行留盘重试，连续失败 parked
+ * 为 `.failed.jsonl` 防毒丸热循环。行内 token 解析项目（项目已删 → 丢行，同
+ * 旧 /hooks 401 语义；归档项目同样丢行——server 不消费，行即焚）；不可归因
+ * 的坏行直接丢（重试无意义）。
+ */
+export declare const INBOX_TICK_MS = 200;
+export declare const INBOX_CLAIM_SUFFIX = ".claim.jsonl";
+export declare const INBOX_FAILED_SUFFIX = ".failed.jsonl";
+/** worker → 主线程的入库记录（结构化克隆友好，全是 plain JSON）。 */
+export interface InboxRecord {
+    eventId: number;
+    projectId: number;
+    input: HookEventInput;
+    /** hook-handler 的改名交付回执（未下发 = null）——透传 dispatcher 落定 pending。 */
+    deliveredTitle?: string | null;
+    /**
+     * 该会话的 inbox 直投凭据（hook 进程是会话自己的 child，继承这两个 env）。
+     * **旁路字段：不进 payload、不落库**——主线程只放内存供 layer① 直投用。
+     */
+    messaging?: {
+        socket: string;
+        token: string | null;
+    } | null;
+    /**
+     * 该会话所在终端 pane 的定位 env（hook 进程生在会话自己的 pane 里）。
+     * **逐行字段**（同一 claim 里不同会话的 pane 不同，不能像 messaging 那样取整组
+     * 最后一个——错配会把键序打进别的会话的模态框）；同样不进 payload、不落库。
+     */
+    terminalEnv?: Record<string, string> | null;
+}
+export interface InboxDrainDeps {
+    hooksDir: string;
+    projects: Pick<ProjectRepository, 'getByToken'>;
+    hookEvents: HookEventRepository;
+    hookSessions: SessionRepository;
+    adapters: readonly EventSource[];
+}
+/**
+ * 一轮消费，两阶段（顺序是安全前提）：
+ * ① 先清所有残留 claim（上轮崩在半途的）；② 再把活文件 rename 认领、逐个消费。
+ * 先 ① 后 ② 保证 rename 不会覆盖尚未消费的 claim（rename 在 POSIX 下静默覆盖
+ * ＝丢数据）；认领失败的（另一进程先到 / 文件被删）本轮跳过。
+ */
+export declare function drainInboxOnce(deps: InboxDrainDeps, attempts?: Map<string, number>): InboxRecord[];
+/**
+ * 停放文件复活（启动时一次）：`.failed.jsonl` 是「连续失败达上限」的保护区，
+ * 停在盘上等人工处理。但多数失败是瞬时争用（多写者/重建 WAL）——进程重启后
+ * 给它新一轮机会：rename 成 claim，消费线程第一阶段就会先消费它；再失败会重新
+ * 停放，不会热循环。
+ */
+export declare function unparkFailedInbox(hooksDir: string): number;
+export interface IngestedHandlerDeps {
+    projects: Pick<ProjectRepository, 'getById'>;
+    hooksDir: string;
+    bus?: HookEventBus;
+    dispatcher?: HookDispatcher;
+    /** 空闲订阅引擎（session-orchestration 批 2）：见目标会话的 idleSignals 即 fire。 */
+    watchEngine?: Pick<WatchEngine, 'onEvent'>;
+    /** 序列引擎（批 3）：inject 步的完成判据 = 目标 idleSignals 事件。 */
+    sequenceEngine?: Pick<SequenceEngine, 'onEvent'>;
+    /** prompt 队列冲洗 + inbox 直投凭据上报 + 投递回执（消息域重塑）；缺省功能降级。 */
+    messagePipe?: Pick<MessageDeliverer, 'hasQueued' | 'flushSession'> & {
+        /** hook 旁路上报的会话 inbox 目标（内存态）。 */
+        noteInboxSocket?(sessionId: string, target: {
+            socket: string;
+            token: string | null;
+        } | null): void;
+        /** hook 旁路上报的会话 pane 定位 env（内存态；层② 精确定位用）。 */
+        notePaneEnv?(sessionId: string, env: Record<string, string>): void;
+        /** UPS 事件 = 投递回执判据（prompt 原文与在途条目匹配）。 */
+        onSessionPrompt?(sessionId: string, prompt: string): void;
+    };
+    /** 阻塞式问答跟踪（toolName 不进帧域，挂点在此）；缺省不跟踪。 */
+    questionTracker?: Pick<QuestionTracker, 'onEvent'>;
+    /** 会话转录路径上报（中断态探测用；转录路径在 payload 里，帧域不带）。 */
+    sessionProbe?: {
+        noteTranscript(sessionId: string, path: string | null): void;
+    };
+}
+/**
+ * worker 入库记录的主线程消费：每条补发 `event.ingested` SSE（任务面板实时），
+ * 再进 dispatcher（manual/webhook/log/plugin、会话标题双向）与 watch 引擎
+ * （空闲订阅触发，消息域与规则域平行），插件注入产出写 outbox 顺延给下一次 hook 事件。
+ */
+export declare function handleIngestedRecords(deps: IngestedHandlerDeps, records: InboxRecord[]): void;
+export interface InboxWorkerOptions {
+    dbPath: string;
+    hooksDir: string;
+    tickMs?: number;
+}
+/**
+ * 起 inbox 消费线程。自举 URL 即本文件（tsx 直跑 .ts、tsc 产物跑 .js 都成立；
+ * daemon 由 `node --import tsx` 起，worker 继承 execArgv 获得同样的 TS 能力）。
+ */
+export declare function startInboxWorker(opts: InboxWorkerOptions): Worker;

package/node_modules/@weavecode/server/dist/hooks/inbox-worker.js

@@ -0,0 +1,4 @@
+import{existsSync as h,readdirSync as g,readFileSync as k,renameSync as f,unlinkSync as j,writeFileSync as S}from"node:fs";import{join as u}from"node:path";import{isMainThread as b,parentPort as T,Worker as w,workerData as I}from"node:worker_threads";import{createRuntimeRegistry as x,frameFacts as E}from"@weavecode/harness";import{openDatabase as P}from"../db/db.js";import{HookEventRepository as M}from"../repositories/hook-events.js";import{ProjectRepository as O}from"../repositories/projects.js";import{SessionRepository as W}from"../repositories/sessions.js";import{appendOutbox as D}from"./mirror.js";export const INBOX_TICK_MS=200,INBOX_CLAIM_SUFFIX=".claim.jsonl",INBOX_FAILED_SUFFIX=".failed.jsonl";const F=5;export function drainInboxOnce(t,n=new Map){const e=u(t.hooksDir,"inbox");let o;try{o=g(e)}catch{return[]}const i=[];for(const p of o)p.endsWith(INBOX_FAILED_SUFFIX)||p.endsWith(".tmp")||p.endsWith(INBOX_CLAIM_SUFFIX)||p.endsWith(".jsonl")&&i.push(p);const s=[];for(const p of o)p.endsWith(INBOX_CLAIM_SUFFIX)&&s.push(...y(t,u(e,p),n));for(const p of i){const l=u(e,`${p.slice(0,-6)}${INBOX_CLAIM_SUFFIX}`);if(!h(l)){try{f(u(e,p),l)}catch{continue}s.push(...y(t,l,n))}}return s}function y(t,n,e){let o;try{o=k(n,"utf8").split(`
+`)}catch{return[]}const i=new Map;for(const c of o){const d=c.trim();if(!d)continue;const r=_(d);if(!r)continue;const a=i.get(r.token)??{lines:[],inputs:[],delivered:[],terminals:[],messaging:null};if(r.messaging&&(a.messaging=r.messaging),a.lines.push(d),a.project||(a.project=t.projects.getByToken(r.token),i.set(r.token,a)),!a.project||a.project.archivedAt)continue;const m=r.report&&typeof r.report=="object"?t.adapters.find(v=>v.source===r.report.source):void 0;if(!(!m||!r.report.eventType))try{a.inputs.push(m.normalize(r.report,a.project.id)),a.delivered.push(r.report.deliveredTitle??null),a.terminals.push(r.terminalEnv)}catch{}}const s=[],p=[];for(const c of i.values())if(!(!c.project||c.inputs.length===0))try{const d=R(t,c.project,c.inputs);for(let r=0;r<c.inputs.length;r++)s.push({eventId:d[r],projectId:c.project.id,input:c.inputs[r],deliveredTitle:c.delivered[r]??null,messaging:c.messaging,terminalEnv:c.terminals[r]??null})}catch{p.push(...c.lines)}if(p.length===0){e.delete(n);try{j(n)}catch{}return s}const l=(e.get(n)??0)+1;if(e.set(n,l),l>=F){e.delete(n);try{f(n,n.replace(INBOX_CLAIM_SUFFIX,INBOX_FAILED_SUFFIX))}catch{}return s}try{S(n,p.join(`
+`)+`
+`)}catch{}return s}function R(t,n,e){const o=t.hookEvents.insertMany(e),i=new Set;for(const s of e)s.sessionId&&!i.has(s.sessionId)&&(i.add(s.sessionId),B(t.hookSessions,s.sessionId,e)&&t.hookSessions.touch(s.sessionId,n.id));return o}function B(t,n,e){return t.getBySessionId(n)?!0:e.some(o=>o.sessionId===n&&o.eventType!=="SessionStart")}function _(t){try{const n=JSON.parse(t);if(!n||typeof n.token!="string"||!n.token||!n.report||typeof n.report!="object")return null;const e=n.messaging?.socket,o=typeof e=="string"&&e?{socket:e,token:typeof n.messaging?.token=="string"?n.messaging.token:null}:null;return{token:n.token,report:n.report,messaging:o,terminalEnv:N(n.terminal)}}catch{return null}}function N(t){if(typeof t!="object"||t===null)return null;const n={};for(const[e,o]of Object.entries(t))typeof o=="string"&&o&&(n[e]=o);return Object.keys(n).length>0?n:null}export function unparkFailedInbox(t){const n=u(t,"inbox");let e;try{e=g(n)}catch{return 0}let o=0;for(const i of e){if(!i.endsWith(INBOX_FAILED_SUFFIX))continue;const s=u(n,`${i.slice(0,-INBOX_FAILED_SUFFIX.length)}${INBOX_CLAIM_SUFFIX}`);if(!h(s))try{f(u(n,i),s),o++}catch{}}return o}export function handleIngestedRecords(t,n){for(const e of n){const o=t.projects.getById(e.projectId);if(!o)continue;let i=null;try{i=JSON.parse(e.input.payload)}catch{i=null}if(t.bus?.emit({kind:"event.ingested",eventId:e.eventId,projectId:o.id,sessionId:e.input.sessionId??null,eventType:e.input.eventType,...E(i),at:new Date().toISOString()}),e.input.sessionId){if(t.questionTracker?.onEvent({sessionId:e.input.sessionId,source:e.input.source,payload:i}),t.watchEngine?.onEvent({sessionId:e.input.sessionId,eventType:e.input.eventType,source:e.input.source}),t.sequenceEngine?.onEvent({sessionId:e.input.sessionId,eventType:e.input.eventType,source:e.input.source}),e.messaging&&t.messagePipe?.noteInboxSocket?.(e.input.sessionId,e.messaging),t.sessionProbe?.noteTranscript(e.input.sessionId,i?.transcriptPath??null),e.terminalEnv&&t.messagePipe?.notePaneEnv?.(e.input.sessionId,e.terminalEnv),e.input.eventType==="UserPromptSubmit"){const s=X(i);s&&t.messagePipe?.onSessionPrompt?.(e.input.sessionId,s)}t.messagePipe?.hasQueued(e.input.sessionId)&&t.messagePipe.flushSession(e.input.sessionId)}t.dispatcher&&t.dispatcher.onIngest({eventId:e.eventId,project:o,sessionId:e.input.sessionId??null,payload:i??{eventType:e.input.eventType,toolName:null,toolInput:null,toolResponse:null,cwd:null,transcriptPath:null,raw:null},source:e.input.source,deliveredTitle:e.deliveredTitle??null}).then(s=>{s.deferred&&e.input.sessionId&&D(t.hooksDir,o.token,[{sessionId:e.input.sessionId,text:s.deferred}])}).catch(()=>{})}}function X(t){const n=t?.raw;return typeof n?.prompt=="string"&&n.prompt?n.prompt:null}export function startInboxWorker(t){return new w(new URL(import.meta.url),{workerData:{inboxWorker:!0,...t}})}if(!b&&I?.inboxWorker===!0){const t=I,n=P(t.dbPath),e={hooksDir:t.hooksDir,projects:new O(n),hookEvents:new M(n),hookSessions:new W(n),adapters:x().byCapability("events").flatMap(s=>s.events??[])},o=new Map,i=()=>{try{const s=drainInboxOnce(e,o);s.length>0&&T?.postMessage(s)}catch(s){console.error("[weave] inbox drain failed:",s)}};i(),setInterval(i,t.tickMs??INBOX_TICK_MS)}

package/node_modules/@weavecode/server/dist/hooks/match.d.ts

@@ -0,0 +1,37 @@
+/** 注入指令的防递归标记：inject/manual 渲染的指令携带它，采集侧据此跳过自动规则。 */
+export declare const DISPATCH_MARKER = "<!--weave-dispatch-->";
+/** 反斜杠归一为 posix（Windows 的 file_path 是原生分隔符）。 */
+export declare function normalizePosix(p: string): string;
+/**
+ * glob 编译为 RegExp：双星号+分隔符匹配任意层前缀、双星号匹配任意段、
+ * 星号匹配单段内、问号匹配单字符。大小写不敏感（Windows 路径）。
+ */
+export declare function globToRegex(glob: string): RegExp;
+/** file_path 与 glob 匹配（两侧都归一为 posix）。 */
+export declare function matchGlob(filePath: string, glob: string): boolean;
+/** 从 toolInput 提取文件路径（Write/Edit 的 file_path、NotebookEdit 的 notebook_path）。 */
+export declare function extractFilePath(toolInput: unknown): string | null;
+/**
+ * 多项目交互判定：target 落在**其他**已注册项目根下（而非当前项目自身）。
+ * currentPath 排除自身；无命中返回 false。
+ */
+export declare function isCrossProjectPath(target: string, currentPath: string, otherProjectPaths: string[]): boolean;
+/**
+ * 渲染指令模板：`{event}` `{tool}` `{file}` `{cwd}` `{session}` `{project}` `{rule}`
+ * 未知占位原样保留（缺参可见，不渲染 undefined）。
+ */
+export declare function renderTemplate(template: string, vars: Record<string, string | null | undefined>): string;
+/** 事件 → 模板变量。 */
+export declare function templateVars(input: {
+    event: string;
+    tool: string | null;
+    filePath: string | null;
+    cwd: string | null;
+    session: string | null;
+    project: string;
+    rule: string;
+}): Record<string, string | null>;
+/** toolInput.file_path 是否落在任一 glob（posix 归一后比较）。 */
+export declare function matchesAnyGlob(filePath: string, globs: string[]): boolean;
+/** 项目根 basename（会话/指令里展示用）。 */
+export declare function projectLabel(projectPath: string): string;

package/node_modules/@weavecode/server/dist/hooks/match.js

@@ -0,0 +1 @@
+import i from"node:path";export const DISPATCH_MARKER="<!--weave-dispatch-->";const c=t=>process.platform==="win32"?t.toLowerCase():t;export function normalizePosix(t){return t.replace(/\\/g,"/")}function p(t){return/[.+^${}()|[\]\\]/.test(t)?`\\${t}`:t}const s=new Map;export function globToRegex(t){const o=s.get(t);if(o)return o;let n="";for(let r=0;r<t.length;r++){const l=t[r];l==="*"?t[r+1]==="*"?(r++,t[r+1]==="/"?(r++,n+="(?:.*/)?"):n+=".*"):n+="[^/]*":l==="?"?n+="[^/]":n+=p(l)}const e=new RegExp(`^${n}$`,"i");return s.set(t,e),e}export function matchGlob(t,o){return globToRegex(o).test(normalizePosix(t))}export function extractFilePath(t){if(typeof t!="object"||t===null)return null;const o=t;for(const n of["file_path","notebook_path","filePath"]){const e=o[n];if(typeof e=="string"&&e.length>0)return e}return null}function u(t,o){const n=c(normalizePosix(t)),e=c(normalizePosix(o).replace(/\/+$/,""));return n===e||n.startsWith(`${e}/`)}export function isCrossProjectPath(t,o,n){const e=c(normalizePosix(o));return u(t,o)?!1:n.some(r=>c(normalizePosix(r))!==e&&u(t,r))}export function renderTemplate(t,o){return t.replace(/\{(\w+)\}/g,(n,e)=>{const r=o[e];return r==null?n:String(r)})}export function templateVars(t){return{event:t.event,tool:t.tool,file:t.filePath?normalizePosix(t.filePath):null,cwd:t.cwd?normalizePosix(t.cwd):null,session:t.session,project:t.project,rule:t.rule}}export function matchesAnyGlob(t,o){return o.some(n=>matchGlob(t,n))}export function projectLabel(t){return i.basename(normalizePosix(t).replace(/\/+$/,""))||t}