@outerlayer/cli 0.2.0 → 0.4.1

package/dist/chunk-RA3O54FC.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { existsSync, readFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+
+createRequire(import.meta.url);
+var FALLBACK_VERSION = "0.1.0";
+function readJson(path) {
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function resolveVersion(entryPath = fileURLToPath(import.meta.url)) {
+  const distDir = dirname(entryPath);
+  const pkg = readJson(join(dirname(distDir), "package.json"));
+  const version = typeof pkg?.version === "string" ? pkg.version : FALLBACK_VERSION;
+  const buildInfo = readJson(join(distDir, "build-info.json"));
+  const buildId = typeof buildInfo?.id === "string" ? buildInfo.id : null;
+  return buildId ? `${version} (build ${buildId})` : version;
+}
+function resolvePackageVersion(entryPath = fileURLToPath(import.meta.url)) {
+  const pkg = readJson(join(dirname(dirname(entryPath)), "package.json"));
+  return typeof pkg?.version === "string" ? pkg.version : FALLBACK_VERSION;
+}
+
+export { resolvePackageVersion, resolveVersion };

package/dist/chunk-RFUPN6KX.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { isPlaceholderCommand } from './chunk-YFHIIH4B.js';
+import { describeCallFailure } from './chunk-HZRNMGLF.js';
+import { WorkCommandError, getJson } from './chunk-W5FVUZXV.js';
+import { sanitizeTerminal } from './chunk-WFJ65NUD.js';
+import { builtinKind } from './chunk-5Y3QQRUH.js';
+import { claudeCredential, CLAUDE_CREDENTIAL_VARIABLES } from './chunk-AUFG23AA.js';
+import { signerFor } from './chunk-M5POMKKW.js';
+
+createRequire(import.meta.url);
+
+// src/runner/host-setup.ts
+function placeholderQueues(config) {
+  return config.queues.filter((queue) => {
+    const command = config.commands[queue];
+    return command !== void 0 && isPlaceholderCommand(command);
+  });
+}
+function placeholderProblem(queues) {
+  const keys = queues.map((queue) => `runner.commands.${queue}`).join(", ");
+  return `${keys} ${queues.length === 1 ? "is" : "are"} still the placeholder \`runner init\` wrote, which fails every item. Edit ${queues.length === 1 ? "it" : "them"} to start your agent on item $OUTERLAYER_WORK`;
+}
+function needsClaudeCredential(hooks) {
+  return builtinKind(hooks.provision) !== "own";
+}
+var CREDENTIAL_FIX = "Run `claude setup-token`, then start the runner with CLAUDE_CODE_OAUTH_TOKEN set to the token it prints (or ANTHROPIC_API_KEY set to an API key), for example with EnvironmentFile= in the runner's systemd unit";
+function claudeCredentialCheck(env, options = {}) {
+  const name = "Claude credential";
+  const held = claudeCredential(env);
+  if (held === void 0) {
+    return {
+      name,
+      status: "fail",
+      detail: `neither ${CLAUDE_CREDENTIAL_VARIABLES.slice(0, 2).join(" nor ")} is set, so every build fails at provision as agent_credential_missing`,
+      fix: `${CREDENTIAL_FIX}.`
+    };
+  }
+  const sameVariables = options.shell === true ? "; the runner must be started with the same variable" : "";
+  return { name, status: "pass", detail: `${held.variable} is set${sameVariables}` };
+}
+function missingPermissionOf(err) {
+  if (!(err instanceof WorkCommandError) || err.status !== 403) return void 0;
+  const permission = /missing required permission '([^']+)'/i.exec(err.message)?.[1];
+  return permission === void 0 ? void 0 : sanitizeTerminal(permission);
+}
+function missingPermissionFix(permission) {
+  return `use a key that holds ${permission}: create one with the Runner preset on the factory's API keys page, then run \`outerlayer login\` with it`;
+}
+async function claimPermissionProblem(config, fetchImpl = fetch) {
+  const unverified = (what, err) => ({
+    status: "unverified",
+    reason: sanitizeTerminal(`${what}: ${err instanceof Error ? describeCallFailure(err) : String(err)}`)
+  });
+  let signer;
+  try {
+    signer = await signerFor(config.configPath);
+  } catch (err) {
+    return unverified("this host's key could not be read, so whether the runner key can claim work was not checked", err);
+  }
+  try {
+    await getJson(config.url, "/v1/runner/host-key", config.apiKey, config.appId, fetchImpl, signer);
+    return { status: "ok" };
+  } catch (err) {
+    const permission = missingPermissionOf(err);
+    if (permission === void 0) return unverified("the host-key call did not say whether the runner key can claim work", err);
+    return { status: "lacks", problem: `the runner key lacks ${permission}, which a runner needs to claim work: ${missingPermissionFix(permission)}` };
+  }
+}
+
+export { claimPermissionProblem, claudeCredentialCheck, missingPermissionFix, missingPermissionOf, needsClaudeCredential, placeholderProblem, placeholderQueues };

package/dist/chunk-SY4GK4SP.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { sanitizeTerminal } from './chunk-WFJ65NUD.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 };

package/dist/chunk-TBT347UY.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+
+createRequire(import.meta.url);
+
+// src/repo-filter.ts
+function toMatcher(pattern) {
+  const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+  return new RegExp(`^${escaped}$`, "i");
+}
+var RepoFilter = class {
+  constructor(config) {
+    /** Sessions dropped, keyed by repo (or "(no repo)") — for the sync summary. */
+    this.skipped = /* @__PURE__ */ new Map();
+    this.include = (config?.include ?? []).map(toMatcher);
+    this.exclude = (config?.exclude ?? []).map(toMatcher);
+  }
+  get active() {
+    return this.include.length > 0 || this.exclude.length > 0;
+  }
+  /** True when the session should sync. Records skips for reporting. */
+  allows(repo) {
+    const label = repo || "(no repo)";
+    if (repo && this.exclude.some((m) => m.test(repo))) {
+      this.skipped.set(label, (this.skipped.get(label) ?? 0) + 1);
+      return false;
+    }
+    if (this.include.length > 0 && !(repo && this.include.some((m) => m.test(repo)))) {
+      this.skipped.set(label, (this.skipped.get(label) ?? 0) + 1);
+      return false;
+    }
+    return true;
+  }
+  get skippedTotal() {
+    let n = 0;
+    for (const c of this.skipped.values()) n += c;
+    return n;
+  }
+};
+
+export { RepoFilter };