mulmoclaude 0.6.2 → 0.6.3

package/server/system/optionalDeps.ts

@@ -0,0 +1,129 @@
+// Optional host-binary registry + graceful-degradation probe (#1385).
+//
+// A missing optional binary must never crash the app: the feature
+// that needs it disables itself, the user is warned once, and the
+// rest keeps working. This module centralises the "is <binary>
+// available?" question so we don't re-implement the lazy-cached
+// probe per dependency (docker's ad-hoc check was the only one
+// before this).
+
+import which from "which";
+import { isDockerLive } from "./docker.js";
+
+/** A single optional host dependency the app can run without. */
+export interface OptionalDep {
+  /** Stable id used by `depStatus()` lookups and notification ids. */
+  readonly id: string;
+  /** Binary name passed to `which` for the default presence probe. */
+  readonly command: string;
+  /** i18n key fragment naming what stops working when absent. */
+  readonly enables: string;
+  /** Override when "on PATH" is insufficient (e.g. docker client
+   *  exists but the daemon is down). Returning false means the
+   *  dependency is treated as unavailable even if `which` found it. */
+  readonly probe?: () => Promise<boolean>;
+}
+
+export type DepReason = "ok" | "not-on-path" | "probe-failed";
+
+export interface DepStatus {
+  readonly id: string;
+  readonly available: boolean;
+  readonly reason: DepReason;
+}
+
+const REGISTRY: readonly OptionalDep[] = [
+  { id: "docker", command: "docker", enables: "dockerSandbox", probe: isDockerLive },
+  { id: "ffmpeg", command: "ffmpeg", enables: "mulmocast" },
+];
+
+async function onPath(command: string): Promise<boolean> {
+  try {
+    const resolved = await which(command, { nothrow: true });
+    return resolved !== null;
+  } catch {
+    // `which` shouldn't throw with nothrow, but a corrupt PATH or
+    // an fs error must degrade to "absent", never bubble up.
+    return false;
+  }
+}
+
+// Never throws — a missing optional dep degrades, it does not crash
+// startup. A throwing PATH check or liveness `probe` is treated as
+// "unavailable" rather than propagating into the boot sequence.
+// `pathCheck` is injectable so unit tests exercise the reason
+// mapping + override precedence without depending on the host's
+// real PATH.
+export async function probeOne(dep: OptionalDep, pathCheck: (command: string) => Promise<boolean> = onPath): Promise<DepStatus> {
+  try {
+    if (!(await pathCheck(dep.command))) {
+      return { id: dep.id, available: false, reason: "not-on-path" };
+    }
+    if (dep.probe && !(await dep.probe())) {
+      return { id: dep.id, available: false, reason: "probe-failed" };
+    }
+    return { id: dep.id, available: true, reason: "ok" };
+  } catch {
+    return { id: dep.id, available: false, reason: "probe-failed" };
+  }
+}
+
+let cache: Record<string, DepStatus> | null = null;
+let inFlight: Promise<Record<string, DepStatus>> | null = null;
+
+/** Probe every registered dependency in parallel. Cached for the
+ *  process lifetime; concurrent callers share one in-flight run so
+ *  `which` / the daemon probe fire once each. */
+export async function probeOptionalDeps(): Promise<Record<string, DepStatus>> {
+  if (cache) return cache;
+  if (inFlight) return inFlight;
+  inFlight = (async () => {
+    try {
+      const statuses = await Promise.all(REGISTRY.map((dep) => probeOne(dep)));
+      cache = Object.fromEntries(statuses.map((status) => [status.id, status]));
+      return cache;
+    } catch {
+      // probeOne never rejects, so this is unreachable in practice —
+      // but if it ever did, returning an empty map keeps boot alive
+      // (callers treat "no status" as "assume available"). Do NOT
+      // poison `cache` so a later call can retry.
+      return {};
+    } finally {
+      // Always clear so a rejected/failed run can't permanently
+      // poison the cache (Codex review).
+      inFlight = null;
+    }
+  })();
+  return inFlight;
+}
+
+/** Synchronous read of a previously-probed dependency. Returns
+ *  undefined if `probeOptionalDeps()` has not completed yet — callers
+ *  on the request path should treat that as "assume available" so a
+ *  not-yet-probed boot window never blocks a feature. */
+export function depStatus(depId: string): DepStatus | undefined {
+  return cache?.[depId];
+}
+
+/** The registry, for callers that need the human-facing `enables`
+ *  label (boot warning composition). */
+export function optionalDeps(): readonly OptionalDep[] {
+  return REGISTRY;
+}
+
+/** Test-only: drop the cache so a fresh probe runs next call. */
+export function _resetOptionalDepsCacheForTest(): void {
+  cache = null;
+  inFlight = null;
+}
+
+/** Test-only: seed the probe cache directly so route guards and
+ *  `announceOptionalDeps` behave deterministically without invoking
+ *  the real `which` / daemon probe (CI has no control over whether
+ *  ffmpeg/docker are installed on the runner). `probeOptionalDeps()`
+ *  returns this seeded cache untouched (its first line is
+ *  `if (cache) return cache;`). */
+export function _setOptionalDepsCacheForTest(seed: Record<string, DepStatus>): void {
+  cache = seed;
+  inFlight = null;
+}

package/server/utils/cli-flags.d.mts

@@ -0,0 +1,14 @@
+// Type declarations for cli-flags.mjs. See the .mjs file for rationale
+// on why the shared registry lives in plain JS.
+
+export interface CliFlag {
+  flag: string;
+  env: string;
+  help: string;
+}
+
+export const CLI_FLAGS: readonly CliFlag[];
+
+export function flagEnvOverrides(argv: readonly string[]): Record<string, "1">;
+
+export function cliFlagHelpLines(): string;

package/server/utils/cli-flags.mjs

@@ -0,0 +1,53 @@
+// Shared registry of the boolean CLI flags that mirror an env var.
+// Single source of truth for: the launcher's argv→env injection
+// (`packages/mulmoclaude/bin/mulmoclaude.js`), the launcher `--help`
+// text, and the server-side argv awareness in `server/system/env.ts`.
+//
+// Kept as plain `.mjs` for the same reason as `dev-plugin-args.mjs` /
+// `port.mjs`: the launcher runs BEFORE tsx is wired up, so it can't
+// import from a `.ts` file. Sibling `cli-flags.d.mts` carries the
+// type declarations.
+//
+// Each flag is a launch-time boolean toggle that was previously only
+// reachable via a `VAR=1` env-var prefix — awkward on Windows
+// PowerShell `npx`, in IDE/launcher run configs, and for quick ad-hoc
+// debugging. Setting `<flag>` is equivalent to exporting `<env>=1`;
+// the env var stays supported in parallel (CI scripts / existing docs
+// rely on it). Secret-bearing vars (auth token, API keys) are
+// deliberately NOT here — argv is visible via `ps` and shell history,
+// so those stay env-only. (#1089 + bundle.)
+
+/** @type {ReadonlyArray<{ flag: string, env: string, help: string }>} */
+export const CLI_FLAGS = Object.freeze([
+  { flag: "--disable-sandbox", env: "DISABLE_SANDBOX", help: "Run without the Docker sandbox (= DISABLE_SANDBOX=1)" },
+  {
+    flag: "--disable-macos-reminders",
+    env: "DISABLE_MACOS_REMINDER_NOTIFICATIONS",
+    help: "Disable the macOS Reminder notification sink (= DISABLE_MACOS_REMINDER_NOTIFICATIONS=1)",
+  },
+  { flag: "--persist-tool-calls", env: "PERSIST_TOOL_CALLS", help: "Also persist tool_call events to the session jsonl (= PERSIST_TOOL_CALLS=1)" },
+  { flag: "--journal-force-run", env: "JOURNAL_FORCE_RUN_ON_STARTUP", help: "Run the journal pass immediately on startup (= JOURNAL_FORCE_RUN_ON_STARTUP=1)" },
+  {
+    flag: "--chat-index-force-run",
+    env: "CHAT_INDEX_FORCE_RUN_ON_STARTUP",
+    help: "Run the chat-index pass immediately on startup (= CHAT_INDEX_FORCE_RUN_ON_STARTUP=1)",
+  },
+]);
+
+/**
+ * Map present CLI flags to the `{ ENV: "1" }` overrides the launcher
+ * merges into the spawned server's env. Pure — caller passes argv in.
+ */
+export function flagEnvOverrides(argv) {
+  const overrides = {};
+  for (const { flag, env } of CLI_FLAGS) {
+    if (argv.includes(flag)) overrides[env] = "1";
+  }
+  return overrides;
+}
+
+/** Render the aligned `--help` lines for the flag block. */
+export function cliFlagHelpLines() {
+  const width = Math.max(...CLI_FLAGS.map(({ flag }) => flag.length));
+  return CLI_FLAGS.map(({ flag, help }) => `  ${flag.padEnd(width)}  ${help}`).join("\n");
+}

package/server/utils/time.ts

@@ -36,6 +36,12 @@ export const DEV_PLUGIN_WATCH_DEBOUNCE_MS = 300;
  *  a fail-fast guarantee. */
 export const STARTUP_FAILURE_FORCE_EXIT_MS = 5 * ONE_SECOND_MS;
 
+/** Tiny grace after an uncaught exception / unhandled rejection so
+ *  the final `log.error` line flushes to disk before the process
+ *  bounces. Long enough for a synchronous append, short enough not
+ *  to delay a crash-restart loop. */
+export const FATAL_LOG_FLUSH_MS = 100;
+
 /** Heavy subprocess work (libreoffice conversion, etc.) */
 export const SUBPROCESS_WORK_TIMEOUT_MS = ONE_MINUTE_MS;
 

package/server/workspace/helps/business.md

@@ -37,8 +37,8 @@ Reach for `presentMulmoScript` when the user asks for a presentation, slideshow,
       }
     }
   },
