@outerlayer/cli 0.2.0 → 0.4.1

package/dist/chunk-WQ6VGRGZ.js

@@ -1,150 +0,0 @@
-#!/usr/bin/env node
-import { createRequire } from 'node:module';
-import { homeFromEnv } from './chunk-VNVZDWO3.js';
-import { existsSync, statSync, accessSync, constants, readFileSync } from 'fs';
-import { hostname } from 'os';
-import { join } from 'path';
-
-createRequire(import.meta.url);
-var RUNNER_QUEUES = ["implement", "amend"];
-var RunnerConfigError = class extends Error {
-};
-var DEFAULT_CONCURRENCY = 1;
-var DEFAULT_POLL_SECONDS = 60;
-var DEFAULT_TIME_LIMIT_MINUTES = 480;
-var DEFAULT_IDLE_LIMIT_MINUTES = 30;
-function defaultRunnerConfigPath(home = homeFromEnv()) {
-  return join(home, ".outerlayer", "config.json");
-}
-function fail(configPath, key, reason) {
-  throw new RunnerConfigError(`${configPath}: ${key} ${reason}`);
-}
-function readConfigFile(configPath) {
-  if (!existsSync(configPath)) return {};
-  const text = readFileSync(configPath, "utf8");
-  try {
-    return JSON.parse(text);
-  } catch (err) {
-    throw new RunnerConfigError(
-      `${configPath}: is not valid JSON: ${err instanceof Error ? err.message : String(err)}`
-    );
-  }
-}
-var RUNNER_KEYS = [
-  "host",
-  "queues",
-  "concurrency",
-  "pollSeconds",
-  "timeLimitMinutes",
-  "idleLimitMinutes",
-  "commands",
-  "hooks"
-];
-var RUNNER_NUMBERS = [
-  { key: "concurrency", min: 1 },
-  // Below five seconds a runner is asking the gateway a question it has
-  // just been answered.
-  { key: "pollSeconds", min: 5 },
-  { key: "timeLimitMinutes", min: 1 },
-  { key: "idleLimitMinutes", min: 1 }
-];
-function nearestKey(unknown, accepted) {
-  const lower = unknown.toLowerCase();
-  let best;
-  for (const key of accepted) {
-    const distance = editDistance(lower, key.toLowerCase());
-    if (distance <= Math.max(1, Math.floor(key.length / 4)) && (!best || distance < best.distance)) {
-      best = { key, distance };
-    }
-  }
-  return best?.key;
-}
-function editDistance(a, b) {
-  const rows = Array.from({ length: a.length + 1 }, (_unused, i) => [i, ...Array(b.length).fill(0)]);
-  for (let j = 0; j <= b.length; j++) rows[0][j] = j;
-  for (let i = 1; i <= a.length; i++) {
-    for (let j = 1; j <= b.length; j++) {
-      rows[i][j] = Math.min(
-        rows[i - 1][j] + 1,
-        rows[i][j - 1] + 1,
-        rows[i - 1][j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1)
-      );
-    }
-  }
-  return rows[a.length][b.length];
-}
-function checkHooks(config) {
-  const named = [
-    ["runner.hooks.provision", config.hooks.provision],
-    ["runner.hooks.cleanup", config.hooks.cleanup],
-    ["runner.hooks.report", config.hooks.report]
-  ];
-  for (const [key, path] of named) {
-    if (path === void 0) continue;
-    if (path.includes("$") || path.startsWith("~")) {
-      return `${key}: ${path} \u2014 hooks are executable paths, not shell lines; $HOME and ~ are not expanded`;
-    }
-    if (!existsSync(path)) return `${key}: ${path} does not exist`;
-    if (!statSync(path).isFile()) return `${key}: ${path} is not a file`;
-    try {
-      accessSync(path, constants.X_OK);
-    } catch {
-      return `${key}: ${path} is not executable`;
-    }
-  }
-  return void 0;
-}
-function loadRunnerConfig(configPath) {
-  const config = readConfigFile(configPath);
-  if (!config.url || !config.apiKey || !config.appId) {
-    fail(configPath, "url/apiKey/appId", "missing \u2014 run `outerlayer login` against this config file first");
-  }
-  const runner = config.runner;
-  if (!runner) {
-    fail(configPath, "runner", "block is missing");
-  }
-  for (const key of Object.keys(runner)) {
-    if (RUNNER_KEYS.includes(key)) continue;
-    const near = nearestKey(key, RUNNER_KEYS);
-    fail(configPath, `runner.${key}`, near ? `is not a key this block accepts; did you mean ${near}?` : "is not a key this block accepts");
-  }
-  for (const { key, min } of RUNNER_NUMBERS) {
-    const value = runner[key];
-    if (value === void 0) continue;
-    if (typeof value !== "number" || !Number.isInteger(value) || value < min) {
-      fail(configPath, `runner.${key}`, `must be a whole number of at least ${min}`);
-    }
-  }
-  const queues = runner.queues && runner.queues.length > 0 ? runner.queues : [...RUNNER_QUEUES];
-  for (const queue of queues) {
-    if (!RUNNER_QUEUES.includes(queue)) {
-      fail(configPath, "runner.queues", `names an unknown queue "${queue}" \u2014 must be implement or amend`);
-    }
-    if (!runner.commands?.[queue]) {
-      fail(configPath, `runner.commands.${queue}`, "is required for an enabled queue");
-    }
-  }
-  if (!runner.hooks?.provision) fail(configPath, "runner.hooks.provision", "is required");
-  if (!runner.hooks?.cleanup) fail(configPath, "runner.hooks.cleanup", "is required");
-  return {
-    configPath,
-    url: config.url,
-    apiKey: config.apiKey,
-    appId: config.appId,
-    repos: config.repos,
-    host: runner.host ?? hostname(),
-    queues,
-    concurrency: runner.concurrency ?? DEFAULT_CONCURRENCY,
-    pollSeconds: runner.pollSeconds ?? DEFAULT_POLL_SECONDS,
-    timeLimitMinutes: runner.timeLimitMinutes ?? DEFAULT_TIME_LIMIT_MINUTES,
-    idleLimitMinutes: runner.idleLimitMinutes ?? DEFAULT_IDLE_LIMIT_MINUTES,
-    commands: runner.commands ?? {},
-    hooks: {
-      provision: runner.hooks.provision,
-      cleanup: runner.hooks.cleanup,
-      report: runner.hooks.report
-    }
-  };
-}
-
-export { RunnerConfigError, checkHooks, defaultRunnerConfigPath, loadRunnerConfig };

