slidemind 0.3.13 → 0.3.14

package/src/cli/session.mjs

@@ -0,0 +1,177 @@
+import { envPhrase } from "../bridge/config.mjs";
+import { fail, loadBridgeModule } from "./common.mjs";
+
+// The one line every "you are not connected" path speaks, so the remedy reads
+// the same wherever a user meets it.
+export const NOT_CONNECTED_LINE =
+  "Not connected. In PowerPoint open slidemind → Settings → General → Connect CLI, press the link button, and run the command it shows.";
+
+// Match a `--backend`-style argument against a paired session the way logout and
+// use do: exact URL, stored label, derived env label, or a substring of the URL.
+export function matchesBackend(cfg, session, want) {
+  return (
+    session.backendURL === want ||
+    session.label === want ||
+    cfg.deriveEnvLabel(session.backendURL) === want ||
+    session.backendURL.includes(want)
+  );
+}
+
+// `slidemind login [--backend <url|env>]` — sign this CLI in to Microsoft 365 so
+// the pane-free engine routes can fetch SharePoint-backed content with the
+// user's OWN identity (docs/slidemind-cli-connect/15-graph-delegated-cli.md).
+// Separate from the CLI session on purpose: that one is minted by the add-in for
+// whoever pressed Connect CLI, this one is an Entra token for whoever completes
+// the browser sign-in, and only the second may read a user's SharePoint content.
+// Everything else — render, bundle, whoami — is unaffected either way.
+export async function cmdLogin(rest) {
+  const stray = rest.find((a) => a.startsWith("-"));
+  if (stray) {
+    fail(`unexpected argument: ${stray}\nusage: slidemind login [--backend <url|env>]`);
+  }
+  const cfg = await loadBridgeModule("config");
+  const sessions = cfg.readSessions();
+  if (sessions.length === 0) fail(NOT_CONNECTED_LINE);
+  // A browser flow targets ONE environment — there is nothing to fan out. The
+  // scope flag picks it; otherwise the default environment does, and the closing
+  // line names the others so nothing looks silently skipped.
+  const want = (process.env.SLIDEMIND_BACKEND || "").trim();
+  let target;
+  if (want) {
+    target = sessions.find((s) => matchesBackend(cfg, s, want));
+    if (!target) {
+      fail(`not paired with '${want}'. Run 'slidemind whoami' to list environments.`);
+    }
+  } else {
+    const def = cfg.getDefaultBackend();
+    target = sessions.find((s) => s.backendURL === def) ?? sessions[0];
+  }
+  const graph = await loadBridgeModule("graph-auth");
+  // This command is routinely typed by an AI agent on the human's machine, and
+  // the browser is where the agent's reach ends — say the handoff out loud.
+  process.stderr.write(
+    `Opening your browser to sign in to Microsoft 365${envPhrase(target.label, "for")}…\n` +
+      "A HUMAN must complete this step (agents: ask your user to finish the " +
+      "sign-in in the browser window that just opened).\n",
+  );
+  const res = await graph.loginGraph({
+    backendURL: target.backendURL,
+    // Printed before the opener runs: on a machine where no opener works this
+    // link is the only way through, and it is useless after the wait times out.
+    onUrl: (url) =>
+      process.stderr.write(`If no browser opens, paste this link into one:\n  ${url}\n`),
+  });
+  process.stdout.write(
+    `Signed in to Microsoft 365 as ${res.username ?? "your account"}${envPhrase(target.label, "for")}.\n` +
+      "SharePoint-backed slides and images now download with no PowerPoint window open.\n",
+  );
+  const others = sessions.filter((s) => s.backendURL !== target.backendURL);
+  if (others.length > 0) {
+    process.stdout.write(
+      `Still signed out: ${others.map((s) => s.label).join(", ")} ` +
+        "(each needs its own 'slidemind login --backend <env>').\n",
+    );
+  }
+}
+
+export async function cmdWhoami() {
+  const cfg = await loadBridgeModule("config");
+  const sessions = cfg.readSessions();
+  if (sessions.length === 0) {
+    process.stderr.write(`${NOT_CONNECTED_LINE}\n`);
+    return;
+  }
+  const { httpJson } = await loadBridgeModule("http-json");
+  const graph = await loadBridgeModule("graph-auth");
+  const def = cfg.getDefaultBackend();
+  const lines = await Promise.all(
+    sessions.map(async (s) => {
+      const marker = s.backendURL === def ? "*" : " ";
+      let detail;
+      try {
+        const res = await httpJson(
+          "GET",
+          `${s.backendURL}/api/cli/whoami`,
+          { token: s.sessionToken },
+        );
+        detail =
+          res.status === 200 && res.json
+            ? `user ${res.json.oid} · tenant ${res.json.tid ?? "(n/a)"}`
+            : `session invalid (${res.status}) — authorize again`;
+      } catch {
+        detail = "unreachable — check your connection or authorize again";
+      }
+      // Storage-only — no probe. The Graph sign-in is a SECOND identity, so it
+      // is reported next to the session rather than folded into it.
+      const graphLine = graph.hasGraphSession(s.backendURL)
+        ? "Microsoft 365: signed in"
+        : "Microsoft 365: not signed in — needed only for window-free SharePoint downloads (`slidemind login`)";
+      return `${marker} ${s.label}\n    ${detail}\n    ${graphLine}`;
+    }),
+  );
+  process.stdout.write(
+    `Connected environments (${sessions.length}):\n${lines.join("\n")}\n`,
+  );
+}
+
+export async function cmdLogout(rest) {
+  const cfg = await loadBridgeModule("config");
+  const all = rest.includes("--all");
+  const target = rest.find((a) => !a.startsWith("--")) ?? null;
+
+  // Which sessions to revoke + remove: all, one (by url/env/label), or the
+  // default (the bare `slidemind logout`).
+  const sessions = cfg.readSessions();
+  if (sessions.length === 0) {
+    process.stdout.write("Already logged out.\n");
+    return;
+  }
+  let toRemove;
+  if (all) {
+    toRemove = sessions;
+  } else if (target) {
+    toRemove = sessions.filter(
+      (s) =>
+        s.backendURL === target ||
+        s.label === target ||
+        cfg.deriveEnvLabel(s.backendURL) === target ||
+        s.backendURL.includes(target),
+    );
+    if (toRemove.length === 0) {
+      fail(`not paired with '${target}'. Run 'slidemind whoami' to list environments.`);
+    }
+  } else {
+    const def = cfg.getDefaultBackend();
+    toRemove = sessions.filter((s) => s.backendURL === def);
+  }
+
+  const { httpJson } = await loadBridgeModule("http-json");
+  // Unpairing takes the WHOLE record, the Microsoft 365 refresh token included —
+  // it was stored for this environment's session and must not outlive it. Said
+  // out loud because signing back in is a second command, not part of `setup`.
+  const droppedGraph = toRemove.filter((s) => s.msGraphRefreshToken);
+  for (const s of toRemove) {
+    try {
+      await httpJson("POST", `${s.backendURL}/api/cli/logout`, {
+        token: s.sessionToken,
+      });
+    } catch {
+      /* best-effort server-side revoke; we still drop the local session */
+    }
+    // Through the token setter, not just the record removal: the refresh token
+    // may live in the macOS keychain (config.mjs), which removing the session
+    // record alone would orphan.
+    cfg.setGraphRefreshToken(s.backendURL, null);
+    cfg.removeSession(s.backendURL);
+  }
+  const remaining = cfg.readSessions().length;
+  process.stdout.write(
+    `Logged out of ${toRemove.map((s) => s.label).join(", ")}.` +
+      (remaining > 0 ? ` ${remaining} environment(s) still connected.\n` : "\n") +
+      (droppedGraph.length > 0
+        ? `The Microsoft 365 sign-in for ${droppedGraph
+            .map((s) => s.label)
+            .join(", ")} was dropped too — run 'slidemind login' after reconnecting.\n`
+        : ""),
+  );
+}

