slidemind 0.3.13 → 0.3.14

package/src/cli/install.mjs

@@ -0,0 +1,257 @@
+import { spawn } from "node:child_process";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { isClaudePluginInstall } from "../install-channel.mjs";
+import { npmBin } from "../update-check.mjs";
+import { readPackageJson, fail, PACKAGE_ROOT, SRC_DIR, INSTALLERS_DIR } from "./common.mjs";
+
+export const HARNESS_TARGETS = ["claude", "codex", "opencode"];
+
+export function parseTargetFlag(rest, { allowAuto = false } = {}) {
+  const idx = rest.findIndex((a) => a === "--for" || a === "-f");
+  if (idx < 0 || !rest[idx + 1]) {
+    fail(
+      `missing --for <claude|codex|opencode|all${allowAuto ? "|auto" : ""}>`,
+    );
+  }
+  const target = rest[idx + 1];
+  const allowed = allowAuto
+    ? [...HARNESS_TARGETS, "all", "auto"]
+    : [...HARNESS_TARGETS, "all"];
+  if (!allowed.includes(target)) {
+    fail(`unknown install target: ${target}`);
+  }
+  return target;
+}
+
+// Which coding agents are actually on this machine, and which of them already
+// get their skills from a plugin. This is what lets `slidemind setup` finish the
+// job on its own: it deploys where a harness exists and stays out of the way
+// where a plugin already supplies the skills, so a separate `init` is no longer
+// part of onboarding.
+export async function detectHarnesses() {
+  const found = [];
+  for (const target of HARNESS_TARGETS) {
+    const mod = await import(
+      pathToFileURL(path.join(INSTALLERS_DIR, `${target}.mjs`)).href
+    );
+    const info =
+      typeof mod.detect === "function"
+        ? mod.detect()
+        : { present: false, pluginInstalled: false, root: null };
+    found.push({ target, ...info });
+  }
+  return found;
+}
+
+/** Expand a `--for` value into the concrete harness list to act on. */
+
+export async function resolveInstallTargets(target) {
+  if (target === "all") return [...HARNESS_TARGETS];
+  if (target !== "auto") return [target];
+  return (await detectHarnesses())
+    .filter((h) => h.present && !h.pluginInstalled)
+    .map((h) => h.target);
+}
+
+export async function runInstaller(target, action, rest) {
+  const targets = await resolveInstallTargets(target);
+  for (const t of targets) {
+    const mod = await import(
+      pathToFileURL(path.join(INSTALLERS_DIR, `${t}.mjs`)).href
+    );
+    const fn = mod[action];
+    if (typeof fn !== "function") {
+      fail(`installer for '${t}' does not implement '${action}'`);
+    }
+    await fn({
+      packageRoot: PACKAGE_ROOT,
+      flags: rest,
+    });
+  }
+  return targets;
+}
+
+export async function loadInstallerUi() {
+  const mod = await import(
+    pathToFileURL(path.join(INSTALLERS_DIR, "lib.mjs")).href
+  );
+  return mod.ui;
+}
+
+export async function cmdInstall(rest) {
+  const target = parseTargetFlag(rest, { allowAuto: true });
+  const ui = await loadInstallerUi();
+  ui.banner(readPackageJson().version, "init");
+  const deployed = await runInstaller(target, "install", rest);
+  if (deployed.length === 0) {
+    ui.step({
+      status: "warn",
+      label: "harnesses",
+      value: "none detected",
+      note: "install a coding agent, then rerun with --for <claude|codex|opencode>",
+    });
+  }
+
+  // Force every design bundle to re-download from the add-in on the next
+  // build/push/download by wiping the materialized cache. init is the
+  // deliberate refresh point (and `slidemind update` redeploys through it), so
+  // a stale binary or an orphaned per-presentation dir never outlives a re-init.
+  const bundle = await import(
+    pathToFileURL(path.join(SRC_DIR, "bridge", "bundle.mjs")).href
+  );
+  const cleared = bundle.clearBundleCache();
+  await ui.section("cache", "design bundles");
+  ui.step({
+    label: "clear",
+    value: cleared ? `${cleared} bundle${cleared === 1 ? "" : "s"}` : "empty",
+    note: "re-downloads on next build",
+  });
+
+  ui.done(
+    deployed.length === 0
+      ? "no coding agent found — the CLI is installed, skills are not"
+      : deployed.length === HARNESS_TARGETS.length
+        ? "ready — ask your agent to plan, create, or edit a deck"
+        : `ready — ${deployed.join(", ")} can now plan, create, or edit decks`,
+  );
+}
+
+export async function cmdUninstall(rest) {
+  const target = parseTargetFlag(rest);
+  const ui = await loadInstallerUi();
+  ui.banner(readPackageJson().version, "uninstall");
+  await runInstaller(target, "uninstall", rest);
+
+  // Drop the materialized bundle cache too — uninstall is a teardown, so leaving
+  // a per-presentation dir (with brand assets) behind would be stale residue.
+  const bundle = await import(
+    pathToFileURL(path.join(SRC_DIR, "bridge", "bundle.mjs")).href
+  );
+  const cleared = bundle.clearBundleCache();
+  await ui.section("cache", "design bundles");
+  ui.step({
+    status: "remove",
+    label: "clear",
+    value: cleared ? `${cleared} bundle${cleared === 1 ? "" : "s"}` : "empty",
+  });
+
+  ui.done(target === "all" ? "removed from all harnesses" : `removed from ${target}`);
+}
+
+// On Windows we must spawn through the shell (Node refuses to exec .cmd
+// shims directly since CVE-2024-27980), and `shell: true` joins file + args
+// into one cmd.exe command string WITHOUT quoting — so an unquoted
+// `C:\Program Files\nodejs\npm.cmd` splits at the space and cmd tries to run
+// `C:\Program`. Quote anything containing whitespace before handing it over.
+export function cmdQuote(s) {
+  return /\s/.test(s) ? `"${s}"` : s;
+}
+
+export function spawnInherit(file, args) {
+  const useShell = process.platform === "win32";
+  return new Promise((resolve, reject) => {
+    const child = spawn(
+      useShell ? cmdQuote(file) : file,
+      useShell ? args.map(cmdQuote) : args,
+      {
+        stdio: "inherit",
+        env: process.env,
+        shell: useShell,
+      },
+    );
+    child.on("error", reject);
+    child.on("exit", (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`${file} ${args.join(" ")} exited with code ${code}`));
+    });
+  });
+}
+
+// Like spawnInherit, but resolves with the child's exit code instead of
+// rejecting — for a step whose failure is a message to the user rather than a
+// failure of the command that ran it (see `setup` → `ready`).
+export function spawnStatus(file, args) {
+  return spawnInherit(file, args).then(
+    () => 0,
+    () => 1,
+  );
+}
+
+//
+// slidemind is published to public npm as `slidemind`. First install is
+// `npm install -g slidemind` (then `slidemind init` to deploy the skill;
+// `install` stays as a back-compat alias); `slidemind update` is a thin
+// wrapper over `npm install -g slidemind@latest`.
+
+export async function cmdUpdate(rest) {
+  let target = "all";
+  let ref = null;
+  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 (!["claude", "codex", "opencode", "all", "none"].includes(target)) {
+        fail(`unknown install target: ${target}`);
+      }
+    } else if (a === "--ref") {
+      ref = rest[++i];
+      if (!ref) fail("--ref expects a version tag (e.g. v0.1.0)");
+    } else {
+      fail(`unknown flag: ${a}`);
+    }
+  }
+
+  const pkg = readPackageJson();
+  const ui = await loadInstallerUi();
+  ui.banner(pkg.version, "update");
+
+  // A plugin-installed CLI cannot update itself this way: npm would drop a
+  // second copy into the global prefix while the plugin session keeps running
+  // its own. Say so instead of letting the user believe they are now current —
+  // the global install is still worth doing (it is what a plain terminal
+  // outside Claude Code picks up), so this warns and continues.
+  if (isClaudePluginInstall()) {
+    ui.step({
+      status: "warn",
+      label: "plugin",
+      value:
+        "this slidemind came from the Claude Code plugin — update it with `/plugin` → slidemind → update; the global install below does NOT replace it inside plugin sessions",
+    });
+  }
+
+  // Upgrade the global install straight from public npm. `@latest` (or a pinned
+  // version) lets npm resolve + verify the tarball — no SAS, no checksum dance.
+  const spec = ref
+    ? `slidemind@${ref.replace(/^v/, "")}`
+    : "slidemind@latest";
+  await ui.section("release", ref ? `pinned ${spec}` : "latest");
+  ui.step({ label: "install", value: spec, note: "global (npm)" });
+  try {
+    await spawnInherit(npmBin(), ["install", "-g", "--loglevel=error", spec]);
+  } catch (err) {
+    console.error(
+      "\nslidemind update 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" +
+        "Then run `slidemind init --for all`.\n",
+    );
+    throw err;
+  }
+
+  if (target !== "none") {
+    await spawnInherit("slidemind", ["init", "--for", target]);
+  }
+
+  ui.done(
+    target === "none"
+      ? "updated — skill files unchanged (run 'slidemind init --for all' when ready)"
+      : `updated and redeployed into ${target === "all" ? "all harnesses" : target}`,
+  );
+}

