slidemind

Connect Claude Code, Codex, and opencode to the slidemind PowerPoint add-in — so your coding agent (or you, from the terminal) can build and edit native, on-brand PowerPoint decks against your active corporate design, without leaving the editor.

Preview. slidemind is in early access while the PowerPoint add-in makes its way to the Microsoft Office Store. The CLI is functional and published, but expect rough edges and breaking changes between releases. You need access to the slidemind add-in to use it.

slidemind is a thin client. The corporate design, the layout palette, and the native .pptx render all live in the slidemind PowerPoint add-in — this package is the bridge that lets a coding agent drive it. It ships two things:

1. A CLI that talks to a running PowerPoint over the add-in's cloud bridge — render native .pptx, push slides straight into an open window, and search the active design's brand engine for imagery. The agent drives it by running slidemind <command> in its shell.
2. An installable skill for Claude Code, Codex, and opencode — so the agent in your editor knows how to plan, compose, and review slides on-brand from the design bundle the add-in serves.

Both drive the same add-in bridge, so an agent and a human end up producing the same artefact: native PowerPoint slides on the active corporate design.

Contents

• Requirements
• Install
  • One command (recommended)
  • Manual install
  • Windows
  • macOS
  • Linux
  • Without a global install (npx)
• Connect to PowerPoint
• Quick start
• Using it with a coding agent
• Command reference
• Pushing slides into an open PowerPoint
• Multiple environments (for slidemind developers)
• Updating
• Troubleshooting
• Uninstall
• How it works

Requirements

| | | |---|---| | Node.js | 18 or newer (node --version). Ships with npm. | | slidemind PowerPoint add-in | Installed in PowerPoint, with a presentation open and a corporate design active. The design and the .pptx render live here — the CLI cannot work without it. | | PowerPoint | Microsoft 365, PowerPoint 2021/2019/2016, or PowerPoint on the web — anything that loads Office Add-ins. | | OS | Windows, macOS, or Linux. See per-OS notes below. |

The CLI reaches PowerPoint through the add-in's cloud relay (no localhost, no certificates). Because of that, the machine running the CLI does not have to be the same machine running PowerPoint — connect it once and commands route to wherever your add-in is registered.

Commands that read the design, render, push, or reach an engine (ready, download-bundle, build-pptx, push, ls engines, search, insert-slide, add-slide) require an open PowerPoint host with the add-in and an active corporate design. build, review, and view-draft work fully offline against a previously materialized bundle. Reading a local PowerPoint file (read <file.pptx>) or folding a slide from one into a deck (add-slide --from <file.pptx>) is host-free too — no PowerPoint, connection, or bundle needed. new scaffolds offline too; when you're connected and a design is open it also best-effort binds the new deck (otherwise it just scaffolds and hints to run slidemind ready <slug>).

Install

One command (recommended)

In PowerPoint, open the slidemind add-in → Settings → General → Connect CLI → Set up CLI, and copy the command it shows. Paste it into your terminal:

npx --yes slidemind@latest setup smc1_…

That single command installs slidemind globally, connects it to your account, deploys the skills into every coding agent it finds on this machine, and runs the first readiness check. There is no slidemind init step — setup detects Claude Code, Codex, and opencode itself (by their config directory or their command on your PATH, so a freshly installed agent you have not opened yet still counts), and skips any harness whose slidemind plugin already supplies the skills. The only prerequisite is Node 18+; you never type a backend address.

If it reports no coding agent found — or you install one later — run slidemind init --for auto to deploy the skills then.

The copied command carries a one-time claim that works once and expires after about 10 minutes. Copy a fresh one if it lapses.

Flags, if you need them: --for <claude|codex|opencode|all|auto|none> overrides harness detection (auto is the default; none skips skills entirely), --no-install skips the global npm install, --no-ready skips the closing readiness check.

Manual install

If your organization distributes the Codex plugin through the admin console, the skills are already present and you only install the CLI binary:

npm install -g slidemind

Do not run slidemind init for an admin- or plugin-installed skill; that would create a second copy. The package is published to public npm as slidemind.

For a standalone/manual install, add the skills after installing the CLI:

npm install -g slidemind
slidemind init --for auto     # deploy the skill into every coding agent found here

Then confirm it's on your PATH:

slidemind --version

slidemind init --for <claude|codex|opencode|all|auto> scopes the harness deployment; auto picks every coding agent found on this machine. You only need init if you installed the CLI by hand or added a new coding agent later — the one-command setup above already does it.

