@outerlayer/cli 0.1.0

package/dist/chunk-XN2XZFTK.js

@@ -0,0 +1,165 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { decodeWrappedCommand } from './chunk-ECSYRPCC.js';
+import { homeFromEnv } from './chunk-VNVZDWO3.js';
+import { readFileSync } from 'fs';
+import { spawn } from 'child_process';
+import { join } from 'path';
+
+createRequire(import.meta.url);
+var STATE_FRESH_MS = 15 * 60 * 1e3;
+var WRAP_TIMEOUT_MS = 750;
+function statuslineStatePath(home = homeFromEnv()) {
+  return join(home, ".outerlayer", "statusline.json");
+}
+var DIM = "\x1B[2m";
+var RESET = "\x1B[0m";
+function dim(s) {
+  return `${DIM}${s}${RESET}`;
+}
+function localDateString(ms) {
+  const d = new Date(ms);
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
+}
+function fmtUsd(n) {
+  if (n >= 100) return `$${Math.round(n).toLocaleString("en-US")}`;
+  return `$${n.toFixed(2)}`;
+}
+function parseStatuslineStdin(text) {
+  try {
+    const parsed = text ? JSON.parse(text) : {};
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function readStatuslineState(home = homeFromEnv()) {
+  try {
+    const parsed = JSON.parse(readFileSync(statuslineStatePath(home), "utf8"));
+    if (!parsed || parsed.v !== 1 || typeof parsed.generatedAt !== "string") return null;
+    if (!parsed.today || typeof parsed.today.date !== "string" || typeof parsed.today.byAgent !== "object") return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function stateFresh(state, now) {
+  const generated = Date.parse(state.generatedAt);
+  return Number.isFinite(generated) && now - generated <= STATE_FRESH_MS;
+}
+function renderStatusline(stdin, state, now) {
+  const segments = [];
+  const sessionCost = stdin.cost?.total_cost_usd;
+  if (Number.isFinite(sessionCost)) {
+    segments.push(`${fmtUsd(sessionCost)} session`);
+  }
+  const fresh = state !== null && stateFresh(state, now);
+  if (fresh && state.today.date === localDateString(now)) {
+    const costs = Object.values(state.today.byAgent).filter((c) => typeof c === "number" && c > 0);
+    if (costs.length > 0) {
+      const total = costs.reduce((sum, c) => sum + c, 0);
+      const sessionCount = state.today.sessionCount;
+      const scope = costs.length >= 2 ? ` across ${costs.length} agents` : typeof sessionCount === "number" && sessionCount >= 2 ? ` across ${sessionCount} sessions` : "";
+      segments.push(`${fmtUsd(total)} today${scope}`);
+    }
+  }
+  if (fresh && typeof state.unsynced === "number" && state.unsynced > 0) {
+    segments.push(`${state.unsynced} unsynced`);
+  }
+  if (!fresh) {
+    segments.push(dim("outerlayer doctor"));
+  }
+  const prefix = "\u2B22 OL";
+  return segments.length === 0 ? prefix : `${prefix}  ${segments.join(dim(" \xB7 "))}`;
+}
+var readStdin = () => {
+  try {
+    if (process.stdin.isTTY) return "";
+    return readFileSync(0, "utf8");
+  } catch {
+    return "";
+  }
+};
+var spawnWrapped = (command, args) => spawn(command, args, { stdio: ["pipe", "pipe", "ignore"] });
+function runWrappedStatusline(original, stdinText, opts = {}) {
+  const spawnImpl = opts.spawnImpl ?? spawnWrapped;
+  const timeoutMs = opts.timeoutMs ?? WRAP_TIMEOUT_MS;
+  return new Promise((resolve) => {
+    let child;
+    try {
+      child = spawnImpl("/bin/sh", ["-c", original]);
+    } catch {
+      resolve(null);
+      return;
+    }
+    let out = "";
+    let done = false;
+    const finish = (value) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      resolve(value);
+    };
+    const timer = setTimeout(() => {
+      try {
+        child.kill("SIGKILL");
+      } catch {
+      }
+      finish(null);
+    }, timeoutMs);
+    try {
+      child.stdout?.on("data", (chunk) => {
+        out += chunk.toString("utf8");
+      });
+      child.stdin?.on("error", () => {
+      });
+      child.stdin?.write(stdinText);
+      child.stdin?.end();
+    } catch {
+    }
+    child.on("error", () => finish(null));
+    child.on("close", (code) => finish(code === 0 ? out : null));
+  });
+}
+function parseStatuslineArgs(args) {
+  const idx = args.indexOf("--wrap-id");
+  return idx === -1 ? {} : { wrapId: args[idx + 1] };
+}
+async function runStatuslineFast(args, opts = {}) {
+  const write = opts.write ?? ((s) => process.stdout.write(s));
+  try {
+    const home = opts.home ?? homeFromEnv();
+    const now = (opts.now ?? Date.now)();
+    const stdinText = (opts.read ?? readStdin)();
+    const stdin = parseStatuslineStdin(stdinText);
+    const state = readStatuslineState(home);
+    const ourLine = renderStatusline(stdin, state, now);
+    const { wrapId } = parseStatuslineArgs(args);
+    if (wrapId) {
+      let original = null;
+      try {
+        original = decodeWrappedCommand(wrapId);
+      } catch {
+        original = null;
+      }
+      if (original) {
+        const theirOutput = await runWrappedStatusline(original, stdinText, {
+          spawnImpl: opts.spawnImpl,
+          timeoutMs: opts.wrapTimeoutMs
+        });
+        if (theirOutput !== null && theirOutput.length > 0) {
+          write(theirOutput.replace(/\n$/, "") + "\n");
+        }
+      }
+    }
+    write(ourLine + "\n");
+  } catch {
+    try {
+      write("\u2B22 OL\n");
+    } catch {
+    }
+  }
+}
+
+export { STATE_FRESH_MS, WRAP_TIMEOUT_MS, localDateString, parseStatuslineArgs, parseStatuslineStdin, readStatuslineState, renderStatusline, runStatuslineFast, runWrappedStatusline, statuslineStatePath };

package/dist/chunk-YMTXR7PJ.js

@@ -0,0 +1,200 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { decodeWrappedCommand } from './chunk-ECSYRPCC.js';
+import { homeFromEnv } from './chunk-VNVZDWO3.js';
+import { readFileSync, mkdirSync, appendFileSync, writeFileSync } from 'fs';
+import { spawn } from 'child_process';
+import { randomUUID, createHash } from 'crypto';
+import { join } from 'path';
+
+createRequire(import.meta.url);
+function spoolDir(home = homeFromEnv()) {
+  return join(home, ".outerlayer", "spool");
+}
+function hookExecSpoolPath(home = homeFromEnv()) {
+  return join(spoolDir(home), "hook-exec.jsonl");
+}
+var MAX_CMD_LEN = 300;
+var MAX_TAIL_BYTES = 4096;
+var readStdin = () => {
+  try {
+    return readFileSync(0);
+  } catch {
+    return Buffer.alloc(0);
+  }
+};
+function hookWrapStdio(captureOutput) {
+  return captureOutput ? ["pipe", "pipe", "pipe"] : ["pipe", "inherit", "inherit"];
+}
+var spawnChild = (command, args, stdio) => spawn(command, args, { stdio });
+function makeSpoolWriter(home) {
+  return (record) => {
+    try {
+      mkdirSync(spoolDir(home), { recursive: true });
+      appendFileSync(hookExecSpoolPath(home), JSON.stringify(record) + "\n");
+    } catch {
+    }
+  };
+}
+function logError(home, err) {
+  try {
+    mkdirSync(spoolDir(home), { recursive: true });
+    writeFileSync(
+      join(spoolDir(home), "hook-errors.log"),
+      `${(/* @__PURE__ */ new Date()).toISOString()} ${err instanceof Error ? err.message : String(err)}
+`,
+      { flag: "a" }
+    );
+  } catch {
+  }
+}
+function parsePayload(bytes) {
+  try {
+    if (bytes.length === 0) return {};
+    return JSON.parse(bytes.toString("utf8"));
+  } catch {
+    return {};
+  }
+}
+function makeTailCollector(max = MAX_TAIL_BYTES) {
+  let buf = Buffer.alloc(0);
+  return {
+    push(chunk) {
+      buf = Buffer.concat([buf, chunk]);
+      if (buf.length > max) buf = buf.subarray(buf.length - max);
+    },
+    value: () => buf.toString("utf8")
+  };
+}
+var ABORT_SIGNALS = ["SIGTERM", "SIGINT"];
+function installAbortForwarding(child, spool, execId, startedAt, now, proc) {
+  const handlers = [];
+  const cleanup = () => {
+    for (const [sig, handler] of handlers) proc.removeListener(sig, handler);
+  };
+  for (const sig of ABORT_SIGNALS) {
+    const handler = (signal) => {
+      cleanup();
+      try {
+        child.kill(signal);
+      } catch {
+      }
+      try {
+        spool({ rec: "aborted", execId, durationMs: now() - startedAt, signal });
+      } catch {
+      }
+      try {
+        proc.kill(proc.pid, signal);
+      } catch {
+      }
+    };
+    handlers.push([sig, handler]);
+    proc.once(sig, handler);
+  }
+  return cleanup;
+}
+function parseHookWrapArgs(args) {
+  let id;
+  let captureOutput = false;
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--id") id = args[++i];
+    else if (args[i] === "--capture-output") captureOutput = true;
+  }
+  return { id, captureOutput };
+}
+async function runHookWrapFast(id, opts = {}) {
+  const home = opts.home ?? homeFromEnv();
+  const read = opts.read ?? readStdin;
+  const spawnImpl = opts.spawnImpl ?? spawnChild;
+  const spool = opts.spool ?? makeSpoolWriter(home);
+  const now = opts.now ?? Date.now;
+  const captureOutput = opts.captureOutput ?? false;
+  const proc = opts.proc ?? process;
+  if (!id) {
+    logError(home, new Error("hook-wrap: missing --id"));
+    return 0;
+  }
+  let original;
+  try {
+    original = decodeWrappedCommand(id);
+  } catch (err) {
+    logError(home, err);
+    return 0;
+  }
+  let stdinBytes;
+  try {
+    stdinBytes = read();
+  } catch {
+    stdinBytes = Buffer.alloc(0);
+  }
+  const payload = parsePayload(stdinBytes);
+  const execId = randomUUID();
+  const startedAt = now();
+  try {
+    spool({
+      rec: "started",
+      execId,
+      t: new Date(startedAt).toISOString(),
+      sessionId: payload.session_id ?? null,
+      hookEvent: payload.hook_event_name ?? null,
+      toolUseId: payload.tool_use_id ?? null,
+      // Costs a few bytes; makes an orphaned started-only record
+      // self-describing ("PostToolUse Edit hung" vs. a bare uuid).
+      toolName: payload.tool_name ?? null,
+      cmdSha: createHash("sha256").update(original).digest("hex"),
+      cmd: original.slice(0, MAX_CMD_LEN),
+      pid: process.pid
+    });
+  } catch {
+  }
+  let child;
+  try {
+    child = spawnImpl("/bin/sh", ["-c", original], hookWrapStdio(captureOutput));
+  } catch (err) {
+    logError(home, err);
+    return 0;
+  }
+  try {
+    child.stdin?.on("error", () => {
+    });
+    child.stdin?.write(stdinBytes);
+    child.stdin?.end();
+  } catch {
+  }
+  const stdoutTail = makeTailCollector();
+  const stderrTail = makeTailCollector();
+  if (captureOutput) {
+    try {
+      child.stdout?.on("data", (chunk) => stdoutTail.push(chunk));
+      child.stderr?.on("data", (chunk) => stderrTail.push(chunk));
+    } catch {
+    }
+  }
+  let stopAbortForwarding = () => {
+  };
+  try {
+    stopAbortForwarding = installAbortForwarding(child, spool, execId, startedAt, now, proc);
+  } catch {
+  }
+  const { exitCode, signal } = await new Promise(
+    (resolve) => {
+      child.on("close", (code, sig) => resolve({ exitCode: code, signal: sig }));
+      child.on("error", () => resolve({ exitCode: null, signal: null }));
+    }
+  );
+  stopAbortForwarding();
+  try {
+    spool({
+      rec: "finished",
+      execId,
+      durationMs: now() - startedAt,
+      exitCode,
+      signal: signal ?? void 0,
+      ...captureOutput ? { stdoutTail: stdoutTail.value(), stderrTail: stderrTail.value() } : {}
+    });
+  } catch {
+  }
+  return exitCode ?? 1;
+}
+
+export { hookExecSpoolPath, hookWrapStdio, installAbortForwarding, makeTailCollector, parseHookWrapArgs, runHookWrapFast, spoolDir };

package/dist/chunk-YRYMNBGQ.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+
+createRequire(import.meta.url);
+
+// src/output.ts
+var NO_COLOR_FLAG = "--no-color";
+var CODES = {
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  red: "\x1B[31m",
+  dim: "\x1B[2m",
+  reset: "\x1B[0m"
+};
+function colorEnabled(input = {}) {
+  const env = input.env ?? process.env;
+  const argv = input.argv ?? process.argv;
+  if (argv.includes(NO_COLOR_FLAG)) return false;
+  if (env.NO_COLOR !== void 0 && env.NO_COLOR !== "") return false;
+  if (env.FORCE_COLOR !== void 0 && env.FORCE_COLOR !== "" && env.FORCE_COLOR !== "0") return true;
+  if (env.TERM === "dumb") return false;
+  return Boolean((input.stream ?? process.stdout).isTTY);
+}
+function palette(enabled) {
+  return enabled ? CODES : { green: "", yellow: "", red: "", dim: "", reset: "" };
+}
+var C = {
+  get green() {
+    return palette(colorEnabled()).green;
+  },
+  get yellow() {
+    return palette(colorEnabled()).yellow;
+  },
+  get red() {
+    return palette(colorEnabled()).red;
+  },
+  get dim() {
+    return palette(colorEnabled()).dim;
+  },
+  get reset() {
+    return palette(colorEnabled()).reset;
+  }
+};
+function stripNoColor(argv) {
+  const noColor = argv.includes(NO_COLOR_FLAG);
+  return { argv: noColor ? argv.filter((a) => a !== NO_COLOR_FLAG) : argv, noColor };
+}
+function warnDeprecated(message) {
+  process.stderr.write(`${C.yellow}!${C.reset} ${message}
+`);
+}
+var API_KEY_FLAG_DEPRECATION = "--api-key is deprecated: a key on the command line lands in shell history and process lists. Run `outerlayer login` once, or set OUTERLAYER_API_KEY.";
+
+export { API_KEY_FLAG_DEPRECATION, C, NO_COLOR_FLAG, stripNoColor, warnDeprecated };

package/dist/chunk-Z5GEFMRW.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+
+const require$1 = createRequire(import.meta.url);
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require$1 !== "undefined" ? require$1 : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require$1 !== "undefined" ? require$1 : a)[b]
+}) : x)(function(x) {
+  if (typeof require$1 !== "undefined") return require$1.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export { __commonJS, __export, __require, __toESM };

package/dist/chunk-ZJSNLVCE.js

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { homeFromEnv } from './chunk-VNVZDWO3.js';
+import { mkdirSync, statSync, renameSync, appendFileSync, readFileSync } from 'fs';
+import { dirname, join } from 'path';
+
+createRequire(import.meta.url);
+function contextProvenancePath(home = homeFromEnv()) {
+  return join(home, ".outerlayer", "spool", "context-source.jsonl");
+}
+var MAX_BYTES = 1024 * 1024;
+function appendContextProvenance(record, home = homeFromEnv()) {
+  const path = contextProvenancePath(home);
+  mkdirSync(dirname(path), { recursive: true });
+  try {
+    if (statSync(path).size > MAX_BYTES) {
+      renameSync(path, `${path}.1`);
+    }
+  } catch {
+  }
+  appendFileSync(path, JSON.stringify(record) + "\n");
+}
+function parseLine(text) {
+  try {
+    const parsed = JSON.parse(text);
+    if (typeof parsed.sessionId === "string" && typeof parsed.repoRoot === "string" && typeof parsed.t === "string" && (parsed.verification === "verified" || parsed.verification === "unverified" || parsed.verification === "none") && (typeof parsed.sha === "string" || parsed.sha === null)) {
+      return parsed;
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+function readContextProvenance(home = homeFromEnv()) {
+  let raw;
+  try {
+    raw = readFileSync(contextProvenancePath(home), "utf8");
+  } catch {
+    return [];
+  }
+  const records = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const record = parseLine(trimmed);
+    if (record) records.push(record);
+  }
+  return records;
+}
+function readLatestProvenanceForSession(sessionId, home = homeFromEnv()) {
+  const records = readContextProvenance(home);
+  for (let i = records.length - 1; i >= 0; i--) {
+    if (records[i].sessionId === sessionId) return records[i];
+  }
+  return void 0;
+}
+
+export { appendContextProvenance, readContextProvenance, readLatestProvenanceForSession };