@outerlayer/cli 0.1.0

package/dist/import-ruler-cmd-7LH2QOMG.js

@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { normalizePath } from './chunk-KFYJV2ZG.js';
+import './chunk-Z5GEFMRW.js';
+import { existsSync, readdirSync, readFileSync, mkdirSync, writeFileSync } from 'fs';
+import { join, dirname } from 'path';
+
+createRequire(import.meta.url);
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git"]);
+var GREEN = "\x1B[32m";
+var YELLOW = "\x1B[33m";
+var DIM = "\x1B[2m";
+var RESET = "\x1B[0m";
+var ImportRulerError = class extends Error {
+};
+function toRepoRelative(base, name) {
+  return normalizePath(`${base}/${name}`);
+}
+function discoverRulerDirs(repoRoot) {
+  const out = [];
+  walk(repoRoot, repoRoot, "", out);
+  return out.sort();
+}
+function walk(dirAbs, repoRoot, dirRel, out) {
+  let entries;
+  try {
+    entries = readdirSync(dirAbs, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (entry.isSymbolicLink() || !entry.isDirectory()) continue;
+    if (SKIP_DIRS.has(entry.name)) continue;
+    const childRel = dirRel === "" ? entry.name : toRepoRelative(dirRel, entry.name);
+    if (entry.name === ".ruler") {
+      out.push(childRel);
+      continue;
+    }
+    walk(join(dirAbs, entry.name), repoRoot, childRel, out);
+  }
+}
+function collectFilesRecursively(dirAbs, dirRel) {
+  const out = [];
+  let entries;
+  try {
+    entries = readdirSync(dirAbs, { withFileTypes: true });
+  } catch {
+    return out;
+  }
+  for (const entry of entries) {
+    if (entry.isSymbolicLink()) continue;
+    const childRel = toRepoRelative(dirRel, entry.name);
+    const childAbs = join(dirAbs, entry.name);
+    if (entry.isDirectory()) out.push(...collectFilesRecursively(childAbs, childRel));
+    else if (entry.isFile()) out.push(childRel);
+  }
+  return out;
+}
+function catalogRulerDir(repoRoot, rulerDirRel) {
+  const abs = join(repoRoot, rulerDirRel);
+  const catalog = { otherMd: [], unmapped: [] };
+  const mdFilenames = [];
+  let entries;
+  try {
+    entries = readdirSync(abs, { withFileTypes: true });
+  } catch {
+    entries = [];
+  }
+  for (const entry of entries) {
+    if (entry.isSymbolicLink()) continue;
+    const childRel = toRepoRelative(rulerDirRel, entry.name);
+    if (entry.isDirectory()) {
+      catalog.unmapped.push(...collectFilesRecursively(join(abs, entry.name), childRel));
+      continue;
+    }
+    if (!entry.isFile()) continue;
+    if (entry.name === "AGENTS.md") catalog.agentsMd = readFileSync(join(abs, entry.name), "utf8");
+    else if (entry.name === "mcp.json") catalog.mcpJson = readFileSync(join(abs, entry.name), "utf8");
+    else if (entry.name === "ruler.toml") catalog.rulerTomlPath = childRel;
+    else if (entry.name.endsWith(".md")) mdFilenames.push(entry.name);
+    else catalog.unmapped.push(childRel);
+  }
+  catalog.otherMd = mdFilenames.sort((a, b) => a.localeCompare(b)).map((filename) => ({ filename, content: readFileSync(join(abs, filename), "utf8") }));
+  return catalog;
+}
+function scopeOf(rulerDirRel) {
+  if (rulerDirRel === ".ruler") return "";
+  return rulerDirRel.slice(0, rulerDirRel.length - "/.ruler".length);
+}
+function outerlayerDirFor(scopePath) {
+  return scopePath === "" ? ".outerlayer" : `${scopePath}/.outerlayer`;
+}
+function writeOutFile(repoRoot, relPath, content) {
+  const abs = join(repoRoot, relPath);
+  mkdirSync(dirname(abs), { recursive: true });
+  writeFileSync(abs, content);
+}
+function renderSuccess(scopes, warnings) {
+  const warningSuffix = warnings.length > 0 ? `, ${warnings.length} warning${warnings.length === 1 ? "" : "s"}` : "";
+  const lines = [`${GREEN}\u2713${RESET} imported ${scopes.length} .ruler/ scope${scopes.length === 1 ? "" : "s"}${warningSuffix}`];
+  for (const s of scopes) {
+    const written = [s.agentsMdWritten, s.mcpWritten].filter((p) => p !== void 0);
+    lines.push(`  ${DIM}${s.scopePath === "" ? "(root)" : s.scopePath}${RESET} \u2192 ${written.join(", ") || "nothing to import"}`);
+  }
+  return lines.join("\n");
+}
+function runImportRuler(opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  if (!existsSync(cwd)) throw new ImportRulerError(`no such directory: ${cwd}`);
+  const rulerDirs = discoverRulerDirs(cwd);
+  if (rulerDirs.length === 0) {
+    const output2 = opts.json ? JSON.stringify({ scopes: [], warnings: [] }) : `${DIM}no .ruler/ directories found \u2014 nothing to import${RESET}`;
+    if (!opts.quiet) process.stdout.write(output2 + "\n");
+    return { scopes: [], warnings: [], output: output2, exitCode: 0 };
+  }
+  const conflicts = rulerDirs.map((rel) => outerlayerDirFor(scopeOf(rel))).filter((outerlayerRel) => existsSync(join(cwd, outerlayerRel)));
+  if (conflicts.length > 0) {
+    throw new ImportRulerError(
+      `refusing to import \u2014 .outerlayer/ already exists at: ${conflicts.join(", ")} (never overwritten; remove it first to replace it)`
+    );
+  }
+  const scopes = [];
+  const warnings = [];
+  for (const rulerDirRel of rulerDirs) {
+    const scopePath = scopeOf(rulerDirRel);
+    const outerlayerRel = outerlayerDirFor(scopePath);
+    const catalog = catalogRulerDir(cwd, rulerDirRel);
+    const scope = { scopePath };
+    if (catalog.agentsMd !== void 0 || catalog.otherMd.length > 0) {
+      let content = catalog.agentsMd ?? "";
+      for (const { filename, content: mdContent } of catalog.otherMd) {
+        content += `
+
+<!-- imported from .ruler/${filename} -->
+
+${mdContent}`;
+      }
+      const agentsPath = toRepoRelative(outerlayerRel, "AGENTS.md");
+      writeOutFile(cwd, agentsPath, content);
+      scope.agentsMdWritten = agentsPath;
+    }
+    if (catalog.mcpJson !== void 0) {
+      const mcpPath = toRepoRelative(outerlayerRel, "mcp.json");
+      writeOutFile(cwd, mcpPath, catalog.mcpJson);
+      scope.mcpWritten = mcpPath;
+    }
+    if (catalog.rulerTomlPath !== void 0) {
+      warnings.push({
+        code: "ruler_toml_not_imported",
+        path: catalog.rulerTomlPath,
+        message: `${catalog.rulerTomlPath} was not imported \u2014 target selection now lives in .outerlayer/config.json; per-tool config is superseded`
+      });
+    }
+    for (const path of catalog.unmapped) {
+      warnings.push({ code: "unmapped_file", path, message: `${path} has no .outerlayer/ equivalent \u2014 not imported` });
+    }
+    scopes.push(scope);
+  }
+  warnings.sort((a, b) => a.path.localeCompare(b.path));
+  const output = opts.json ? JSON.stringify({ scopes, warnings }) : renderSuccess(scopes, warnings);
+  if (!opts.quiet) {
+    if (opts.json) {
+      process.stdout.write(output + "\n");
+    } else {
+      process.stdout.write(output + "\n");
+      for (const w of warnings) process.stderr.write(`  ${YELLOW}!${RESET} ${w.path}: ${w.message}
+`);
+    }
+  }
+  return { scopes, warnings, output, exitCode: 0 };
+}
+
+export { ImportRulerError, runImportRuler };

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/index.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+
+createRequire(import.meta.url);
+
+// src/index.ts
+var argv = process.argv.slice(2);
+if (argv[0] === "hook") {
+  const { runHookFast } = await import('./hook-fast-CBW4ZETX.js');
+  await runHookFast(argv[1]);
+  process.exit(0);
+}
+if (argv[0] === "hook-wrap") {
+  const { runHookWrapFast, parseHookWrapArgs } = await import('./hook-wrap-fast-36WGE6EX.js');
+  const { id, captureOutput } = parseHookWrapArgs(argv.slice(1));
+  const code = await runHookWrapFast(id, { captureOutput });
+  process.exit(code);
+}
+if (argv[0] === "statusline") {
+  const { runStatuslineFast } = await import('./statusline-fast-Z5U5CEC6.js');
+  await runStatuslineFast(argv.slice(1));
+  process.exit(0);
+}
+var { runCli } = await import('./cli-3JYGL2OB.js');
+await runCli(process.argv);

package/dist/init-PTBITAUO.js

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { runnerDir, RUNNER_DIR_MODE, RUNNER_FILE_MODE } from './chunk-JJP7YLMN.js';
+import './chunk-Z5GEFMRW.js';
+import { existsSync, readFileSync, mkdirSync, writeFileSync, chmodSync } from 'fs';
+import { join, dirname } from 'path';
+
+createRequire(import.meta.url);
+var RunnerInitError = class extends Error {
+};
+var PLACEHOLDER_COMMAND = "echo 'edit runner.commands in this config file: it must start your agent on item $OUTERLAYER_WORK' >&2; exit 1";
+var PROVISION = `#!/bin/sh
+# provision.sh \u2014 makes the place this job runs in.
+# Runs in $OUTERLAYER_JOB_DIR, before the command. Exit 75 to decline the
+# item for now; any other non-zero exit fails the job.
+set -e
+
+if ! df -Pk . | awk 'NR==2 {exit ($4 < 6*1024*1024)}'; then
+  exit 75  # not enough disk free right now
+fi
+
+repo=$(outerlayer work status --item "$OUTERLAYER_WORK" --json \\
+  | jq -r '.trackerKey | split("#")[0]')
+workdir="$OUTERLAYER_JOB_DIR/work"
+git clone --depth 1 "https://github.com/$repo.git" "$workdir"
+
+echo "workdir=$workdir" > "$OUTERLAYER_JOB_DIR/provision.out"
+`;
+var CLEANUP = `#!/bin/sh
+# cleanup.sh \u2014 runs after the command, however it ended, and on recovery.
+# $OUTERLAYER_OUTCOME is the attempt's fate, not a verdict on the work: a
+# command that ran and exited says "ok" whatever its exit status.
+workdir="$OUTERLAYER_JOB_DIR/work"
+
+if grep -q "pull request opened" "$OUTERLAYER_LOG" 2>/dev/null; then
+  rm -rf "$workdir"
+else
+  echo "kept $workdir for inspection (outcome: $OUTERLAYER_OUTCOME)"
+fi
+`;
+var REPORT = `#!/bin/sh
+# report.sh \u2014 optional. Runs once at the start of a job and once at the end.
+# At the start there is no working directory yet and $OUTERLAYER_LOG is
+# unset; the command's log is always $OUTERLAYER_JOB_DIR/command.log.
+case "$OUTERLAYER_PHASE" in
+  start) echo "starting #$OUTERLAYER_WORK" ;;
+  end)   echo "#$OUTERLAYER_WORK ended: $OUTERLAYER_OUTCOME" ;;
+esac
+`;
+function runRunnerInit(configPath) {
+  if (!existsSync(configPath)) {
+    throw new RunnerInitError(
+      `${configPath}: no config file. Run \`outerlayer login --url <your gateway>\` first, then this command.`
+    );
+  }
+  let config;
+  try {
+    config = JSON.parse(readFileSync(configPath, "utf8"));
+  } catch (err) {
+    throw new RunnerInitError(`${configPath}: not valid JSON (${err instanceof Error ? err.message : String(err)})`);
+  }
+  if (config.runner !== void 0) {
+    throw new RunnerInitError(`${configPath}: a runner block is already here. Edit it, or remove it and run this again.`);
+  }
+  const hooksDir = join(runnerDir(configPath), "hooks");
+  mkdirSync(hooksDir, { recursive: true, mode: RUNNER_DIR_MODE });
+  const written = [];
+  for (const [name, body] of [
+    ["provision.sh", PROVISION],
+    ["cleanup.sh", CLEANUP],
+    ["report.sh", REPORT]
+  ]) {
+    const path = join(hooksDir, name);
+    if (existsSync(path)) continue;
+    writeFileSync(path, body, { mode: 448 });
+    chmodSync(path, 448);
+    written.push(path);
+  }
+  config.runner = {
+    queues: ["implement", "amend"],
+    concurrency: 1,
+    pollSeconds: 60,
+    timeLimitMinutes: 480,
+    idleLimitMinutes: 30,
+    // A placeholder that fails loudly. A command line that quietly did
+    // nothing would claim an item, run, exit zero, and record `ok` —
+    // every attempt reading as a success that produced nothing.
+    commands: {
+      implement: PLACEHOLDER_COMMAND,
+      amend: PLACEHOLDER_COMMAND
+    },
+    hooks: {
+      provision: join(hooksDir, "provision.sh"),
+      cleanup: join(hooksDir, "cleanup.sh")
+    }
+  };
+  mkdirSync(dirname(configPath), { recursive: true });
+  writeFileSync(configPath, `${JSON.stringify(config, null, 2)}
+`, { mode: RUNNER_FILE_MODE });
+  return { configPath, hooksDir, hooks: written };
+}
+
+export { RunnerInitError, runRunnerInit };

package/dist/login-cmd-IRX6LZT7.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { writeCloudConfig, readCloudConfig, cloudConfigPath } from './chunk-TFUIDMOB.js';
+import { homeFromEnv } from './chunk-VNVZDWO3.js';
+import './chunk-Z5GEFMRW.js';
+import { createInterface } from 'readline';
+import { Writable } from 'stream';
+
+createRequire(import.meta.url);
+var LoginError = class extends Error {
+};
+function runLogin(opts) {
+  const apiKey = opts.apiKey.trim();
+  if (apiKey.length === 0) throw new LoginError("no API key given \u2014 pipe it on stdin or enter it at the prompt");
+  if (/\s/.test(apiKey)) throw new LoginError("the API key must be a single token with no spaces or line breaks");
+  const url = opts.url?.trim() || void 0;
+  const appId = opts.appId?.trim() || void 0;
+  const home = opts.home ?? homeFromEnv();
+  writeCloudConfig(
+    {
+      apiKey,
+      ...url ? { url } : {},
+      ...appId ? { appId } : {}
+    },
+    home
+  );
+  const saved = readCloudConfig(home);
+  return { path: cloudConfigPath(home), url: saved.url, appId: saved.appId };
+}
+async function readAllStdin(stdin) {
+  const chunks = [];
+  for await (const chunk of stdin) chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+  return Buffer.concat(chunks).toString("utf8");
+}
+function promptHidden(stdin, stdout, question) {
+  return new Promise((resolve, reject) => {
+    const muted = new Writable({
+      write(_chunk, _encoding, callback) {
+        callback();
+      }
+    });
+    const rl = createInterface({ input: stdin, output: muted, terminal: true });
+    stdout.write(question);
+    rl.question("", (answer) => {
+      rl.close();
+      stdout.write("\n");
+      resolve(answer);
+    });
+    rl.on("error", reject);
+  });
+}
+async function readApiKey(input = {}) {
+  const stdin = input.stdin ?? process.stdin;
+  const stdout = input.stdout ?? process.stdout;
+  if (!stdin.isTTY) return (await readAllStdin(stdin)).trim();
+  if (input.noInput) {
+    throw new LoginError('no API key on stdin and --no-input forbids prompting \u2014 pipe the key: echo "$KEY" | outerlayer login');
+  }
+  return (await promptHidden(stdin, stdout, "API key (input hidden): ")).trim();
+}
+
+export { LoginError, readApiKey, runLogin };

package/dist/logs-TRNPQM42.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { jobsDir } from './chunk-JJP7YLMN.js';
+import './chunk-Z5GEFMRW.js';
+import { existsSync, watch, statSync, createReadStream } from 'fs';
+import { join } from 'path';
+
+createRequire(import.meta.url);
+var RunnerLogsError = class extends Error {
+};
+var STAGE_LOG = {
+  provision: "provision.log",
+  command: "command.log",
+  sync: "command.log",
+  cleanup: "cleanup.log",
+  report: "report.log"
+};
+function newestAttempt(jobs, item) {
+  return jobs.filter(({ job }) => Number(job.item) === item).sort((a, b) => b.job.startedAt.localeCompare(a.job.startedAt))[0];
+}
+function logPathFor(configPath, dirName, job) {
+  const dirPath = join(jobsDir(configPath), dirName);
+  const finished = job.outcome !== void 0 || job.endedAt !== void 0;
+  const byStage = finished || job.stage === void 0 ? "command.log" : STAGE_LOG[job.stage];
+  const candidate = join(dirPath, byStage);
+  if (existsSync(candidate)) return candidate;
+  const command = join(dirPath, "command.log");
+  return existsSync(command) ? command : candidate;
+}
+async function tail(path, follow, out = process.stdout) {
+  if (!existsSync(path)) throw new RunnerLogsError(`${path}: no log yet`);
+  let offset = 0;
+  const pump = () => new Promise((resolve, reject) => {
+    const size = statSync(path).size;
+    if (size <= offset) {
+      resolve();
+      return;
+    }
+    const stream = createReadStream(path, { start: offset, end: size - 1 });
+    stream.on("data", (chunk) => out.write(chunk));
+    stream.on("error", reject);
+    stream.on("end", () => {
+      offset = size;
+      resolve();
+    });
+  });
+  await pump();
+  if (!follow) return;
+  await new Promise((resolve, reject) => {
+    const watcher = watch(path, () => {
+      void pump().catch((err) => {
+        watcher.close();
+        reject(err instanceof Error ? err : new Error(String(err)));
+      });
+    });
+    process.on("SIGINT", () => {
+      watcher.close();
+      resolve();
+    });
+  });
+}
+
+export { RunnerLogsError, logPathFor, newestAttempt, tail };