-  "imageParams": { "provider": "google", "model": "gemini-2.5-flash-image" },
-  "movieParams": { "provider": "google", "model": "veo-2.0-generate-001" },
+  "imageParams": { "provider": "google", "model": "gemini-3.1-flash-image-preview" },
+  "movieParams": { "provider": "google", "model": "veo-3.1-generate" },
   "textSlideParams": { "cssStyles": "body { background-color: white; }" },
   "beats": [
     {

package/server/workspace/helps/mulmoscript.md

@@ -11,8 +11,8 @@ MulmoScript files are rendered in the canvas. The underlying engine is [mulmocas
 | Purpose | Provider | Example config |
 |---|---|---|
 | TTS (speech) | `gemini` | `"provider": "gemini", "voiceId": "Kore"` |
-| Image generation | `google` | `"provider": "google", "model": "gemini-2.5-flash-image"` |
-| Video generation | `google` | `"provider": "google", "model": "veo-2.0-generate-001"` |
+| Image generation | `google` | `"provider": "google", "model": "gemini-3.1-flash-image-preview"` |
+| Video generation | `google` | `"provider": "google", "model": "veo-3.1-generate"` |
 
 Do not use `openai`, `elevenlabs`, or other providers — they are not configured in this app.
 
@@ -225,7 +225,7 @@ Control BGM and volume mixing.
       "Presenter": { "provider": "gemini", "voiceId": "Kore", "displayName": { "en": "Presenter" } }
     }
   },
-  "imageParams": { "provider": "google", "model": "gemini-2.5-flash-image" },
+  "imageParams": { "provider": "google", "model": "gemini-3.1-flash-image-preview" },
   "beats": [
     {
       "speaker": "Presenter",

package/server/workspace/helps/sandbox.md

@@ -23,11 +23,11 @@ The container runs with `--cap-drop ALL` and as the host user's UID/GID, so it h
 
 ## Disabling the Sandbox
 
-Set the environment variable `DISABLE_SANDBOX=1` to always run the agent directly on the host, even when Docker is available.
+Set the environment variable `DISABLE_SANDBOX=1` to always run the agent directly on the host, even when Docker is available. Equivalently, pass the `--disable-sandbox` CLI flag — `yarn dev --disable-sandbox` or `npx mulmoclaude --disable-sandbox`. The flag form is handy on Windows PowerShell (no inline `VAR=value` syntax), in IDE / launcher run configs, and for quick ad-hoc debugging. Both set the same internal switch; the env var stays supported in parallel.
 
 ## Debug aids (opt-in env vars)
 
-These flags exist for development / debugging only. Off by default so production runs aren't surprised.
+These flags exist for development / debugging only. Off by default so production runs aren't surprised. Each has an equivalent `--flag` CLI form (drop the `=1`, kebab-case the name) accepted by both `yarn dev` and `npx mulmoclaude` — e.g. `DISABLE_SANDBOX=1` ≡ `--disable-sandbox`, `PERSIST_TOOL_CALLS=1` ≡ `--persist-tool-calls`, `DISABLE_MACOS_REMINDER_NOTIFICATIONS=1` ≡ `--disable-macos-reminders`, `JOURNAL_FORCE_RUN_ON_STARTUP=1` ≡ `--journal-force-run`, `CHAT_INDEX_FORCE_RUN_ON_STARTUP=1` ≡ `--chat-index-force-run`. Secret-bearing vars (auth token, API keys) have no flag form on purpose — argv is visible via `ps` / shell history.
 
 - `DISABLE_SANDBOX=1` — see above. Bypasses the Docker sandbox.
 - `PERSIST_TOOL_CALLS=1` — also persist `tool_call` events to the session jsonl alongside `tool_result`. Useful for reading the args sent to a tool after the run is over (page refresh / server restart). Off by default because args can be large and may carry payload bytes (inline images, full MulmoScript JSON) you didn't expect to land in the jsonl. See [issue #1096](https://github.com/receptron/mulmoclaude/issues/1096) for the rationale.

package/server/workspace/hooks/dispatcher.mjs

@@ -297,4 +297,4 @@ async function main() {
 }
 main().catch(() => {
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["shared/sidecar.ts", "../../utils/time.ts", "shared/workspace.ts", "shared/stdin.ts", "handlers/configRefresh.ts", "handlers/skillBridge.ts", "../../utils/errors.ts", "handlers/wikiSnapshot.ts", "../../../src/lib/wiki-page/paths.ts", "../../../src/lib/wiki-page/slug.ts", "dispatcher.ts"],
  "sourcesContent": ["// Read the bearer token and server port from sidecar files the\n// parent server writes on each startup. Hooks POST back to the\n// parent server using these \u2014 they need to run without any\n// runtime config baked in.\n//\n// Strict integer parsing on the port: a crafted file value like\n// `80@attacker.example` would otherwise change the request\n// authority and exfiltrate the bearer token off-host. Same\n// hardening applied as the Codex review on PR #1284.\n\nimport { readFileSync } from \"node:fs\";\nimport path from \"node:path\";\nimport { ONE_SECOND_MS } from \"../../../utils/time.js\";\nimport { workspaceRoot } from \"./workspace.js\";\n\nconst TOKEN_FILE = \".session-token\";\nconst PORT_FILE = \".server-port\";\n\n// In Docker mode the parent server lives on the host's 127.0.0.1\n// which the container can't reach via plain loopback. The Docker\n// spawn plumbing sets MULMOCLAUDE_HOST=host.docker.internal so\n// fetch() resolves to the host server. Outside Docker (or when the\n// var is unset) we fall back to the loopback address.\nexport function serverHost(): string {\n  return process.env.MULMOCLAUDE_HOST ?? \"127.0.0.1\";\n}\n\nfunction readSidecar(rel: string): string {\n  try {\n    return readFileSync(path.join(workspaceRoot(), rel), \"utf-8\").trim();\n  } catch {\n    return \"\";\n  }\n}\n\nexport function readToken(): string {\n  return readSidecar(TOKEN_FILE);\n}\n\nexport function readPort(): number | null {\n  const raw = readSidecar(PORT_FILE);\n  if (!raw) return null;\n  const port = Number.parseInt(raw, 10);\n  return Number.isInteger(port) && port > 0 && port < 65536 ? port : null;\n}\n\n// Build an authenticated POST request against the parent server.\n// Returns null when token / port are missing (server isn't up yet);\n// caller treats null as a silent no-op so a one-off hook miss\n// during startup doesn't surface as a tool error.\n// `Parameters<typeof fetch>[1]` derives the request-init shape\n// from the global `fetch` type rather than naming `RequestInit`\n// directly \u2014 keeps the file lint-clean under our shared no-undef\n// config without needing a custom DOM-types tsconfig for the hook\n// bundle.\ntype FetchInit = Parameters<typeof fetch>[1];\n\nexport interface PostRequest {\n  url: string;\n  init: FetchInit;\n}\n\nexport function buildAuthPost(pathname: string, body?: unknown): PostRequest | null {\n  const token = readToken();\n  const port = readPort();\n  if (!token || port === null) return null;\n  const headers: Record<string, string> = {\n    Authorization: `Bearer ${token}`,\n  };\n  const init: FetchInit = { method: \"POST\", headers };\n  if (body !== undefined) {\n    headers[\"Content-Type\"] = \"application/json\";\n    init.body = JSON.stringify(body);\n  }\n  return {\n    url: `http://${serverHost()}:${port}${pathname}`,\n    init,\n  };\n}\n\n// 2 s default timeout. PostToolUse hooks block Claude CLI's tool\n// turn until the script exits, so a slow / hung parent server\n// (refresh deadlock, GC pause, unrelated long-running route) would\n// leave the user's Write/Edit appearing frozen. The refresh-style\n// POSTs are fire-and-forget anyway; if the server can't respond\n// inside that window, the file is already on disk and the next\n// restart picks it up.\nconst DEFAULT_TIMEOUT_MS = 2 * ONE_SECOND_MS;\n\nexport async function safePost(req: PostRequest | null, timeoutMs = DEFAULT_TIMEOUT_MS): Promise<void> {\n  if (!req) return;\n  const controller = new AbortController();\n  const timer = setTimeout(() => controller.abort(), timeoutMs);\n  try {\n    await fetch(req.url, { ...req.init, signal: controller.signal });\n  } catch {\n    // Server might be restarting / unreachable / timed out \u2014 silent\n    // fail is fine; the file is on disk and the next manual restart\n    // picks it up.\n  } finally {\n    clearTimeout(timer);\n  }\n}\n\n// Forward a structured log line into the server's logger via\n// `POST /api/hooks/log`. Handlers call this after each meaningful\n// side-effect (mirror copy, delete, etc.) so the user can verify\n// from server logs that the hook fired and what it did. The endpoint\n// authenticates via bearer token (same as every other internal hook\n// POST); a missing token / port is the silent no-op safePost\n// already handles. 1 s timeout \u2014 logging shouldn't stall the user's\n// tool turn even if the server is briefly slow.\nconst LOG_TIMEOUT_MS = ONE_SECOND_MS;\n\nexport async function serverLog(namespace: string, message: string, options: { level?: \"info\" | \"warn\" | \"error\"; data?: object } = {}): Promise<void> {\n  const body = {\n    namespace,\n    message,\n    level: options.level ?? \"info\",\n    ...(options.data ? { data: options.data } : {}),\n  };\n  const req = buildAuthPost(\"/api/hooks/log\", body);\n  await safePost(req, LOG_TIMEOUT_MS);\n}\n", "// Common time constants in milliseconds. Avoids magic numbers like\n// 3_600_000 scattered across the codebase.\n//\n// All server-side code should import from here instead of using raw\n// numeric literals. When a specific duration is needed (e.g. a\n// 5-second timeout), express it as `5 * ONE_SECOND_MS`.\n\nexport const ONE_SECOND_MS = 1_000;\nexport const ONE_MINUTE_MS = 60_000;\nexport const ONE_HOUR_MS = 3_600_000;\nexport const ONE_DAY_MS = 86_400_000;\n\n/** Map time-unit suffixes (s/m/h) to milliseconds. */\nexport const TIME_UNIT_MS: Record<string, number> = {\n  s: ONE_SECOND_MS,\n  m: ONE_MINUTE_MS,\n  h: ONE_HOUR_MS,\n};\n\n// \u2500\u2500 Common timeout presets \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n// Named timeouts for recurring patterns. Prefer these over inline\n// `5 * ONE_SECOND_MS` when the same value is used in 3+ places.\n\n/** Quick subprocess probe (docker ps, libreoffice --version, etc.) */\nexport const SUBPROCESS_PROBE_TIMEOUT_MS = 5 * ONE_SECOND_MS;\n\n/** Debounce window for dev-plugin `dist/` watcher (#1159 PR3). Vite\n *  writes 4-5 files within ~100ms on a single rebuild; 300ms collapses\n *  the burst into one publish. */\nexport const DEV_PLUGIN_WATCH_DEBOUNCE_MS = 300;\n\n/** Hard cap on how long the startup-failure path waits for\n *  `httpServer.close()` to drain in-flight connections before\n *  forcing `process.exit(1)`. SSE streams + WebSocket upgrades hold\n *  connections open indefinitely, so the graceful close alone isn't\n *  a fail-fast guarantee. */\nexport const STARTUP_FAILURE_FORCE_EXIT_MS = 5 * ONE_SECOND_MS;\n\n/** Heavy subprocess work (libreoffice conversion, etc.) */\nexport const SUBPROCESS_WORK_TIMEOUT_MS = ONE_MINUTE_MS;\n\n/** CLI subprocess timeout (claude -p for summarization, etc.) */\nexport const CLI_SUBPROCESS_TIMEOUT_MS = 5 * ONE_MINUTE_MS;\n\n/** Maximum one-shot notification delay */\nexport const MAX_NOTIFICATION_DELAY_SEC = 3_600; // 1 hour in seconds\n", "// Workspace root resolution for hook scripts.\n//\n// `CLAUDE_PROJECT_DIR` is set by Claude CLI to the workspace root\n// the hook fired against \u2014 this is the value we trust at runtime.\n// Falling back to `~/mulmoclaude` keeps the script robust when run\n// outside CLI context (test harness, manual reproduction).\n\nimport { homedir } from \"node:os\";\nimport path from \"node:path\";\n\nexport function workspaceRoot(): string {\n  return process.env.CLAUDE_PROJECT_DIR ?? path.join(homedir(), \"mulmoclaude\");\n}\n", "// Read the JSON PostToolUse payload Claude CLI streams on stdin.\n// Returns the parsed payload or null when the input is empty /\n// malformed \u2014 the dispatcher treats null as a fast no-op so a hook\n// fired with no body never crashes the user's tool turn.\n\nexport interface HookPayload {\n  tool_name?: unknown;\n  tool_input?: {\n    file_path?: unknown;\n    command?: unknown;\n    [key: string]: unknown;\n  };\n  tool_response?: {\n    filePath?: unknown;\n    [key: string]: unknown;\n  };\n  session_id?: unknown;\n  [key: string]: unknown;\n}\n\nexport async function readHookPayload(): Promise<HookPayload | null> {\n  const chunks: Buffer[] = [];\n  for await (const chunk of process.stdin) {\n    chunks.push(typeof chunk === \"string\" ? Buffer.from(chunk) : chunk);\n  }\n  const raw = Buffer.concat(chunks).toString(\"utf-8\");\n  if (!raw.trim()) return null;\n  try {\n    return JSON.parse(raw) as HookPayload;\n  } catch {\n    return null;\n  }\n}\n\n// Different tools surface the path under different keys (Write/Edit\n// use tool_input.file_path; the response shape uses filePath). The\n// helper checks both defensively so handlers don't need to.\nexport function extractFilePath(payload: HookPayload): string {\n  const fromInput = payload.tool_input?.file_path;\n  if (typeof fromInput === \"string\") return fromInput;\n  const fromResponse = payload.tool_response?.filePath;\n  if (typeof fromResponse === \"string\") return fromResponse;\n  return \"\";\n}\n\n// Bash tool calls put the shell command string in tool_input.command.\n// Empty string when the payload is a non-Bash tool or malformed.\nexport function extractCommand(payload: HookPayload): string {\n  const command = payload.tool_input?.command;\n  return typeof command === \"string\" ? command : \"\";\n}\n\nexport function extractToolName(payload: HookPayload): string {\n  return typeof payload.tool_name === \"string\" ? payload.tool_name : \"\";\n}\n\nexport function extractSessionId(payload: HookPayload): string | undefined {\n  const sessionId = payload.session_id;\n  return typeof sessionId === \"string\" && sessionId.length > 0 ? sessionId : undefined;\n}\n", "// Config-refresh handler \u2014 fires after Write/Edit on files that\n// drive workspace state the parent server hot-reloads:\n//\n//   <ws>/.claude/skills/<slug>/SKILL.md   (manual edits to canonical skills)\n//   <ws>/config/scheduler/tasks.json      (user-task scheduler config)\n//\n// POSTs /api/config/refresh so the change activates without a server\n// restart. Migrated from `server/workspace/config-refresh/hook.mjs`.\n//\n// NOTE on staging skills (`data/skills/<slug>/SKILL.md`):\n// The staging path is INTENTIONALLY excluded from PATTERNS here.\n// Refreshing on the staging write would race with `skillBridge`'s\n// mirror copy \u2014 `/api/config/refresh` could land before the canonical\n// file is written, leaving a fresh skill unregistered until the next\n// restart. `skillBridge` owns its own refresh trigger and fires it\n// AFTER the mirror succeeds, so the ordering is deterministic.\n\nimport { buildAuthPost, safePost } from \"../shared/sidecar.js\";\nimport type { HookPayload } from \"../shared/stdin.js\";\nimport { extractFilePath, extractToolName } from \"../shared/stdin.js\";\n\n// Each pattern is matched against the absolute path the CLI\n// delivered. Windows path separators are tolerated for cross-\n// platform robustness even though the host is currently darwin /\n// linux only.\nconst PATTERNS = [/[\\\\/]\\.claude[\\\\/]skills[\\\\/][^\\\\/]+[\\\\/]SKILL\\.md$/, /[\\\\/]config[\\\\/]scheduler[\\\\/]tasks\\.json$/];\n\nexport async function handleConfigRefresh(payload: HookPayload): Promise<void> {\n  const tool = extractToolName(payload);\n  if (tool !== \"Write\" && tool !== \"Edit\") return;\n\n  const filePath = extractFilePath(payload);\n  if (!filePath) return;\n  if (!PATTERNS.some((pattern) => pattern.test(filePath))) return;\n\n  const req = buildAuthPost(\"/api/config/refresh\");\n  await safePost(req);\n}\n", "// Skill-bridge handler \u2014 agent writes skill drafts to\n// `data/skills/<slug>/SKILL.md` (a plain data dir, no permission\n// special case) and this hook mirrors them into\n// `.claude/skills/<slug>/SKILL.md` so Claude CLI's skill discovery\n// picks them up.\n//\n// Why a bridge: Claude Code's permission system gives `.claude/`\n// stricter scrutiny than ordinary cwd subdirs (the dir holds the\n// agent's own skills / hooks / settings, so writes there are a\n// self-modification risk). Even with explicit `Write(.claude/**)`\n// allow rules in workspace settings.json, writes prompt \u2014 and the\n// host GUI has no surface to answer the prompt. Routing writes\n// through `data/skills/` avoids the gate; this hook (a regular\n// subprocess, NOT a Claude tool call) does the mirror copy and is\n// not subject to the gate.\n//\n// Why mirror as `<slug>/SKILL.md` (not flat `<slug>.md`): Claude\n// CLI's canonical skill layout IS the nested form, and the agent\n// naturally writes that shape. A flat staging path forced the agent\n// to reason against its own training, missed the regex, and the\n// mirror silently never fired. Mirroring 1:1 keeps the path math\n// trivial for both sides.\n//\n// Mirror operations:\n//\n//   Write/Edit data/skills/<slug>/SKILL.md\n//     \u2192 copy content to .claude/skills/<slug>/SKILL.md\n//       (creates the parent dir on first install)\n//\n//   Bash \"rm -rf data/skills/<slug>/\" or \"rm -rf data/skills/<slug>\"\n//     \u2192 rm -rf .claude/skills/<slug>/\n//       (regex-matched so the agent's intent is unambiguous;\n//        a bulk `rm -rf data/skills/` or wildcards are intentionally\n//        NOT mirrored to avoid mass deletion surprises)\n\nimport { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from \"node:fs\";\nimport path from \"node:path\";\nimport { buildAuthPost, safePost, serverLog } from \"../shared/sidecar.js\";\nimport type { HookPayload } from \"../shared/stdin.js\";\nimport { extractCommand, extractFilePath, extractToolName } from \"../shared/stdin.js\";\nimport { workspaceRoot } from \"../shared/workspace.js\";\nimport { errorMessage } from \"../../../utils/errors.js\";\n\nconst DATA_SKILLS_DIR = path.join(\"data\", \"skills\");\nconst CLAUDE_SKILLS_DIR = path.join(\".claude\", \"skills\");\nconst SKILL_FILENAME = \"SKILL.md\";\n\n// Slugs follow Claude Code's skill-name convention: lowercase ASCII\n// letters / digits with single-hyphen separators. Matching is\n// strict so a typo or path traversal attempt (`../foo`) never\n// reaches the destination path math.\n//\n// eslint-disable-next-line security/detect-unsafe-regex -- input is always a basename slice \u2264 64 chars, so the theoretical worst-case backtracking is bounded; this is the canonical kebab-case pattern used across the skill toolchain.\nconst SLUG_RE = /^[a-z0-9]+(-[a-z0-9]+)*$/;\n\n// `rm -rf data/skills/<slug>` regex. Captures the flag run as\n// `match[1]` so the caller can post-validate that the user passed\n// a recursive flag (`-r`, `-R`, `-rf`, `-fr`, \u2026). Tolerates optional\n// trailing slash and optional quoting around the path. A literal\n// `rm -rf data/skills` (the parent dir itself) or paths with\n// wildcards / shell expansion are intentionally NOT matched.\n//\n// Recursive-flag enforcement (Codex review on this PR): plain `rm`\n// or `rm -f` cannot remove a directory, so the staging delete fails\n// silently while the canonical delete still runs \u2014 desyncing the\n// two trees. Requiring at least one `r` / `R` in the flags rejects\n// those forms outright.\n//\n// eslint-disable-next-line security/detect-unsafe-regex -- the `(-[a-z0-9]+)*` slug clause is bounded by the path tail and the input is a single-line Bash command Claude CLI captured; no pathological backtracking surface.\nconst RM_RE = /^\\s*rm\\s+((?:-[a-zA-Z]+\\s+)+)['\"]?data\\/skills\\/([a-z0-9-]+)\\/?['\"]?\\s*$/;\nconst RECURSIVE_FLAG_RE = /[rR]/;\n\n// Pure helpers exported for unit testing. Source paths stay relative\n// to the workspace root resolved at call time so the handler is\n// safe to run from any cwd.\n\nexport function dataSkillDir(slug: string): string {\n  return path.join(workspaceRoot(), DATA_SKILLS_DIR, slug);\n}\n\nexport function dataSkillFilePath(slug: string): string {\n  return path.join(dataSkillDir(slug), SKILL_FILENAME);\n}\n\nexport function claudeSkillDir(slug: string): string {\n  return path.join(workspaceRoot(), CLAUDE_SKILLS_DIR, slug);\n}\n\nexport function claudeSkillFilePath(slug: string): string {\n  return path.join(claudeSkillDir(slug), SKILL_FILENAME);\n}\n\n// Extract the slug from a Write/Edit on a\n// `data/skills/<slug>/SKILL.md` path. Returns null when:\n//   - the path doesn't sit directly under data/skills/<slug>/\n//   - the filename isn't SKILL.md\n//   - the slug isn't a valid kebab-case identifier\n//\n// Sibling files in the same dir (e.g. data/skills/<slug>/README.md\n// or data/skills/<slug>/assets/foo.png) are intentionally NOT\n// bridged \u2014 only the canonical SKILL.md crosses over. Skill authors\n// can keep extra material staging-side until they decide what\n// belongs in the bundle.\nexport function slugFromDataPath(filePath: string): string | null {\n  const root = workspaceRoot();\n  const staging = path.join(root, DATA_SKILLS_DIR);\n  const rel = path.relative(staging, filePath);\n  if (!rel || rel.startsWith(\"..\")) return null;\n  // Expect exactly `<slug>/SKILL.md` \u2014 two segments deep.\n  const segments = rel.split(path.sep);\n  if (segments.length !== 2) return null;\n  const [slug, basename] = segments;\n  if (basename !== SKILL_FILENAME) return null;\n  return SLUG_RE.test(slug) ? slug : null;\n}\n\n// Extract the slug from a Bash `rm -rf data/skills/<slug>/` command.\n// Returns null on any mismatch \u2014 wildcards, paths outside the\n// staging dir, or non-recursive `rm` / `rm -f` (which can't delete\n// the staging dir anyway, so mirroring would desync) are all\n// intentionally rejected.\nexport function slugFromRmCommand(command: string): string | null {\n  const match = RM_RE.exec(command);\n  if (!match) return null;\n  const [, flags, slug] = match;\n  if (!RECURSIVE_FLAG_RE.test(flags)) return null;\n  return SLUG_RE.test(slug) ? slug : null;\n}\n\n// Atomic mirror: write to a tmp file in the destination dir, then\n// rename onto the canonical path. `fs.renameSync` is atomic on POSIX\n// when source + destination share a filesystem (always true here \u2014\n// both are inside `.claude/skills/<slug>/`). If the hook is killed\n// mid-write, the half-written tmp file is left behind (harmless,\n// never read) and SKILL.md still has its previous contents \u2014 Claude\n// CLI's skill discovery never sees a torn file. CodeRabbit review\n// on PR #1298.\nfunction mirrorWrite(slug: string): void {\n  const content = readFileSync(dataSkillFilePath(slug), \"utf-8\");\n  const destDir = claudeSkillDir(slug);\n  mkdirSync(destDir, { recursive: true });\n  const dest = claudeSkillFilePath(slug);\n  const tmp = path.join(destDir, `.SKILL.md.${process.pid}.tmp`);\n  writeFileSync(tmp, content, \"utf-8\");\n  renameSync(tmp, dest);\n}\n\nfunction mirrorDelete(slug: string): void {\n  rmSync(claudeSkillDir(slug), { recursive: true, force: true });\n}\n\n// `configRefresh` used to fan this out for us as a sibling handler,\n// but running it in parallel with the mirror race'd: the\n// `/api/config/refresh` POST could land before the canonical\n// `.claude/skills/<slug>/SKILL.md` existed on disk, leaving a fresh\n// skill unregistered until the next restart. `skillBridge` now\n// fires the refresh itself, ALWAYS after a successful mirror (or\n// delete), so ordering is deterministic (Codex review on this PR).\nasync function refreshConfig(): Promise<void> {\n  await safePost(buildAuthPost(\"/api/config/refresh\"));\n}\n\nasync function handleWriteOrEdit(payload: HookPayload): Promise<void> {\n  const filePath = extractFilePath(payload);\n  if (!filePath) return;\n  const slug = slugFromDataPath(filePath);\n  if (slug === null) return;\n  try {\n    mirrorWrite(slug);\n    // Order matters: mirror must complete before refresh so the\n    // server's skill scan sees the new SKILL.md. See refreshConfig\n    // comment for the race history.\n    await refreshConfig();\n    // Server-side log line so the user can see from\n    // `server-<date>.log` that the hook fired and what it did.\n    // Without this the mirror is invisible \u2014 a successful copy\n    // and \"the hook never ran\" look identical from the chat UI.\n    await serverLog(\"skill-bridge\", `mirrored ${dataSkillFilePath(slug)} \u2192 ${claudeSkillFilePath(slug)}`, { data: { slug, op: \"write\" } });\n  } catch (err) {\n    // The Write itself succeeded; a failed mirror would leave the\n    // staging copy in place. Surface the failure to server logs\n    // (so the user has a chance to react) but never throw \u2014 the\n    // user's tool turn must stay clean.\n    await serverLog(\"skill-bridge\", `mirror write failed for slug=${slug}`, {\n      level: \"error\",\n      data: { slug, error: errorMessage(err) },\n    });\n  }\n}\n\nasync function handleBash(payload: HookPayload): Promise<void> {\n  const command = extractCommand(payload);\n  if (!command) return;\n  const slug = slugFromRmCommand(command);\n  if (slug === null) return;\n  try {\n    mirrorDelete(slug);\n    // Same ordering invariant as handleWriteOrEdit \u2014 refresh must\n    // run after the canonical dir is gone so the server's rescan\n    // deregisters the deleted skill.\n    await refreshConfig();\n    await serverLog(\"skill-bridge\", `removed ${claudeSkillDir(slug)}`, { data: { slug, op: \"delete\" } });\n  } catch (err) {\n    // Same silent-fail discipline \u2014 a missed delete leaves an\n    // orphan in `.claude/skills/` that the user can clean up\n    // manually, which is better than aborting the tool turn.\n    await serverLog(\"skill-bridge\", `mirror delete failed for slug=${slug}`, {\n      level: \"error\",\n      data: { slug, error: errorMessage(err) },\n    });\n  }\n}\n\nexport async function handleSkillBridge(payload: HookPayload): Promise<void> {\n  const tool = extractToolName(payload);\n  if (tool === \"Write\" || tool === \"Edit\") {\n    await handleWriteOrEdit(payload);\n    return;\n  }\n  if (tool === \"Bash\") {\n    await handleBash(payload);\n  }\n}\n", "// Shared error helpers. Use `errorMessage(err)` instead of inlining\n// `err instanceof Error ? err.message : String(err)` \u2014 searching for\n// one canonical helper is easier than grepping for the inline form.\n//\n// Non-Error objects with a `details` (gRPC convention) or `message`\n// string field have that field surfaced \u2014 without this, gRPC errors\n// like `{ code, details, metadata }` show up to users as\n// `[object Object]`.\n//\n// The optional `fallback` covers the common route-handler idiom where\n// a throw of a plain non-Error value should surface as a descriptive\n// message (\"rebuild failed\") rather than `String(err)` noise. Prefer\n// passing a fallback at error-response boundaries \u2014 omit it for\n// logging contexts where `String(err)` is fine.\n\nexport function errorMessage(err: unknown, fallback?: string): string {\n  if (err instanceof Error) return err.message;\n  if (err !== null && typeof err === \"object\") {\n    const obj = err as { details?: unknown; message?: unknown };\n    if (typeof obj.details === \"string\" && obj.details) return obj.details;\n    if (typeof obj.message === \"string\" && obj.message) return obj.message;\n  }\n  if (fallback !== undefined) return fallback;\n  return String(err);\n}\n", "// Wiki page snapshot handler \u2014 fires after Write/Edit on a wiki\n// page so the snapshot pipeline (#763 PR 2) records the new state.\n//\n// Migrated from `server/workspace/wiki-history/hook/snapshot.ts`.\n// Same behaviour, now part of the unified dispatcher so settings.json\n// carries a single PostToolUse entry instead of one per hook source.\n\nimport path from \"node:path\";\nimport { wikiSlugFromAbsPath } from \"../../../../src/lib/wiki-page/paths.js\";\nimport { buildAuthPost, safePost } from \"../shared/sidecar.js\";\nimport type { HookPayload } from \"../shared/stdin.js\";\nimport { extractFilePath, extractSessionId, extractToolName } from \"../shared/stdin.js\";\nimport { workspaceRoot } from \"../shared/workspace.js\";\n\nconst WIKI_PAGES_REL = path.join(\"data\", \"wiki\", \"pages\");\n\nexport async function handleWikiSnapshot(payload: HookPayload): Promise<void> {\n  const tool = extractToolName(payload);\n  // Wiki pages are written via Write or Edit \u2014 Bash rm or shell\n  // mutations don't go through the snapshot pipeline (the wiki\n  // route does that explicitly server-side when needed).\n  if (tool !== \"Write\" && tool !== \"Edit\") return;\n\n  const filePath = extractFilePath(payload);\n  if (!filePath) return;\n\n  const wikiPagesDir = path.join(workspaceRoot(), WIKI_PAGES_REL);\n  const slug = wikiSlugFromAbsPath(filePath, wikiPagesDir);\n  if (slug === null) return;\n\n  // Prefer the parent server's chatSessionId (#963) \u2014 the server's\n  // session store keys by chatSessionId, not Claude CLI's internal\n  // session_id, so the toolResult publish on the server side only\n  // matches when we forward our own id. Fall back to Claude CLI's\n  // session_id when the env var is absent.\n  const envChatSessionId = process.env.MULMOCLAUDE_CHAT_SESSION_ID;\n  const payloadSessionId = extractSessionId(payload);\n  const sessionId = envChatSessionId && envChatSessionId.length > 0 ? envChatSessionId : payloadSessionId;\n  const body = sessionId === undefined ? { slug } : { slug, sessionId };\n\n  const req = buildAuthPost(\"/api/wiki/internal/snapshot\", body);\n  await safePost(req);\n}\n", "// Node-only wiki-page helpers \u2014 anything that needs `node:path`\n// lives here so the rest of `src/lib/wiki-page/` stays pure\n// (string-only, importable from both browser and Node bundles).\n// Frontend code MUST NOT import this file directly; use the pure\n// modules instead.\n\nimport path from \"node:path\";\nimport { isSafeSlug } from \"./slug.js\";\n\n/** Given an absolute path and the absolute `pagesDir`, return the\n *  slug if `absPath` is a direct `.md` child of `pagesDir`, else\n *  null. Pure path-string math \u2014 no fs IO, no symlink resolution.\n *\n *  Caller responsibility: pass already-realpath'd values for both\n *  arguments. Mixing a realpath'd `absPath` with a symlinked\n *  `pagesDir` (or vice versa) silently mismatches because\n *  `path.relative` is plain string arithmetic. The trap caused\n *  #883 review-iter-1 \u2014 a symlinked workspace silently routed\n *  wiki writes through the generic writer. */\nexport function wikiSlugFromAbsPath(absPath: string, pagesDir: string): string | null {\n  const rel = path.relative(pagesDir, absPath);\n  if (rel.length === 0) return null;\n  if (path.isAbsolute(rel)) return null;\n  // Direct child only \u2014 no nested layout today. Any separator\n  // means the path either escapes (`../secret.md`) or descends\n  // (`subdir/foo.md`). A literal page name like `..foo.md` is a\n  // single segment without a separator and is allowed (codex\n  // iter-3 #883 \u2014 the prior `startsWith(\"..\")` rule wrongly\n  // rejected it).\n  if (rel.includes(path.sep)) return null;\n  if (!rel.endsWith(\".md\")) return null;\n  const slug = rel.slice(0, -\".md\".length);\n  if (!isSafeSlug(slug)) return null;\n  return slug;\n}\n", "// Pure wiki-page slug helpers \u2014 string-only, no Node / browser\n// dependencies, importable from any bundle.\n//\n// Used by:\n//   - server/workspace/wiki-pages/io.ts (the write chokepoint)\n//   - server/workspace/hooks/handlers/wikiSnapshot.ts (the\n//     PostToolUse handler that fires on Write/Edit of a wiki page)\n//   - server/api/routes/wiki.ts (page resolver + lint)\n//   - server/api/routes/wiki/history.ts (history slug guard)\n//   - src/plugins/wiki/route.ts (router slug guard \u2014 replaces the\n//     local `isSafeWikiSlug` duplicate that existed before the\n//     pure-lib refactor)\n//   - src/plugins/wiki/helpers.ts (renderer slugify for [[\u2026]] links)\n//\n// Any helper that needs `node:path` lives in `./paths.ts` so that\n// importing this file from frontend code never pulls in Node\n// builtins.\n\n/** Reject slugs that would escape `data/wiki/pages/` once\n *  joined back into a path, or that are otherwise invalid as\n *  page filenames. The chokepoint must defend itself even when\n *  callers derive the slug from a trusted source \u2014 a typo or\n *  future caller mistake should fail loud, not silently write\n *  outside the wiki tree.\n *\n *  The rule is intentionally narrow \u2014 separators / `..` / NUL /\n *  empty \u2014 so it only rejects unambiguous violations. Aesthetic\n *  concerns (e.g. dot-prefixed filenames) are out of scope: a\n *  pre-existing `data/wiki/pages/.foo.md` should remain writable\n *  through the chokepoint (codex review iter-2 #883). */\nexport function isSafeSlug(slug: string): boolean {\n  if (slug.length === 0) return false;\n  if (slug === \".\" || slug === \"..\") return false;\n  if (slug.includes(\"/\") || slug.includes(\"\\\\\")) return false;\n  if (slug.includes(\"\\0\")) return false;\n  return true;\n}\n\n/** Slug rules for `[[wiki link]]` text \u2192 slug derivation:\n *  lowercase, spaces collapsed to hyphens, every non-ASCII /\n *  non-alphanumeric / non-hyphen character stripped.\n *\n *  Pure: no normalisation, no transliteration \u2014 this is the\n *  same shape the index parser, page resolver, and frontend\n *  renderer all need to agree on. Non-ASCII titles (e.g.\n *  Japanese) collapse to an empty string here; callers fall back\n *  to other strategies (title-match in the index, or the agent\n *  pre-resolving to a slug-form target via `[[slug|display]]`). */\nexport function wikiSlugify(text: string): string {\n  return text\n    .toLowerCase()\n    .replace(/\\s+/g, \"-\")\n    .replace(/[^a-z0-9-]/g, \"\");\n}\n", "// PostToolUse dispatcher \u2014 runs after every Claude CLI Write / Edit\n// / Bash tool call and fans out to the registered handlers. Each\n// handler decides for itself whether the call is relevant (by\n// tool_name + file_path / command), so adding a new behaviour means\n// dropping a new file under `handlers/` and registering it here \u2014\n// settings.json never changes.\n//\n// THIS FILE IS THE SOURCE OF TRUTH. Edits here, then run\n// `yarn build:hooks` (or `yarn build`) to regenerate `./dispatcher.mjs`.\n// The bundled `.mjs` is committed to git so `provision.ts` can read\n// it at server startup without invoking esbuild on the runtime path.\n// CI runs `yarn build:hooks && git diff --exit-code` to catch a\n// stale bundle.\n//\n// The hook executes inside Claude CLI's process space \u2014 must be a\n// self-contained ESM bundle. esbuild rolls every import (handlers,\n// shared, and the wiki-slug helper from `src/lib/`) into one file.\n\nimport { handleConfigRefresh } from \"./handlers/configRefresh.js\";\nimport { handleSkillBridge } from \"./handlers/skillBridge.js\";\nimport { handleWikiSnapshot } from \"./handlers/wikiSnapshot.js\";\nimport { readHookPayload, type HookPayload } from \"./shared/stdin.js\";\n\ntype Handler = (payload: HookPayload) => Promise<void>;\n\n// Order is informational only \u2014 handlers don't interact. Add new\n// entries here. Each one is wrapped so an individual failure\n// doesn't block its siblings (the user's tool turn would visibly\n// stall otherwise).\nconst HANDLERS: Handler[] = [handleWikiSnapshot, handleConfigRefresh, handleSkillBridge];\n\nasync function runHandler(handler: Handler, payload: HookPayload): Promise<void> {\n  try {\n    await handler(payload);\n  } catch {\n    // Hooks run synchronously to the LLM tool flow \u2014 never throw.\n    // A busted handler would make the tool itself look like it\n    // failed to the LLM, which is much worse than a missed\n    // side-effect.\n  }\n}\n\nasync function main(): Promise<void> {\n  const payload = await readHookPayload();\n  if (!payload) return;\n  // Run handlers in parallel \u2014 they touch disjoint resources\n  // (wiki snapshot endpoint vs config-refresh endpoint vs local\n  // file copy) and serialising them would push the per-turn\n  // latency past the 2 s safePost timeout under bad conditions.\n  await Promise.all(HANDLERS.map((handler) => runHandler(handler, payload)));\n}\n\nmain().catch(() => {\n  // Outermost safety net \u2014 see runHandler comment.\n});\n"],
  "mappings": "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",
  "names": ["path", "path", "readFileSync", "path", "path", "readFileSync", "path", "path", "path", "path"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["shared/sidecar.ts", "../../utils/time.ts", "shared/workspace.ts", "shared/stdin.ts", "handlers/configRefresh.ts", "handlers/skillBridge.ts", "../../utils/errors.ts", "handlers/wikiSnapshot.ts", "../../../src/lib/wiki-page/paths.ts", "../../../src/lib/wiki-page/slug.ts", "dispatcher.ts"],
  "sourcesContent": ["// Read the bearer token and server port from sidecar files the\n// parent server writes on each startup. Hooks POST back to the\n// parent server using these \u2014 they need to run without any\n// runtime config baked in.\n//\n// Strict integer parsing on the port: a crafted file value like\n// `80@attacker.example` would otherwise change the request\n// authority and exfiltrate the bearer token off-host. Same\n// hardening applied as the Codex review on PR #1284.\n\nimport { readFileSync } from \"node:fs\";\nimport path from \"node:path\";\nimport { ONE_SECOND_MS } from \"../../../utils/time.js\";\nimport { workspaceRoot } from \"./workspace.js\";\n\nconst TOKEN_FILE = \".session-token\";\nconst PORT_FILE = \".server-port\";\n\n// In Docker mode the parent server lives on the host's 127.0.0.1\n// which the container can't reach via plain loopback. The Docker\n// spawn plumbing sets MULMOCLAUDE_HOST=host.docker.internal so\n// fetch() resolves to the host server. Outside Docker (or when the\n// var is unset) we fall back to the loopback address.\nexport function serverHost(): string {\n  return process.env.MULMOCLAUDE_HOST ?? \"127.0.0.1\";\n}\n\nfunction readSidecar(rel: string): string {\n  try {\n    return readFileSync(path.join(workspaceRoot(), rel), \"utf-8\").trim();\n  } catch {\n    return \"\";\n  }\n}\n\nexport function readToken(): string {\n  return readSidecar(TOKEN_FILE);\n}\n\nexport function readPort(): number | null {\n  const raw = readSidecar(PORT_FILE);\n  if (!raw) return null;\n  const port = Number.parseInt(raw, 10);\n  return Number.isInteger(port) && port > 0 && port < 65536 ? port : null;\n}\n\n// Build an authenticated POST request against the parent server.\n// Returns null when token / port are missing (server isn't up yet);\n// caller treats null as a silent no-op so a one-off hook miss\n// during startup doesn't surface as a tool error.\n// `Parameters<typeof fetch>[1]` derives the request-init shape\n// from the global `fetch` type rather than naming `RequestInit`\n// directly \u2014 keeps the file lint-clean under our shared no-undef\n// config without needing a custom DOM-types tsconfig for the hook\n// bundle.\ntype FetchInit = Parameters<typeof fetch>[1];\n\nexport interface PostRequest {\n  url: string;\n  init: FetchInit;\n}\n\nexport function buildAuthPost(pathname: string, body?: unknown): PostRequest | null {\n  const token = readToken();\n  const port = readPort();\n  if (!token || port === null) return null;\n  const headers: Record<string, string> = {\n    Authorization: `Bearer ${token}`,\n  };\n  const init: FetchInit = { method: \"POST\", headers };\n  if (body !== undefined) {\n    headers[\"Content-Type\"] = \"application/json\";\n    init.body = JSON.stringify(body);\n  }\n  return {\n    url: `http://${serverHost()}:${port}${pathname}`,\n    init,\n  };\n}\n\n// 2 s default timeout. PostToolUse hooks block Claude CLI's tool\n// turn until the script exits, so a slow / hung parent server\n// (refresh deadlock, GC pause, unrelated long-running route) would\n// leave the user's Write/Edit appearing frozen. The refresh-style\n// POSTs are fire-and-forget anyway; if the server can't respond\n// inside that window, the file is already on disk and the next\n// restart picks it up.\nconst DEFAULT_TIMEOUT_MS = 2 * ONE_SECOND_MS;\n\nexport async function safePost(req: PostRequest | null, timeoutMs = DEFAULT_TIMEOUT_MS): Promise<void> {\n  if (!req) return;\n  const controller = new AbortController();\n  const timer = setTimeout(() => controller.abort(), timeoutMs);\n  try {\n    await fetch(req.url, { ...req.init, signal: controller.signal });\n  } catch {\n    // Server might be restarting / unreachable / timed out \u2014 silent\n    // fail is fine; the file is on disk and the next manual restart\n    // picks it up.\n  } finally {\n    clearTimeout(timer);\n  }\n}\n\n// Forward a structured log line into the server's logger via\n// `POST /api/hooks/log`. Handlers call this after each meaningful\n// side-effect (mirror copy, delete, etc.) so the user can verify\n// from server logs that the hook fired and what it did. The endpoint\n// authenticates via bearer token (same as every other internal hook\n// POST); a missing token / port is the silent no-op safePost\n// already handles. 1 s timeout \u2014 logging shouldn't stall the user's\n// tool turn even if the server is briefly slow.\nconst LOG_TIMEOUT_MS = ONE_SECOND_MS;\n\nexport async function serverLog(namespace: string, message: string, options: { level?: \"info\" | \"warn\" | \"error\"; data?: object } = {}): Promise<void> {\n  const body = {\n    namespace,\n    message,\n    level: options.level ?? \"info\",\n    ...(options.data ? { data: options.data } : {}),\n  };\n  const req = buildAuthPost(\"/api/hooks/log\", body);\n  await safePost(req, LOG_TIMEOUT_MS);\n}\n", "// Common time constants in milliseconds. Avoids magic numbers like\n// 3_600_000 scattered across the codebase.\n//\n// All server-side code should import from here instead of using raw\n// numeric literals. When a specific duration is needed (e.g. a\n// 5-second timeout), express it as `5 * ONE_SECOND_MS`.\n\nexport const ONE_SECOND_MS = 1_000;\nexport const ONE_MINUTE_MS = 60_000;\nexport const ONE_HOUR_MS = 3_600_000;\nexport const ONE_DAY_MS = 86_400_000;\n\n/** Map time-unit suffixes (s/m/h) to milliseconds. */\nexport const TIME_UNIT_MS: Record<string, number> = {\n  s: ONE_SECOND_MS,\n  m: ONE_MINUTE_MS,\n  h: ONE_HOUR_MS,\n};\n\n// \u2500\u2500 Common timeout presets \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n// Named timeouts for recurring patterns. Prefer these over inline\n// `5 * ONE_SECOND_MS` when the same value is used in 3+ places.\n\n/** Quick subprocess probe (docker ps, libreoffice --version, etc.) */\nexport const SUBPROCESS_PROBE_TIMEOUT_MS = 5 * ONE_SECOND_MS;\n\n/** Debounce window for dev-plugin `dist/` watcher (#1159 PR3). Vite\n *  writes 4-5 files within ~100ms on a single rebuild; 300ms collapses\n *  the burst into one publish. */\nexport const DEV_PLUGIN_WATCH_DEBOUNCE_MS = 300;\n\n/** Hard cap on how long the startup-failure path waits for\n *  `httpServer.close()` to drain in-flight connections before\n *  forcing `process.exit(1)`. SSE streams + WebSocket upgrades hold\n *  connections open indefinitely, so the graceful close alone isn't\n *  a fail-fast guarantee. */\nexport const STARTUP_FAILURE_FORCE_EXIT_MS = 5 * ONE_SECOND_MS;\n\n/** Tiny grace after an uncaught exception / unhandled rejection so\n *  the final `log.error` line flushes to disk before the process\n *  bounces. Long enough for a synchronous append, short enough not\n *  to delay a crash-restart loop. */\nexport const FATAL_LOG_FLUSH_MS = 100;\n\n/** Heavy subprocess work (libreoffice conversion, etc.) */\nexport const SUBPROCESS_WORK_TIMEOUT_MS = ONE_MINUTE_MS;\n\n/** CLI subprocess timeout (claude -p for summarization, etc.) */\nexport const CLI_SUBPROCESS_TIMEOUT_MS = 5 * ONE_MINUTE_MS;\n\n/** Maximum one-shot notification delay */\nexport const MAX_NOTIFICATION_DELAY_SEC = 3_600; // 1 hour in seconds\n", "// Workspace root resolution for hook scripts.\n//\n// `CLAUDE_PROJECT_DIR` is set by Claude CLI to the workspace root\n// the hook fired against \u2014 this is the value we trust at runtime.\n// Falling back to `~/mulmoclaude` keeps the script robust when run\n// outside CLI context (test harness, manual reproduction).\n\nimport { homedir } from \"node:os\";\nimport path from \"node:path\";\n\nexport function workspaceRoot(): string {\n  return process.env.CLAUDE_PROJECT_DIR ?? path.join(homedir(), \"mulmoclaude\");\n}\n", "// Read the JSON PostToolUse payload Claude CLI streams on stdin.\n// Returns the parsed payload or null when the input is empty /\n// malformed \u2014 the dispatcher treats null as a fast no-op so a hook\n// fired with no body never crashes the user's tool turn.\n\nexport interface HookPayload {\n  tool_name?: unknown;\n  tool_input?: {\n    file_path?: unknown;\n    command?: unknown;\n    [key: string]: unknown;\n  };\n  tool_response?: {\n    filePath?: unknown;\n    [key: string]: unknown;\n  };\n  session_id?: unknown;\n  [key: string]: unknown;\n}\n\nexport async function readHookPayload(): Promise<HookPayload | null> {\n  const chunks: Buffer[] = [];\n  for await (const chunk of process.stdin) {\n    chunks.push(typeof chunk === \"string\" ? Buffer.from(chunk) : chunk);\n  }\n  const raw = Buffer.concat(chunks).toString(\"utf-8\");\n  if (!raw.trim()) return null;\n  try {\n    return JSON.parse(raw) as HookPayload;\n  } catch {\n    return null;\n  }\n}\n\n// Different tools surface the path under different keys (Write/Edit\n// use tool_input.file_path; the response shape uses filePath). The\n// helper checks both defensively so handlers don't need to.\nexport function extractFilePath(payload: HookPayload): string {\n  const fromInput = payload.tool_input?.file_path;\n  if (typeof fromInput === \"string\") return fromInput;\n  const fromResponse = payload.tool_response?.filePath;\n  if (typeof fromResponse === \"string\") return fromResponse;\n  return \"\";\n}\n\n// Bash tool calls put the shell command string in tool_input.command.\n// Empty string when the payload is a non-Bash tool or malformed.\nexport function extractCommand(payload: HookPayload): string {\n  const command = payload.tool_input?.command;\n  return typeof command === \"string\" ? command : \"\";\n}\n\nexport function extractToolName(payload: HookPayload): string {\n  return typeof payload.tool_name === \"string\" ? payload.tool_name : \"\";\n}\n\nexport function extractSessionId(payload: HookPayload): string | undefined {\n  const sessionId = payload.session_id;\n  return typeof sessionId === \"string\" && sessionId.length > 0 ? sessionId : undefined;\n}\n", "// Config-refresh handler \u2014 fires after Write/Edit on files that\n// drive workspace state the parent server hot-reloads:\n//\n//   <ws>/.claude/skills/<slug>/SKILL.md   (manual edits to canonical skills)\n//   <ws>/config/scheduler/tasks.json      (user-task scheduler config)\n//\n// POSTs /api/config/refresh so the change activates without a server\n// restart. Migrated from `server/workspace/config-refresh/hook.mjs`.\n//\n// NOTE on staging skills (`data/skills/<slug>/SKILL.md`):\n// The staging path is INTENTIONALLY excluded from PATTERNS here.\n// Refreshing on the staging write would race with `skillBridge`'s\n// mirror copy \u2014 `/api/config/refresh` could land before the canonical\n// file is written, leaving a fresh skill unregistered until the next\n// restart. `skillBridge` owns its own refresh trigger and fires it\n// AFTER the mirror succeeds, so the ordering is deterministic.\n\nimport { buildAuthPost, safePost } from \"../shared/sidecar.js\";\nimport type { HookPayload } from \"../shared/stdin.js\";\nimport { extractFilePath, extractToolName } from \"../shared/stdin.js\";\n\n// Each pattern is matched against the absolute path the CLI\n// delivered. Windows path separators are tolerated for cross-\n// platform robustness even though the host is currently darwin /\n// linux only.\nconst PATTERNS = [/[\\\\/]\\.claude[\\\\/]skills[\\\\/][^\\\\/]+[\\\\/]SKILL\\.md$/, /[\\\\/]config[\\\\/]scheduler[\\\\/]tasks\\.json$/];\n\nexport async function handleConfigRefresh(payload: HookPayload): Promise<void> {\n  const tool = extractToolName(payload);\n  if (tool !== \"Write\" && tool !== \"Edit\") return;\n\n  const filePath = extractFilePath(payload);\n  if (!filePath) return;\n  if (!PATTERNS.some((pattern) => pattern.test(filePath))) return;\n\n  const req = buildAuthPost(\"/api/config/refresh\");\n  await safePost(req);\n}\n", "// Skill-bridge handler \u2014 agent writes skill drafts to\n// `data/skills/<slug>/SKILL.md` (a plain data dir, no permission\n// special case) and this hook mirrors them into\n// `.claude/skills/<slug>/SKILL.md` so Claude CLI's skill discovery\n// picks them up.\n//\n// Why a bridge: Claude Code's permission system gives `.claude/`\n// stricter scrutiny than ordinary cwd subdirs (the dir holds the\n// agent's own skills / hooks / settings, so writes there are a\n// self-modification risk). Even with explicit `Write(.claude/**)`\n// allow rules in workspace settings.json, writes prompt \u2014 and the\n// host GUI has no surface to answer the prompt. Routing writes\n// through `data/skills/` avoids the gate; this hook (a regular\n// subprocess, NOT a Claude tool call) does the mirror copy and is\n// not subject to the gate.\n//\n// Why mirror as `<slug>/SKILL.md` (not flat `<slug>.md`): Claude\n// CLI's canonical skill layout IS the nested form, and the agent\n// naturally writes that shape. A flat staging path forced the agent\n// to reason against its own training, missed the regex, and the\n// mirror silently never fired. Mirroring 1:1 keeps the path math\n// trivial for both sides.\n//\n// Mirror operations:\n//\n//   Write/Edit data/skills/<slug>/SKILL.md\n//     \u2192 copy content to .claude/skills/<slug>/SKILL.md\n//       (creates the parent dir on first install)\n//\n//   Bash \"rm -rf data/skills/<slug>/\" or \"rm -rf data/skills/<slug>\"\n//     \u2192 rm -rf .claude/skills/<slug>/\n//       (regex-matched so the agent's intent is unambiguous;\n//        a bulk `rm -rf data/skills/` or wildcards are intentionally\n//        NOT mirrored to avoid mass deletion surprises)\n\nimport { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from \"node:fs\";\nimport path from \"node:path\";\nimport { buildAuthPost, safePost, serverLog } from \"../shared/sidecar.js\";\nimport type { HookPayload } from \"../shared/stdin.js\";\nimport { extractCommand, extractFilePath, extractToolName } from \"../shared/stdin.js\";\nimport { workspaceRoot } from \"../shared/workspace.js\";\nimport { errorMessage } from \"../../../utils/errors.js\";\n\nconst DATA_SKILLS_DIR = path.join(\"data\", \"skills\");\nconst CLAUDE_SKILLS_DIR = path.join(\".claude\", \"skills\");\nconst SKILL_FILENAME = \"SKILL.md\";\n\n// Slugs follow Claude Code's skill-name convention: lowercase ASCII\n// letters / digits with single-hyphen separators. Matching is\n// strict so a typo or path traversal attempt (`../foo`) never\n// reaches the destination path math.\n//\n// eslint-disable-next-line security/detect-unsafe-regex -- input is always a basename slice \u2264 64 chars, so the theoretical worst-case backtracking is bounded; this is the canonical kebab-case pattern used across the skill toolchain.\nconst SLUG_RE = /^[a-z0-9]+(-[a-z0-9]+)*$/;\n\n// `rm -rf data/skills/<slug>` regex. Captures the flag run as\n// `match[1]` so the caller can post-validate that the user passed\n// a recursive flag (`-r`, `-R`, `-rf`, `-fr`, \u2026). Tolerates optional\n// trailing slash and optional quoting around the path. A literal\n// `rm -rf data/skills` (the parent dir itself) or paths with\n// wildcards / shell expansion are intentionally NOT matched.\n//\n// Recursive-flag enforcement (Codex review on this PR): plain `rm`\n// or `rm -f` cannot remove a directory, so the staging delete fails\n// silently while the canonical delete still runs \u2014 desyncing the\n// two trees. Requiring at least one `r` / `R` in the flags rejects\n// those forms outright.\n//\n// eslint-disable-next-line security/detect-unsafe-regex -- the `(-[a-z0-9]+)*` slug clause is bounded by the path tail and the input is a single-line Bash command Claude CLI captured; no pathological backtracking surface.\nconst RM_RE = /^\\s*rm\\s+((?:-[a-zA-Z]+\\s+)+)['\"]?data\\/skills\\/([a-z0-9-]+)\\/?['\"]?\\s*$/;\nconst RECURSIVE_FLAG_RE = /[rR]/;\n\n// Pure helpers exported for unit testing. Source paths stay relative\n// to the workspace root resolved at call time so the handler is\n// safe to run from any cwd.\n\nexport function dataSkillDir(slug: string): string {\n  return path.join(workspaceRoot(), DATA_SKILLS_DIR, slug);\n}\n\nexport function dataSkillFilePath(slug: string): string {\n  return path.join(dataSkillDir(slug), SKILL_FILENAME);\n}\n\nexport function claudeSkillDir(slug: string): string {\n  return path.join(workspaceRoot(), CLAUDE_SKILLS_DIR, slug);\n}\n\nexport function claudeSkillFilePath(slug: string): string {\n  return path.join(claudeSkillDir(slug), SKILL_FILENAME);\n}\n\n// Extract the slug from a Write/Edit on a\n// `data/skills/<slug>/SKILL.md` path. Returns null when:\n//   - the path doesn't sit directly under data/skills/<slug>/\n//   - the filename isn't SKILL.md\n//   - the slug isn't a valid kebab-case identifier\n//\n// Sibling files in the same dir (e.g. data/skills/<slug>/README.md\n// or data/skills/<slug>/assets/foo.png) are intentionally NOT\n// bridged \u2014 only the canonical SKILL.md crosses over. Skill authors\n// can keep extra material staging-side until they decide what\n// belongs in the bundle.\nexport function slugFromDataPath(filePath: string): string | null {\n  const root = workspaceRoot();\n  const staging = path.join(root, DATA_SKILLS_DIR);\n  const rel = path.relative(staging, filePath);\n  if (!rel || rel.startsWith(\"..\")) return null;\n  // Expect exactly `<slug>/SKILL.md` \u2014 two segments deep.\n  const segments = rel.split(path.sep);\n  if (segments.length !== 2) return null;\n  const [slug, basename] = segments;\n  if (basename !== SKILL_FILENAME) return null;\n  return SLUG_RE.test(slug) ? slug : null;\n}\n\n// Extract the slug from a Bash `rm -rf data/skills/<slug>/` command.\n// Returns null on any mismatch \u2014 wildcards, paths outside the\n// staging dir, or non-recursive `rm` / `rm -f` (which can't delete\n// the staging dir anyway, so mirroring would desync) are all\n// intentionally rejected.\nexport function slugFromRmCommand(command: string): string | null {\n  const match = RM_RE.exec(command);\n  if (!match) return null;\n  const [, flags, slug] = match;\n  if (!RECURSIVE_FLAG_RE.test(flags)) return null;\n  return SLUG_RE.test(slug) ? slug : null;\n}\n\n// Atomic mirror: write to a tmp file in the destination dir, then\n// rename onto the canonical path. `fs.renameSync` is atomic on POSIX\n// when source + destination share a filesystem (always true here \u2014\n// both are inside `.claude/skills/<slug>/`). If the hook is killed\n// mid-write, the half-written tmp file is left behind (harmless,\n// never read) and SKILL.md still has its previous contents \u2014 Claude\n// CLI's skill discovery never sees a torn file. CodeRabbit review\n// on PR #1298.\nfunction mirrorWrite(slug: string): void {\n  const content = readFileSync(dataSkillFilePath(slug), \"utf-8\");\n  const destDir = claudeSkillDir(slug);\n  mkdirSync(destDir, { recursive: true });\n  const dest = claudeSkillFilePath(slug);\n  const tmp = path.join(destDir, `.SKILL.md.${process.pid}.tmp`);\n  writeFileSync(tmp, content, \"utf-8\");\n  renameSync(tmp, dest);\n}\n\nfunction mirrorDelete(slug: string): void {\n  rmSync(claudeSkillDir(slug), { recursive: true, force: true });\n}\n\n// `configRefresh` used to fan this out for us as a sibling handler,\n// but running it in parallel with the mirror race'd: the\n// `/api/config/refresh` POST could land before the canonical\n// `.claude/skills/<slug>/SKILL.md` existed on disk, leaving a fresh\n// skill unregistered until the next restart. `skillBridge` now\n// fires the refresh itself, ALWAYS after a successful mirror (or\n// delete), so ordering is deterministic (Codex review on this PR).\nasync function refreshConfig(): Promise<void> {\n  await safePost(buildAuthPost(\"/api/config/refresh\"));\n}\n\nasync function handleWriteOrEdit(payload: HookPayload): Promise<void> {\n  const filePath = extractFilePath(payload);\n  if (!filePath) return;\n  const slug = slugFromDataPath(filePath);\n  if (slug === null) return;\n  try {\n    mirrorWrite(slug);\n    // Order matters: mirror must complete before refresh so the\n    // server's skill scan sees the new SKILL.md. See refreshConfig\n    // comment for the race history.\n    await refreshConfig();\n    // Server-side log line so the user can see from\n    // `server-<date>.log` that the hook fired and what it did.\n    // Without this the mirror is invisible \u2014 a successful copy\n    // and \"the hook never ran\" look identical from the chat UI.\n    await serverLog(\"skill-bridge\", `mirrored ${dataSkillFilePath(slug)} \u2192 ${claudeSkillFilePath(slug)}`, { data: { slug, op: \"write\" } });\n  } catch (err) {\n    // The Write itself succeeded; a failed mirror would leave the\n    // staging copy in place. Surface the failure to server logs\n    // (so the user has a chance to react) but never throw \u2014 the\n    // user's tool turn must stay clean.\n    await serverLog(\"skill-bridge\", `mirror write failed for slug=${slug}`, {\n      level: \"error\",\n      data: { slug, error: errorMessage(err) },\n    });\n  }\n}\n\nasync function handleBash(payload: HookPayload): Promise<void> {\n  const command = extractCommand(payload);\n  if (!command) return;\n  const slug = slugFromRmCommand(command);\n  if (slug === null) return;\n  try {\n    mirrorDelete(slug);\n    // Same ordering invariant as handleWriteOrEdit \u2014 refresh must\n    // run after the canonical dir is gone so the server's rescan\n    // deregisters the deleted skill.\n    await refreshConfig();\n    await serverLog(\"skill-bridge\", `removed ${claudeSkillDir(slug)}`, { data: { slug, op: \"delete\" } });\n  } catch (err) {\n    // Same silent-fail discipline \u2014 a missed delete leaves an\n    // orphan in `.claude/skills/` that the user can clean up\n    // manually, which is better than aborting the tool turn.\n    await serverLog(\"skill-bridge\", `mirror delete failed for slug=${slug}`, {\n      level: \"error\",\n      data: { slug, error: errorMessage(err) },\n    });\n  }\n}\n\nexport async function handleSkillBridge(payload: HookPayload): Promise<void> {\n  const tool = extractToolName(payload);\n  if (tool === \"Write\" || tool === \"Edit\") {\n    await handleWriteOrEdit(payload);\n    return;\n  }\n  if (tool === \"Bash\") {\n    await handleBash(payload);\n  }\n}\n", "// Shared error helpers. Use `errorMessage(err)` instead of inlining\n// `err instanceof Error ? err.message : String(err)` \u2014 searching for\n// one canonical helper is easier than grepping for the inline form.\n//\n// Non-Error objects with a `details` (gRPC convention) or `message`\n// string field have that field surfaced \u2014 without this, gRPC errors\n// like `{ code, details, metadata }` show up to users as\n// `[object Object]`.\n//\n// The optional `fallback` covers the common route-handler idiom where\n// a throw of a plain non-Error value should surface as a descriptive\n// message (\"rebuild failed\") rather than `String(err)` noise. Prefer\n// passing a fallback at error-response boundaries \u2014 omit it for\n// logging contexts where `String(err)` is fine.\n\nexport function errorMessage(err: unknown, fallback?: string): string {\n  if (err instanceof Error) return err.message;\n  if (err !== null && typeof err === \"object\") {\n    const obj = err as { details?: unknown; message?: unknown };\n    if (typeof obj.details === \"string\" && obj.details) return obj.details;\n    if (typeof obj.message === \"string\" && obj.message) return obj.message;\n  }\n  if (fallback !== undefined) return fallback;\n  return String(err);\n}\n", "// Wiki page snapshot handler \u2014 fires after Write/Edit on a wiki\n// page so the snapshot pipeline (#763 PR 2) records the new state.\n//\n// Migrated from `server/workspace/wiki-history/hook/snapshot.ts`.\n// Same behaviour, now part of the unified dispatcher so settings.json\n// carries a single PostToolUse entry instead of one per hook source.\n\nimport path from \"node:path\";\nimport { wikiSlugFromAbsPath } from \"../../../../src/lib/wiki-page/paths.js\";\nimport { buildAuthPost, safePost } from \"../shared/sidecar.js\";\nimport type { HookPayload } from \"../shared/stdin.js\";\nimport { extractFilePath, extractSessionId, extractToolName } from \"../shared/stdin.js\";\nimport { workspaceRoot } from \"../shared/workspace.js\";\n\nconst WIKI_PAGES_REL = path.join(\"data\", \"wiki\", \"pages\");\n\nexport async function handleWikiSnapshot(payload: HookPayload): Promise<void> {\n  const tool = extractToolName(payload);\n  // Wiki pages are written via Write or Edit \u2014 Bash rm or shell\n  // mutations don't go through the snapshot pipeline (the wiki\n  // route does that explicitly server-side when needed).\n  if (tool !== \"Write\" && tool !== \"Edit\") return;\n\n  const filePath = extractFilePath(payload);\n  if (!filePath) return;\n\n  const wikiPagesDir = path.join(workspaceRoot(), WIKI_PAGES_REL);\n  const slug = wikiSlugFromAbsPath(filePath, wikiPagesDir);\n  if (slug === null) return;\n\n  // Prefer the parent server's chatSessionId (#963) \u2014 the server's\n  // session store keys by chatSessionId, not Claude CLI's internal\n  // session_id, so the toolResult publish on the server side only\n  // matches when we forward our own id. Fall back to Claude CLI's\n  // session_id when the env var is absent.\n  const envChatSessionId = process.env.MULMOCLAUDE_CHAT_SESSION_ID;\n  const payloadSessionId = extractSessionId(payload);\n  const sessionId = envChatSessionId && envChatSessionId.length > 0 ? envChatSessionId : payloadSessionId;\n  const body = sessionId === undefined ? { slug } : { slug, sessionId };\n\n  const req = buildAuthPost(\"/api/wiki/internal/snapshot\", body);\n  await safePost(req);\n}\n", "// Node-only wiki-page helpers \u2014 anything that needs `node:path`\n// lives here so the rest of `src/lib/wiki-page/` stays pure\n// (string-only, importable from both browser and Node bundles).\n// Frontend code MUST NOT import this file directly; use the pure\n// modules instead.\n\nimport path from \"node:path\";\nimport { isSafeSlug } from \"./slug.js\";\n\n/** Given an absolute path and the absolute `pagesDir`, return the\n *  slug if `absPath` is a direct `.md` child of `pagesDir`, else\n *  null. Pure path-string math \u2014 no fs IO, no symlink resolution.\n *\n *  Caller responsibility: pass already-realpath'd values for both\n *  arguments. Mixing a realpath'd `absPath` with a symlinked\n *  `pagesDir` (or vice versa) silently mismatches because\n *  `path.relative` is plain string arithmetic. The trap caused\n *  #883 review-iter-1 \u2014 a symlinked workspace silently routed\n *  wiki writes through the generic writer. */\nexport function wikiSlugFromAbsPath(absPath: string, pagesDir: string): string | null {\n  const rel = path.relative(pagesDir, absPath);\n  if (rel.length === 0) return null;\n  if (path.isAbsolute(rel)) return null;\n  // Direct child only \u2014 no nested layout today. Any separator\n  // means the path either escapes (`../secret.md`) or descends\n  // (`subdir/foo.md`). A literal page name like `..foo.md` is a\n  // single segment without a separator and is allowed (codex\n  // iter-3 #883 \u2014 the prior `startsWith(\"..\")` rule wrongly\n  // rejected it).\n  if (rel.includes(path.sep)) return null;\n  if (!rel.endsWith(\".md\")) return null;\n  const slug = rel.slice(0, -\".md\".length);\n  if (!isSafeSlug(slug)) return null;\n  return slug;\n}\n", "// Pure wiki-page slug helpers \u2014 string-only, no Node / browser\n// dependencies, importable from any bundle.\n//\n// Used by:\n//   - server/workspace/wiki-pages/io.ts (the write chokepoint)\n//   - server/workspace/hooks/handlers/wikiSnapshot.ts (the\n//     PostToolUse handler that fires on Write/Edit of a wiki page)\n//   - server/api/routes/wiki.ts (page resolver + lint)\n//   - server/api/routes/wiki/history.ts (history slug guard)\n//   - src/plugins/wiki/route.ts (router slug guard \u2014 replaces the\n//     local `isSafeWikiSlug` duplicate that existed before the\n//     pure-lib refactor)\n//   - src/plugins/wiki/helpers.ts (renderer slugify for [[\u2026]] links)\n//\n// Any helper that needs `node:path` lives in `./paths.ts` so that\n// importing this file from frontend code never pulls in Node\n// builtins.\n\n/** Reject slugs that would escape `data/wiki/pages/` once\n *  joined back into a path, or that are otherwise invalid as\n *  page filenames. The chokepoint must defend itself even when\n *  callers derive the slug from a trusted source \u2014 a typo or\n *  future caller mistake should fail loud, not silently write\n *  outside the wiki tree.\n *\n *  The rule is intentionally narrow \u2014 separators / `..` / NUL /\n *  empty \u2014 so it only rejects unambiguous violations. Aesthetic\n *  concerns (e.g. dot-prefixed filenames) are out of scope: a\n *  pre-existing `data/wiki/pages/.foo.md` should remain writable\n *  through the chokepoint (codex review iter-2 #883). */\nexport function isSafeSlug(slug: string): boolean {\n  if (slug.length === 0) return false;\n  if (slug === \".\" || slug === \"..\") return false;\n  if (slug.includes(\"/\") || slug.includes(\"\\\\\")) return false;\n  if (slug.includes(\"\\0\")) return false;\n  return true;\n}\n\n/** Slug rules for `[[wiki link]]` text \u2192 slug derivation:\n *  lowercase, spaces collapsed to hyphens, every non-ASCII /\n *  non-alphanumeric / non-hyphen character stripped.\n *\n *  Pure: no normalisation, no transliteration \u2014 this is the\n *  same shape the index parser, page resolver, and frontend\n *  renderer all need to agree on. Non-ASCII titles (e.g.\n *  Japanese) collapse to an empty string here; callers fall back\n *  to other strategies (title-match in the index, or the agent\n *  pre-resolving to a slug-form target via `[[slug|display]]`). */\nexport function wikiSlugify(text: string): string {\n  return text\n    .toLowerCase()\n    .replace(/\\s+/g, \"-\")\n    .replace(/[^a-z0-9-]/g, \"\");\n}\n", "// PostToolUse dispatcher \u2014 runs after every Claude CLI Write / Edit\n// / Bash tool call and fans out to the registered handlers. Each\n// handler decides for itself whether the call is relevant (by\n// tool_name + file_path / command), so adding a new behaviour means\n// dropping a new file under `handlers/` and registering it here \u2014\n// settings.json never changes.\n//\n// THIS FILE IS THE SOURCE OF TRUTH. Edits here, then run\n// `yarn build:hooks` (or `yarn build`) to regenerate `./dispatcher.mjs`.\n// The bundled `.mjs` is committed to git so `provision.ts` can read\n// it at server startup without invoking esbuild on the runtime path.\n// CI runs `yarn build:hooks && git diff --exit-code` to catch a\n// stale bundle.\n//\n// The hook executes inside Claude CLI's process space \u2014 must be a\n// self-contained ESM bundle. esbuild rolls every import (handlers,\n// shared, and the wiki-slug helper from `src/lib/`) into one file.\n\nimport { handleConfigRefresh } from \"./handlers/configRefresh.js\";\nimport { handleSkillBridge } from \"./handlers/skillBridge.js\";\nimport { handleWikiSnapshot } from \"./handlers/wikiSnapshot.js\";\nimport { readHookPayload, type HookPayload } from \"./shared/stdin.js\";\n\ntype Handler = (payload: HookPayload) => Promise<void>;\n\n// Order is informational only \u2014 handlers don't interact. Add new\n// entries here. Each one is wrapped so an individual failure\n// doesn't block its siblings (the user's tool turn would visibly\n// stall otherwise).\nconst HANDLERS: Handler[] = [handleWikiSnapshot, handleConfigRefresh, handleSkillBridge];\n\nasync function runHandler(handler: Handler, payload: HookPayload): Promise<void> {\n  try {\n    await handler(payload);\n  } catch {\n    // Hooks run synchronously to the LLM tool flow \u2014 never throw.\n    // A busted handler would make the tool itself look like it\n    // failed to the LLM, which is much worse than a missed\n    // side-effect.\n  }\n}\n\nasync function main(): Promise<void> {\n  const payload = await readHookPayload();\n  if (!payload) return;\n  // Run handlers in parallel \u2014 they touch disjoint resources\n  // (wiki snapshot endpoint vs config-refresh endpoint vs local\n  // file copy) and serialising them would push the per-turn\n  // latency past the 2 s safePost timeout under bad conditions.\n  await Promise.all(HANDLERS.map((handler) => runHandler(handler, payload)));\n}\n\nmain().catch(() => {\n  // Outermost safety net \u2014 see runHandler comment.\n});\n"],
  "mappings": "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",
  "names": ["path", "path", "readFileSync", "path", "path", "readFileSync", "path", "path", "path", "path"]
}


package/server/workspace/paths.ts

@@ -12,10 +12,9 @@
 //   artifacts/       LLM-generated (charts, html, images, documents,
 //                    spreadsheets, stories, news)
 //
-// Existing workspaces need the one-shot `scripts/migrate-workspace-284.ts`
-// script run before first startup with this code. `server/workspace.ts`
-// detects the pre-migration layout at boot and aborts with a pointer
-// to the script.
+// Pre-#284 workspaces (with `chat/`, `summaries/`, `memory.md` at the
+// root) continue to boot — the modern layout above is what new
+// installs use, but the older directory names are still accepted.
 //
 // When adding a new top-level directory: add the name to the
 // `WORKSPACE_DIRS` record below. The absolute path is derived
@@ -154,6 +153,16 @@ const HOST_WORKSPACE_DIRS = {
   // so server code references it through `WORKSPACE_PATHS.claudeSkills`
   // instead of inlining the string.
   claudeSkills: ".claude/skills",
+  // Skill catalog root (#1335). Holds preset skills shipped with the
+  // launcher (`catalog/preset/`) and — in later PRs — git-synced
+  // Anthropic skills (`catalog/anthropic/`) and community URL-install
+  // entries (`catalog/community/`). Entries here are catalog-only:
+  // visible to UI / tooling but NOT discovered by Claude Code's
+  // slash-command resolver. An entry becomes active by being copied
+  // (or symlinked) into `.claude/skills/`. The catalog vs active
+  // split keeps unused skills out of the system prompt.
+  skillsCatalog: "data/skills/catalog",
+  skillsCatalogPreset: "data/skills/catalog/preset",
   // Nested subdirs inside a top-level grouping. Kept here (rather
   // than module-local constants) when multiple modules need to
   // reference the same nested path — e.g. wiki/pages/ is used by