@outerlayer/cli 0.1.0

package/dist/chunk-A6NNKRJU.js

@@ -0,0 +1,650 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { deadHooksState, huskyPrepareScript, preparePackageManagerCommand } from './chunk-IWIUYLDR.js';
+import { homeFromEnv } from './chunk-VNVZDWO3.js';
+import { readFileSync, mkdirSync, writeFileSync, renameSync, existsSync, statSync, appendFileSync, openSync, opendirSync, unlinkSync } from 'fs';
+import { spawn, execFileSync } from 'child_process';
+import { createHash } from 'crypto';
+import { join, dirname, isAbsolute, resolve } from 'path';
+
+createRequire(import.meta.url);
+var SYNC_STALE_AFTER_MS = 6 * 60 * 60 * 1e3;
+function syncStatusPath(home = homeFromEnv()) {
+  return join(home, ".outerlayer", "last-sync.json");
+}
+function readSyncStatus(home = homeFromEnv()) {
+  try {
+    const raw = readFileSync(syncStatusPath(home), "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed.at !== "string" || typeof parsed.ok !== "boolean") return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function writeSyncStatus(status, home = homeFromEnv()) {
+  try {
+    const previous = readSyncStatus(home);
+    const merged = {
+      ...status,
+      lastOkAt: status.ok && status.contacted !== false ? status.at : status.lastOkAt ?? previous?.lastOkAt
+    };
+    const path = syncStatusPath(home);
+    mkdirSync(join(home, ".outerlayer"), { recursive: true });
+    const tmp = `${path}.tmp`;
+    writeFileSync(tmp, JSON.stringify(merged, null, 2), { mode: 384 });
+    renameSync(tmp, path);
+  } catch {
+  }
+}
+function formatAgo(ms) {
+  const age = formatAge(ms);
+  return age === "just now" || age === "unknown" ? age : `${age} ago`;
+}
+function formatAge(ms) {
+  if (!Number.isFinite(ms) || ms < 0) return "unknown";
+  const minutes = Math.floor(ms / 6e4);
+  if (minutes < 1) return "just now";
+  if (minutes < 60) return `${minutes}m`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 48) return `${hours}h`;
+  return `${Math.floor(hours / 24)}d`;
+}
+function assessSyncHealth(status, now = Date.now(), staleAfterMs = SYNC_STALE_AFTER_MS) {
+  if (!status) {
+    return {
+      level: "unknown",
+      headline: "no sync has run on this machine yet",
+      details: ["run `outerlayer sync` once to verify the connection"]
+    };
+  }
+  const host = status.url ? safeHost(status.url) : "the configured endpoint";
+  if (!status.ok) {
+    const brokenFor = status.lastOkAt ? formatAgo(now - Date.parse(status.lastOkAt)) : null;
+    const details = [];
+    details.push(
+      status.error?.status ? `HTTP ${status.error.status} from ${host}: ${status.error.message}` : `${host}: ${status.error?.message ?? "unknown error"}`
+    );
+    details.push(
+      brokenFor ? `last successful sync ${brokenFor}` : "no successful sync has ever been recorded for this destination"
+    );
+    if (status.pending) details.push(`${status.pending} session(s) waiting to ship`);
+    if (status.held) details.push(`${status.held} transcript(s) held \u2014 their launch could not be determined`);
+    details.push("run `outerlayer doctor` for the full picture");
+    return {
+      level: "error",
+      headline: `sync is FAILING \u2014 last attempt ${formatAgo(now - Date.parse(status.at))}`,
+      details
+    };
+  }
+  const age = now - Date.parse(status.at);
+  const verifiedAt = status.contacted === false ? status.lastOkAt : status.at;
+  const verifiedAge = verifiedAt === void 0 ? null : now - Date.parse(verifiedAt);
+  if (verifiedAge !== null && verifiedAge > staleAfterMs) {
+    return {
+      level: "warn",
+      headline: `last successful sync ${formatAgo(verifiedAge)}`,
+      details: [`destination ${host}`, "expected continuously while you are coding"]
+    };
+  }
+  if (status.synced === 0 && (status.skippedNotLaunched ?? 0) > 0) {
+    return {
+      level: "warn",
+      headline: `synced ${formatAgo(age)} \u2192 ${host}, but nothing uploaded`,
+      details: [
+        `${status.skippedNotLaunched} transcript(s) were not launched with OUTERLAYER_WORK, so none may upload`,
+        "launch a session with OUTERLAYER_WORK naming its issue to upload it"
+      ]
+    };
+  }
+  if (verifiedAge === null) {
+    return {
+      level: "warn",
+      headline: `sync ran ${formatAgo(age)} but ${host} has never been reached`,
+      details: [
+        "every run so far had an empty queue, so the connection is unproven",
+        "run `outerlayer sync --all` to verify it"
+      ]
+    };
+  }
+  if (status.contacted === false) {
+    return {
+      level: "ok",
+      headline: `nothing to sync \u2014 ${host} last reached ${formatAgo(verifiedAge)}`,
+      details: []
+    };
+  }
+  return {
+    level: "ok",
+    headline: `synced ${formatAgo(age)} \u2192 ${host}`,
+    details: []
+  };
+}
+function safeHost(url) {
+  try {
+    return new URL(url).host;
+  } catch {
+    return url;
+  }
+}
+var PKG_NAME = "outerlayer";
+function installedCliDistDir(home) {
+  return join(home, ".outerlayer", "cli", "dist");
+}
+function readBuildInfo(distDir) {
+  try {
+    const raw = readFileSync(join(distDir, "build-info.json"), "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed.pkg !== PKG_NAME) return null;
+    if (typeof parsed.id !== "string" || parsed.id.length === 0) return null;
+    return { id: parsed.id, root: typeof parsed.root === "string" && parsed.root.length > 0 ? parsed.root : null };
+  } catch {
+    return null;
+  }
+}
+function buildTimestampMs(id) {
+  const iso = id.split("+")[0];
+  const ms = Date.parse(iso);
+  return Number.isNaN(ms) ? null : ms;
+}
+var MAX_ANCESTOR_HOPS = 25;
+function resolveWorkspaceCliDist(cwd) {
+  let dir = resolve(cwd);
+  for (let i = 0; i < MAX_ANCESTOR_HOPS; i++) {
+    const candidate = join(dir, "packages", "cli", "dist");
+    if (readBuildInfo(candidate) !== null) return candidate;
+    const parent = dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+  return null;
+}
+var SKIP_CHILD_NAMES = /* @__PURE__ */ new Set(["node_modules"]);
+var MAX_CHILD_PROBES = 200;
+function probeChildCheckouts(cwd) {
+  let dir;
+  try {
+    dir = opendirSync(cwd);
+  } catch {
+    return { distDir: null, ambiguous: false };
+  }
+  const candidates = [];
+  try {
+    let probed = 0;
+    let entry;
+    while (probed < MAX_CHILD_PROBES && (entry = dir.readSync()) !== null) {
+      probed += 1;
+      if (!entry.isDirectory()) continue;
+      if (entry.name.startsWith(".") || SKIP_CHILD_NAMES.has(entry.name)) continue;
+      const candidate = join(cwd, entry.name, "packages", "cli", "dist");
+      if (readBuildInfo(candidate) !== null) {
+        candidates.push(candidate);
+        if (candidates.length > 1) break;
+      }
+    }
+  } catch {
+    return { distDir: null, ambiguous: false };
+  } finally {
+    try {
+      dir.closeSync();
+    } catch {
+    }
+  }
+  if (candidates.length === 0) return { distDir: null, ambiguous: false };
+  if (candidates.length > 1) return { distDir: null, ambiguous: true };
+  return { distDir: candidates[0], ambiguous: false };
+}
+function resolveWorkspaceDist(cwd, recordedRoot) {
+  const recordedDist = recordedRoot ? join(recordedRoot, "packages", "cli", "dist") : null;
+  const viaWalkUp = resolveWorkspaceCliDist(cwd);
+  if (viaWalkUp) return { distDir: viaWalkUp, trusted: viaWalkUp === recordedDist, ambiguous: false };
+  const probed = probeChildCheckouts(cwd);
+  if (probed.distDir) return { distDir: probed.distDir, trusted: probed.distDir === recordedDist, ambiguous: false };
+  if (probed.ambiguous) return { distDir: null, trusted: false, ambiguous: true };
+  if (recordedDist && readBuildInfo(recordedDist) !== null) return { distDir: recordedDist, trusted: true, ambiguous: false };
+  return { distDir: null, trusted: false, ambiguous: false };
+}
+function checkInstalledCliStaleness(opts) {
+  const installedDir = installedCliDistDir(opts.home);
+  if (!existsSync(join(installedDir, "index.js"))) return null;
+  const installed = readBuildInfo(installedDir);
+  const resolved = resolveWorkspaceDist(opts.cwd, installed?.root ?? null);
+  const workspaceDistDir = resolved.distDir;
+  const workspaceRootTrusted = resolved.trusted;
+  const workspace = workspaceDistDir ? readBuildInfo(workspaceDistDir) : null;
+  const installedId = installed?.id ?? null;
+  const workspaceId = workspace?.id ?? null;
+  if (workspaceId === null) {
+    return {
+      stale: false,
+      installedId,
+      workspaceId: null,
+      workspaceDistDir: null,
+      workspaceRootTrusted: false,
+      ambiguousWorkspace: resolved.ambiguous,
+      unorderable: false,
+      installedAhead: false
+    };
+  }
+  if (installedId === null) {
+    return {
+      stale: true,
+      installedId: null,
+      workspaceId,
+      workspaceDistDir,
+      workspaceRootTrusted,
+      ambiguousWorkspace: false,
+      unorderable: false,
+      installedAhead: false
+    };
+  }
+  const installedMs = buildTimestampMs(installedId);
+  const workspaceMs = buildTimestampMs(workspaceId);
+  if (installedMs === null || workspaceMs === null) {
+    return {
+      stale: false,
+      installedId,
+      workspaceId,
+      workspaceDistDir,
+      workspaceRootTrusted,
+      ambiguousWorkspace: false,
+      unorderable: true,
+      installedAhead: false
+    };
+  }
+  return {
+    stale: installedMs < workspaceMs,
+    installedId,
+    workspaceId,
+    workspaceDistDir,
+    workspaceRootTrusted,
+    ambiguousWorkspace: false,
+    unorderable: false,
+    installedAhead: installedMs > workspaceMs
+  };
+}
+function workspaceRootOf(workspaceDistDir) {
+  return dirname(dirname(dirname(workspaceDistDir)));
+}
+var MAX_SANITIZED_LENGTH = 200;
+var MAX_RAW_SCAN_LENGTH = 2e3;
+var UNICODE_FORMAT_CHAR = /\p{Cf}/u;
+function isUnsafeContextChar(ch) {
+  const code = ch.codePointAt(0) ?? 0;
+  if (code < 32 || code === 127) return true;
+  if (code >= 128 && code <= 159) return true;
+  if (code === 8232 || code === 8233) return true;
+  return UNICODE_FORMAT_CHAR.test(ch);
+}
+function sanitizeForContext(value) {
+  const bounded = value.length > MAX_RAW_SCAN_LENGTH ? value.slice(0, MAX_RAW_SCAN_LENGTH) : value;
+  let out = "";
+  for (const ch of bounded) {
+    if (out.length >= MAX_SANITIZED_LENGTH) break;
+    if (isUnsafeContextChar(ch)) continue;
+    out += ch;
+  }
+  return out;
+}
+function containsUnsafeContextChar(value) {
+  for (const ch of value) {
+    if (isUnsafeContextChar(ch)) return true;
+  }
+  return false;
+}
+var SHELL_UNSAFE = /["$`\\\n]/;
+function refreshCommand(workspaceDistDir, trusted) {
+  if (!trusted) return null;
+  const root = workspaceRootOf(workspaceDistDir);
+  if (SHELL_UNSAFE.test(root) || containsUnsafeContextChar(root)) return null;
+  return `cd "${root}" && yarn workspace @outerlayer/cli build && mkdir -p ~/.outerlayer/cli && rm -rf ~/.outerlayer/cli/dist && cp -r packages/cli/dist ~/.outerlayer/cli/dist`;
+}
+
+// src/hook-fast.ts
+function spoolDir(home = homeFromEnv()) {
+  return join(home, ".outerlayer", "spool");
+}
+function hookFiredMarkerPath(event, home = homeFromEnv()) {
+  const safe = event.replace(/[^A-Za-z0-9_-]/g, "").slice(0, 64) || "unknown";
+  return join(spoolDir(home), `last-fired-${safe}`);
+}
+function fileSizeBytes(path) {
+  try {
+    return statSync(path).size;
+  } catch {
+    return 0;
+  }
+}
+function hookErrorsSeenPath(home) {
+  return join(spoolDir(home), "hook-errors-seen");
+}
+function hookErrorsSeenBytes(home) {
+  try {
+    const bytes = Number.parseInt(readFileSync(hookErrorsSeenPath(home), "utf8"), 10);
+    return bytes >= 0 ? bytes : 0;
+  } catch {
+    return 0;
+  }
+}
+function recordHookErrorsSeen(home, bytes) {
+  try {
+    writeFileSync(hookErrorsSeenPath(home), String(bytes) + "\n");
+  } catch {
+  }
+}
+function markHookFired(event, home) {
+  try {
+    writeFileSync(hookFiredMarkerPath(event, home), (/* @__PURE__ */ new Date()).toISOString() + "\n");
+  } catch {
+  }
+}
+var readStdin = () => {
+  try {
+    return readFileSync(0, "utf8");
+  } catch {
+    return "";
+  }
+};
+var AUTO_SYNC_DEBOUNCE_MS = 5 * 60 * 1e3;
+function appendFd(path) {
+  if (path === void 0) return "ignore";
+  try {
+    return openSync(path, "a");
+  } catch {
+    return "ignore";
+  }
+}
+var spawnDetached = (command, args, stderrPath) => {
+  const child = spawn(command, args, { detached: true, stdio: ["ignore", "ignore", appendFd(stderrPath)] });
+  child.unref();
+};
+function maybeAutoSync(event, home = homeFromEnv(), spawnImpl = spawnDetached, now = Date.now()) {
+  try {
+    if (event !== "SessionEnd" && event !== "Stop") return;
+    const marker = join(spoolDir(home), "last-auto-sync");
+    try {
+      if (now - statSync(marker).mtimeMs < AUTO_SYNC_DEBOUNCE_MS) return;
+    } catch {
+    }
+    const configPath = join(home, ".outerlayer", "config.json");
+    if (!existsSync(configPath)) return;
+    const config = JSON.parse(readFileSync(configPath, "utf8"));
+    if (config.autoSync === false) return;
+    if (!config.url || !config.apiKey || !config.appId) return;
+    writeFileSync(marker, String(now));
+    spawnImpl(process.execPath, [process.argv[1], "sync", "--quiet"]);
+  } catch {
+  }
+}
+var WORK_ADD_RETRIES = 4;
+function hookErrorsContext(home, writtenBytes, seenBytes) {
+  if (writtenBytes === 0) return null;
+  if (writtenBytes === seenBytes) return null;
+  const path = join(spoolDir(home), "hook-errors.log");
+  return `OuterLayer recorded a hook failure since your last session started \u2014 a refused OUTERLAYER_WORK value, or a work-item session link that could not reach the Floor. The log is ${path}.`;
+}
+async function handleWorkLaunch(sessionId, home, env, spawnImpl = spawnDetached) {
+  if (!sessionId || env.OUTERLAYER_WORK === void 0) return void 0;
+  const { parseWorkItemEnv, appendLaunchRecord } = await import('./work-launch-YNNCKIH3.js');
+  const parsed = parseWorkItemEnv(env.OUTERLAYER_WORK);
+  if ("reason" in parsed) {
+    logHookError(home, new Error(`OUTERLAYER_WORK ignored: ${parsed.reason}`));
+    return `OuterLayer ignored this session's OUTERLAYER_WORK value: ${sanitizeForContext(parsed.reason)}. The session is not attached to a work item and will not upload. Hook failures are logged to ${join(spoolDir(home), "hook-errors.log")}.`;
+  }
+  appendLaunchRecord({ sessionId, item: parsed.number }, home);
+  spawnImpl(
+    process.execPath,
+    [
+      process.argv[1],
+      "work",
+      "link-session",
+      String(parsed.number),
+      "--session-id",
+      sessionId,
+      // The ordinary failure is a gateway that is briefly unreachable — a
+      // laptop that has not joined the network yet, a restart. Nothing else
+      // ever retries this link: the launch record is already written, so
+      // the session uploads whether or not the Floor ever hears about the
+      // link. Retrying costs nothing here (this process is detached; the
+      // hook has already returned) and cannot double-link, because the
+      // link is keyed by the session id passed above.
+      "--retry",
+      String(WORK_ADD_RETRIES)
+    ],
+    // The link runs after this hook has exited, so its own failure
+    // (offline, revoked key, unknown item number) has nowhere else to be
+    // seen: without this the session uploads later with no Floor link and
+    // no trace of why.
+    join(spoolDir(home), "hook-errors.log")
+  );
+  return void 0;
+}
+function syncHealthContext(home) {
+  if (!existsSync(join(home, ".outerlayer", "config.json"))) return null;
+  const health = assessSyncHealth(readSyncStatus(home));
+  if (health.level !== "error") return null;
+  return [`OuterLayer sync is failing on this machine: ${health.headline}`, ...health.details.map((d) => `  - ${d}`)].join("\n");
+}
+var UNTRUSTED_STALE_CLI_CONTEXT = "The installed OuterLayer CLI appears stale relative to a checkout near your working directory; run `outerlayer doctor` for details.";
+function installedCliStalenessContext(home, cwd) {
+  const result = checkInstalledCliStaleness({ home, cwd });
+  if (result === null || !result.stale) return null;
+  if (!result.workspaceRootTrusted) return UNTRUSTED_STALE_CLI_CONTEXT;
+  const installedLabel = sanitizeForContext(result.installedId);
+  const workspaceLabel = sanitizeForContext(result.workspaceId);
+  const command = refreshCommand(result.workspaceDistDir, result.workspaceRootTrusted);
+  const howToRefresh = command ? `Refresh it: ${command}` : `Workspace build found at ${sanitizeForContext(workspaceRootOf(result.workspaceDistDir))}. Rebuild it (yarn workspace @outerlayer/cli build) and copy packages/cli/dist to ~/.outerlayer/cli/dist to refresh the installed copy.`;
+  return `The installed OuterLayer CLI (~/.outerlayer/cli) is behind the workspace build: installed ${installedLabel}, workspace ${workspaceLabel}.
+${howToRefresh}`;
+}
+function writeSessionStartContext(event, home, cwd, write, extraParts = []) {
+  try {
+    if (event !== "SessionStart") return;
+    const parts = [syncHealthContext(home), installedCliStalenessContext(home, cwd), ...extraParts].filter(
+      (s) => s !== null
+    );
+    if (parts.length === 0) return;
+    write(
+      JSON.stringify({
+        hookSpecificOutput: { hookEventName: "SessionStart", additionalContext: parts.join("\n\n") }
+      })
+    );
+  } catch {
+  }
+}
+var HEAL_RETRY_INTERVAL_MS = 6 * 60 * 60 * 1e3;
+function healFailureMarkerPath(home, repoRoot) {
+  const key = createHash("sha256").update(repoRoot).digest("hex").slice(0, 16);
+  return join(spoolDir(home), `dead-hooks-heal-failed-${key}`);
+}
+function recentHealFailure(home, repoRoot) {
+  try {
+    const ageMs = Date.now() - statSync(healFailureMarkerPath(home, repoRoot)).mtimeMs;
+    return ageMs < HEAL_RETRY_INTERVAL_MS;
+  } catch {
+    return false;
+  }
+}
+function markHealFailure(home, repoRoot) {
+  try {
+    mkdirSync(spoolDir(home), { recursive: true });
+    writeFileSync(healFailureMarkerPath(home, repoRoot), (/* @__PURE__ */ new Date()).toISOString());
+  } catch {
+  }
+}
+function clearHealFailureMarker(home, repoRoot) {
+  try {
+    unlinkSync(healFailureMarkerPath(home, repoRoot));
+  } catch {
+  }
+}
+function deadHooksAutoHealContext(cwd, home) {
+  if (findGitRoot(cwd) === void 0) return null;
+  const state = deadHooksState(cwd);
+  if (!state.dead || state.repoRoot === void 0 || state.hooksDir === void 0) return null;
+  const hooksDirLabel = sanitizeForContext(state.hooksDir);
+  const script = huskyPrepareScript(state.repoRoot);
+  if (script === null) {
+    return `Git hooks are dead in this checkout (${hooksDirLabel} is missing or empty, via core.hooksPath) and package.json declares no husky prepare script to run automatically. Run \`outerlayer doctor\` for the fix.`;
+  }
+  if (recentHealFailure(home, state.repoRoot)) {
+    return `Git hooks are still dead in this checkout (${hooksDirLabel}) \u2014 a previous auto-heal attempt failed recently, so it will not retry yet. Run \`outerlayer doctor\` for the fix.`;
+  }
+  const command = preparePackageManagerCommand(state.repoRoot);
+  const [bin, ...args] = command.split(" ");
+  try {
+    execFileSync(bin, args, { cwd: state.repoRoot, stdio: "ignore", timeout: 3e4 });
+  } catch (err) {
+    markHealFailure(home, state.repoRoot);
+    return `OuterLayer tried to regenerate dead git hooks by running \`${command}\`, but it failed: ${sanitizeForContext(err instanceof Error ? err.message : String(err))}`;
+  }
+  const after = deadHooksState(state.repoRoot);
+  if (after.dead) {
+    markHealFailure(home, state.repoRoot);
+    return `OuterLayer ran \`${command}\` to regenerate dead git hooks, but ${hooksDirLabel} is still missing or empty afterward. Run \`outerlayer doctor\` for the fix.`;
+  }
+  clearHealFailureMarker(home, state.repoRoot);
+  return null;
+}
+var PIN_FILENAME = ".outerlayer-pin.json";
+function sourceCachePath(gitCommonDir) {
+  return join(gitCommonDir, "outerlayer", "source.json");
+}
+function findGitRoot(cwd) {
+  let dir = cwd;
+  for (; ; ) {
+    const gitPath = join(dir, ".git");
+    let stat;
+    try {
+      stat = statSync(gitPath);
+    } catch {
+      stat = void 0;
+    }
+    if (stat?.isDirectory()) return { repoRoot: dir, gitCommonDir: gitPath };
+    if (stat?.isFile()) {
+      try {
+        const content = readFileSync(gitPath, "utf8").trim();
+        const match = /^gitdir:\s*(.+)$/.exec(content);
+        if (match) {
+          const gitdir = isAbsolute(match[1]) ? match[1] : join(dir, match[1]);
+          try {
+            const commondir = readFileSync(join(gitdir, "commondir"), "utf8").trim();
+            return { repoRoot: dir, gitCommonDir: isAbsolute(commondir) ? commondir : join(gitdir, commondir) };
+          } catch {
+            return { repoRoot: dir, gitCommonDir: gitdir };
+          }
+        }
+      } catch {
+      }
+    }
+    const parent = dirname(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}
+function contextPossiblyGoverned(cwd, home = homeFromEnv()) {
+  try {
+    const found = findGitRoot(cwd);
+    if (found === void 0) return false;
+    const { repoRoot, gitCommonDir } = found;
+    if (existsSync(join(repoRoot, PIN_FILENAME))) return true;
+    if (!existsSync(join(home, ".outerlayer", "config.json"))) return false;
+    let cache;
+    try {
+      cache = JSON.parse(readFileSync(sourceCachePath(gitCommonDir), "utf8"));
+    } catch {
+      cache = void 0;
+    }
+    if (!cache) return true;
+    if (cache.status === "governed") return true;
+    if (typeof cache.checkedAt !== "string" || typeof cache.ttlMs !== "number") return true;
+    const fresh = Date.now() - Date.parse(cache.checkedAt) < cache.ttlMs;
+    return !fresh;
+  } catch {
+    return false;
+  }
+}
+async function runHookFast(event, home = homeFromEnv(), read = readStdin, env = process.env, spawnImpl = spawnDetached) {
+  try {
+    const dir = spoolDir(home);
+    mkdirSync(dir, { recursive: true });
+    const stdin = read();
+    let payload = {};
+    try {
+      payload = stdin ? JSON.parse(stdin) : {};
+    } catch {
+      payload = {};
+    }
+    const resolvedEvent = String(event ?? payload.hook_event_name ?? "unknown");
+    const record = {
+      t: (/* @__PURE__ */ new Date()).toISOString(),
+      event: resolvedEvent,
+      sessionId: payload.session_id ?? null,
+      transcriptPath: payload.transcript_path ?? null,
+      cwd: payload.cwd ?? null
+    };
+    appendFileSync(join(dir, "events.jsonl"), JSON.stringify(record) + "\n");
+    markHookFired(resolvedEvent, home);
+    maybeAutoSync(resolvedEvent, home, spawnImpl);
+    const sessionCwd = typeof payload.cwd === "string" ? payload.cwd : process.cwd();
+    let materializeMessage;
+    let deadHooksMessage;
+    let workLaunchMessage;
+    let hookErrorsMessage;
+    if (resolvedEvent === "SessionStart") {
+      const hookErrorsBytes = fileSizeBytes(join(dir, "hook-errors.log"));
+      const hookErrorsSeen = hookErrorsSeenBytes(home);
+      recordHookErrorsSeen(home, hookErrorsBytes);
+      if (contextPossiblyGoverned(sessionCwd, home)) {
+        try {
+          const { materializeContext: materialize } = await import('./context-materialize-J6CRQ7O7.js');
+          const sessionId = typeof payload.session_id === "string" ? payload.session_id : "unknown";
+          const result = await materialize({ cwd: sessionCwd, sessionId, home });
+          materializeMessage = result.message;
+        } catch (err) {
+          logHookError(home, err);
+        }
+      }
+      try {
+        deadHooksMessage = deadHooksAutoHealContext(sessionCwd, home) ?? void 0;
+      } catch (err) {
+        logHookError(home, err);
+      }
+      try {
+        const sessionId = typeof payload.session_id === "string" ? payload.session_id : void 0;
+        workLaunchMessage = await handleWorkLaunch(sessionId, home, env, spawnImpl);
+      } catch (err) {
+        logHookError(home, err);
+      }
+      if (workLaunchMessage === void 0) {
+        hookErrorsMessage = hookErrorsContext(home, hookErrorsBytes, hookErrorsSeen) ?? void 0;
+      }
+    }
+    writeSessionStartContext(
+      resolvedEvent,
+      home,
+      sessionCwd,
+      (out) => process.stdout.write(out),
+      [materializeMessage, deadHooksMessage, workLaunchMessage, hookErrorsMessage].filter(
+        (s) => s !== void 0
+      )
+    );
+  } catch (err) {
+    logHookError(home, err);
+  }
+}
+function logHookError(home, err) {
+  try {
+    const dir = spoolDir(home);
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(
+      join(dir, "hook-errors.log"),
+      `${(/* @__PURE__ */ new Date()).toISOString()} ${err instanceof Error ? err.message : String(err)}
+`,
+      { flag: "a" }
+    );
+  } catch {
+  }
+}
+
+export { AUTO_SYNC_DEBOUNCE_MS, SYNC_STALE_AFTER_MS, WORK_ADD_RETRIES, assessSyncHealth, checkInstalledCliStaleness, contextPossiblyGoverned, formatAgo, handleWorkLaunch, hookFiredMarkerPath, maybeAutoSync, readSyncStatus, refreshCommand, runHookFast, sanitizeForContext, spoolDir, workspaceRootOf, writeSyncStatus };

package/dist/chunk-D77LS3UI.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { isSameProcess } from './chunk-OZ7C3XUE.js';
+import { RUNNER_DIR_MODE, RUNNER_FILE_MODE } from './chunk-JJP7YLMN.js';
+import { existsSync, readFileSync, rmSync, mkdirSync, writeFileSync } from 'fs';
+import { dirname } from 'path';
+
+createRequire(import.meta.url);
+function readPidFile(path) {
+  if (!existsSync(path)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (typeof parsed.pid !== "number" || typeof parsed.start !== "string") return null;
+    return { pid: parsed.pid, start: parsed.start };
+  } catch {
+    return null;
+  }
+}
+function writePidFile(path, entry) {
+  mkdirSync(dirname(path), { recursive: true, mode: RUNNER_DIR_MODE });
+  writeFileSync(path, JSON.stringify(entry), { mode: RUNNER_FILE_MODE });
+}
+function releasePidFile(path, self) {
+  const existing = readPidFile(path);
+  if (!existing || existing.pid !== self.pid || existing.start !== self.start) return;
+  rmSync(path, { force: true });
+}
+var RunnerAlreadyRunningError = class extends Error {
+  constructor(pid) {
+    super(`a runner is already running on this config (pid ${pid})`);
+    this.pid = pid;
+  }
+};
+function claimPidFile(path, self, isSameProcessFn = isSameProcess) {
+  const existing = readPidFile(path);
+  if (existing && isSameProcessFn(existing.pid, existing.start)) {
+    throw new RunnerAlreadyRunningError(existing.pid);
+  }
+  writePidFile(path, self);
+}
+
+export { RunnerAlreadyRunningError, claimPidFile, readPidFile, releasePidFile };