package/src/cli/read.mjs

@@ -0,0 +1,120 @@
+import fs from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { fail, LOCAL_PPTX_RE, SRC_DIR } from "./common.mjs";
+
+// Print a read result — the `{ ok, mode, slideCount, slides[] }` shape, whether
+// it came from the add-in (open presentation) or a local .pptx. Shared by both
+// `cmdRead` branches so their output is byte-for-byte identical.
+export function printReadResult(res, asJson) {
+  if (asJson) {
+    process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+    return;
+  }
+  const slides = Array.isArray(res.slides) ? res.slides : [];
+  if (slides.length === 0) {
+    process.stderr.write("(presentation has no slides)\n");
+    return;
+  }
+  if (res.mode === "summary") {
+    for (const s of slides) {
+      const label = s.title || "(untitled)";
+      const sub = s.subtitle ? ` — ${s.subtitle}` : "";
+      const layout = s.layout ? `  [${s.layout}]` : "";
+      process.stdout.write(
+        `${String(s.index).padStart(3)}.${layout}  ${label}${sub}\n`,
+      );
+    }
+  } else {
+    slides.forEach((s, i) => {
+      if (i > 0) process.stdout.write("\n");
+      const layout = s.layout ? ` (${s.layout})` : "";
+      process.stdout.write(`── Slide ${s.index}${layout} ──\n`);
+      process.stdout.write(`${s.text && s.text.length ? s.text : "(no text)"}\n`);
+    });
+  }
+}
+
+// Pull the current content of an open presentation. Content is window-bound, so
+// pick exactly one window (positional presId or --to; pickPresentationEntry errors
+// listing the windows if several are open and none was named). `--mode summary`
+// prints a per-slide outline; default `raw` prints each slide's plain text.
+//
+// A positional arg with a local PowerPoint extension (LOCAL_PPTX_RE: .pptx and
+// its .pptm/.potx/.potm/.ppsx/.ppsm siblings) AND resolving to an existing
+// regular file is read host-free from disk instead (no bridge). The gate is
+// strict: a nonexistent path or a real presId falls through to the host path
+// unchanged, and it is skipped when --to is given (--to targets an open window).
+export async function cmdRead(rest) {
+  let presId = null;
+  let mode = "raw";
+  let asJson = false;
+  let toGiven = false;
+  let fileArg = null; // the positional (a candidate local .pptx path)
+  for (let i = 0; i < rest.length; i++) {
+    const a = rest[i];
+    if (a === "--mode") {
+      const next = rest[++i];
+      if (next !== "summary" && next !== "raw") {
+        fail(`--mode expects 'summary' or 'raw', got '${next ?? ""}'`);
+      }
+      mode = next;
+    } else if (a === "--to") {
+      presId = rest[++i];
+      if (!presId) fail("--to expects a presId");
+      toGiven = true;
+    } else if (a === "--json") {
+      asJson = true;
+    } else if (a.startsWith("-")) {
+      fail(`unknown flag: ${a}`);
+    } else if (!presId) {
+      presId = a; // positional presId (or local .pptx path)
+      fileArg = a;
+    } else {
+      fail(`unexpected argument: ${a}`);
+    }
+  }
+
+  // Local-file gate: applies ONLY to the positional, and never when --to is set.
+  // The positional must end in .pptx and resolve to an existing regular file;
+  // anything else (missing path, real presId) falls through to the host path.
+  if (fileArg && !toGiven && LOCAL_PPTX_RE.test(fileArg)) {
+    const p = path.isAbsolute(fileArg)
+      ? fileArg
+      : path.resolve(process.cwd(), fileArg);
+    let st = null;
+    try {
+      st = fs.statSync(p);
+    } catch {
+      st = null;
+    }
+    if (st && st.isFile()) {
+      const { readLocalPptx } = await import(
+        pathToFileURL(path.join(SRC_DIR, "pptx", "read-local.mjs")).href
+      );
+      let res;
+      try {
+        res = readLocalPptx(fs.readFileSync(p), { mode });
+      } catch (err) {
+        fail(`read failed: ${err.message}`);
+      }
+      printReadResult(res, asJson);
+      return;
+    }
+  }
+
+  const client = await import(
+    pathToFileURL(path.join(SRC_DIR, "bridge", "client.mjs")).href
+  );
+  const registry = await client.requirePaneHost();
+  const entry = client.pickPresentationEntry(registry, presId);
+  const res = await client.getPresentationContent({
+    presId: entry.presId,
+    mode,
+    backendURL: entry.backendURL ?? null,
+  });
+  if (!res?.ok) {
+    fail(`read failed: ${res?.error ?? "unknown error"}`);
+  }
+  printReadResult(res, asJson);
+}