lurqrun 0.1.7 → 0.1.9

package/dist/autopilotInit-JO2SH5K3.js

@@ -0,0 +1,266 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  WORKFLOW_PATH,
+  detectInstallCommand,
+  renderWorkflow
+} from "./chunk-SWMWVK2R.js";
+import {
+  bold,
+  dim,
+  green,
+  red,
+  yellow
+} from "./chunk-4KCPOMG6.js";
+import {
+  logger
+} from "./chunk-MYGSLK44.js";
+import {
+  resolveApiKey
+} from "./chunk-J6XQ7OPZ.js";
+import "./chunk-L3V7AVM6.js";
+import {
+  init_esm_shims
+} from "./chunk-I3M2KJXB.js";
+
+// src/cli/autopilotInit.ts
+init_esm_shims();
+import { spawnSync } from "child_process";
+var LOCKFILES = ["package-lock.json", "yarn.lock", "pnpm-lock.yaml", "bun.lockb", "bun.lock"];
+var SETUP_BRANCH = "lurq/autopilot-setup";
+var COMMIT_MESSAGE = "ci: lurq upgrade autopilot";
+function parseRepoFromRemote(url) {
+  const trimmed = url.trim().replace(/\.git$/, "");
+  if (!trimmed) return null;
+  const match = (
+    // git@github.com:owner/name  |  ssh://git@github.com/owner/name
+    trimmed.match(/^(?:ssh:\/\/)?git@[^:/]+[:/]([^/]+)\/([^/]+)$/) ?? // https://github.com/owner/name
+    trimmed.match(/^https?:\/\/[^/]+\/([^/]+)\/([^/]+)$/)
+  );
+  if (!match) return null;
+  const [, owner, name] = match;
+  return owner && name ? `${owner}/${name}` : null;
+}
+function needsAgentCredential(mode) {
+  return mode === "pr";
+}
+function missingWorkflowScope(authStatus) {
+  const line = authStatus.split("\n").find((l) => /token scopes:/i.test(l));
+  return line !== void 0 && !/['"]workflow['"]/.test(line);
+}
+function parseMode(raw) {
+  if (!raw) return "fix";
+  if (raw === "comment" || raw === "fix" || raw === "pr") return raw;
+  throw new Error(`Unknown mode "${raw}". Use comment, fix, or pr.`);
+}
+function run(cmd, args, input, cwd) {
+  return spawnSync(cmd, args, { cwd, input, encoding: "utf8" });
+}
+function have(cmd) {
+  return run(cmd, ["--version"]).status === 0;
+}
+function errorText(res) {
+  return (res.stderr || res.stdout || "").trim().split("\n")[0] ?? "unknown error";
+}
+function ghApi(path, method = "GET", body) {
+  const args = ["api", "-X", method, path];
+  if (body !== void 0) args.push("--input", "-");
+  const res = run("gh", args, body === void 0 ? void 0 : JSON.stringify(body));
+  if (res.status !== 0) throw new Error(errorText(res));
+  return res.stdout.trim() ? JSON.parse(res.stdout) : null;
+}
+function setSecret(repo, name, value) {
+  const res = run("gh", ["secret", "set", name, "--repo", repo], value);
+  return res.status === 0 ? null : `could not set ${name}: ${errorText(res)}`;
+}
+function mintClaudeToken() {
+  const res = spawnSync("claude", ["setup-token"], {
+    stdio: ["inherit", "pipe", "inherit"],
+    encoding: "utf8"
+  });
+  if (res.status !== 0) return null;
+  const lines = (res.stdout ?? "").split("\n").map((l) => l.trim()).filter(Boolean);
+  const token = lines[lines.length - 1];
+  if (!token || token.includes(" ") || token.length < 20) return null;
+  return token;
+}
+function putWorkflow(repo, branch, content, sha) {
+  ghApi(`repos/${repo}/contents/${WORKFLOW_PATH}`, "PUT", {
+    message: COMMIT_MESSAGE,
+    content: Buffer.from(content).toString("base64"),
+    branch,
+    ...sha ? { sha } : {}
+  });
+}
+function openSetupPr(repo, base, content) {
+  const head = ghApi(`repos/${repo}/git/ref/heads/${base}`).object.sha;
+  try {
+    ghApi(`repos/${repo}/git/refs`, "POST", { ref: `refs/heads/${SETUP_BRANCH}`, sha: head });
+  } catch {
+    ghApi(`repos/${repo}/git/refs/heads/${SETUP_BRANCH}`, "PATCH", { sha: head, force: true });
+  }
+  putWorkflow(repo, SETUP_BRANCH, content, existingSha(repo, SETUP_BRANCH));
+  const res = run("gh", [
+    "pr",
+    "create",
+    "--repo",
+    repo,
+    "--base",
+    base,
+    "--head",
+    SETUP_BRANCH,
+    "--title",
+    COMMIT_MESSAGE,
+    "--body",
+    "Adds the lurq upgrade autopilot. Merge to turn it on; delete the file to turn it off. https://lurq.run/docs/autopilot"
+  ]);
+  if (res.status !== 0) throw new Error(errorText(res));
+  return res.stdout.trim();
+}
+function existingSha(repo, branch) {
+  try {
+    return ghApi(`repos/${repo}/contents/${WORKFLOW_PATH}?ref=${branch}`).sha;
+  } catch {
+    return void 0;
+  }
+}
+function initRepo(repo, mode, secrets, opts) {
+  try {
+    for (const [name, value] of Object.entries(secrets)) {
+      const err = setSecret(repo, name, value);
+      if (err) return { repo, outcome: "failed", detail: err };
+    }
+    const base = ghApi(`repos/${repo}`).default_branch;
+    const sha = existingSha(repo, base);
+    if (sha && !opts.force) {
+      return {
+        repo,
+        outcome: "exists",
+        detail: "workflow already committed (--force replaces it)"
+      };
+    }
+    const root = ghApi(`repos/${repo}/contents/?ref=${base}`).map(
+      (e) => e.name
+    );
+    const content = renderWorkflow({
+      mode,
+      installCommand: detectInstallCommand(LOCKFILES.filter((f) => root.includes(f)))
+    });
+    if (!opts.pr) {
+      try {
+        putWorkflow(repo, base, content, sha);
+        const started = run("gh", [
+          "workflow",
+          "run",
+          WORKFLOW_PATH.split("/").pop(),
+          "--repo",
+          repo
+        ]);
+        return {
+          repo,
+          outcome: "committed",
+          detail: started.status === 0 ? "first run started" : "first run starts on schedule"
+        };
+      } catch {
+      }
+    }
+    return { repo, outcome: "pull-request", detail: openSetupPr(repo, base, content) };
+  } catch (err) {
+    return { repo, outcome: "failed", detail: err instanceof Error ? err.message : String(err) };
+  }
+}
+async function runAutopilotInit(opts) {
+  const mode = parseMode(opts.mode);
+  let repos = (opts.repo ?? []).map((r) => r.trim()).filter(Boolean);
+  if (repos.length === 0) {
+    const remote = run("git", ["remote", "get-url", "origin"], void 0, opts.cwd);
+    const here = remote.status === 0 ? parseRepoFromRemote(remote.stdout) : null;
+    if (here) repos = [here];
+  }
+  if (repos.length === 0) {
+    logger.error("Could not work out which repository this is.");
+    logger.error("Pass one or more: lurq autopilot init --repo owner/a owner/b");
+    process.exitCode = 1;
+    return;
+  }
+  const apiKey = resolveApiKey(opts.apiKey);
+  if (!apiKey) {
+    logger.error(
+      "No lurq API key on this machine. Run `npx lurqrun setup` first, then this again."
+    );
+    process.exitCode = 1;
+    return;
+  }
+  if (!have("gh")) {
+    logger.error("The GitHub CLI (`gh`) is not installed. https://cli.github.com");
+    process.exitCode = 1;
+    return;
+  }
+  const auth = run("gh", ["auth", "status"]);
+  if (auth.status !== 0) {
+    logger.error("`gh` is not signed in. Run `gh auth login`, then this again.");
+    process.exitCode = 1;
+    return;
+  }
+  if (missingWorkflowScope(`${auth.stdout}
+${auth.stderr}`)) {
+    logger.error(
+      "GitHub only lets a token write workflow files with the `workflow` scope. Add it:"
+    );
+    logger.error("    gh auth refresh -s workflow");
+    process.exitCode = 1;
+    return;
+  }
+  const secrets = { LURQ_API_KEY: apiKey };
+  const notes = [];
+  if (needsAgentCredential(mode) && opts.credential !== false) {
+    const token = have("claude") ? (logger.info(dim("Minting a Claude token \u2014 sign in when prompted.")), mintClaudeToken()) : null;
+    if (token) {
+      secrets.CLAUDE_CODE_OAUTH_TOKEN = token;
+      notes.push(
+        `${yellow("The Claude token expires one year from today, with no warning.")} An ANTHROPIC_API_KEY does not:
+    gh secret set ANTHROPIC_API_KEY --repo <owner/name>`
+      );
+    } else {
+      notes.push(
+        "pr mode needs an Anthropic credential and none was set. Per repo:\n    gh secret set ANTHROPIC_API_KEY --repo <owner/name>"
+      );
+    }
+  }
+  if (!opts.json)
+    logger.info(
+      `${bold("mode")} ${mode} \xB7 ${repos.length} ${repos.length === 1 ? "repository" : "repositories"}
+`
+    );
+  const results = [];
+  for (const repo of repos) {
+    const result = initRepo(repo, mode, secrets, opts);
+    results.push(result);
+    if (!opts.json)
+      logger.info(`${resultMark(result)} ${repo}${result.detail ? dim(`  ${result.detail}`) : ""}`);
+  }
+  if (results.some((r) => r.outcome === "failed")) process.exitCode = 1;
+  if (opts.json) {
+    logger.info(JSON.stringify({ mode, results }, null, 2));
+    return;
+  }
+  if (results.some((r) => r.outcome === "pull-request")) {
+    notes.push("Merge the pull requests above to turn those repositories on.");
+  }
+  if (results.some((r) => r.outcome === "committed") && !opts.repo?.length) {
+    notes.push("Committed on GitHub, not locally: `git pull` to see it in this checkout.");
+  }
+  for (const note of notes) logger.info(`
+  \xB7 ${note}`);
+}
+function resultMark(r) {
+  if (r.outcome === "failed") return red("\u2717");
+  if (r.outcome === "pull-request") return yellow("\u2197");
+  if (r.outcome === "exists") return dim("\xB7");
+  return green("\u2713");
+}
+export {
+  missingWorkflowScope,
+  needsAgentCredential,
+  parseRepoFromRemote,
+  runAutopilotInit
+};