Heads-up — first install downloads a headless Chrome. slidemind renders decks by capturing slides with a local headless browser (then assembling the .pptx server-side), so npm install -g slidemind pulls a pinned Chromium (~150–300 MB) via puppeteer's postinstall. Behind a corporate proxy/firewall this download can fail; set HTTPS_PROXY (and, if needed, PUPPETEER_DOWNLOAD_BASE_URL) so npm can reach it, or point PUPPETEER_EXECUTABLE_PATH at an existing Chrome/Edge. The browser lives in puppeteer's own cache, not the slidemind package.

Windows

slidemind runs on native Windows (PowerShell, Windows Terminal, or cmd) — no WSL or Git Bash required.

1. Install Node 18+ from nodejs.org (the LTS installer adds Node + npm to your PATH and ticks the right boxes by default).

2. Open Windows Terminal or PowerShell and run:

   npm install -g slidemind
   slidemind init --for auto
   slidemind --version

The global install lands in %APPDATA%\npm, which the Node installer puts on your PATH. Your pairing credentials are stored under %APPDATA%\slidemind\.

If PowerShell blocks the command with an execution-policy error, that's the .ps1 shim npm generates — run slidemind.cmd <command> instead, or use a cmd.exe tab in Windows Terminal. (To permanently allow local scripts — downloaded ones still need a signature: Set-ExecutionPolicy -Scope CurrentUser RemoteSigned.)

macOS

1. Install Node 18+ — the nodejs.org installer, or brew install node.

2. In Terminal (or iTerm):

   npm install -g slidemind
   slidemind init --for auto
   slidemind --version

If npm install -g fails with EACCES on /usr/local/lib/node_modules, you've hit a permissions issue with the official macOS Node installer: npm's global package directory is system-owned. Avoid sudo npm; it can leave root-owned files in npm's cache and makes later updates brittle. Either install a user-owned Node with Homebrew or nvm, or move npm's global prefix into your home directory:

mkdir -p ~/.npm-global
npm config set prefix ~/.npm-global
echo 'export PATH="$HOME/.npm-global/bin:$PATH"' >> ~/.zshrc
source ~/.zshrc
npm install -g slidemind
slidemind init --for auto

Credentials are stored under ~/.config/slidemind/.

Linux

The CLI runs fine on Linux. There's no PowerPoint desktop on Linux, so you'll connect to a PowerPoint host elsewhere — a Windows/Mac desktop, or PowerPoint on the web — over the cloud relay.

npm install -g slidemind
slidemind init --for auto
slidemind --version

If a system Node gives you EACCES on global installs, use nvm or set a user-writable npm prefix rather than sudo. Credentials honor XDG_CONFIG_HOME (default ~/.config/slidemind/).

Without a global install (npx)

Run any command without installing globally:

npx slidemind <command>

Note that npx only runs the package from its cache — it never installs it. That is why the one-command setup above goes through npx --yes slidemind@latest setup …: the bootstrap runs from the cache and then performs the persistent npm install -g itself.

Install as a plugin (Claude Code / Codex)

Both harnesses can install slidemind as a plugin instead of the two-command npm flow.

Claude Code — fully self-contained (no npm install -g, no GitHub account):

/plugin marketplace add https://unpkg.com/slidemind/.claude-plugin/marketplace.json
/plugin install slidemind@slidemind

The marketplace is served straight out of the published npm package — the tarball ships .claude-plugin/marketplace.json, and an npm CDN serves it over plain HTTPS. Nothing here needs repo access, and it follows releases automatically (no version in the URL, no version pin in the plugin entry). https://cdn.jsdelivr.net/npm/slidemind/.claude-plugin/marketplace.json works the same way.

The plugin ships both skills and the CLI: Claude Code installs the public npm package and puts slidemind on PATH inside its sessions (the headless-Chrome heads-up above applies to this install too). Outside Claude Code sessions the command is not on your PATH — add the global install if you also want to drive the CLI by hand. Apply updates via /plugin.

/plugin marketplace add STATWORX/intern-slidemind-cli also works if you have read access to the repo, but the URL above is preferred — it needs no credentials. If background refreshes ever fail against the private repo, use SSH or set CLAUDE_CODE_PLUGIN_KEEP_MARKETPLACE_ON_FAILURE=1.

Codex — skills via plugin, CLI via npm:

codex plugin marketplace add STATWORX/intern-slidemind-cli
codex plugin add slidemind@slidemind

