@outerlayer/cli 0.1.0

package/dist/chunk-ECSYRPCC.js

@@ -0,0 +1,334 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { homeFromEnv } from './chunk-VNVZDWO3.js';
+import { existsSync, readFileSync, mkdirSync, copyFileSync, writeFileSync } from 'fs';
+import { join, dirname } from 'path';
+
+createRequire(import.meta.url);
+var REGISTERED_EVENTS = ["SessionStart", "SessionEnd", "Stop"];
+var MARKER = "_outerlayer";
+function settingsPath(scope, opts = {}) {
+  const home = opts.home ?? homeFromEnv();
+  const cwd = opts.cwd ?? process.cwd();
+  return scope === "user" ? join(home, ".claude", "settings.json") : join(cwd, ".claude", "settings.json");
+}
+var WRAP_MARKER = "_outerlayerWrapped";
+function tokenizeCommand(command) {
+  const tokens = [];
+  let current = "";
+  let inToken = false;
+  let quote = null;
+  for (const ch of command) {
+    if (quote !== null) {
+      if (ch === quote) quote = null;
+      else current += ch;
+    } else if (ch === '"' || ch === "'") {
+      quote = ch;
+      inToken = true;
+    } else if (/\s/.test(ch)) {
+      if (inToken) {
+        tokens.push(current);
+        current = "";
+        inToken = false;
+      }
+    } else {
+      current += ch;
+      inToken = true;
+    }
+  }
+  if (quote !== null) return null;
+  if (inToken) tokens.push(current);
+  return tokens;
+}
+function quoteBin(bin) {
+  return /\s/.test(bin) ? `"${bin}"` : bin;
+}
+function isOurBin(bin, cliBin) {
+  if (cliBin !== void 0 && normalizeBinPath(bin) === normalizeBinPath(cliBin)) return true;
+  const parts = bin.replace(/\\/g, "/").split("/");
+  const base = (parts.pop() ?? "").toLowerCase();
+  if (base === "outerlayer" || base === "outerlayer.exe" || base === "outerlayer.cmd") return true;
+  return parts.some((p) => p.toLowerCase() === ".outerlayer");
+}
+function normalizeBinPath(bin) {
+  return bin.replace(/\\/g, "/");
+}
+function parseCliInvocation(command, cliBin) {
+  if (typeof command !== "string") return null;
+  const tokens = tokenizeCommand(command.trim());
+  if (!tokens) return null;
+  let i = 0;
+  const launcher = (tokens[0] ?? "").replace(/\\/g, "/").split("/").pop() ?? "";
+  if (launcher === "node" || launcher === "node.exe" || launcher === "npx") i = 1;
+  const bin = tokens[i];
+  if (!bin || !isOurBin(bin, cliBin)) return null;
+  return tokens.slice(i + 1);
+}
+function parseLifecycleHookCommand(command, cliBin) {
+  const args = parseCliInvocation(command, cliBin);
+  if (!args || args.length !== 2 || args[0] !== "hook") return null;
+  return REGISTERED_EVENTS.includes(args[1]) ? args[1] : null;
+}
+function decodeVerifiedWrapId(token) {
+  if (typeof token !== "string") return null;
+  const original = decodeWrappedCommand(token);
+  const canonical = encodeWrappedCommand(original);
+  return canonical.replace(/=+$/, "") === token.replace(/=+$/, "") ? original : null;
+}
+function parseWrappedHookCommand(command, cliBin) {
+  const args = parseCliInvocation(command, cliBin);
+  if (!args || args[0] !== "hook-wrap" || args[1] !== "--id") return null;
+  if (args.length === 4 ? args[3] !== "--capture-output" : args.length !== 3) return null;
+  return decodeVerifiedWrapId(args[2]);
+}
+function isOurHookCommand(h) {
+  return isOurHookCommandFor(h, void 0);
+}
+function isOurHookCommandFor(h, cliBin) {
+  return h[MARKER] === true || parseLifecycleHookCommand(h.command, cliBin) !== null;
+}
+function wrappedOriginalCommand(h, cliBin) {
+  if (typeof h[WRAP_MARKER] === "string") return h[WRAP_MARKER];
+  return parseWrappedHookCommand(h.command, cliBin);
+}
+function isWrapped(h, cliBin) {
+  return wrappedOriginalCommand(h, cliBin) !== null;
+}
+function cliBinResolvable(cliBin) {
+  if (!cliBin.includes("/") && !cliBin.includes("\\")) return true;
+  return existsSync(cliBin);
+}
+function readSettings(path) {
+  if (!existsSync(path)) return null;
+  const text = readFileSync(path, "utf8");
+  if (text.trim() === "") return {};
+  try {
+    return JSON.parse(text);
+  } catch (err) {
+    throw new SettingsParseError(path, err);
+  }
+}
+var SettingsParseError = class extends Error {
+  constructor(path, cause) {
+    super(`refusing to modify ${path}: it is not valid JSON (${cause instanceof Error ? cause.message : cause})`);
+    this.path = path;
+    this.cause = cause;
+    this.name = "SettingsParseError";
+  }
+};
+function ourEntry(cliBin, event) {
+  return {
+    hooks: [{ type: "command", command: `${quoteBin(cliBin)} hook ${event}`, [MARKER]: true }]
+  };
+}
+function pruneOurHooks(blocks, cliBin) {
+  let removedAny = false;
+  const kept = blocks.filter((block) => {
+    const original = block.hooks ?? [];
+    const remaining = original.filter((h) => !isOurHookCommandFor(h, cliBin));
+    if (remaining.length !== original.length) {
+      removedAny = true;
+      block.hooks = remaining;
+    }
+    return remaining.length > 0 || original.length === 0;
+  });
+  return { kept, removedAny };
+}
+function mergeHooks(settings, cliBin) {
+  const next = settings ? structuredClone(settings) : {};
+  next.hooks = next.hooks ? { ...next.hooks } : {};
+  let changed = false;
+  for (const event of REGISTERED_EVENTS) {
+    const existing = next.hooks[event] ?? [];
+    const before = JSON.stringify(existing);
+    const foreign = pruneOurHooks(existing, cliBin).kept;
+    const desired = [...foreign, ourEntry(cliBin, event)];
+    if (before !== JSON.stringify(desired)) changed = true;
+    next.hooks[event] = desired;
+  }
+  return { next, changed };
+}
+function removeHooks(settings, cliBin) {
+  const next = settings ? structuredClone(settings) : {};
+  if (!next.hooks) return { next, changed: false };
+  let changed = false;
+  for (const event of Object.keys(next.hooks)) {
+    const { kept, removedAny } = pruneOurHooks(next.hooks[event] ?? [], cliBin);
+    if (removedAny) changed = true;
+    if (kept.length === 0) delete next.hooks[event];
+    else next.hooks[event] = kept;
+  }
+  if (next.hooks && Object.keys(next.hooks).length === 0) delete next.hooks;
+  return { next, changed };
+}
+function writeSettings(path, settings, now = Date.now) {
+  mkdirSync(dirname(path), { recursive: true });
+  let backupPath;
+  if (existsSync(path)) {
+    backupPath = `${path}.bak-${now()}`;
+    copyFileSync(path, backupPath);
+  }
+  writeSettingsPreservingTrailingNewline(path, settings);
+  return backupPath;
+}
+function writeSettingsPreservingTrailingNewline(path, settings) {
+  writeFileSync(path, JSON.stringify(settings, null, 2) + "\n");
+}
+function encodeWrappedCommand(command) {
+  return Buffer.from(command, "utf8").toString("base64");
+}
+function decodeWrappedCommand(id) {
+  return Buffer.from(id, "base64").toString("utf8");
+}
+function listHookCandidates(settings, cliBin) {
+  const out = [];
+  const hooks = settings?.hooks ?? {};
+  for (const event of Object.keys(hooks)) {
+    (hooks[event] ?? []).forEach((matcher, matcherIndex) => {
+      matcher.hooks.forEach((h, hookIndex) => {
+        if (isOurHookCommandFor(h, cliBin)) return;
+        const original = wrappedOriginalCommand(h, cliBin);
+        out.push({
+          event,
+          matcherIndex,
+          hookIndex,
+          matcher: matcher.matcher,
+          command: original ?? h.command,
+          wrapped: original !== null
+        });
+      });
+    });
+  }
+  return out;
+}
+function wrapHookCommand(cliBin, h, opts = {}) {
+  if (isWrapped(h, cliBin)) return h;
+  const id = encodeWrappedCommand(h.command);
+  const flag = opts.captureOutput ? " --capture-output" : "";
+  return { type: "command", command: `${quoteBin(cliBin)} hook-wrap --id ${id}${flag}`, [WRAP_MARKER]: h.command };
+}
+function unwrapHookCommand(h, cliBin) {
+  const original = wrappedOriginalCommand(h, cliBin);
+  if (original === null) return h;
+  return { type: "command", command: original };
+}
+var AUTO_WRAP_EVENTS = ["PreToolUse", "PostToolUse"];
+function wrapHooks(settings, cliBin, opts = {}) {
+  const next = settings ? structuredClone(settings) : {};
+  const wrapped = [];
+  if (!cliBinResolvable(cliBin)) {
+    return { next, changed: false, wrapped, skippedUnresolvedBin: true };
+  }
+  let changed = false;
+  if (!next.hooks) return { next, changed, wrapped };
+  for (const event of Object.keys(next.hooks)) {
+    if (opts.events && !opts.events.includes(event)) continue;
+    const matchers = next.hooks[event] ?? [];
+    for (let mi = 0; mi < matchers.length; mi++) {
+      const matcher = matchers[mi];
+      for (let hi = 0; hi < matcher.hooks.length; hi++) {
+        const h = matcher.hooks[hi];
+        if (isOurHookCommandFor(h, cliBin) || isWrapped(h, cliBin)) continue;
+        const candidate = {
+          event,
+          matcherIndex: mi,
+          hookIndex: hi,
+          matcher: matcher.matcher,
+          command: h.command,
+          wrapped: false
+        };
+        if (opts.select && !opts.select(candidate)) continue;
+        matcher.hooks[hi] = wrapHookCommand(cliBin, h, { captureOutput: opts.captureOutput });
+        wrapped.push(candidate);
+        changed = true;
+      }
+    }
+  }
+  return { next, changed, wrapped };
+}
+function statuslineCommand(cliBin) {
+  return `${quoteBin(cliBin)} statusline`;
+}
+function statuslineWrapCommand(cliBin, original) {
+  return `${quoteBin(cliBin)} statusline --wrap-id ${encodeWrappedCommand(original)}`;
+}
+function isOurStatuslineSlot(slot, cliBin) {
+  if (slot[MARKER] === true) return true;
+  const args = parseCliInvocation(slot.command, cliBin);
+  if (!args || args[0] !== "statusline") return false;
+  return args.length === 1 || statuslineWrappedOriginal(slot, cliBin) !== null;
+}
+function statuslineWrappedOriginal(slot, cliBin) {
+  if (typeof slot[WRAP_MARKER] === "string") return slot[WRAP_MARKER];
+  const args = parseCliInvocation(slot.command, cliBin);
+  if (!args || args.length !== 3 || args[0] !== "statusline" || args[1] !== "--wrap-id") return null;
+  return decodeVerifiedWrapId(args[2]);
+}
+function mergeStatusline(settings, cliBin) {
+  const next = settings ? structuredClone(settings) : {};
+  const slot = next.statusLine;
+  if (slot === void 0 || slot === null) {
+    next.statusLine = { type: "command", command: statuslineCommand(cliBin), [MARKER]: true };
+    return { next, changed: true, outcome: "installed" };
+  }
+  if (typeof slot !== "object") {
+    return { next, changed: false, outcome: "skipped" };
+  }
+  if (isOurStatuslineSlot(slot, cliBin)) {
+    const original2 = statuslineWrappedOriginal(slot, cliBin);
+    const desired = original2 !== null ? statuslineWrapCommand(cliBin, original2) : statuslineCommand(cliBin);
+    const stripped = slot[MARKER] !== true || original2 !== null && typeof slot[WRAP_MARKER] !== "string";
+    if (slot.command === desired && !stripped) {
+      return { next, changed: false, outcome: "unchanged", ...original2 !== null ? { wrappedCommand: original2 } : {} };
+    }
+    slot.command = desired;
+    slot[MARKER] = true;
+    if (original2 !== null) slot[WRAP_MARKER] = original2;
+    return { next, changed: true, outcome: "repaired", ...original2 !== null ? { wrappedCommand: original2 } : {} };
+  }
+  if (slot.type !== "command" || typeof slot.command !== "string") {
+    return { next, changed: false, outcome: "skipped" };
+  }
+  const original = slot.command;
+  slot.command = statuslineWrapCommand(cliBin, original);
+  slot[MARKER] = true;
+  slot[WRAP_MARKER] = original;
+  return { next, changed: true, outcome: "wrapped", wrappedCommand: original };
+}
+function removeStatusline(settings, cliBin) {
+  const next = settings ? structuredClone(settings) : {};
+  const slot = next.statusLine;
+  if (!slot || typeof slot !== "object" || !isOurStatuslineSlot(slot, cliBin)) {
+    return { next, changed: false };
+  }
+  const original = statuslineWrappedOriginal(slot, cliBin);
+  if (original !== null) {
+    delete slot[MARKER];
+    delete slot[WRAP_MARKER];
+    slot.command = original;
+    return { next, changed: true, restoredCommand: original };
+  }
+  delete next.statusLine;
+  return { next, changed: true };
+}
+function unwrapHooks(settings, cliBin) {
+  const next = settings ? structuredClone(settings) : {};
+  let changed = false;
+  let unwrapped = 0;
+  if (!next.hooks) return { next, changed, unwrapped };
+  for (const event of Object.keys(next.hooks)) {
+    const matchers = next.hooks[event] ?? [];
+    for (const matcher of matchers) {
+      for (let hi = 0; hi < matcher.hooks.length; hi++) {
+        const h = matcher.hooks[hi];
+        if (!isWrapped(h, cliBin)) continue;
+        matcher.hooks[hi] = unwrapHookCommand(h, cliBin);
+        unwrapped++;
+        changed = true;
+      }
+    }
+  }
+  return { next, changed, unwrapped };
+}
+
+export { AUTO_WRAP_EVENTS, REGISTERED_EVENTS, SettingsParseError, cliBinResolvable, decodeWrappedCommand, isOurHookCommand, isOurStatuslineSlot, listHookCandidates, mergeHooks, mergeStatusline, readSettings, removeHooks, removeStatusline, settingsPath, statuslineWrappedOriginal, unwrapHooks, wrapHooks, wrappedOriginalCommand, writeSettings };