package/dist/hook-fast-J5LCDHUJ.js

@@ -1,8 +0,0 @@
-#!/usr/bin/env node
-import { createRequire } from 'node:module';
-export { AUTO_SYNC_DEBOUNCE_MS, WORK_ADD_RETRIES, contextPossiblyGoverned, handleWorkLaunch, hookFiredMarkerPath, maybeAutoSync, runHookFast, spoolDir } from './chunk-NXLLURA4.js';
-import './chunk-I3ETLSNE.js';
-import './chunk-VNVZDWO3.js';
-import './chunk-Z5GEFMRW.js';
-
-createRequire(import.meta.url);

package/dist/import-capture-cmd-EUMBGIV3.js

@@ -1,176 +0,0 @@
-#!/usr/bin/env node
-import { createRequire } from 'node:module';
-import './chunk-Z5GEFMRW.js';
-import { statSync, existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
-import { join, dirname } from 'path';
-
-createRequire(import.meta.url);
-var GREEN = "\x1B[32m";
-var DIM = "\x1B[2m";
-var YELLOW = "\x1B[33m";
-var RESET = "\x1B[0m";
-var ImportCaptureError = class extends Error {
-};
-var SKILL_PATH = ".outerlayer/skills/emitting-evidence/SKILL.md";
-var SNIPPET_PATH = ".outerlayer/skills/emitting-evidence/references/agents-snippet.md";
-var AGENTS_MD_PATH = ".outerlayer/AGENTS.md";
-var AGENTS_MD_MARKER = "<!-- outerlayer:capture-pack -->";
-var SKILL_CONTENT = `---
-name: emitting-evidence
-description: >
-  Emit artifacts \u2014 screenshots, recordings, reports, logs \u2014 as proof that a
-  change works, bound to the pull request via \`outerlayer emit artifact\`.
-  Use when finishing work a spec criterion or tracked requirement covers,
-  when asked to "provide evidence", "attach a screenshot", or "prove it
-  works", and in CI steps that produce verifiable output.
----
-
-An artifact is an exhibit: evidence *of* a specific change, anchored to the
-pull request and rendered in its evidence comment. Emit the few exhibits the
-spec asks for \u2014 a reviewer should see the change working, not a gallery.
-
-## When to capture
-
-Capture AFTER the state exists, never before: run the app, the test, or the
-flow first, and shoot the working result. A screenshot of code is not
-evidence; a screenshot of the rendered page is. If the state takes setup
-(seed data, a logged-in user), finish the setup, verify by eye, then capture.
-
-## Per-kind mechanics
-
-Kind is inferred from the file's media type \u2014 name files honestly. Every
-artifact shares one upload cap of 8 MiB, whatever its kind:
-
-- **screenshot** (\`.png\`, \`.jpg\`) \u2014 one focused window or region showing the
-  proven state. Crop noise; keep enough chrome (URL bar, test summary line)
-  to show it is real.
-- **video** (\`.webm\`, \`.mp4\`) \u2014 a short recording of the flow, start to
-  outcome. Video is the kind most likely to hit the 8 MiB cap: trim dead
-  time, prefer webm.
-- **report** (\`.html\`, \`.pdf\`) \u2014 generated reports: coverage, benchmark,
-  audit output. Emit the file the tool produced, unedited.
-- **log** (\`.txt\`, \`.log\`) \u2014 command output proving a run happened: test
-  runs, migrations, gate output. Pipe to a file and emit that file.
-
-Anything else uploads as plain \`file\` \u2014 it is never guessed into a stronger
-kind, so a \`.mov\` will NOT count where a video is required; convert first.
-
-## Captions
-
-One sentence, present tense, saying what the exhibit shows and what that
-proves: "Signup blocked for a disallowed domain \u2014 the 403 page renders."
-Never put secrets, tokens, or personal data in the caption \u2014 or the pixels.
-
-## Binding with --for
-
-When a criterion is the reason you captured, bind it:
-
-    outerlayer emit artifact shot.png --caption "\u2026" --for LOGIN-01
-
-The id comes from your team's own spec or tracker \u2014 wherever criteria for
-this change are written down. The PR comment's Evidence section shows the
-id next to the artifact, and the dashboard's Floor lists it against the
-work item \u2014 but deciding whether a given criterion still needs proof, and
-of what kind, is your team's own check to write, typically a custom
-validator recorded with \`outerlayer emit\`.
-
-## The noise rule
-
-Satisfy the declared proofs; don't document everything. One exhibit per
-criterion is the norm. An unrequested artifact is worth emitting only when
-it would change how a reviewer reads the diff. When in doubt, leave it out \u2014
-evidence works because there is little of it.
-
-## Mechanics
-
-Inside a recorded session, just run the command \u2014 the artifact spools
-locally and uploads with the next \`outerlayer sync\`, bound to this session
-and turn. In CI, run it after the step that produced the file (repo and PR
-come from the CI environment). From a plain machine it anchors through the
-git checkout, or pass \`--pr <n>\` explicitly. If there is nothing to attach
-to, the command refuses \u2014 emit from the work, not from nowhere.
-`;
-var AGENTS_SNIPPET_CONTENT = `${AGENTS_MD_MARKER}
-## Emitting evidence
-
-When you finish work a spec criterion or tracked requirement covers,
-capture the working state and emit it:
-
-    outerlayer emit artifact <file> --caption "what it shows" [--for <criterion-id>] [--pr <n>]
-
-Rules: capture AFTER the state exists (run it, then shoot it); kind comes
-from the file type (png/jpg screenshot, webm/mp4 video, html/pdf report,
-txt/log log \u2014 anything else is a plain file); every artifact caps at 8
-MiB, and video is the kind most likely to hit it; captions are one
-present-tense sentence with no secrets; bind an artifact to the id of the
-requirement it proves \u2014 \`--for <id>\`, from the team's own spec or
-tracker \u2014 and pick the kind that shows the state best; the platform
-records the kind and the id and shows them next to the artifact; satisfy
-what's asked for and stop \u2014 don't document everything. Inside a recorded
-session the artifact uploads on the next \`outerlayer sync\`; in CI it
-anchors via the CI environment; otherwise the git checkout or \`--pr\`
-anchors it, and with nothing to attach to the command refuses.
-`;
-function writeOutFile(repoRoot, relPath, content) {
-  const abs = join(repoRoot, relPath);
-  mkdirSync(dirname(abs), { recursive: true });
-  writeFileSync(abs, content);
-}
-function runImportCapture(opts = {}) {
-  const cwd = opts.cwd ?? process.cwd();
-  let cwdStat;
-  try {
-    cwdStat = statSync(cwd);
-  } catch {
-    throw new ImportCaptureError(`no such directory: ${cwd}`);
-  }
-  if (!cwdStat.isDirectory()) throw new ImportCaptureError(`not a directory: ${cwd}`);
-  const skillAbs = join(cwd, SKILL_PATH);
-  if (existsSync(skillAbs) && readFileSync(skillAbs, "utf8") !== SKILL_CONTENT) {
-    throw new ImportCaptureError(
-      `refusing to import \u2014 ${SKILL_PATH} already exists with local edits (never overwritten; remove it first to reinstall)`
-    );
-  }
-  const files = [];
-  for (const [relPath, content] of [
-    [SKILL_PATH, SKILL_CONTENT],
-    [SNIPPET_PATH, AGENTS_SNIPPET_CONTENT]
-  ]) {
-    if (existsSync(join(cwd, relPath))) continue;
-    writeOutFile(cwd, relPath, content);
-    files.push(relPath);
-  }
-  let appendedAgentsMd = false;
-  const agentsMdAbs = join(cwd, AGENTS_MD_PATH);
-  if (existsSync(agentsMdAbs)) {
-    const existing = readFileSync(agentsMdAbs, "utf8");
-    if (!existing.includes(AGENTS_MD_MARKER)) {
-      writeFileSync(agentsMdAbs, existing + "\n" + AGENTS_SNIPPET_CONTENT);
-      appendedAgentsMd = true;
-    }
-  }
-  let output;
-  if (opts.json) {
-    output = JSON.stringify({ files, appendedAgentsMd });
-  } else {
-    const lines = files.map((f) => `${GREEN}\u2713${RESET} wrote ${f}`);
-    if (appendedAgentsMd) lines.push(`${GREEN}\u2713${RESET} appended the evidence snippet to ${AGENTS_MD_PATH}`);
-    if (files.length === 0 && !appendedAgentsMd) {
-      lines.push(`${DIM}capture pack already installed \u2014 nothing to write${RESET}`);
-    }
-    lines.push(`Run ${YELLOW}\`outerlayer emit\`${RESET} to compile the pack into your agent's native files.`);
-    output = lines.join("\n");
-  }
-  if (!opts.quiet) {
-    process.stdout.write(output + "\n");
-    if (!opts.json && !appendedAgentsMd && !existsSync(agentsMdAbs)) {
-      process.stdout.write(
-        `${DIM}  no ${AGENTS_MD_PATH} to append to \u2014 paste ${SNIPPET_PATH} into your instructions file if your harness reads no skills${RESET}
-`
-      );
-    }
-  }
-  return { files, appendedAgentsMd, output };
-}
-
-export { ImportCaptureError, runImportCapture };

package/dist/init-PTBITAUO.js

@@ -1,103 +0,0 @@
-#!/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

@@ -1,62 +0,0 @@
-#!/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 };