@zvada/cr8 0.0.1 → 0.2.0

package/.claude-plugin/marketplace.json

@@ -0,0 +1,14 @@
+{
+  "name": "cr8",
+  "owner": {
+    "name": "Adam Zvada",
+    "url": "https://github.com/zvadaadam"
+  },
+  "plugins": [
+    {
+      "name": "cr8",
+      "source": "./",
+      "description": "A local-first design canvas shared by people and AI agents: typed MCP tools, a CLI, and a loopback browser workspace."
+    }
+  ]
+}

package/.claude-plugin/plugin.json

@@ -0,0 +1,23 @@
+{
+  "name": "cr8",
+  "version": "0.2.0",
+  "description": "A local-first design canvas shared by people and AI agents.",
+  "author": {
+    "name": "Adam Zvada",
+    "url": "https://github.com/zvadaadam"
+  },
+  "repository": "https://github.com/zvadaadam/baby-canva",
+  "license": "SEE LICENSE IN LICENSE",
+  "mcpServers": {
+    "cr8": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@zvada/cr8@0.2.0",
+        "mcp",
+        "--workspace",
+        "${CLAUDE_PROJECT_DIR}"
+      ]
+    }
+  }
+}

package/.codex-plugin/mcp.json

@@ -0,0 +1,11 @@
+{
+  "mcpServers": {
+    "cr8": {
+      "command": "node",
+      "args": [
+        "${PLUGIN_ROOT}/dist/cr8.mjs",
+        "mcp"
+      ]
+    }
+  }
+}

package/.codex-plugin/plugin.json

@@ -0,0 +1,35 @@
+{
+  "name": "cr8",
+  "version": "0.2.0",
+  "description": "A local-first design canvas shared by people and AI agents.",
+  "author": {
+    "name": "Adam Zvada",
+    "url": "https://github.com/zvadaadam"
+  },
+  "repository": "https://github.com/zvadaadam/baby-canva",
+  "license": "SEE LICENSE IN LICENSE",
+  "keywords": [
+    "design",
+    "canvas",
+    "mcp",
+    "agents"
+  ],
+  "mcpServers": "./.codex-plugin/mcp.json",
+  "interface": {
+    "displayName": "CR8",
+    "shortDescription": "Design with agents on a local canvas",
+    "longDescription": "Create and edit Git-friendly visual projects through typed agent tools while a person watches or collaborates in the same local canvas.",
+    "developerName": "Adam Zvada",
+    "category": "Productivity",
+    "capabilities": [
+      "Interactive",
+      "Write"
+    ],
+    "defaultPrompt": [
+      "Create a YouTube thumbnail in designs/thumbnail",
+      "Open my CR8 design and improve its layout",
+      "Build an editable mobile app concept"
+    ],
+    "brandColor": "#654CFF"
+  }
+}

package/.mcp.json

@@ -0,0 +1,13 @@
+{
+  "mcpServers": {
+    "cr8": {
+      "command": "node",
+      "args": [
+        "./dist/cr8.mjs",
+        "mcp",
+        "--workspace",
+        "."
+      ]
+    }
+  }
+}

package/LICENSE

@@ -0,0 +1,28 @@
+CR8 License
+
+Copyright (c) 2026 Adam Zvada. All rights reserved.
+
+CR8 (the "Software") is proprietary software of Adam Zvada (the "Author"). By installing or using the Software you accept this license.
+
+1. What you may do. The Author grants you a personal, non-exclusive, non-transferable, revocable license to install and run the Software, as the Author distributes it, to create and edit designs, including in your own commercial work.
+
+2. What you may not do, unless the Author permits it in writing:
+   a. copy, redistribute, publish, sell, sublicense, rent or lease the Software or any part of it;
+   b. modify, translate, adapt or create derivative works of the Software;
+   c. reverse engineer, decompile or disassemble the Software, except where the law grants you that right regardless of this license;
+   d. remove or alter any copyright, license or attribution notice;
+   e. use the Software's source, internals or design knowledge to build a competing product.
+
+3. Your work is yours. Everything you make with the Software, including designs, flows, assets and exports, belongs to you. The Author claims no rights in it.
+
+4. Third-party components. The Software includes open-source components, each under its own license. Those licenses govern those components and this license does not restrict them.
+
+5. Services. The Software connects to hosted services of the Author for account sign-in and AI media generation. Those services are provided under their own terms and may change or end.
+
+6. Names and marks. This license grants no right to use the name CR8 or any mark of the Author, except to describe the Software truthfully.
+
+7. No warranty. The Software is provided "as is", without warranty of any kind, express or implied, including warranties of merchantability, fitness for a particular purpose and non-infringement.
+
+8. Limitation of liability. To the extent the law allows, the Author is not liable for any loss or damage arising from the use of, or the inability to use, the Software.
+
+9. Termination. This license ends automatically if you break it. When it ends, stop using the Software and delete your copies.