Codex plugins carry the skills only — the CLI still comes from npm install -g slidemind (the skills walk you through it if it's missing). Codex clones the repo for this, so it needs read access; without it, get the skills from your workspace's Codex admin skill upload and the CLI from npm. slidemind init --for codex remains the most robust path; it additionally writes an ~/.codex/AGENTS.md pointer.

Already ran slidemind init and switching to a plugin? Drop the copied skills once with slidemind uninstall --for claude (or --for codex) so they don't duplicate the plugin's.

Connect to PowerPoint

Connecting starts in PowerPoint, because that is where slidemind already knows both who you are and which slidemind deployment you belong to. A freshly installed CLI knows neither — every organization runs its own backend, so there is no address it could guess.

Copy one command (recommended)

1. In PowerPoint, open the slidemind add-in task pane → Settings → General → Connect CLI → Set up CLI.
2. Press Copy command and paste it into your terminal.
3. Done. The add-in flips to Connected on its own, and the CLI continues into its readiness check — no add-in restart, no backend URL, nothing else to confirm.

This is the same command shown under Install: it works whether or not slidemind is already installed, and re-running it later connects an additional machine.

Already installed?

Same panel, same claim — press CLI already installed? and it swaps the copied line to the short form, skipping the npx bootstrap:

slidemind setup smc1_…

It does exactly the same work: connect, refresh the skills, run ready. Add --no-install --for none if you want the connection alone and nothing touched.

Either way, verify with:

slidemind whoami          # lists connected environment(s)
slidemind presentations   # lists open PowerPoint windows the add-in sees

A setup command works once and expires after about 10 minutes; copy a fresh one from the add-in if that happens.

slidemind logout            # unpair this machine

Quick start

slidemind ready                   # one-shot session start: check the connection, resolve the open design, fetch its bundle (host required)
slidemind new my-deck             # scaffold ./decks/my-deck/ (auto-binds to the open design when one is available)
slidemind build my-deck           # build a self-contained HTML preview (offline)
slidemind review my-deck          # spatial preview review: leave comments / approve in the browser (offline)
slidemind build-pptx my-deck      # render a native .pptx via the add-in (host required)
                                  # template packs may pass --pack <exact-pack-directory>
slidemind push my-deck            # stream slides straight into an open PowerPoint (host required)
slidemind read <presId|file.pptx> # read an open presentation (host required) or a local .pptx on disk (host-free)
slidemind ls engines              # list the active design's image + slide engines (host required)
slidemind search "shield"         # search an engine for imagery or slides (host required)
slidemind insert-slide ...        # reuse a found slide live into an open PowerPoint (host required)
slidemind add-slide ...           # fold a found slide — or one from a local .pptx (--from, host-free) — into a deck as a native .pptx

slidemind ready is the one command to run at the start of a session — it verifies the connection, resolves whichever corporate design the add-in has open, and downloads its bundle in a single call, printing exactly one next step if anything's missing. Continuing an existing deck? slidemind ready <deck> also binds the deck to that design.

Decks live under ./decks/ in your current working directory — one folder per deck: decks/<name>/slides/*.jsx. Override the location with SLIDEMIND_DECKS=/abs/path.

You don't hand-write OOXML or hardcode brand colors — slides are small .jsx files that compose the layouts and tokens the add-in serves. The render happens server-side in PowerPoint; slidemind build gives you a quick HTML preview while you iterate.

Using it with a coding agent

slidemind init installs a skill into your coding agent. After that, just ask:

"Make me a 5-slide deck introducing our Q3 roadmap."

Your agent (Claude Code, Codex, or opencode) auto-discovers the slidemind-create-slides skill, reads the active corporate design's rules from the add-in, writes the slide files, and renders + pushes them into PowerPoint for you. The skill owns the whole plan → create → edit → render workflow — there are no slash commands to memorize.

A second skill, slidemind-search, owns engine discovery and slide reuse: ask "is there a slide on X in our library?" or "drop in our pricing slide" and the agent searches the brand's image/slide engines, then either inserts a found slide live into PowerPoint or folds it into a deck as a native .pptx.

Under the hood the skill just runs the slidemind CLI in the agent's shell — list open presentations, push decks, list engines, search for imagery or slides, view a result, insert a slide live, fold a slide into a deck, and download brand imagery are all plain subcommands (see the command reference below).

Command reference

slidemind ready [deck]           One-shot session start: connect + resolve the open design + fetch bundle + bind deck (host required)
                                 --to <presId> --force --connect-only --json
slidemind new <name>             Scaffold ./decks/<name>/ (auto-binds to the open design when available)
                                 --to <presId> --no-bind
slidemind plan <deck>            Plan sign-off gate on <deck>/plan.md; blocks for approve/comments (offline)
slidemind build <deck>           Build a self-contained HTML preview (offline)
slidemind review <deck>          Spatial preview review; blocks for approve/comments (offline)
slidemind build-pptx <deck>      Render a native .pptx via the add-in        (host required)
                                 --pack <dir> for an explicit fill-template pack
slidemind inspect-template-deck <deck>  Emit a normalized template-deck model for pack validation
                                 --pack <dir> --json [--allow-unrendered-freeform]
slidemind view-draft <deck>      Render slides to per-slide PNGs, no push — look before review (offline once cached)
                                 --to <presId> --out <dir> --open
slidemind push <deck>            Build + push slides into an open PowerPoint  (host required)
slidemind ls engines             List the live engine catalog (image + slide) (host required)
slidemind search "<query>"       Search an engine for imagery or slides       (host required)
                                 --engine <id> --intent auto|content|visual --top <N>
slidemind view-slide [opts]      Fetch a slide result's preview image to a file (host required)
                                 --search <id> --pick <n> --to <presId> [--out <dir>]
slidemind insert-slide [opts]    Insert reused slide results live into a window (host required)
                                 --search <id> --pick <n[,n,...]> --to <presId> [--at <N>]
slidemind add-slide [opts]       Fold slide(s) into a deck as native .pptx — from an engine (host required) or a local file (host-free)
                                 --search <id> --pick <n[,n,...]> --deck <deck> [--to <presId>] [--at <N>]
                                 --from <file.pptx> --pick <n[,n,...]> --deck <deck> [--at <N>]   (local file; host-free; not with --search)
slidemind download-result [opts] Download image/icon result(s) into a deck's assets/ (host required)
                                 --search <id> --pick <n[,n,...]> --deck <deck> --to <presId> [--icon-color <hex[,hex,...]>]
slidemind download-bundle [deck] Materialize the active corporate design locally (host required; lower-level — `ready` covers this)
slidemind presentations          List PowerPoint windows registered with the add-in
slidemind read [presId|file.pptx] Read an open presentation (presId; host required) or a local .pptx on disk (file path; host-free)
                                 --mode summary|raw (default raw) [--to <presId>] [--json]
slidemind setup <claim>          One-command onboarding: connect + global install + skills + ready
                                 --for <target> --no-install --no-ready --json
slidemind whoami                 Show connected environment(s)
slidemind use <url|env>          Set the default environment
slidemind logout [url|env]       Unpair an environment (--all unpairs every one)
slidemind init --for <target>    Install the skill into a harness (clears the bundle cache)
                                 <target> = claude | codex | opencode | all | auto (every harness found here)
                                 Not needed after `setup` — only when adding a coding agent later
slidemind uninstall --for <t>    Remove a previously-installed skill (clears the bundle cache)
slidemind update [--for <t>]     Fetch the latest release and redeploy
slidemind --help                 Full usage
slidemind --version              Print version

<target> is claude | codex | opencode | all | none. <deck> resolves as: absolute path → ./<arg> if it exists → ./decks/<arg>.

Export formats at a glance

| Command | Output | When to use | |---|---|---| | slidemind build <deck> | decks/<deck>/presentation.html | Self-contained HTML preview in a browser (offline) | | slidemind build-pptx <deck> | decks/<deck>/<deck>.pptx | An editable native PowerPoint file | | slidemind push <deck> | (streamed via the add-in) | Live insertion into an open PowerPoint window |

Reviewing before you export

slidemind review <deck> opens the HTML preview in your browser with a comment overlay and waits until you decide:

• Click any element on a slide to leave a comment pinned to that spot. Each comment is anchored to the exact slide source (slides/<file>.jsx:line:col), so your agent knows precisely what to change.
• Approve & continue when it looks right — the command unblocks and your agent proceeds to the export you asked for (push / build-pptx).
• Send comments to hand your notes back to the agent; it edits the cited files and re-runs review, where your previous notes appear as faded "ghost" pins so you can confirm each was addressed.

It runs entirely offline (no open PowerPoint needed) — review happens before the native render. There's no copy-paste: the moment you approve or send comments in the browser, your coding agent picks up where it left off.

Pushing slides into an open PowerPoint

With PowerPoint open and the slidemind add-in loaded, stream a deck's slides straight into the running window — no .pptx written to disk:

slidemind presentations                   # list windows (presId, env, title)
slidemind push my-deck                     # append after the current slides
slidemind push my-deck --to <presId>       # required if more than one window is open
slidemind push my-deck --at 0              # insert after slide 1 (0-based index)
slidemind push my-deck --replace           # delete every existing slide first (destructive — confirm!)
slidemind push my-deck --slides 02,05,07   # push only a subset of source slides

Multiple environments (for slidemind developers)

If you run the add-in against more than one backend (local / dev / prod), the CLI is multi-environment: connect once per backend and every command automatically discovers your open PowerPoint across all of them, tags each window with its environment, and routes to the right one — no manual switching.

slidemind setup <claim-from-local-add-in> --no-install --for none   # each claim carries its own backend
slidemind setup <claim-from-dev-add-in>   --no-install --for none
slidemind whoami                           # lists every connected environment (* = default)
slidemind presentations                    # windows from all environments, each tagged [env]
slidemind push my-deck --to <presId>       # routed to whichever environment owns that window
slidemind use dev                          # set the default environment
slidemind logout dev                       # disconnect one (or --all to disconnect every one)
slidemind --backend local presentations    # scope a single command to one environment

setup is the easiest way to add an environment because the claim carries its backend — that is exactly the fact the CLI cannot otherwise know. --no-install --for none keeps it to the connection alone, leaving your existing binary and skills untouched. Because the claim carries the backend, there is no environment to select and no URL to configure — the CLI hardcodes no backend at all. Once connected, sessions stay per-environment and routing is automatic. A normal user connects one environment.

Updating

slidemind update                 # = npm install -g slidemind@latest, then redeploy the skill
slidemind update --ref 0.1.0     # pin a specific version
slidemind update --for codex     # redeploy into one harness (--for none to skip)

Equivalently: npm install -g slidemind@latest && slidemind init --for auto.

Troubleshooting

| Symptom | Fix | |---|---| | slidemind: command not found (or not recognized) | The npm global bin isn't on your PATH. Run npm prefix -g and add its bin (Windows: %APPDATA%\npm) to PATH, or use npx slidemind. | | PowerShell: running scripts is disabled | npm's .ps1 shim hit the execution policy. Use slidemind.cmd <command>, or Set-ExecutionPolicy -Scope CurrentUser RemoteSigned. | | A command can't reach PowerPoint (empty presentations, "no host", nothing seems connected) | Run slidemind ready — it checks the secure connection, backend, CLI version, and open windows in one shot and prints the single next step to take. | | slidemind presentations is empty immediately after approval | Bring PowerPoint forward and click the slidemind pane once; its authenticated relay reconnects and registers automatically. Reopen the pane only if the Office webview itself is suspended. | | Not connected / not_connected | In PowerPoint → slidemind → Settings → General → Connect CLI, press the link button and run the command it shows. | | this setup command has already been used or has expired | A setup claim works exactly once and lasts ~10 minutes. Copy a fresh one from Connect CLI → Set up CLI. | | this slidemind add-in is too old for one-command setup | That deployment predates the setup route and must be updated before this CLI can connect to it. | | build-pptx / push / search error about no host | These require an open PowerPoint host with an active corporate design. slidemind build (HTML) is the only fully-offline preview. | | EACCES on npm install -g (macOS/Linux) | Don't sudo npm. Use a user-owned Node via nvm or Homebrew, or run mkdir -p ~/.npm-global && npm config set prefix ~/.npm-global, add ~/.npm-global/bin to PATH, then retry. |

Uninstall

slidemind uninstall --for all    # remove the skill from each harness
npm uninstall -g slidemind       # remove the CLI

How it works

The design truth lives in the add-in, not the CLI:

• The .pptx is rendered server-side over the bridge — there's no local exporter.
• The corporate design is fetched as a bundle (slidemind download-bundle) — tokens, layout palette, brand rules, assets — keyed to the active presentation.
• Brand imagery comes from the add-in's engine (slidemind search → the agent downloads a result into the deck's assets/).

So an open PowerPoint host with the slidemind add-in and an active corporate design is required for everything except the offline HTML preview. The CLI ships no brand and no exporter of its own — it's deliberately brand-agnostic, working against whatever corporate design the add-in has loaded.

slidemind is published by statworx. Source lives in a private repository; the npm tarball is the install artifact. License: UNLICENSED (publicly installable, proprietary).