lurqrun 0.1.6 → 0.1.8

package/dist/check-PQSQ2MMA.js

@@ -0,0 +1,192 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  checkApi
+} from "./chunk-SOXFMMXC.js";
+import {
+  require_dist
+} from "./chunk-QKGYDMWB.js";
+import "./chunk-3GHJR7XR.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-I3M2KJXB.js";
+
+// src/api/check.ts
+init_esm_shims();
+import { execFile } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import { relative, resolve } from "path";
+import { promisify } from "util";
+
+// src/api/openapi.ts
+init_esm_shims();
+var import_yaml = __toESM(require_dist(), 1);
+var METHODS = ["get", "put", "post", "delete", "options", "head", "patch", "trace"];
+var isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+function deref(root, node, seen = /* @__PURE__ */ new Set()) {
+  if (!isRecord(node)) return null;
+  const ref = node.$ref;
+  if (typeof ref !== "string") return node;
+  if (!ref.startsWith("#/") || seen.has(ref)) return null;
+  seen.add(ref);
+  let cursor = root;
+  for (const segment of ref.slice(2).split("/")) {
+    if (!isRecord(cursor)) return null;
+    cursor = cursor[segment.replace(/~1/g, "/").replace(/~0/g, "~")];
+  }
+  return deref(root, cursor, seen);
+}
+function readParams(root, shared, own) {
+  const required = /* @__PURE__ */ new Set();
+  const optional = /* @__PURE__ */ new Set();
+  for (const list of [shared, own]) {
+    if (!Array.isArray(list)) continue;
+    for (const raw of list) {
+      const param = deref(root, raw);
+      const name = param?.name;
+      if (typeof name !== "string") continue;
+      const key = `${name} (${typeof param?.in === "string" ? param.in : "unknown"})`;
+      if (param?.required === true) {
+        required.add(key);
+        optional.delete(key);
+      } else if (!required.has(key)) {
+        optional.add(key);
+      }
+    }
+  }
+  return { required: [...required].sort(), optional: [...optional].sort() };
+}
+function readBodyFields(root, requestBody) {
+  const body = deref(root, requestBody);
+  if (!body || body.required !== true) return [];
+  const content = body.content;
+  if (!isRecord(content)) return [];
+  const out = /* @__PURE__ */ new Set();
+  for (const media of Object.values(content)) {
+    const schema = deref(root, isRecord(media) ? media.schema : null);
+    const required = schema?.required;
+    if (!Array.isArray(required)) continue;
+    for (const field of required) if (typeof field === "string") out.add(field);
+  }
+  return [...out].sort();
+}
+function extractApiSurface(source, label = "document") {
+  const empty = { title: null, version: null, operations: /* @__PURE__ */ new Map() };
+  let doc;
+  try {
+    doc = (0, import_yaml.parse)(source);
+  } catch (err) {
+    return {
+      ...empty,
+      unreadableReason: `${label} is not valid YAML or JSON: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  if (!isRecord(doc)) return { ...empty, unreadableReason: `${label} is not an object` };
+  if (!doc.openapi && !doc.swagger) {
+    return { ...empty, unreadableReason: `${label} has no openapi/swagger version field` };
+  }
+  const info = isRecord(doc.info) ? doc.info : {};
+  const paths = isRecord(doc.paths) ? doc.paths : {};
+  const operations = /* @__PURE__ */ new Map();
+  for (const [path, rawItem] of Object.entries(paths)) {
+    const item = deref(doc, rawItem);
+    if (!item) continue;
+    for (const method of METHODS) {
+      const op = item[method];
+      if (!isRecord(op)) continue;
+      const { required, optional } = readParams(doc, item.parameters, op.parameters);
+      const responses = isRecord(op.responses) ? Object.keys(op.responses).sort() : [];
+      const id = `${method.toUpperCase()} ${path}`;
+      operations.set(id, {
+        id,
+        method: method.toUpperCase(),
+        path,
+        requiredParams: required,
+        optionalParams: optional,
+        requiredBodyFields: readBodyFields(doc, op.requestBody),
+        responseCodes: responses,
+        deprecated: op.deprecated === true
+      });
+    }
+  }
+  return {
+    title: typeof info.title === "string" ? info.title : null,
+    version: typeof info.version === "string" ? info.version : null,
+    operations,
+    ...operations.size === 0 ? { unreadableReason: `${label} declares no operations` } : {}
+  };
+}
+
+// src/api/check.ts
+var execFileP = promisify(execFile);
+var CANDIDATES = [
+  "openapi.yaml",
+  "openapi.yml",
+  "openapi.json",
+  "swagger.yaml",
+  "swagger.yml",
+  "swagger.json",
+  "api/openapi.yaml",
+  "api/openapi.yml",
+  "api/openapi.json",
+  "docs/openapi.yaml",
+  "docs/openapi.yml"
+];
+function findSpec(dir) {
+  for (const candidate of CANDIDATES) {
+    const full = resolve(dir, candidate);
+    if (existsSync(full)) return full;
+  }
+  return null;
+}
+async function showAtRevision(dir, rev, repoPath) {
+  try {
+    const { stdout } = await execFileP("git", ["show", `${rev}:${repoPath}`], {
+      cwd: dir,
+      maxBuffer: 32 * 1024 * 1024
+    });
+    return stdout;
+  } catch {
+    return null;
+  }
+}
+async function runApiCheck(dir, opts = {}) {
+  const against = opts.against ?? "HEAD";
+  const specPath = opts.spec ? resolve(dir, opts.spec) : findSpec(dir);
+  const spec = specPath ? relative(dir, specPath) || specPath : "(none found)";
+  const base = { spec, against, title: null, fromVersion: null, toVersion: null };
+  if (!specPath) {
+    return {
+      ...base,
+      verdict: "inconclusive",
+      versionCovers: null,
+      diff: {
+        breaking: [],
+        other: [],
+        inconclusive: `no OpenAPI document found in ${dir}. Name one: lurq check-api <file>`
+      }
+    };
+  }
+  const current = extractApiSurface(readFileSync(specPath, "utf8"), spec);
+  const previousSource = await showAtRevision(dir, against, spec);
+  if (previousSource === null) {
+    return {
+      ...base,
+      title: current.title,
+      toVersion: current.version,
+      verdict: "inconclusive",
+      versionCovers: null,
+      diff: {
+        breaking: [],
+        other: [],
+        inconclusive: `${spec} does not exist at ${against}, so there is nothing to compare against`
+      }
+    };
+  }
+  const previous = extractApiSurface(previousSource, `${spec} at ${against}`);
+  return { ...base, ...checkApi(previous, current) };
+}
+export {
+  findSpec,
+  runApiCheck
+};

package/dist/checkUpgrade-5YW77OBL.js

@@ -0,0 +1,24 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  SCAN_LIMIT,
+  fixableTargets,
+  modeDisagreement,
+  parseUpgradeSpec,
+  planMode,
+  planUpgrades,
+  runCheckUpgrade,
+  targetsFromPlanFile,
+  targetsFromUpgrades
+} from "./chunk-QCRBX3LV.js";
+import "./chunk-I3M2KJXB.js";
+export {
+  SCAN_LIMIT,
+  fixableTargets,
+  modeDisagreement,
+  parseUpgradeSpec,
+  planMode,
+  planUpgrades,
+  runCheckUpgrade,
+  targetsFromPlanFile,
+  targetsFromUpgrades
+};

package/dist/chunk-2GAYNIHG.js

@@ -0,0 +1,40 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-I3M2KJXB.js";
+
+// src/github/types.ts
+init_esm_shims();
+var DEFAULT_REPO_POLICY = {
+  enabled: false,
+  scope: "blocking",
+  autoMerge: false,
+  // Stated rather than relied upon. `permits()` already reads an absent
+  // `checks` as on, so a repo connected before this shipped behaves the same as
+  // a new one — which is the point of the inversion. Writing it here keeps the
+  // default visible in the policy the dashboard round-trips.
+  checks: { env: true }
+};
+var RUN_TRIGGERS = ["schedule", "dispatch", "push", "pull_request", "other"];
+var UPGRADE_SEVERITIES = ["blocking", "warning", "ok", "unverified"];
+var UPGRADE_RUN_STATUSES = [
+  "checked",
+  "skipped",
+  "edited",
+  "pr_open",
+  "merged",
+  "failed"
+];
+var REPO_MANIFEST_CAP = 25;
+var REPO_DRIFT_DETAIL_CAP = 200;
+var TRANSITIVE_DETAIL_CAP = 100;
+
+export {
+  DEFAULT_REPO_POLICY,
+  RUN_TRIGGERS,
+  UPGRADE_SEVERITIES,
+  UPGRADE_RUN_STATUSES,
+  REPO_MANIFEST_CAP,
+  REPO_DRIFT_DETAIL_CAP,
+  TRANSITIVE_DETAIL_CAP
+};

package/dist/chunk-2O6Z37IT.js

@@ -0,0 +1,423 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  bold,
+  dim,
+  green,
+  yellow
+} from "./chunk-4KCPOMG6.js";
+import {
+  agentSpecs,
+  installAgent,
+  installInstructionsFile,
+  lurqInvocation,
+  printInstallReport,
+  resolveAgents
+} from "./chunk-DM37MTOO.js";
+import {
+  MissingKeyError
+} from "./chunk-OTJFHESY.js";
+import {
+  readUserConfig,
+  resolveApiKey,
+  resolveEndpoint,
+  writeUserConfig
+} from "./chunk-J6XQ7OPZ.js";
+import {
+  openInBrowser
+} from "./chunk-TNTXWSYA.js";
+import {
+  DEFAULT_ENDPOINT,
+  KEYS_URL,
+  PACKAGE_NAME
+} from "./chunk-72Y2FDVS.js";
+import {
+  init_esm_shims
+} from "./chunk-I3M2KJXB.js";
+
+// src/cli/install.ts
+init_esm_shims();
+import { spawnSync } from "child_process";
+
+// src/cli/agentLink.ts
+init_esm_shims();
+import { spawn } from "child_process";
+var LINK_PREFIX = "LURQ_SIGNIN ";
+var LINK_WAIT_MS = 15 * 6e4;
+var START_TIMEOUT_MS = 15e3;
+function setupMode(o) {
+  if (o.yes) return o.hasKey ? "non-interactive" : "needs-key";
+  if (o.tty) return "interactive";
+  if (o.hasKey) return "non-interactive";
+  return o.ci || o.selfHosted ? "needs-key" : "agent-link";
+}
+function startAgentLink(opts, spawnImpl = spawn) {
+  const args = [...process.execArgv, process.argv[1] ?? "", "setup", "--wait-for-signin"];
+  if (opts.agent) args.push("--agent", opts.agent);
+  if (opts.noOpen) args.push("--no-open");
+  const child = spawnImpl(process.execPath, args, {
+    detached: true,
+    stdio: ["ignore", "pipe", "ignore"],
+    // The link has to be the first thing it prints; an update notice first would only be noise.
+    env: { ...process.env, NO_UPDATE_NOTIFIER: "1" }
+  });
+  return new Promise((resolve) => {
+    let buffered = "";
+    const done = (link) => {
+      clearTimeout(timer);
+      child.stdout?.removeAllListeners("data");
+      child.stdout?.destroy();
+      child.unref();
+      resolve(link);
+    };
+    const timer = setTimeout(() => done(null), START_TIMEOUT_MS);
+    child.stdout?.on("data", (chunk) => {
+      buffered += chunk.toString();
+      const line = buffered.split("\n").find((l) => l.startsWith(LINK_PREFIX));
+      if (line) done(line.slice(LINK_PREFIX.length).trim());
+    });
+    child.once("error", () => done(null));
+    child.once("exit", () => done(null));
+  });
+}
+
+// src/cli/install.ts
+async function withSetupOnMissingKey(run, ask = askToConnect, setup = () => runSetup({})) {
+  try {
+    await run();
+  } catch (err) {
+    if (!(err instanceof MissingKeyError) || !await ask()) throw err;
+    await setup();
+    await run();
+  }
+}
+async function askToConnect() {
+  const interactive = process.stdin.isTTY && process.stdout.isTTY && !process.env.CI && !process.argv.includes("--json");
+  if (!interactive) return false;
+  const { confirm } = await import("./dist-4XXIXHHZ.js");
+  return confirm({
+    message: "This machine has no lurq API key yet. Connect it now?",
+    default: true
+  });
+}
+async function validateKey(url, apiKey) {
+  try {
+    const res = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json, text/event-stream",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/list" }),
+      // A black-holed endpoint must not hang setup; it reads as unreachable.
+      signal: AbortSignal.timeout(15e3)
+    });
+    if (res.ok) return "valid";
+    if (res.status === 401 || res.status === 403) return "invalid";
+    return "unreachable";
+  } catch {
+    return "unreachable";
+  }
+}
+function runningFromNpx(moduleUrl = import.meta.url) {
+  return moduleUrl.includes("/_npx/");
+}
+function installGlobally() {
+  process.stdout.write(`  Installing ${PACKAGE_NAME} globally (npm install -g, a few seconds)\u2026 `);
+  const res = spawnSync("npm", ["install", "--global", `${PACKAGE_NAME}@latest`], {
+    stdio: ["ignore", "ignore", "pipe"],
+    encoding: "utf8",
+    // npm is a .cmd shim on Windows, which is not directly executable.
+    shell: process.platform === "win32"
+  });
+  if (res.status === 0) {
+    console.log(green("ok"));
+    console.log(dim("  `lurq` now works in any terminal, no npx needed."));
+    return;
+  }
+  console.log(yellow("skipped"));
+  const reason = (res.stderr || res.error?.message || "").trim().split("\n").pop();
+  if (reason) console.log(dim(`  ${reason}`));
+  console.log(
+    dim(`  Setup continues. Run \`npm install -g ${PACKAGE_NAME}\` later if you want it.`)
+  );
+}
+async function runSetup(opts) {
+  if (opts.waitForSignin) return waitForSigninAndFinish(opts);
+  const url = resolveEndpoint(opts.url) ?? DEFAULT_ENDPOINT;
+  let apiKey = resolveApiKey(opts.apiKey);
+  const selfHosted = url !== DEFAULT_ENDPOINT;
+  const mode = setupMode({
+    yes: Boolean(opts.yes),
+    tty: Boolean(process.stdin.isTTY && process.stdout.isTTY),
+    ci: Boolean(process.env.CI),
+    hasKey: Boolean(apiKey),
+    selfHosted
+  });
+  if (mode === "agent-link") return runAgentLink(opts);
+  if (mode === "needs-key" && !opts.yes) {
+    throw new Error(
+      `lurq setup asks questions, and this is not an interactive terminal (CI, a pipe, or an agent shell).
+Run it non-interactively:  npx ${PACKAGE_NAME} setup --yes --api-key <key>
+Get a key at ${KEYS_URL}`
+    );
+  }
+  const interactive = mode === "interactive";
+  if (interactive) {
+    const { input, checkbox, confirm, select } = await import("./dist-4XXIXHHZ.js");
+    console.log(`
+  ${bold("lurq setup")}: connect this machine to the package index.
+`);
+    console.log(`  Endpoint: ${url}${selfHosted ? dim("  (your own server)") : ""}
+`);
+    if (runningFromNpx()) {
+      const goGlobal = await confirm({
+        message: `Install ${PACKAGE_NAME} globally, so \`lurq\` works without npx?`,
+        default: true
+      });
+      if (goGlobal) installGlobally();
+      console.log("");
+    }
+    if (apiKey && !opts.apiKey) {
+      const stored = readUserConfig().apiKey === apiKey;
+      const reuse = await confirm({
+        message: `Use the API key already configured${stored ? " on this machine" : " in your environment"}?`,
+        default: true
+      });
+      if (!reuse) apiKey = void 0;
+    }
+    if (!apiKey && !selfHosted) {
+      const { keyViaBrowser } = await import("./browserAuth-J7APSD4P.js");
+      console.log("  Sign in and this machine gets its key. Nothing to copy.\n");
+      process.stdout.write("  Waiting for the browser\u2026 ");
+      const skip = new AbortController();
+      const onEnter = () => skip.abort();
+      process.stdin.once("data", onEnter);
+      const handoff = await keyViaBrowser({
+        noOpen: opts.noOpen,
+        signal: skip.signal,
+        via: "terminal",
+        // Printed rather than only opened: the browser may not have launched,
+        // and a spinner pointing at a URL nobody can see is a hung flow.
+        onUrl: (link) => console.log(`
+
+  ${dim(link)}
+  ${dim("Press Enter to paste a key instead.")}
+`)
+      });
+      process.stdin.off("data", onEnter);
+      process.stdin.pause();
+      if (handoff) {
+        apiKey = handoff.key;
+        console.log(green(`  \u2713 key received${handoff.label ? dim(` (${handoff.label})`) : ""}
+`));
+      } else {
+        console.log(yellow(skip.signal.aborted ? "  skipped" : "  no response"));
+        console.log(dim("  Falling back to pasting it in.\n"));
+      }
+    }
+    if (!apiKey) {
+      if (selfHosted) {
+        console.log(`  Issue a key on the machine running ${url}:
+`);
+        console.log(`    ${bold("lurq keys create --label my-laptop")}
+`);
+        console.log("  Then paste it below.\n");
+      } else {
+        if (!opts.noOpen) {
+          console.log(`  Opening ${KEYS_URL}
+`);
+          openInBrowser(KEYS_URL);
+        } else {
+          console.log(`  Open ${KEYS_URL}
+`);
+        }
+        console.log("  1. Sign in, or create an account. It takes a moment.");
+        console.log("  2. Create an API key and copy it.");
+        console.log("  3. Paste it below.\n");
+      }
+      apiKey = (await input({
+        message: "Paste your lurq API key",
+        validate: (v) => v.trim().startsWith("lurq_") ? true : "Keys look like lurq_live_\u2026 "
+      })).trim();
+    }
+    process.stdout.write("  Validating key\u2026 ");
+    const check2 = await validateKey(url, apiKey);
+    console.log(
+      check2 === "valid" ? green("ok") : check2 === "invalid" ? yellow("rejected") : yellow("could not reach endpoint")
+    );
+    if (check2 !== "valid") {
+      const proceed = await confirm({
+        message: check2 === "invalid" ? `That key was rejected (401) by ${url}. Continue anyway?` : `Couldn't reach ${url} to validate the key. Continue anyway?`,
+        default: false
+      });
+      if (!proceed) {
+        console.log("Aborted. No config was changed.");
+        return;
+      }
+    }
+    if (opts.agent) {
+      await finish(resolveAgents(opts.agent), { url, apiKey });
+      return;
+    }
+    const specs = agentSpecs();
+    const detected = specs.filter((s) => s.detected);
+    const primary = detected.find((s) => s.id === "claude-code") ?? detected[0];
+    if (primary) {
+      const others = detected.length - 1;
+      const choice = await select({
+        message: others > 0 ? `Looks like you have ${detected.map((s) => s.label).join(", ")}. Connect lurq to them?` : `Looks like you have ${primary.label}. Connect lurq to it?`,
+        default: "yes",
+        choices: [
+          {
+            name: others > 0 ? `Yes, set up all ${detected.length} detected agents` : `Yes, set up ${primary.label} for me`,
+            value: "yes"
+          },
+          { name: "No, let me choose which agent(s)", value: "other" },
+          { name: "Cancel, change nothing", value: "cancel" }
+        ]
+      });
+      if (choice === "cancel") {
+        console.log("No problem. Nothing was changed; run `lurq setup` again anytime.");
+        return;
+      }
+      if (choice === "yes") {
+        await finish(detected, { url, apiKey });
+        return;
+      }
+    }
+    const ids = await checkbox({
+      message: "Which assistant(s) should I configure?",
+      choices: specs.map((s) => ({
+        name: `${s.label}${s.detected ? " (detected)" : ""}`,
+        value: s.id,
+        checked: s.detected
+      }))
+    });
+    await finish(
+      specs.filter((s) => ids.includes(s.id)),
+      { url, apiKey }
+    );
+    return;
+  }
+  if (!apiKey) {
+    throw new Error(
+      `No API key. Pass --api-key <key> or set LURQ_API_KEY (or drop --yes to be prompted). Get a key at ${KEYS_URL}`
+    );
+  }
+  const check = await validateKey(url, apiKey);
+  if (check === "invalid") {
+    throw new Error(
+      `${url} rejected that API key (401). Nothing was written. ` + (selfHosted ? `Issue one on the server with \`lurq keys create\`.` : `Check it, or create a new one at ${KEYS_URL}`)
+    );
+  }
+  if (check === "unreachable") {
+    throw new Error(
+      `Could not reach ${url} to validate the API key. Nothing was written. Check the URL and your connection, then re-run.`
+    );
+  }
+  const selected = opts.agent ? resolveAgents(opts.agent) : agentSpecs().filter((s) => s.detected);
+  await finish(selected, { url, apiKey });
+}
+async function runAgentLink(opts) {
+  const link = await startAgentLink({ agent: opts.agent, noOpen: opts.noOpen });
+  if (!link) {
+    throw new Error(
+      `Could not start the sign-in listener on this machine.
+Run it non-interactively instead:  npx ${PACKAGE_NAME} setup --yes --api-key <key>
+Get a key at ${KEYS_URL}`
+    );
+  }
+  const selected = opts.agent ? resolveAgents(opts.agent) : agentSpecs().filter((s) => s.detected);
+  console.log(
+    "lurq needs a one-time sign-in to connect this machine. Open this link on this computer:\n"
+  );
+  console.log(`  ${link}
+`);
+  console.log(
+    `Signing in finishes setup by itself: the key is stored${selected.length ? ` and lurq is connected to ${selected.map((s) => s.label).join(", ")}` : " for the lurq CLI (no coding agents detected)"}. The link works for ${LINK_WAIT_MS / 6e4} minutes.`
+  );
+  console.log("Afterwards, restart your coding agent so it loads lurq.");
+}
+async function waitForSigninAndFinish(opts) {
+  process.stdout.on("error", () => {
+  });
+  const { keyViaBrowser } = await import("./browserAuth-J7APSD4P.js");
+  const handoff = await keyViaBrowser({
+    noOpen: opts.noOpen,
+    deadlineMs: LINK_WAIT_MS,
+    via: "agent",
+    onUrl: (link) => {
+      process.stdout.write(`${LINK_PREFIX}${link}
+`);
+      console.log = () => {
+      };
+    }
+  });
+  if (!handoff) return;
+  if (await validateKey(DEFAULT_ENDPOINT, handoff.key) !== "valid") return;
+  const selected = opts.agent ? resolveAgents(opts.agent) : agentSpecs().filter((s) => s.detected);
+  await finish(selected, { url: DEFAULT_ENDPOINT, apiKey: handoff.key });
+}
+async function finish(selected, remote) {
+  const configPath = writeUserConfig({
+    apiKey: remote.apiKey,
+    // Only persist a non-default endpoint. Storing the default would pin this
+    // machine to today's URL and quietly ignore a later change to the built-in.
+    endpoint: remote.url === DEFAULT_ENDPOINT ? void 0 : remote.url
+  });
+  console.log(`
+${green("\u2713")} API key saved to ${configPath} ${dim("(mode 0600)")}`);
+  console.log(
+    `${green("\u2713")} Pointed at ${remote.url}${remote.url === DEFAULT_ENDPOINT ? "" : dim("  (your own server)")}`
+  );
+  const { command } = lurqInvocation();
+  console.log(
+    dim(
+      `  \`${command} verify <package>\`, \`evaluate\`, \`compare\`, \`usage\` now work anywhere.`
+    )
+  );
+  if (selected.length === 0) {
+    console.log(
+      "\nNo agents selected or detected. Re-run `lurq setup --agent <id>` once your assistant is installed."
+    );
+  } else {
+    const mode = { kind: "remote", ...remote };
+    const results = selected.map((s) => installAgent(s, mode));
+    const instructionsPath = installInstructionsFile();
+    console.log("");
+    printInstallReport(results, instructionsPath, mode);
+  }
+  await printFirstScan(remote);
+}
+var FIRST_SCAN_TIMEOUT_MS = 15e3;
+async function printFirstScan(remote) {
+  try {
+    const { buildUpgradePlan, planHeadline, scanSourceDrift } = await import("./upgradePlan-ZS5IOVMZ.js");
+    const [plan, source] = await Promise.all([
+      buildUpgradePlan(process.cwd(), {
+        url: remote.url,
+        apiKey: remote.apiKey,
+        timeoutMs: FIRST_SCAN_TIMEOUT_MS
+      }),
+      scanSourceDrift(process.cwd())
+    ]);
+    const headline = planHeadline(plan, source);
+    if (!headline) return;
+    const { command } = lurqInvocation();
+    console.log(`
+${yellow("!")} ${bold("In this project right now:")} ${headline}`);
+    console.log(
+      dim(
+        `  \`${command} upgrade-plan\` for the list, \`${command} fix\` to write the changes that need no judgement.`
+      )
+    );
+  } catch {
+  }
+}
+
+export {
+  withSetupOnMissingKey,
+  runningFromNpx,
+  runSetup
+};