package/README.md

@@ -1,5 +1,177 @@
 # CR8
 
-A local-first design canvas and flows for people and their agents. This version only holds the name; the first release follows.
+CR8 is a design canvas that you and your AI agents work on together, on your own computer. You open a design in your browser and draw, type, place images and generate them; an agent works on the same design at the same time through its own tools. The design is a folder of files in your repository, so it travels with your code and its history lives in Git.
 
-Adam Zvada
+Two workspaces share one project:
+
+- **Design** is the canvas: artboards, layers, text, images and vectors, with generation built in.
+- **Flows** is where repeatable AI-media recipes live: a graph of steps over image, vector and video models that a person can rerun and edit, and an agent can build and run.
+
+One local process serves both to the browser, speaks MCP to an agent, and answers a JSON command line. Nothing runs in the cloud except the AI media itself: generation runs on hosted models with your CR8 account, and every result is copied into the project. Your designs never leave your computer.
+
+> [!NOTE]
+> CR8 is an invited preview, and it is proprietary software: install it and use it, including for your own commercial work, but do not copy, modify or redistribute it. What you make with it is yours. The terms are in [LICENSE](LICENSE).
+
+## Install
+
+You need Node.js 20.19 or newer for the npm and source installs. The binaries and the desktop app need nothing.
+
+**From npm** (after the first release). One command creates a project, serves it and opens your browser:
+
+```bash
+npx @zvada/cr8 start designs/first
+```
+
+Install it once to have `cr8` on your path:
+
+```bash
+npm install -g @zvada/cr8
+cr8 start designs/first
+```
+
+**A release binary** (after the first release). Each GitHub release carries one executable per platform (`cr8-darwin-arm64.zip`, `cr8-darwin-x64.zip`, `cr8-linux-x64.tar.gz`, `cr8-linux-arm64.tar.gz`, `cr8-windows-x64.zip`), a `SHA256SUMS.txt`, and a build attestation. Check the sum, unpack, run:
+
+```bash
+shasum -a 256 -c SHA256SUMS.txt --ignore-missing
+unzip cr8-darwin-arm64.zip && ./cr8-darwin-arm64 start designs/first
+```
+
+**The desktop app** (after the first release). The same release carries a macOS app (dmg and zip), a Windows installer and a Linux AppImage. It is a window around the same local process: open a project folder and the canvas appears, no browser tab needed.
+
+**From source** (today). With Git and Node.js:
+
+```bash
+git clone https://github.com/zvadaadam/baby-canva.git "$HOME/.cr8"
+cd "$HOME/.cr8" && npm ci && npm run build:package
+ln -s "$HOME/.cr8/dist/cr8.mjs" /usr/local/bin/cr8      # or: alias cr8='node "$HOME/.cr8/dist/cr8.mjs"'
+cr8 start designs/first
+```
+
+The build makes one file, `dist/cr8.mjs`: the CLI, the MCP server, the browser workspace and the MCP App together.
+
+The full page, with the agent-host details, is [docs/user/install.md](docs/user/install.md).
+
+## Update
+
+Your designs live in their own repositories, so an update never touches them. Restart your agent host afterwards, since it keeps the server running.
+
+| Installed from | Update with |
+| --- | --- |
+| npm | `npm install -g @zvada/cr8@latest` (or keep using `npx @zvada/cr8@latest`) |
+| A binary | Download the new archive from the release and check its sum |
+| The desktop app | Download the new build; the app does not update itself |
+| Source | `cd "$HOME/.cr8" && git pull --ff-only && npm ci && npm run build:package` |
+
+## Use it
+
+There are four ways in, and they all work on the same running process and the same project, at the same time. Pick the one that fits the moment.
+
+### In the browser, as a person
+
+```bash
+cr8 start designs/first
+```
+
+The browser opens on the canvas. Draw frames, add text and rectangles, drop in images, move and resize with the mouse, nudge with the arrow keys, undo and redo. Artboards are your alternatives: duplicate one to try another direction, and keep the directions side by side. Switch to **Flows** at the top to build a recipe, run it, and add what it made to the design. **Export** writes an artboard as a PNG.
+
+The first time you generate an image, CR8 asks you to connect your account: **Connect AI media** opens a sign-in page in your browser, once per device. Everything else needs no account.
+
+### With an agent
+
+Claude Code, Codex and any MCP host can drive CR8. The host starts the server when a tool is called and stops it when the session ends, so do not run `cr8 start` for the agent.
+
+```bash
+claude mcp add --transport stdio --scope user cr8 -- cr8 mcp      # Claude Code
+codex mcp add cr8 -- cr8 mcp                                       # Codex
+```
+
+Then ask for a deliverable, not a tool:
+
+> Initialize CR8 at `designs/thumbnail` and make a 1280 × 720 YouTube thumbnail for an AI mobile-app builder. Keep every layer editable and show me the canvas.
+
+The agent creates the project, starts the canvas and hands you its URL. You watch and edit in the browser while it works; a host that renders MCP Apps shows the same canvas inline. Three skills ship with CR8 and teach the agent how to work well: `cr8-design` for the canvas, `cr8-flows` for recipes, `cr8-feedback` for reporting. Put them where the hosts look with `cr8 skills install`. Once the package is public, `/plugin marketplace add zvadaadam/baby-canva` installs the server and the skills into Claude Code in one step.
+
+The tools and what the agent sees are described in [docs/user/mcp.md](docs/user/mcp.md).
+
+### From a terminal or a script
+
+Every command answers one JSON line, so CR8 fits shell scripts and agents without MCP alike. Start a server without a browser, then talk to it:
+
+```bash
+cr8 start designs/first --no-open           # prints the URL, keeps serving
+cr8 status --pretty                         # what the project holds
+cr8 compose --json '[{"key":"hero","type":"frame","name":"Hero","x":0,"y":0,"width":1280,"height":720,"fill":"#111111"}]'
+cr8 doctor                                  # layout, overlap, legibility, clutter
+cr8 generate --prompt "A coral disc on cream" --model fast --ratio 16:9 --count 1
+cr8 export --root FRAME_ID --out hero.png
+```
+
+Bring references in and check the result against them: `cr8 import picture.png --as-frame`, `cr8 capture https://example.com`, `cr8 verify --reference picture.png --root FRAME_ID`. Build and run a recipe: `cr8 workflow-templates`, `cr8 workflow-create --file flow.json`, `cr8 workflow-run FLOW_ID`, `cr8 workflow-place FLOW_ID`. `cr8 schema` prints the whole command contract. The complete guide is [docs/user/cli.md](docs/user/cli.md).
+
+### In the desktop app
+
+Open the app on a project folder, or launch it with `--workspace DIR --project designs/first`. It spawns the same local process, or joins one that already holds the project, and shows the canvas in its own window. See [docs/user/desktop.md](docs/user/desktop.md).
+
+## Your files
+
+A design is an ordinary folder. Commit it like code.
+
+```text
+designs/first/
+├── cr8.json          # the design itself, readable and versioned
+├── flows.json        # the project's recipes, created with the first saved flow
+├── flow-runs.json    # what each flow last made, created with the first run
+├── assets/           # images and SVGs, imported or generated, named by their content
+├── .gitignore        # ignores .cr8/
+└── .cr8/             # disposable: the session, the selection, the lock
+```
+
+Commit `cr8.json`, `flows.json`, `flow-runs.json`, `assets/` and `.gitignore`; a clone opens with every design, every flow and what each flow last made. Never commit `.cr8/`. Keep alternatives as artboards in one project rather than as `v2` folders; the rules of thumb are in [docs/user/projects.md](docs/user/projects.md).
+
+## Your account and AI media
+
+Drawing, editing, importing, exporting, the CLI and the agent tools all work without an account. Generating images, vectors, video and image-to-layers runs on hosted models and needs your CR8 account, connected once per device: the sign-in page hands this computer a grant that renews itself and lives in CR8's home folder, readable by you alone. `cr8 connect --open` does the same from a terminal, `cr8 status` shows the connection, `cr8 disconnect` forgets it. An agent never sees your credentials; when a generation needs the account, it hands you the sign-in URL.
+
+Every generation is recorded in the cloud with its model, prompt and parameters, and the result is copied into the project's `assets/` before the design may use it. Only video clips stay in the cloud; `cr8 media-download` writes one to a file.
+
+## Feedback
+
+When something is broken, confusing or notably good, tell the team. From a terminal:
+
+```bash
+cr8 feedback --category cli --subject "cr8 export" "export writes a black PNG when the artboard is rotated."
+```
+
+Agents have the same path through the `cr8-feedback` skill and the `canvas_feedback` tool, and without the CLI they can report to Hivenet directly with `npx --yes hivenet@0.4.2 --to babycanva --category <category> --subject "<exact item>" "<feedback>"`. Nothing is ever sent automatically, and a report carries no canvas content or ambient context; `--dry-run` shows the exact event first. A task that failed after real effort goes with `--task`, `--expected` and `--actual`, and becomes a test case for the team. See [docs/user/feedback.md](docs/user/feedback.md).
+
+## Documentation
+
+- [Install](docs/user/install.md), [CLI](docs/user/cli.md), [MCP and the MCP App](docs/user/mcp.md), [desktop app](docs/user/desktop.md), [projects](docs/user/projects.md), [feedback](docs/user/feedback.md), [App Store screenshots](docs/user/app-store-screenshots.md).
+- [Architecture](docs/internals/architecture.md), [workflows](docs/internals/workflows.md), [media API](docs/internals/media-api.md), [authentication](docs/operations/auth.md), [releases](docs/operations/release.md), and the [decisions](docs/decisions/) behind them. The index is [docs/README.md](docs/README.md).
+
+## For developers
+
+```bash
+npm run dev                      # the runtime behind Vite with hot reload
+npm run cli -- status --pretty   # the development CLI entry
+npm run typecheck && npm run lint && npm test
+npm run build                    # the package, the account hub and the desktop main process
+npm run test:install             # pack the npm artifact and install it the way a user would
+```
+
+The product lives in eight private npm workspaces. Each owns its dependencies, configuration and focused tests:
+
+| Package | Owns |
+| --- | --- |
+| [core](packages/core/) | Canonical scene, commands, layout and local protocol |
+| [runtime](packages/runtime/) | Local process, project files, CLI, MCP and media clients |
+| [editor](packages/editor/) | Browser editor, Flows and embedded MCP App |
+| [desktop](packages/desktop/) | Electron launcher over the local runtime |
+| [account-hub](packages/account-hub/) | Cloud account UI, WorkOS and installation grants |
+| [media-api](packages/media-api/) | Cloud generation Worker, providers and output catalog |
+| [contracts](packages/contracts/) | Contracts shared with the Workers |
+| [media-safety](packages/media-safety/) | Image and SVG byte validation |
+
+Run a focused command from the root with `npm run test --workspace @cr8/editor`, or from inside that package with `npm test`. Root `tests/` holds cross-package integration and installation checks. Root scripts assemble and verify the whole product.
+
+The root remains the published `@zvada/cr8` package and plugin: `npm run build:package` bundles the private workspace source into one `dist/cr8.mjs`, with no installed runtime dependencies. The account hub has its own build into `dist/account`; the local editor is loopback-only. See [architecture](docs/internals/architecture.md), the [package decision](docs/decisions/2026-09-10-package-ownership.md), and the [release runbook](docs/operations/release.md).