dsh-artcraft (plugin-figcraft)

$ dsh --profile web
you › make me a Q3 sales spreadsheet with a chart, save it to ~/Documents

  ⏺ gridcraft_commands  {"search": "chart"}          315 commands, 8 families
  ⏺ gridcraft_describe  {"id": "insert.chart"}       {range?, type?, title?, at?}
  ⏺ gridcraft_run       sample "sales", 2 commands   exited 0 in 41ms
  ⏺ gridcraft_inspect   ~/Documents/q3.xlsx          1 sheet, 1 chart, A1:H24

✔ GridCraft wrote ~/Documents/q3.xlsx (14,208 bytes)

What this is

The ArtCraft suite is fourteen native Rust applications. Each one already ships a headless CLI and its own MCP server — but nothing tells an agent they exist, what they can do, or how to call them.

This repository closes that gap. Each app becomes a DSH plugin that registers model-callable tools on ctx.tools, discovers the app's binary on your machine, and drives it as an external process.

No craft source is ever modified. Every plugin lives here. The applications are dependencies, not forks.

The fourteen

_{Command counts are read live from each binary; MCP counts are what each server declares.}

Two surfaces per craft

Every plugin exposes both, because they answer different questions:

gridcraft_commands  {"search": "chart"}
gridcraft_describe  {"id": "insert.chart"}
gridcraft_run       {"commands": [...], "save": "..."}
gridcraft_inspect   {"file": "..."}
gridcraft_convert   {"input": "...", "output": "..."}

gridcraft_mcp_tools  {"search": "range"}
gridcraft_mcp_call   {"tool": "write_range",
                      "arguments": {"range": "A1",
                                    "values": [["x"]]}}
gridcraft_mcp_status {}

The MCP server is spawned once per plugin and kept warm — starting GridCraft's engine costs ~600 ms — then shut down after five idle minutes or when the plugin unloads.

What else the bridge gives you

• Look at the result. A render, screenshot or page image comes back as a file and a path; the agent opens it with read_image, so a visual task is checked instead of assumed.
• Work in the open window. Twelve of the fourteen publish a control channel, so pass attach: <port> to an MCP call and the agent edits the document the user already has open, with every change visible in the app. LightCraft and PdfCraft are headless only.
• Use the app's own recipes. <craft>_mcp_tools also lists the MCP resources (the open document, the command catalogue, comments) and prompts — FigCraft ships six curated workflows such as design_system and prototype_flow.
• Watch the document change. After a call writes a document, the plugin renders it with the application's own renderer and returns the image with the result, so each step of the work is visible in the transcript. The same render feeds a local panel (node scripts/preview/server.mjs, then open http://127.0.0.1:4177) showing the step list, the current page and a filmstrip of the ones before it; dsh-artcraft-preview-panel embeds that panel inside the DSH Web GUI. See docs/PREVIEW.md for the state contract.
• Long jobs run in the background. A 4K render, a texture bake or an audio bounce outlasts a tool timeout; pass background: true to _run and the process keeps going while the call returns a job id, a log path and a _job tool to poll, wait on or kill.
• Skills, not just tools. The workflow knowledge lives in lznnnnn1998/dsh-artcraft-skills: a family overview plus five end-to-end workflows (report, brand kit, explainer video, drawing set, conversion). scripts/install-into-profile.mjs installs them from a checkout beside this repository, or pass --skills-dir. Tools provide the capability; the skills provide the competence, and cost context only when loaded. The dependency is one-way and declared: the skills repository carries a compatibility.json naming the minimum plugin release and every tool it calls, and it refuses to install against older plugins.

It suggests what completes the workflow

Installing one craft gives you a tool, not the workflow. scripts/doctor.mjs reports what this machine has and recommends the missing partners of the workflows you have started — install GridCraft and it points at WordCraft and PdfCraft for a report, at DeckCraft for a deck; it also checks the craft CLIs, the preview panel and the skills.

node scripts/doctor.mjs          # human summary
node scripts/doctor.mjs --json   # for tooling

The same knowledge is in dsh-plugins/craft-kit/src/suite.ts: the installer prints the suggestions, and each plugin's prompt names its workflow partners so the agent can offer the missing plugin instead of failing at the join. The preview panel and the skills repository are the two suite-wide companions.

Quick start

Windows — from a fresh clone, in PowerShell:

git clone https://github.com/lznnnnn1998/dsh-artcraft
cd dsh-artcraft
.\install.ps1                      # or: install.cmd   (if .ps1 files are blocked)

