premanmcp 0.15.2 → 0.16.0

package/bin/integrations.js

@@ -374,6 +374,106 @@ export async function slackCommand(args) {
  * that asks defaults to yes today; the desktop app, which used to be the
  * exception, no longer asks at all.
  */
+/**
+ * Ask, once, before PreMan writes into an SDK repository or a docs site.
+ *
+ * Two questions rather than one. Agreeing to a generated client library is not
+ * agreeing to have your documentation site rewritten (a docs release replaces
+ * mkdocs.yml), and a single answer used to buy both.
+ *
+ * Says nothing when there is nothing to ask: no connected repository, no
+ * detected target, or an answer already on file. A walk that re-asks a question
+ * it has already had answered teaches people that answering buys them nothing,
+ * which is the whole reason this moved out of the delivery run.
+ */
+async function offerReleaseTargets(args, checkout, { assumeYes }) {
+  const integrationId = checkout?.match?.integration_id;
+  if (!integrationId) return { state: "skipped" };
+
+  const token = resolveApiKey(args);
+  const path = `/sdk/integrations/${integrationId}/distribution`;
+  let detected = null;
+  try {
+    detected = await callBackendJson(args, "GET", path, { token });
+  } catch {
+    // Detection costs one root listing per repository in the installation. It
+    // is the least important thing in this walk and never worth failing setup
+    // over.
+    return { state: "skipped" };
+  }
+
+  if (detected?.confirmed) {
+    process.stdout.write(`${MARK.ok()} Release targets already answered.\n`);
+    return;
+  }
+
+  const sdkRepo = detected?.sdk_repo || "";
+  const docsRepo = detected?.docs_repo || "";
+  if (!sdkRepo && !docsRepo) return { state: "skipped" };
+
+  const body = {};
+  const decided = [];
+  for (const [repo, field, flag, question] of [
+    [
+      sdkRepo,
+      "sdk_repo",
+      "publish_sdk",
+      `${sdkRepo} looks like your client library. Open pull requests there with generated SDKs?`,
+    ],
+    [
+      docsRepo,
+      "docs_repo",
+      "publish_docs",
+      // The wider blast radius is named in the question, because it is the part
+      // somebody would resent discovering afterwards.
+      `${docsRepo} looks like your docs site. Open pull requests there? Releases rewrite mkdocs.yml.`,
+    ],
+  ]) {
+    if (!repo) continue;
+    const answer = await askRelease(question, assumeYes);
+    if (answer === null) continue;
+    body[field] = repo;
+    body[flag] = answer;
+    decided.push([repo, answer]);
+  }
+  if (!decided.length) return { state: "skipped" };
+
+  await callBackendJson(args, "PUT", path, { token, json: body });
+
+  for (const [repo, allowed] of decided) {
+    // A no is reported as recorded, not as a step that failed. It is an answer,
+    // and PreMan will not come back to it.
+    if (allowed) process.stdout.write(`${MARK.ok()} Publishing to ${repo}.\n`);
+    else
+      process.stdout.write(
+        `${MARK.skip()} Not publishing to ${repo}. PreMan will not ask again.\n`
+      );
+  }
+}
+
+/**
+ * Yes, no, or nobody answered.
+ *
+ * Three outcomes rather than two, and the third is the whole reason this does
+ * not use `confirm`. That helper reads a closed stdin as a no, which is right
+ * for a step that then simply does less work. A no here is *recorded*, and a
+ * recorded no is never asked again, so reading silence as refusal would retire
+ * a question the customer never saw.
+ *
+ * The same argument applies to --yes: accepting defaults on someone's behalf is
+ * fine for a hook or a download, and is not a way to acquire write access to a
+ * repository nobody mentioned. So an unattended run leaves both questions open.
+ *
+ * The default is no, for the reason silence means no everywhere else PreMan
+ * writes to somebody's repository.
+ */
+async function askRelease(question, assumeYes) {
+  if (assumeYes) return null;
+  const answer = (await promptText(`${question} [y/N]: `)).trim().toLowerCase();
+  if (answer === "") return null;
+  return answer === "y" || answer === "yes";
+}
+
 async function askStep(question, { assumeYes, canGoBack, defaultYes = true }) {
   const fallback = defaultYes ? "yes" : "no";
   if (assumeYes) return fallback;
@@ -525,6 +625,15 @@ export async function onboardCommand(
     });
   }
 
+  // The only questions in this walk about repositories *other* than the one
+  // being connected. They are asked here, while PreMan has just read the
+  // installation and can name what it found, rather than weeks later from
+  // inside a delivery run, on a screen most people never opened.
+  steps.push({
+    name: "Releases",
+    run: () => offerReleaseTargets(args, checkout, { assumeYes }),
+  });
+
   steps.push({
     name: "Push checks",
     question: "Check your endpoints on every git push in this repo?",
@@ -615,7 +724,9 @@ export async function onboardCommand(
                 // why they are looking at a login screen.
                 process.stdout.write("Opened PreMan \u2014 sign in with the account you just used.\n");
               }
-              return installed;
+              // Whether the app is on screen decides what the last line of the walk
+              // should say, and only this closure knows.
+              return { ...installed, appOpened: opened.state !== "not-installed" };
             } finally {
               stopOpening?.();
             }
@@ -665,10 +776,18 @@ export async function onboardCommand(
     }
 
     try {
-      // A step that caught its own failure and already explained it says so, and
-      // is not summarised as done; anything else that returns is taken as done.
+      // A step that caught its own failure and already explained it says so; a step
+      // with nothing to do says that; anything else that returns is done.
+      //
+      // Translated rather than spread over, because the summary knows three words
+      // and a step may report any of its own. Spreading put `Desktop app: undefined`
+      // at the end of a successful install: the install reports state "installed",
+      // which is none of the three, so it printed as a failure with no detail.
       const reported = await step.run();
-      outcome.set(step.name, { state: "done", ...(reported || {}) });
+      const state =
+        { failed: "failed", skipped: "skipped", unsupported: "skipped" }[reported?.state] ||
+        "done";
+      outcome.set(step.name, { ...(reported || {}), state });
     } catch (err) {
       // Report and carry on: a failed Slack install must not cost the customer
       // the AWS connection they just finished.
@@ -687,7 +806,16 @@ export async function onboardCommand(
     else if (result.state === "skipped") process.stdout.write(`${MARK.skip()} ${step.name} (skipped)\n`);
     else process.stdout.write(`${MARK.fail()} ${step.name}: ${result.detail}\n`);
   }
-  process.stdout.write(`\nOpen ${frontendUrl(args)} to see your logs and endpoints.\n`);
+  // The app is on screen by the time this prints, so telling them to go and open
+  // a website is a step backwards. The website still earns its mention -- it is
+  // the way in from a machine that has no app, and the account is the same one --
+  // but as an alternative, not as the next thing to do.
+  const appOpened = outcome.get("Desktop app")?.appOpened === true;
+  process.stdout.write(
+    appOpened
+      ? `\nPreMan is open. You can also sign in at ${frontendUrl(args)}.\n`
+      : `\nOpen ${frontendUrl(args)} to see your logs and endpoints.\n`
+  );
 }
 
 export const INTEGRATIONS_HELP = `

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "premanmcp",
-  "version": "0.15.2",
+  "version": "0.16.0",
   "description": "Turn APIs into agent-callable MCP tools with auth, testing, and audit logs",
   "type": "module",
   "bin": {