@outerlayer/cli 0.1.1 → 0.4.0

package/dist/agent-setup-IFH3FB5X.js

@@ -0,0 +1,197 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { installStarterPack } from './chunk-ZMYPLFG3.js';
+import { runEmit } from './chunk-H5NCNVDA.js';
+import { addStdioMcpEntryIfAbsent } from './chunk-MQ3IPHIZ.js';
+import { C } from './chunk-YRYMNBGQ.js';
+import { resolveGitCommonDir, defaultGitRunner } from './chunk-XDDW4FRS.js';
+import { pinExists, readContextManifest } from './chunk-WIOZAJ2W.js';
+import { loadTemplateFiles, loadMaintainedFiles, skillDir } from './chunk-WO2BXCTQ.js';
+import { generatedHeaderSource } from './chunk-EMY4I27X.js';
+import './chunk-ZJSNLVCE.js';
+import './chunk-BCLJSQCV.js';
+import './chunk-BOLTI6LR.js';
+import './chunk-EABW6AJQ.js';
+import './chunk-RA3O54FC.js';
+import './chunk-M5POMKKW.js';
+import './chunk-ZM2IMMYN.js';
+import './chunk-XCCLFVXM.js';
+import './chunk-BJ3KTMDH.js';
+import './chunk-VNVZDWO3.js';
+import './chunk-Z5GEFMRW.js';
+import { execFileSync } from 'child_process';
+import { existsSync, mkdirSync, writeFileSync } from 'fs';
+import { join, dirname } from 'path';
+
+createRequire(import.meta.url);
+var CONFIG_PATH = ".outerlayer/config.json";
+var MCP_OUTPUT_PATH = ".mcp.json";
+var POLICY_PATH = ".outerlayer/policy.yaml";
+var DEFAULT_CONFIG = `${JSON.stringify({ targets: ["claude-code"] }, null, 2)}
+`;
+var errorMessage = (err) => err instanceof Error ? err.message : String(err);
+var skipped = (reason) => ({
+  outcome: "skipped",
+  reason,
+  text: `${C.dim}- Agent setup skipped: ${reason}${C.reset}
+`,
+  paths: []
+});
+var GitLookupError = class extends Error {
+};
+function gitTopLevel(cwd) {
+  try {
+    const top = execFileSync("git", ["rev-parse", "--show-toplevel"], { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+    return top === "" ? void 0 : top;
+  } catch (err) {
+    const stderr = String(err.stderr ?? "");
+    if (/not a git repository/i.test(stderr)) return void 0;
+    throw new GitLookupError(`git could not report the repository root: ${(stderr.trim() || errorMessage(err)).split("\n")[0]}`);
+  }
+}
+function contextComesFromControlPlane(repoRoot) {
+  if (pinExists(repoRoot)) return true;
+  const gitCommonDir = resolveGitCommonDir(defaultGitRunner, repoRoot);
+  if (gitCommonDir === void 0) throw new GitLookupError("git could not report this repository's git directory");
+  return readContextManifest(gitCommonDir) !== void 0;
+}
+function mcpReplacementLosesNothing(existing, content) {
+  try {
+    const have = JSON.parse(existing);
+    const next = JSON.parse(content);
+    return Object.entries(have).every(([key, value]) => {
+      if (key !== "mcpServers") return JSON.stringify(next[key]) === JSON.stringify(value);
+      const nextServers = next.mcpServers ?? {};
+      return Object.entries(value ?? {}).every(([name, entry]) => JSON.stringify(nextServers[name]) === JSON.stringify(entry));
+    });
+  } catch {
+    return false;
+  }
+}
+function keepHandWritten(createdSources) {
+  return (output) => {
+    if (output.kind === "copy") return createdSources.has(output.source);
+    if (output.path.endsWith("mcp.json")) return !mcpReplacementLosesNothing(output.existing, output.content);
+    return generatedHeaderSource(output.existing) === null;
+  };
+}
+function runAgentSetup(opts) {
+  let repoRoot;
+  try {
+    repoRoot = gitTopLevel(opts.cwd);
+    if (repoRoot === void 0) return skipped("not a git repository");
+    if (contextComesFromControlPlane(repoRoot)) {
+      return skipped("this repository's context comes from a control plane and arrives at session start");
+    }
+  } catch (err) {
+    return failed(errorMessage(err), /* @__PURE__ */ new Set(), []);
+  }
+  const written = /* @__PURE__ */ new Set();
+  const kept = [];
+  const problems = [];
+  const keptOutputs = /* @__PURE__ */ new Set();
+  const createdSources = new Set(
+    [...loadTemplateFiles(), ...loadMaintainedFiles()].map((f) => f.path).filter((p) => !existsSync(join(repoRoot, p)))
+  );
+  const keep = keepHandWritten(createdSources);
+  try {
+    const pack = installStarterPack({ repoRoot });
+    for (const file of loadTemplateFiles().filter((f) => pack.copied.includes(f.skill))) written.add(file.path);
+    for (const path of pack.maintained) written.add(path);
+    for (const skill of pack.kept) kept.push(`${skillDir(skill)}/`);
+    if (pack.policy === "written") written.add(POLICY_PATH);
+    else kept.push(POLICY_PATH);
+    if (existsSync(join(repoRoot, CONFIG_PATH))) {
+      kept.push(CONFIG_PATH);
+    } else {
+      mkdirSync(dirname(join(repoRoot, CONFIG_PATH)), { recursive: true });
+      writeFileSync(join(repoRoot, CONFIG_PATH), DEFAULT_CONFIG);
+      written.add(CONFIG_PATH);
+    }
+  } catch (err) {
+    return failed(`could not install the skills: ${errorMessage(err)}`, written, kept);
+  }
+  try {
+    const mcp = addStdioMcpEntryIfAbsent(repoRoot);
+    if (mcp.added) written.add(mcp.path);
+    else kept.push(`${mcp.path} (already has an outerlayer server)`);
+  } catch (err) {
+    problems.push(errorMessage(err));
+  }
+  let pending;
+  try {
+    const check = runEmit({ cwd: repoRoot, check: true, quiet: true, keep });
+    pending = check.drift ?? [];
+    const emitted = runEmit({ cwd: repoRoot, quiet: true, keep });
+    for (const path of emitted.kept) keptOutputs.add(path);
+    if (emitted.exitCode !== 0) {
+      const detail = emitted.errors.map((e) => `${e.path}: ${e.message}`).join("; ");
+      problems.push(`context emit failed: ${detail}`);
+    } else {
+      for (const d of pending) if (d.kind !== "orphaned") written.add(d.path);
+    }
+  } catch (err) {
+    problems.push(`context emit failed: ${errorMessage(err)}`);
+  }
+  for (const path of [...keptOutputs].sort()) kept.push(`${path} (written by hand, not replaced)`);
+  const keptPaths = [...keptOutputs].sort();
+  if (problems.length > 0) {
+    for (const path of writtenBeforeFailure(repoRoot, pending, keep)) written.add(path);
+    return failed(problems.join("; "), written, kept, keptPaths);
+  }
+  const paths = [...written].sort();
+  return {
+    outcome: "done",
+    reason: paths.length === 0 ? "already set up" : `${paths.length} files written`,
+    text: renderDone(paths, kept, keptOutputs.has(MCP_OUTPUT_PATH)),
+    paths,
+    kept: keptPaths
+  };
+}
+function writtenBeforeFailure(repoRoot, pending, keep) {
+  if (pending === void 0 || pending.length === 0) return [];
+  try {
+    const now = new Set((runEmit({ cwd: repoRoot, check: true, quiet: true, keep }).drift ?? []).map((d) => d.path));
+    return pending.filter((d) => d.kind !== "orphaned" && !now.has(d.path)).map((d) => d.path);
+  } catch {
+    return [];
+  }
+}
+function failed(reason, written, kept, keptPaths = []) {
+  const paths = [...written].sort();
+  return {
+    outcome: "failed",
+    reason,
+    text: `${C.red}\u2717${C.reset} Agent setup: ${reason}
+${paths.length > 0 ? renderPaths(paths, kept) : ""}`,
+    paths,
+    kept: keptPaths
+  };
+}
+function renderPaths(paths, kept) {
+  const lines = [];
+  if (paths.length > 0) {
+    lines.push("  Written, uncommitted:");
+    for (const p of paths) lines.push(`    ${p}`);
+  }
+  if (kept.length > 0) {
+    lines.push("  Kept as they were:");
+    for (const p of kept) lines.push(`    ${C.dim}${p}${C.reset}`);
+  }
+  return `${lines.join("\n")}
+`;
+}
+function renderDone(paths, kept, mcpKept) {
+  const mcpNote = mcpKept ? `  ${C.yellow}!${C.reset} The outerlayer entry was not added to .mcp.json, so its MCP server is not set up. Add it to .mcp.json by hand, or move the servers you wrote into .outerlayer/mcp.json and run \`outerlayer context emit\`.
+` : "";
+  const what = mcpKept ? "the OuterLayer skills" : "the OuterLayer skills and MCP server";
+  if (paths.length === 0) {
+    return `${C.green}\u2713${C.reset} Agent setup: already in place, nothing changed
+${renderPaths(paths, kept)}${mcpNote}`;
+  }
+  return `${C.green}\u2713${C.reset} Agent setup: Claude Code has ${what}
+` + renderPaths(paths, kept) + mcpNote + `  ${C.dim}\`context emit\` compiled every source under .outerlayer/ for the targets in ${CONFIG_PATH}, not only the skills.${C.reset}
+`;
+}
+
+export { runAgentSetup };

package/dist/build-TZUUTRGH.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+export { buildRepositoryImage } from './chunk-ZNA27WEV.js';
+import './chunk-N5FOE5PS.js';
+export { RecipeError } from './chunk-QOZKPLVJ.js';
+import './chunk-ZM2IMMYN.js';
+import './chunk-Z5GEFMRW.js';
+
+createRequire(import.meta.url);

package/dist/build-info.json

@@ -1 +1 @@
-{"id":"2026-09-24T11:40:02.645Z+05fbecd","root":"/home/runner/_work/outerlayer/outerlayer","pkg":"outerlayer"}
+{"id":"2026-10-02T18:11:11.100Z+54c322e","root":"/home/runner/_work/outerlayer/outerlayer","pkg":"outerlayer"}

package/dist/check-WQP2CZDW.js

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { probeCredentials } from './chunk-FS2VYGZT.js';
+import './chunk-FAJSS2WN.js';
+import './chunk-FV2CCGXK.js';
+import './chunk-ABIWDUMS.js';
+import './chunk-YYYXRJUW.js';
+import './chunk-CBPPJSAR.js';
+import { placeholderQueues, placeholderProblem, needsClaudeCredential, claudeCredentialCheck, claimPermissionProblem } from './chunk-7YIOOFVJ.js';
+import './chunk-HE2D4EY5.js';
+import './chunk-TBT347UY.js';
+import './chunk-CBZB6XY6.js';
+import './chunk-L2DBRKRA.js';
+import './chunk-7A6RVXPZ.js';
+import './chunk-ZNA27WEV.js';
+import './chunk-N5FOE5PS.js';
+import './chunk-OGFGZQA3.js';
+import './chunk-774HEQL6.js';
+import './chunk-QOZKPLVJ.js';
+import './chunk-W4SQCOZU.js';
+import './chunk-B2G7JHHB.js';
+import './chunk-5DLBAXY5.js';
+import './chunk-BFESLKPP.js';
+import './chunk-6Y63SXFO.js';
+import './chunk-G7FSV7JX.js';
+import { loadRunnerConfig, RunnerConfigError, checkHooks } from './chunk-5Y3QQRUH.js';
+import './chunk-F6GFZXZ3.js';
+import './chunk-AUFG23AA.js';
+import './chunk-WZBHBH3J.js';
+import './chunk-XDDW4FRS.js';
+import './chunk-WIOZAJ2W.js';
+import './chunk-WO2BXCTQ.js';
+import './chunk-EMY4I27X.js';
+import './chunk-ZJSNLVCE.js';
+import './chunk-BCLJSQCV.js';
+import './chunk-BOLTI6LR.js';
+import './chunk-EABW6AJQ.js';
+import './chunk-RA3O54FC.js';
+import './chunk-M5POMKKW.js';
+import './chunk-ZM2IMMYN.js';
+import './chunk-XCCLFVXM.js';
+import './chunk-BJ3KTMDH.js';
+import './chunk-VNVZDWO3.js';
+import './chunk-Z5GEFMRW.js';
+
+createRequire(import.meta.url);
+
+// src/runner/check.ts
+async function runRunnerCheck(configPath, deps = {}) {
+  let config;
+  try {
+    config = loadRunnerConfig(configPath);
+  } catch (err) {
+    return { ok: false, check: "config", message: err instanceof RunnerConfigError ? err.message : String(err) };
+  }
+  const hookProblem = checkHooks(config, deps.env ?? process.env);
+  if (hookProblem) return { ok: false, check: "hooks", message: `${configPath}: ${hookProblem}` };
+  const placeholders = placeholderQueues(config);
+  if (placeholders.length > 0) {
+    return { ok: false, check: "placeholders", message: `${configPath}: ${placeholderProblem(placeholders)}` };
+  }
+  if (needsClaudeCredential(config.hooks)) {
+    const credential = claudeCredentialCheck(deps.env ?? process.env);
+    if (credential.status === "fail") {
+      return { ok: false, check: "claude credential", message: `${credential.detail}. ${credential.fix}` };
+    }
+  }
+  const probe = await probeCredentials(config, deps.fetchImpl);
+  if (!probe.ok && probe.fatal) return { ok: false, check: "credentials", message: probe.reason };
+  const claimProblem = await claimPermissionProblem(config, deps.fetchImpl);
+  if (claimProblem.status === "lacks") {
+    return { ok: false, check: "claim permission", message: `${configPath}: ${claimProblem.problem}` };
+  }
+  const unverifiedReason = probe.ok ? claimProblem.reason : probe.reason;
+  const lines = [
+    `config              ${configPath}`,
+    `host                ${config.host}`,
+    `queues              ${config.queues.join(", ")}`,
+    `concurrency         ${config.concurrency}`,
+    `poll                ${config.pollSeconds}s`,
+    `time limit          ${config.timeLimitMinutes}m`,
+    `idle limit          ${config.idleLimitMinutes}m`,
+    `auto update         ${config.autoUpdate ? "on" : "off"}`,
+    ...config.queues.map((queue) => `command ${queue.padEnd(11)} ${config.commands[queue] ?? "(none)"}`),
+    `hook provision      ${config.hooks.provision}`,
+    `hook cleanup        ${config.hooks.cleanup}`,
+    `hook report         ${config.hooks.report ?? "(none)"}`,
+    `repos include       ${config.repos?.include?.join(", ") ?? "(all)"}`,
+    `repos exclude       ${config.repos?.exclude?.join(", ") ?? "(none)"}`
+  ];
+  return { ok: true, lines, unverifiedReason, summary: `${config.url} \xB7 app ${config.appId}` };
+}
+
+export { runRunnerCheck };

package/dist/chunk-2E54Z3P5.js

@@ -0,0 +1,232 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { dashboardBase, isRepositoryLinked, workPageUrl, notLinkedText } from './chunk-3TT7RQYB.js';
+import { sanitizeTerminal } from './chunk-6Y63SXFO.js';
+import { remoteLookupFailed } from './chunk-G7FSV7JX.js';
+import { resolveGatewayCredentials } from './chunk-BOLTI6LR.js';
+import { findGitDirs, readRepoConnection, writeRepoConnection } from './chunk-BJ3KTMDH.js';
+import { createInterface } from 'readline/promises';
+
+createRequire(import.meta.url);
+var REQUEST_TIMEOUT_MS = 15e3;
+var EXIT_NOT_LINKED = 2;
+var REASON_TEXT = {
+  flag: "you passed --factory",
+  saved: "already connected",
+  linked: "the repository is linked to it",
+  only: "the only factory you can use",
+  prompt: "you chose it"
+};
+var slug = (f) => `${f.organization.name}/${f.name}`;
+function result(code, outcome, reason, text) {
+  return { code, outcome, reason, text: text.endsWith("\n") ? text : `${text}
+` };
+}
+function realConnectDeps() {
+  return { fetchImpl: fetch, env: process.env, prompt: promptOnTerminal, now: () => /* @__PURE__ */ new Date() };
+}
+async function promptOnTerminal(question, io = { input: process.stdin, output: process.stderr }) {
+  const rl = createInterface(io);
+  try {
+    let text = `
+${question.message}
+`;
+    question.options.forEach((o, i) => {
+      text += `  ${i + 1}) ${o.label}
+`;
+    });
+    for (; ; ) {
+      const answer = (await rl.question(`${text}Choose 1-${question.options.length}: `)).trim();
+      if (answer === "") return void 0;
+      const picked = question.options[Number(answer) - 1];
+      if (picked !== void 0) return picked.value;
+      text = "";
+    }
+  } catch {
+    return void 0;
+  } finally {
+    rl.close();
+  }
+}
+function parseFactories(body) {
+  const rows = body?.data;
+  if (!Array.isArray(rows)) return void 0;
+  const out = [];
+  for (const row of rows) {
+    const org = row?.organization;
+    if (typeof row?.id !== "string" || typeof row.name !== "string" || typeof org?.id !== "string" || typeof org.name !== "string") return void 0;
+    out.push({
+      id: row.id,
+      name: sanitizeTerminal(row.name),
+      displayName: sanitizeTerminal(typeof row.displayName === "string" ? row.displayName : row.name),
+      organization: {
+        id: org.id,
+        name: sanitizeTerminal(org.name),
+        displayName: sanitizeTerminal(typeof org.displayName === "string" ? org.displayName : org.name)
+      },
+      linked: typeof row.linked === "boolean" ? row.linked : null
+    });
+  }
+  return out;
+}
+function listText(factories, repository) {
+  return factories.map((f) => `  ${slug(f)}  ${f.displayName}${f.linked === true ? ` (linked to ${repository})` : ""}`).join("\n");
+}
+async function fetchFactories(deps, url, token, repository) {
+  let res;
+  try {
+    res = await deps.fetchImpl(`${url.replace(/\/+$/, "")}/v1/me/factories?${new URLSearchParams({ repository }).toString()}`, {
+      method: "GET",
+      headers: { authorization: `Bearer ${token}` },
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+    });
+  } catch (err) {
+    const message = `could not reach ${url}: ${err instanceof Error ? err.message : String(err)}`;
+    return { ok: false, result: result(1, "failed", message, message) };
+  }
+  if (res.status === 401) {
+    const message = "the gateway refused the login. Run `outerlayer login` to sign in again.";
+    return { ok: false, result: result(1, "failed", message, message) };
+  }
+  if (!res.ok) {
+    const message = `${url} answered HTTP ${res.status} when listing your factories`;
+    return { ok: false, result: result(1, "failed", message, message) };
+  }
+  const factories = parseFactories(await res.json().catch(() => null));
+  if (factories === void 0) {
+    const message = `${url} answered, but the reply is not a list of factories. Check the gateway address with \`outerlayer doctor\`, then run \`outerlayer connect\` again.`;
+    return { ok: false, result: result(1, "failed", `${url} did not answer with a factory list`, message) };
+  }
+  return { ok: true, factories };
+}
+async function choose(flags, deps, factories, saved, repository) {
+  if (flags.factory !== void 0) {
+    const wanted = flags.factory.toLowerCase();
+    const named = factories.find((f) => f.id.toLowerCase() === wanted || slug(f).toLowerCase() === wanted);
+    if (named) return { factory: named, reason: "flag" };
+    const message = `no factory you can use is named "${flags.factory}". Choose one with --factory:
+${listText(factories, repository)}`;
+    return result(1, "failed", `--factory ${flags.factory} names no factory you can use`, message);
+  }
+  const remembered = saved && factories.find((f) => f.id === saved.appId);
+  if (remembered) return { factory: remembered, reason: "saved" };
+  const linked = factories.filter((f) => f.linked === true);
+  if (linked.length === 1) return { factory: linked[0], reason: "linked" };
+  if (factories.length === 1) return { factory: factories[0], reason: "only" };
+  if (!deps.isTerminal) {
+    const why = linked.length > 1 ? `${repository} is linked to more than one factory you can use` : `you can use more than one factory, and none is the only one ${repository} is linked to`;
+    const message = `${why}, and there is no terminal to ask on.
+Run \`outerlayer connect --factory <org>/<factory>\` with one of:
+${listText(factories, repository)}`;
+    return result(1, "failed", "more than one factory fits; pass --factory", message);
+  }
+  let pool = factories;
+  const orgs = new Map(factories.map((f) => [f.organization.id, f.organization]));
+  if (orgs.size > 1) {
+    const org = await deps.prompt({
+      message: "Which organization?",
+      options: [...orgs.values()].map((o) => ({ label: `${o.displayName} (${o.name})`, value: o.id }))
+    });
+    pool = factories.filter((f) => f.organization.id === org);
+  }
+  const picked = pool.length === 0 ? void 0 : await deps.prompt({
+    message: `Which factory should ${repository} use?`,
+    options: pool.map((f) => ({
+      label: `${f.displayName} (${slug(f)})${f.linked === true ? ` - linked to ${repository}` : ""}`,
+      value: f.id
+    }))
+  });
+  const factory = pool.find((f) => f.id === picked);
+  if (!factory) return result(1, "failed", "no factory was chosen", "no factory was chosen. Run `outerlayer connect` again, or pass --factory <org>/<factory>.");
+  return { factory, reason: "prompt" };
+}
+async function runConnect(flags, deps) {
+  const creds = resolveGatewayCredentials({ home: deps.home, env: deps.env, cwd: deps.cwd });
+  if (creds.credential === void 0) {
+    const message = "no saved credential. Run `outerlayer login` to sign in, then run `outerlayer connect` again.";
+    return { ...result(1, "skipped", "no credential; run `outerlayer login` first", message), next: "Run `outerlayer login`, then `outerlayer init` again." };
+  }
+  if (creds.kind === "key") {
+    if (flags.factory !== void 0 && flags.factory !== creds.appId) {
+      const message2 = `a factory key decides the factory${creds.appId ? ` (${creds.appId})` : ""}, so --factory ${flags.factory} cannot apply. Remove --factory, or sign in with \`outerlayer login\` and unset the key.`;
+      return result(1, "failed", "--factory names a factory other than the key's", message2);
+    }
+    const message = `Your factory key decides the factory${creds.appId ? ` (${creds.appId})` : ""}, so there is nothing to connect. No file was changed.`;
+    return result(0, "done", "the factory key decides the factory", message);
+  }
+  if (findGitDirs(deps.cwd) === void 0) {
+    return result(1, "skipped", "not in a git repository", "connect chooses a factory for a repository, and this directory is not in a git repository. Run it inside one.");
+  }
+  const repository = deps.resolveRepository(deps.cwd);
+  if (repository === void 0 && remoteLookupFailed(deps.cwd)) {
+    const message = "git did not answer when asked for this repository's remote, so connect cannot tell which repository it is. Run `git remote -v` here, then run `outerlayer connect` again.";
+    return result(1, "failed", "git could not read this repository's remote", message);
+  }
+  if (repository === void 0) {
+    return result(1, "skipped", "this repository has no git remote", "this repository has no git remote, so connect cannot tell which repository it is. Add one (`git remote add origin <url>`), then run `outerlayer connect` again.");
+  }
+  if (creds.url === void 0) {
+    const message = "no gateway address is saved. Run `outerlayer login` to sign in.";
+    return result(1, "failed", message, message);
+  }
+  const listed = await fetchFactories(deps, creds.url, creds.credential, repository);
+  if (!listed.ok) return listed.result;
+  const { factories } = listed;
+  if (factories.length === 0) {
+    const message = `you can use no factory yet. Create one in the dashboard: ${dashboardBase(deps.home)}/orgs`;
+    return result(1, "failed", "no factory to choose from; create one in the dashboard", message);
+  }
+  const dirs = findGitDirs(deps.cwd);
+  const saved = readRepoConnection(deps.cwd);
+  const choice = await choose(flags, deps, factories, saved, repository);
+  if ("code" in choice) return choice;
+  const { factory, reason } = choice;
+  if (saved?.appId !== factory.id) {
+    try {
+      writeRepoConnection(dirs.gitCommonDir, {
+        appId: factory.id,
+        organization: { name: factory.organization.name, displayName: factory.organization.displayName },
+        factory: { name: factory.name, displayName: factory.displayName },
+        savedAt: deps.now().toISOString()
+      });
+    } catch (err) {
+      const message = `could not save the connection under ${dirs.gitCommonDir}: ${err instanceof Error ? err.message : String(err)}`;
+      return result(1, "failed", "could not save the connection", message);
+    }
+  }
+  const connected = `Connected ${repository} to factory "${factory.displayName}" in ${factory.organization.displayName} (${REASON_TEXT[reason]}).
+`;
+  const why = `connected to ${slug(factory)}: ${REASON_TEXT[reason]}`;
+  const linked = await isRepositoryLinked(deps.fetchImpl, creds.url, creds.credential, factory.id, repository);
+  const chosen = { repository, factory: slug(factory) };
+  if (linked === false) {
+    const linkUrl = workPageUrl(deps.home, factory.organization.name, factory.name);
+    return { ...result(EXIT_NOT_LINKED, "done", why, connected + notLinkedText(factory.displayName, repository, linkUrl)), ...chosen, linked, linkUrl };
+  }
+  const changeIt = "Run `outerlayer connect --factory <org>/<factory>` to change it.";
+  const text = linked === null ? `${connected}Could not check whether ${sanitizeTerminal(repository)} is linked to ${factory.displayName}.
+${changeIt}` : connected + changeIt;
+  return { ...result(0, "done", why, text), ...chosen, linked };
+}
+function connectDocument(r) {
+  return {
+    status: r.outcome,
+    reason: r.reason,
+    ...r.repository === void 0 ? {} : { repository: r.repository, factory: r.factory },
+    ...r.linked === void 0 ? {} : { linked: r.linked },
+    ...r.linkUrl === void 0 ? {} : { linkUrl: r.linkUrl }
+  };
+}
+async function runConnectCommand(flags, deps, out) {
+  const r = await runConnect(flags, deps);
+  if (flags.json) {
+    out.stdout.write(`${JSON.stringify(connectDocument(r), null, 2)}
+`);
+    out.stderr.write(r.outcome === "done" ? r.text : `\u2717 ${r.text}`);
+    return r.code;
+  }
+  (r.code === 0 ? out.stdout : out.stderr).write(r.outcome === "done" ? r.text : `\u2717 ${r.text}`);
+  return r.code;
+}
+
+export { promptOnTerminal, realConnectDeps, runConnect, runConnectCommand };

package/dist/chunk-3TT7RQYB.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { sanitizeTerminal } from './chunk-6Y63SXFO.js';
+import { DEFAULT_DASHBOARD } from './chunk-USO2DKBD.js';
+import { readCloudConfig } from './chunk-EABW6AJQ.js';
+
+createRequire(import.meta.url);
+
+// src/repository-link.ts
+var LINKS_TIMEOUT_MS = 15e3;
+var GITHUB_PREFIX = "github.com/";
+function isLinkedRepository(local, linked) {
+  if (linked.provider !== "github" || typeof linked.repository !== "string") return false;
+  return local.toLowerCase() === `${GITHUB_PREFIX}${linked.repository.toLowerCase()}`;
+}
+function ownerAndName(repository) {
+  return repository.toLowerCase().startsWith(GITHUB_PREFIX) ? repository.slice(GITHUB_PREFIX.length) : repository;
+}
+async function isRepositoryLinked(fetchImpl, gatewayUrl, token, appId, repository) {
+  if (!repository.toLowerCase().startsWith(GITHUB_PREFIX)) return null;
+  let res;
+  try {
+    res = await fetchImpl(`${gatewayUrl.replace(/\/+$/, "")}/v1/apps/${encodeURIComponent(appId)}/git/links`, {
+      method: "GET",
+      headers: { authorization: `Bearer ${token}`, "x-outerlayer-app-id": appId },
+      signal: AbortSignal.timeout(LINKS_TIMEOUT_MS)
+    });
+  } catch {
+    return null;
+  }
+  if (!res.ok) return null;
+  const listed = (await res.json().catch(() => void 0))?.data;
+  if (!Array.isArray(listed)) return null;
+  return listed.some((entry) => isLinkedRepository(repository, entry ?? {}));
+}
+function dashboardBase(home) {
+  const saved = readCloudConfig(home).dashboard;
+  const base = typeof saved === "string" && saved.trim() !== "" ? saved : DEFAULT_DASHBOARD;
+  return base.replace(/\/+$/, "");
+}
+function workPageUrl(home, organization, factory) {
+  return `${dashboardBase(home)}/orgs/${encodeURIComponent(organization)}/factories/${encodeURIComponent(factory)}/work`;
+}
+function notLinkedText(factoryName, repository, url) {
+  const shown = sanitizeTerminal(repository);
+  const name = sanitizeTerminal(ownerAndName(repository));
+  return `${factoryName} has no link to ${shown} yet, so work from this repository cannot reach it.
+Link it on the factory's Work page: ${url}
+  1. Connect GitHub repository, and grant the App access to ${name}.
+  2. Link repository, and pick ${name} and its default branch.
+Then run \`outerlayer connect\` again.
+`;
+}
+
+export { dashboardBase, isLinkedRepository, isRepositoryLinked, notLinkedText, workPageUrl };