That finds the Node the harness already ships (no node, npm or pnpm on PATH needed), downloads every craft CLI for your platform, and installs the fourteen plugins into your DSH profile. Add -Crafts gridcraft for one craft, -List for a dry run, or -Verify to prove it works:

.\install.ps1 -Crafts gridcraft,wordcraft -Profile desktop -Verify

macOS and Linux — the same two steps by hand:

git clone https://github.com/lznnnnn1998/dsh-artcraft
cd dsh-artcraft

# 1. the craft CLIs — macOS, Windows and Linux, no Rust toolchain needed
node scripts/install-craft.mjs
#    …or compile them from source instead (needs Rust, ~1 min per craft):
# node scripts/install-craft.mjs --from-source

# 2. install the plugins into a DSH profile, then restart it
node scripts/install-into-profile.mjs --profile web

Both platforms run the same Node scripts; install.ps1 only adds Node discovery and PowerShell-friendly defaults. Nothing is installed machine-wide and no shell profile is modified.

Or install a single craft from npm, straight into a profile:

dsh plugin --profile web add dsh-artcraft-plugin-gridcraft

Each craft is its own package: dsh-artcraft-plugin-<craft> for cadcraft, gridcraft, soundcraft, deckcraft, wordcraft, photocraft, lightcraft, pdfcraft, vectorcraft, effectcraft, filmcraft and designcraft.

Then just ask:

"Open the CADCraft sample floor plan and export a PNG of the kitchen." "Take the demo song in SoundCraft, drop the kick 6 dB and bounce it." "Render page 3 of this PDF at 300 dpi."

Full instructions, configuration and troubleshooting: docs/INSTALL.md

Verify it yourself

node scripts/verify.mjs

Every craft must locate its binary, load its live catalog, expose the right tool set, complete an MCP handshake, and produce a non-empty artifact from a real headless run:

cadcraft       v0.16.0   449 commands   12 MCP tools   ok
gridcraft      v0.15.0   364 commands   22 MCP tools   ok
soundcraft     v0.16.0   479 commands   17 MCP tools   ok
photocraft     v0.19.0   953 commands   26 MCP tools   ok
lightcraft     v0.17.0   375 commands  397 MCP tools   ok
pdfcraft       v0.17.0   183 commands  183 MCP tools   ok
vectorcraft    v0.20.0   906 commands   33 MCP tools   ok
effectcraft    v0.20.0   743 commands   27 MCP tools   ok
filmcraft      v0.16.0   716 commands   17 MCP tools   ok
designcraft    v0.16.0   545 commands   26 MCP tools   ok
deckcraft      v0.14.1   331 commands   25 MCP tools   ok
wordcraft      v0.14.0   648 commands   17 MCP tools   ok
figcraft       v0.14.0   629 commands   19 MCP tools   ok
texturecraft   v0.2.0    135 commands   22 MCP tools   ok

all 14 plugin(s) verified

How it works

Each craft is described once, in dsh-plugins/craft-kit/src/profiles.mjs. The kernel turns that description into tools and hides every difference between the apps:

dsh-plugins/
├── craft-kit/              shared kernel
│   ├── src/                discovery · exec · catalogs · tool factory · MCP client
│   ├── lib/                generated plain ESM
│   └── catalog/            command snapshots + discovered binary paths
├── plugin-cadcraft/        one DSH plugin per craft
├── plugin-gridcraft/       …
└── plugin-wordcraft/

Every fact about the binaries was measured by running them, never assumed. Where a craft's real CLI contradicted an expectation, the raw output is recorded in docs/craft-notes/.

Beyond the fourteen

All 23 repositories matching craft under github.com/storytold were cloned and assessed (docs/CRAFT-MATRIX.md). Fourteen are applications with a published headless CLI and became plugins. The other eleven are libraries, asset bundles, or GUIs without a scriptable entry point — including artcraft, the umbrella app, whose MCP support is a documented UI stub.

Documentation

Contributing

Found a craft whose CLI behaves differently than described? The notes are meant to be corrected — open an issue with the raw output, or run the offending command with tracing on:

# macOS / Linux
DSH_ARTCRAFT_TRACE=/tmp/trace.log node scripts/verify.mjs <craft>

# Windows (PowerShell)
$env:DSH_ARTCRAFT_TRACE = "$env:TEMP\artcraft-trace.log"; node scripts\verify.mjs <craft>

That writes the exact argv of every invocation to the trace file.

License

Dual-licensed under MIT or Apache-2.0, at your option — the same terms the craft applications use.

The craft binaries are downloaded from their own GitHub releases and remain under their own licences; none of their source is vendored here.