package/src/cli/setup.mjs

@@ -0,0 +1,282 @@
+import { isClaudePluginInstall } from "../install-channel.mjs";
+import { npmBin } from "../update-check.mjs";
+import { readPackageJson, fail, loadBridgeModule, BIN_PATH } from "./common.mjs";
+import { HARNESS_TARGETS, detectHarnesses, runInstaller, loadInstallerUi, spawnInherit, spawnStatus } from "./install.mjs";
+
+//
+// `npx --yes slidemind@latest setup <claim>` is the whole onboarding: the user
+// clicks "Connect CLI" in the add-in, pastes ONE command, and ends up with a
+// connected, globally-installed CLI. npx only runs the package from its cache —
+// it never installs it — so this command performs the persistent
+// `npm install -g` itself.
+//
+// Order matters: redeem FIRST. The claim is short-lived and one-time, while a
+// global npm install can take a while or hit an EACCES prefix problem. Spending
+// the claim up front means a failed install leaves a connected CLI the user can
+// fix at their leisure, instead of forcing them back to PowerPoint for a fresh
+// command.
+export async function cmdSetup(rest) {
+  let claimArg = null;
+  // `auto` is the whole point: setup finishes onboarding by itself, so it
+  // deploys into the coding agents this machine actually has instead of asking
+  // the user to run `init` afterwards.
+  let target = "auto";
+  let doInstall = true;
+  let doReady = true;
+  let doLogin = true;
+  let asJson = false;
+  for (let i = 0; i < rest.length; i++) {
+    const a = rest[i];
+    if (a === "--for" || a === "-f") {
+      target = rest[++i];
+      if (!target) fail("--for expects a target");
+      if (![...HARNESS_TARGETS, "all", "auto", "none"].includes(target)) {
+        fail(`unknown install target: ${target}`);
+      }
+    } else if (a === "--no-install") {
+      doInstall = false;
+    } else if (a === "--no-ready") {
+      doReady = false;
+    } else if (a === "--no-login") {
+      doLogin = false;
+    } else if (a === "--json") {
+      asJson = true;
+    } else if (a.startsWith("-")) {
+      fail(`unknown flag: ${a}`);
+    } else if (claimArg === null) {
+      claimArg = a;
+    } else {
+      fail("setup takes exactly one setup claim");
+    }
+  }
+
+  if (!claimArg) {
+    fail(
+      "setup needs the connection command from the add-in.\n" +
+        "  Open PowerPoint → slidemind → Settings → General → Connect CLI, copy the command, and paste it here.\n" +
+        "  Already have the CLI? The panel's `CLI already installed?` toggle gives the short `slidemind setup …` form.",
+    );
+  }
+
+  const pkg = readPackageJson();
+  const claims = await loadBridgeModule("setup-claim");
+  // Decode before any UI so a mistyped/partial paste fails in one clean line.
+  const { backendURL, secret } = claims.decodeSetupClaim(claimArg);
+  const cfg = await loadBridgeModule("config");
+  const envLabel = cfg.deriveEnvLabel(backendURL);
+
+  // The installers paint their own progress rail. In --json mode stdout is
+  // reserved for the payload, so silence the whole UI rather than letting it
+  // corrupt what the caller parses.
+  const ui = await loadInstallerUi();
+  if (asJson) ui.silence();
+  ui.banner(pkg.version, "setup");
+
+  // --- 1. spend the claim -------------------------------------------------
+  // Whether to name the environment at all. Decided BEFORE the claim is spent
+  // so every line in this run agrees: a first connection has nothing to
+  // disambiguate against and stays quiet, while adding a second (or third)
+  // environment names each one. Computing it per-line would flip mid-run, since
+  // `upsertSession` below changes the count.
+  const showEnv = cfg.readSessions().length > 0;
+  await ui.section("connect", showEnv ? envLabel : "");
+  const { sessionToken, oid } = await claims.redeemSetupClaim({
+    backendURL,
+    secret,
+    cliVersion: pkg.version,
+  });
+  cfg.upsertSession({ backendURL, sessionToken, label: envLabel, oid });
+  ui.step({
+    label: "authorize",
+    value: showEnv ? envLabel : "connected",
+    note: "session saved",
+  });
+
+  // --- 2. make this CLI permanent ----------------------------------------
+  // Without this the whole thing evaporates with npx's cache: the user would be
+  // connected but have no `slidemind` on PATH.
+  let installed = false;
+  let installError = null;
+  const pluginInstall = isClaudePluginInstall();
+  if (doInstall && pluginInstall) {
+    ui.step({
+      status: "warn",
+      label: "install",
+      value: "skipped",
+      note: "this slidemind came from the Claude Code plugin — update it with /plugin",
+    });
+  } else if (doInstall) {
+    await ui.section("install", "npm global");
+    ui.step({ label: "install", value: "slidemind@latest", note: "global (npm)" });
+    try {
+      await spawnInherit(npmBin(), [
+        "install",
+        "-g",
+        "--loglevel=error",
+        "slidemind@latest",
+      ]);
+      installed = true;
+    } catch (err) {
+      installError = err?.message || String(err);
+      ui.step({
+        status: "warn",
+        label: "install",
+        value: "failed",
+        note: "the connection is saved — see the note below",
+      });
+    }
+  }
+
+  // --- 3. deploy the skills ----------------------------------------------
+  // In-process, from THIS package copy: the npx copy and the global install are
+  // the same published version, and going through PATH here would fail on a
+  // shell that has not rehashed yet.
+  //
+  // With the default `auto` this is what removes `slidemind init` from
+  // onboarding: the skills land in every coding agent present on the machine,
+  // and skip any whose plugin already supplies them (copying over a plugin's
+  // skills plants a second set that drifts on the next plugin update).
+  let skills = [];
+  let skippedPlugins = [];
+  if (target !== "none") {
+    if (target === "auto") {
+      const harnesses = await detectHarnesses();
+      skippedPlugins = harnesses
+        .filter((h) => h.present && h.pluginInstalled)
+        .map((h) => h.target);
+    }
+    await ui.section(
+      "skills",
+      target === "auto"
+        ? "detected harnesses"
+        : target === "all"
+          ? "all harnesses"
+          : target,
+    );
+    skills = await runInstaller(target, "install", []);
+    for (const t of skippedPlugins) {
+      ui.step({
+        status: "warn",
+        label: t,
+        value: "skipped",
+        note: "its slidemind plugin already supplies the skills",
+      });
+    }
+    if (skills.length === 0 && skippedPlugins.length === 0) {
+      ui.step({
+        status: "warn",
+        label: "harnesses",
+        value: "none detected",
+        note: "install a coding agent, then run `slidemind init --for auto`",
+      });
+    }
+    const bundleMod = await loadBridgeModule("bundle");
+    bundleMod.clearBundleCache();
+  }
+
+  // --- 4. Microsoft 365 sign-in (best-effort) -----------------------------
+  // The pasted-claim moment is the one time the user is reliably at the
+  // keyboard in consent headspace, so offer the browser sign-in NOW and no
+  // later command has to interrupt a task for it. Strictly best-effort and
+  // interactive-only: --json or no TTY (an agent ran setup — a browser tab it
+  // cannot see must never block onboarding), --no-login, a backend that does
+  // not honour the token, a decline or a timeout all skip WITHOUT failing
+  // setup — the closing `ready` and the failure-time remediations still name
+  // `slidemind login`.
+  if (doLogin && !asJson && process.stdout.isTTY) {
+    try {
+      const client = await loadBridgeModule("client");
+      if (await client.backendSupportsGraphDelegated(backendURL)) {
+        await ui.section("sign in", "Microsoft 365");
+        process.stderr.write(
+          "Opening your browser to sign in to Microsoft 365 — this lets SharePoint-backed\n" +
+            "content download with no PowerPoint window open.\n",
+        );
+        const graph = await loadBridgeModule("graph-auth");
+        const res = await graph.loginGraph({
+          backendURL,
+          // Shorter than `slidemind login`'s: the user is mid-setup, not
+          // parked on a sign-in they asked for — a walked-away browser tab
+          // should not stall onboarding for five minutes.
+          timeoutMs: 120_000,
+          onUrl: (url) =>
+            process.stderr.write(
+              `If no browser opens, paste this link into one:\n  ${url}\n`,
+            ),
+        });
+        ui.step({
+          label: "Microsoft 365",
+          value: res.username ?? "signed in",
+          ...(showEnv ? { note: envLabel } : {}),
+        });
+      }
+    } catch {
+      ui.step({
+        status: "warn",
+        label: "Microsoft 365",
+        value: "skipped",
+        note: "run 'slidemind login' anytime for window-free SharePoint downloads",
+      });
+    }
+  }
+
+  if (asJson) {
+    const globalInstall =
+      doInstall && !pluginInstall
+        ? installed
+          ? "installed"
+          : "failed"
+        : "skipped";
+    process.stdout.write(
+      `${JSON.stringify(
+        {
+          ok: true,
+          connected: true,
+          env: envLabel,
+          globalInstall,
+          skills,
+          // Present-but-plugin-served harnesses, so an agent can tell "nothing
+          // deployed because nothing is installed" from "nothing needed".
+          skippedPlugins,
+          nextAction: "slidemind ready",
+          // Only on the unhappy path: the session IS saved, so `ok` stays true,
+          // but an agent needs to know the binary did not land.
+          ...(installError ? { installError } : {}),
+        },
+        null,
+        2,
+      )}\n`,
+    );
+    return;
+  }
+
+  ui.done(
+    target === "none" || (skills.length === 0 && skippedPlugins.length === 0)
+      ? `connected${showEnv ? ` to ${envLabel}` : ""} — run 'slidemind ready' to start`
+      : `connected${showEnv ? ` to ${envLabel}` : ""} and ready to use`,
+  );
+
+  if (installError) {
+    process.stderr.write(
+      "\nslidemind is connected, but the global install could not write to npm's global package directory.\n" +
+        "This usually happens on macOS/Linux when Node was installed with a system-owned npm prefix.\n\n" +
+        "Avoid `sudo npm`. Use Homebrew/nvm, or move npm's global prefix into your home directory:\n\n" +
+        "  mkdir -p ~/.npm-global\n" +
+        "  npm config set prefix ~/.npm-global\n" +
+        "  echo 'export PATH=\"$HOME/.npm-global/bin:$PATH\"' >> ~/.zshrc\n" +
+        "  source ~/.zshrc\n" +
+        "  npm install -g slidemind\n\n" +
+        `(details: ${installError})\n`,
+    );
+    return;
+  }
+
+  // --- 5. finish the session the user actually came for -------------------
+  // `ready` exits non-zero for every legitimate not-yet blocker (PowerPoint
+  // closed, no design activated). Setup already succeeded at that point, so its
+  // blocker is information, not a failure — run it for the message and the
+  // warmed bundle, and never inherit its exit code.
+  if (doReady) {
+    await spawnStatus(process.execPath, [BIN_PATH, "ready"]);
+  }
+}