@drawsy/companion 0.1.29 → 0.1.31

package/README.md

@@ -1,86 +1,75 @@
-# Drawsy Companion from your terminal
+# Install Drawsy Companion
 
-The CLI runs the same local Companion server without the desktop app. It connects Drawsy to your existing Codex/OpenCode installation. It does not install either engine, sign you in, or change their authentication settings.
+Choose the desktop app unless you specifically want to control Companion from a terminal.
 
-## Requirements
+## Desktop app: one line, no Node.js needed
 
-- Windows, macOS, or Linux.
-- Node.js 22 or later with npm, installed for your user account.
-- The public npm package [@drawsy/companion](https://www.npmjs.com/package/@drawsy/companion).
+Open Terminal on macOS/Linux, or Command Prompt or PowerShell on Windows. The desktop app does not need Node.js, npm, administrator access, or `sudo`.
 
-The package is published under Drawsy's npm account. A public package does not require a paid private npm plan. No paid app signing certificate or Microsoft Store approval is required for this Node.js CLI package; the separate desktop app has its own release requirements.
+macOS (Apple Silicon) or Linux (x64):
 
-## Install permanently
+```sh
+curl -fsSL https://raw.githubusercontent.com/DrawsyAI/drawsy-ai-companion/main/scripts/install.sh | sh
+```
 
-Install the public npm package:
+Windows (64-bit), in Command Prompt or PowerShell:
 
-```sh
-npm install --global --ignore-scripts @drawsy/companion
+```cmd
+winget install --id 9PD4MGJ9BW4F --source msstore
 ```
 
-This installs the CLI globally; npx is not needed. npm must be configured so your user account can install global packages; this flow does not request administrator access.
+This installs the Store version. You can also [open the Microsoft Store listing](https://apps.microsoft.com/detail/9PD4MGJ9BW4F). The GitHub release page still includes an unsigned Windows `.exe` and `.zip` for people who specifically need those files; Windows may show a security warning for them.
 
-Once installed, run:
+The macOS/Linux command downloads the latest stable GitHub release, checks its SHA-256 checksum, installs it for your account, and opens Companion. To update the desktop app, close Companion and run the same install command again. To update the Windows Store app, update it through Microsoft Store. Supported builds are Apple Silicon macOS, 64-bit Windows, and x64 Linux.
 
-```sh
-drawsy-companion setup
-```
+The desktop app stays available in the tray/menu bar while it is open. It does not start automatically when you sign in. Closing its window leaves it running in the background; choose **Quit Drawsy Companion** from the tray/menu to stop it.
 
-`setup` starts Companion in the background and enables startup when you sign in. Then open [Drawsy](https://drawsyai.com), the URL allowed by the Companion connection policy. For app details, see [app.drawsyai.com](https://app.drawsyai.com). Closing the terminal does not stop the background server.
+## Terminal CLI: background service and controls
 
-To install and set up in one line:
+Choose this if you want Companion to run without its desktop window and start when you sign in. It requires Node.js 22 or later to remain installed. Use npm, pnpm, or Bun only if you already have it; there is no need to install another package manager.
 
-macOS/Linux:
+macOS/Linux, using npm:
 
 ```sh
-npm install --global --ignore-scripts @drawsy/companion && drawsy-companion setup
+npm install --global --ignore-scripts @drawsy/companion@latest && drawsy-companion setup
 ```
 
-Windows PowerShell:
+Windows PowerShell, using npm:
 
 ```powershell
-npm.cmd install --global --ignore-scripts @drawsy/companion; if ($LASTEXITCODE -eq 0) { drawsy-companion.cmd setup }
+npm.cmd install --global --ignore-scripts @drawsy/companion@latest; if ($LASTEXITCODE -eq 0) { drawsy-companion.cmd setup }
 ```
 
-The Windows `.cmd` commands avoid requiring a PowerShell script execution policy change.
-
-### Optional GitHub tarball source
-
-If you prefer to install a published GitHub release tarball, use its versioned `.tgz` asset. For CLI version 0.1.28:
-
-```sh
-npm install --global --ignore-scripts https://github.com/DrawsyAI/drawsy-ai-companion/releases/download/cli-v0.1.28/drawsy-companion-0.1.28.tgz
-```
+If you already use a different package manager, run only its command:
 
-The tarball is built by this repository's CLI release workflow and is available after its draft release is published. Use the tarball asset, not the desktop ZIP or AppX.
+- macOS/Linux with pnpm: `pnpm add --global --ignore-scripts @drawsy/companion@latest && drawsy-companion setup`
+- macOS/Linux with Bun: `bun add --global --ignore-scripts @drawsy/companion@latest && drawsy-companion setup`
+- Windows PowerShell with pnpm: `pnpm.cmd add --global --ignore-scripts @drawsy/companion@latest; if ($LASTEXITCODE -eq 0) { drawsy-companion.cmd setup }`
+- Windows PowerShell with Bun: `bun add --global --ignore-scripts @drawsy/companion@latest; if ($LASTEXITCODE -eq 0) { drawsy-companion.cmd setup }`
 
-## Commands
+`setup` starts Companion in the background and enables it when you sign in. Useful commands:
 
 ```sh
-drawsy-companion start
-drawsy-companion stop
 drawsy-companion status
 drawsy-companion logs
-drawsy-companion serve
-drawsy-companion autostart enable
+drawsy-companion start
+drawsy-companion stop
 drawsy-companion autostart disable
 ```
 
-`serve` keeps the server visible in your current terminal. Press Ctrl+C to stop it. `status` reports whether the local server is running. Startup at login uses Windows Task Scheduler, macOS launchd, or Linux's user systemd service; Linux requires a working user systemd session. `start` alone does not enable startup at login.
+On Windows, use `drawsy-companion.cmd` in PowerShell. Desktop app and CLI use the same local server; close the desktop app before starting the CLI. The CLI will not stop or replace another Companion.
 
-The desktop app and CLI use the same local server address. Quit the desktop app before switching to the CLI; an existing server is not silently replaced or stopped.
+## Updates and removal
 
-## Update or remove
-
-Run `drawsy-companion autostart disable`, then `drawsy-companion stop` before updating from the public npm registry:
+The desktop app and CLI update separately. To update the desktop app, close it and run its installer command again. To update the CLI, disable sign-in startup, stop it, install the latest package with the same package manager, then run setup again. Example for npm:
 
 ```sh
+drawsy-companion autostart disable
 npm install --global --ignore-scripts @drawsy/companion@latest
+drawsy-companion setup
 ```
 
-Run `drawsy-companion setup` after installation to restore background startup. This also refreshes the saved Node.js executable path if your Node installation changed.
-
-Before removing the package, disable startup at login, stop Companion, and remove the package:
+To remove the CLI, disable startup and stop it first, then uninstall the package with the same package manager:
 
 ```sh
 drawsy-companion autostart disable
@@ -88,12 +77,12 @@ drawsy-companion stop
 npm uninstall --global @drawsy/companion
 ```
 
-This does not uninstall your Codex/OpenCode installation.
-
-## Release preparation
+Neither install route installs, updates, or signs in to Codex or OpenCode. Keep using the installation and login flow you already have for those tools.
 
-The first public version, 0.1.28, was built and uploaded by GitHub Actions and approved through npm's staged publication flow. Follow [the npm publishing guide](https://github.com/DrawsyAI/drawsy-ai-companion/blob/main/docs/npm-publishing.md) for GitHub trusted publishing setup. Future public package releases use this repository's **Publish Companion CLI to npm** GitHub workflow. It requires the current `main` commit, rejects a mismatched existing CLI version tag, builds and packages the CLI, and publishes the package with npm provenance. It runs no tests and launches no app or server.
+## Release sources
 
-The **Build Companion CLI release** GitHub workflow builds and packages a selected commit, runs no tests, and launches no app or server. It uploads the tarball and `CLI-SHA256SUMS` to a draft release named `cli-v` followed by the package version. Review and manually verify the draft before publishing it; existing published releases are never replaced. This GitHub tarball is an optional install source.
+- macOS and Linux desktop installers are built and published to this repository's [GitHub Releases](https://github.com/DrawsyAI/drawsy-ai-companion/releases/latest). The release page also retains the unsigned Windows `.exe` and `.zip` alternate. The Windows Store package is built separately and submitted through Partner Center.
+- The npm CLI is published separately by the repository's **Publish Companion CLI to npm** GitHub workflow. Installing or updating the desktop app does not publish or update the npm package.
+- The CLI release tarball excludes Electron, the desktop window, build dependencies, personal configuration, and credentials.
 
-The package contains the compiled local server, bundled Drawsy skills, and npm runtime dependency declarations. It excludes Electron, the desktop UI, build dependencies, personal configuration, and credentials. npm installs the declared runtime dependencies when installing the tarball.
+For maintainers: desktop releases follow a version tag matching `package.json` (`v` followed by the package version) and are built by the release workflow. npm releases require a package version bump on `main` and a deliberate run of **Publish Companion CLI to npm** in GitHub Actions. The two release routes do not trigger each other.

package/dist/drawsy/cli-ui.js

@@ -0,0 +1,121 @@
+const colors = {
+    violet: "38;2;101;84;217",
+    coral: "38;2;255;125;136",
+    blue: "38;2;88;162;232",
+    orange: "38;2;245;119;45",
+    green: "38;2;55;153;80",
+    muted: "38;2;137;143;156",
+    amber: "38;2;210;153;34",
+};
+const canColor = () => Boolean(process.stdout.isTTY && !("NO_COLOR" in process.env) && process.env.TERM !== "dumb");
+const paint = (text, color, bold = false) => canColor() ? `\u001b[${bold ? "1;" : ""}${color}m${text}\u001b[0m` : text;
+const delay = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
+function wordmark() {
+    return [
+        paint("D", colors.violet, true),
+        paint("r", colors.violet, true),
+        paint("a", colors.coral, true),
+        paint("w", colors.orange, true),
+        paint("s", colors.green, true),
+        paint("y", colors.blue, true),
+    ].join("");
+}
+async function printHeader(animate) {
+    const letters = ["D", "r", "a", "w", "s", "y"];
+    const letterColors = [colors.violet, colors.violet, colors.coral, colors.orange, colors.green, colors.blue];
+    const animated = animate && process.stdout.isTTY && !process.env.CI && process.env.TERM !== "dumb";
+    if (animated) {
+        let visible = "";
+        for (let index = 0; index < letters.length; index++) {
+            visible += paint(letters[index], letterColors[index], true);
+            process.stdout.write(`\r  ${visible} Companion`);
+            await delay(38);
+        }
+        process.stdout.write("\n");
+        return;
+    }
+    console.log(`\n  ${wordmark()} Companion`);
+}
+/** Animate one drawn stroke across the line only in an interactive terminal. */
+export function startDrawsyIndicator(label) {
+    if (!process.stdout.isTTY || process.env.CI || process.env.TERM === "dumb") {
+        return { stop: () => undefined };
+    }
+    const width = 9;
+    let position = 0;
+    let direction = 1;
+    const render = () => {
+        const stroke = `${"-".repeat(position)}${paint("/", colors.violet)}${"-".repeat(width - position - 1)}`;
+        process.stdout.write(`\r\u001b[2K  ${stroke}  ${label}`);
+        position += direction;
+        if (position === width - 1 || position === 0)
+            direction *= -1;
+    };
+    render();
+    const timer = setInterval(render, 75);
+    timer.unref();
+    return {
+        stop(message) {
+            clearInterval(timer);
+            process.stdout.write(`\r\u001b[2K  ${paint("OK", colors.green, true)}  ${message}\n`);
+        },
+    };
+}
+export async function printDashboard(state, animate = false) {
+    await printHeader(animate);
+    console.log(`  ${paint("Local bridge", colors.muted)}  ${paint(`v${state.version}`, colors.muted)}`);
+    console.log("");
+    const companionLabel = {
+        running: ["Running", colors.green],
+        starting: ["Starting", colors.amber],
+        stopped: ["Not running", colors.muted],
+        other: ["Another Companion is running", colors.amber],
+    };
+    const [companionText, companionColor] = companionLabel[state.companion];
+    const companionVersion = state.companionVersion ? ` · v${state.companionVersion}` : "";
+    console.log(`  ${"Companion".padEnd(12)} ${paint(`${companionText}${companionVersion}`, companionColor)}`);
+    for (const engine of state.engines) {
+        let label;
+        let color;
+        if (!engine.installed) {
+            label = "Not found";
+            color = colors.muted;
+        }
+        else if (engine.id === "opencode" && process.platform === "win32") {
+            label = "Installed · unavailable on Windows";
+            color = colors.amber;
+        }
+        else {
+            label = `Available${engine.version ? ` · v${engine.version}` : ""}`;
+            color = colors.green;
+        }
+        console.log(`  ${engine.name.padEnd(12)} ${paint(label, color)}`);
+    }
+    if (state.autostart !== undefined) {
+        console.log(`  ${"At sign-in".padEnd(12)} ${paint(state.autostart ? "Enabled" : "Off", state.autostart ? colors.green : colors.muted)}`);
+    }
+    if (state.includeLinks) {
+        console.log("");
+        console.log(`  Open Drawsy  ${paint("https://drawsyai.com", colors.blue)}`);
+        console.log(`  Plans        ${paint("https://app.drawsyai.com/pricing", colors.muted)}`);
+    }
+    if (state.hint) {
+        console.log("");
+        console.log(`  ${paint(state.hint, colors.muted)}`);
+    }
+    console.log("");
+}
+export async function printHelp(version) {
+    await printHeader(false);
+    console.log(`  ${paint(`v${version}`, colors.muted)} · local canvas bridge`);
+    console.log("");
+    console.log("  no command          Show status and links");
+    console.log("  setup              Start now and at sign-in");
+    console.log("  start              Start for this login session");
+    console.log("  serve              Run in this terminal");
+    console.log("  status | stop | logs");
+    console.log("  autostart enable | disable");
+    console.log("");
+    console.log("  Update: npm install --global --ignore-scripts @drawsy/companion@latest");
+    console.log("");
+}

package/dist/drawsy/cli.js

@@ -11,6 +11,7 @@ import { createWriteStream } from "node:fs";
 import { createDrawsyBridge } from "./bridge.js";
 import { readLocalEngineStatus } from "./engine-status.js";
 import { enableAutostart, disableAutostart, autostartEnabled } from "./cli-autostart.js";
+import { printDashboard, printHelp, startDrawsyIndicator } from "./cli-ui.js";
 const directory = path.join(homedir(), ".drawsy-companion");
 const lockDirectory = path.join(directory, "runtime.lock");
 const recordPath = path.join(lockDirectory, "runtime.json");
@@ -67,6 +68,29 @@ const bridgePresent = async () => {
         return null;
     }
 };
+const showStatus = async (options = {}) => {
+    const running = await control("status");
+    const other = running ? null : await bridgePresent();
+    const autostart = await autostartEnabled();
+    const companion = running ? "running" : other ? "other" : options.missingState ?? "stopped";
+    const hint = options.hint ?? (other
+        ? "Quit the desktop app before starting CLI mode."
+        : running
+            ? autostart ? "Ready for Drawsy." : "Run drawsy-companion setup to keep it ready at sign-in."
+            : companion === "starting"
+                ? "Startup is enabled; run drawsy-companion status to check readiness."
+                : "Run drawsy-companion setup to start now and at sign-in.");
+    await printDashboard({
+        version: manifest.version,
+        companion,
+        companionVersion: running?.version ?? other?.version,
+        autostart,
+        engines: readLocalEngineStatus(),
+        includeLinks: options.includeLinks,
+        hint,
+    }, options.animate);
+    return { running, other, autostart };
+};
 const acquire = async () => {
     await mkdir(directory, { recursive: true, mode: 0o700 });
     try {
@@ -148,7 +172,14 @@ const serve = async (backgroundLog) => {
         await writeFile(recordPath, JSON.stringify({ pid: process.pid, port: address.port, token, version: manifest.version }), { mode: 0o600 });
         process.once("SIGINT", () => { void shutdown(); });
         process.once("SIGTERM", () => { void shutdown(); });
-        console.log(`Drawsy Companion ${manifest.version} running at ${bridge.address}`);
+        await printDashboard({
+            version: manifest.version,
+            companion: "running",
+            companionVersion: manifest.version,
+            engines: readLocalEngineStatus(),
+            includeLinks: !backgroundLog,
+            hint: backgroundLog ? `Local bridge ready at ${bridge.address}.` : "Press Ctrl+C to stop.",
+        });
         process.send?.({ ready: true });
         process.disconnect?.();
     }
@@ -165,13 +196,14 @@ const serve = async (backgroundLog) => {
 const start = async () => {
     const existing = await control("status");
     if (existing) {
-        console.log(`Companion ${existing.version} is already running.`);
+        await showStatus({ includeLinks: true });
         return;
     }
     if (await bridgePresent())
         throw new Error("The desktop app or another Companion server is running. Quit it first; this command will not replace it.");
     await mkdir(directory, { recursive: true, mode: 0o700 });
     const output = await open(logPath, "a", 0o600);
+    const indicator = startDrawsyIndicator("Starting local Companion");
     try {
         await new Promise((resolve, reject) => {
             const child = spawn(process.execPath, [entry, "serve"], {
@@ -192,30 +224,27 @@ const start = async () => {
             });
         });
     }
+    catch (error) {
+        indicator.stop("Startup did not finish.");
+        throw error;
+    }
     finally {
         await output.close();
     }
-    console.log(`Companion ${manifest.version} is running in the background. Open https://drawsyai.com`);
+    indicator.stop("Local Companion started.");
+    await showStatus({ includeLinks: true });
 };
-const help = () => console.log(`Drawsy Companion ${manifest.version}
-
-  setup              Start now and automatically when you sign in
-  start              Start in the background for this login session
-  serve              Run visibly in this terminal (Ctrl+C stops it)
-  stop               Stop the CLI server; keep login startup configured
-  status             Show server and automatic startup status
-  logs               Show the latest local log output
-  autostart enable   Enable startup at login
-  autostart disable  Disable startup at login and stop its managed job
-
-Requires Node.js 22 or later. Codex/OpenCode installation and login stay unchanged.
-Update or remove the package with npm after disabling automatic startup.
-Only the CLI's authenticated process is stopped; the desktop app is never killed.`);
 try {
-    const [command = "help", option, ...extra] = process.argv.slice(2);
+    const [command = "welcome", option, ...extra] = process.argv.slice(2);
     if (extra.length || (option && command !== "autostart" && !(command === "serve" && option === "--background-log")))
         throw new Error("Unexpected arguments. Use drawsy-companion help.");
     switch (command) {
+        case "welcome":
+            await showStatus({
+                includeLinks: true,
+                animate: true,
+            });
+            break;
         case "serve":
             await serve(option === "--background-log");
             break;
@@ -230,17 +259,11 @@ try {
                 if (alive(running.pid))
                     throw new Error("Shutdown is still in progress. Check status before restarting.");
             }
-            console.log(running ? "Companion CLI stopped." : "Companion CLI is not running.");
+            await showStatus({ hint: running ? "Companion CLI stopped." : "Companion CLI is not running." });
             break;
         }
         case "status": {
-            const running = await control("status");
-            const other = running ? null : await bridgePresent();
-            console.log(running ? `Companion CLI ${running.version} running.` : other ? `Another Companion server ${other.version ?? ""} is running.` : "Companion is not running.");
-            console.log(`Startup at login: ${await autostartEnabled() ? "enabled" : "disabled"}.`);
-            for (const engine of readLocalEngineStatus()) {
-                console.log(`${engine.name}: ${engine.id === "opencode" && process.platform === "win32" ? "not supported by Companion on Windows" : engine.installed ? `available${engine.version ? ` (${engine.version})` : ""}` : "not found"}.`);
-            }
+            await showStatus();
             break;
         }
         case "logs": {
@@ -269,18 +292,29 @@ try {
             if (action === "disable") {
                 await control("stop");
                 await disableAutostart();
-                console.log("Startup at login disabled; CLI shutdown requested.");
+                await showStatus({ hint: "Startup at sign-in disabled." });
             }
             else if (action === "enable") {
                 if (await autostartEnabled() && await control("status")) {
-                    console.log("Companion running; startup at login enabled.");
+                    await showStatus({ includeLinks: true, hint: "Ready at sign-in." });
                     break;
                 }
                 if (await control("status") || await bridgePresent())
                     throw new Error("Stop Companion first, then run setup. Existing sessions will not be interrupted automatically.");
                 await mkdir(directory, { recursive: true, mode: 0o700 });
-                await enableAutostart(process.execPath, entry);
-                console.log("Startup at login enabled. Run drawsy-companion status to check readiness; open https://drawsyai.com when running.");
+                const indicator = startDrawsyIndicator("Setting up sign-in startup");
+                try {
+                    await enableAutostart(process.execPath, entry);
+                }
+                catch (error) {
+                    indicator.stop("Setup could not be completed.");
+                    throw error;
+                }
+                indicator.stop("Startup at sign-in enabled.");
+                await showStatus({
+                    includeLinks: true,
+                    missingState: "starting",
+                });
             }
             else
                 throw new Error("Use autostart enable or autostart disable.");
@@ -289,7 +323,7 @@ try {
         case "help":
         case "--help":
         case "-h":
-            help();
+            await printHelp(manifest.version);
             break;
         case "--version":
             console.log(manifest.version);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drawsy/companion",
-  "version": "0.1.29",
+  "version": "0.1.31",
   "private": false,
   "type": "module",
   "description": "Drawsy's local Companion server and background command-line controls",

package/skills/drawsy-fast-diagrams/SKILL.md

@@ -8,7 +8,7 @@ description: Generate semantic Mermaid source and render it through Drawsy Fast
 Use this skill only for Fast Mode canvas diagram work.
 
 - Read the current canvas and call `get_canvas_capabilities`. When present, treat `diagramCode.nativeEditableTypes` and `diagramCode.sourceMaxBytes` as the converter's runtime authority. Choose Mermaid syntax from the request's meaning and actual support; do not use a fixed intent-to-family mapping or prescribe a visual style. Keep the user's facts, supplied numbers, canvas context, and existing visual language intact. Never invent data to force a chart.
-- The current converter has editable native handlers for flowchart/graph, packet, architecture, ER, use case, mindmap, tree view, XY chart, pie, radar, and Sankey families. The installed parser may accept more syntax and render it as an image. Check `outputKind` (`editable-vector` or `image-fallback`) and `diagramType`; do not promise that fallback content stays editable. Mermaid's official syntax references follow `https://mermaid.js.org/syntax/<diagram-name>.html`; documentation can describe newer syntax than Drawsy's bundled parser.
+- Discover editable diagram families from the live `diagramCode.nativeEditableTypes` catalog rather than a bundled list, so newly installed converters are available automatically. The installed parser may accept more syntax and render it as an image. Check `outputKind` (`editable-vector` or `image-fallback`) and `diagramType`; do not promise that fallback content stays editable. Mermaid's official syntax references follow `https://mermaid.js.org/syntax/<diagram-name>.html`; documentation can describe newer syntax than Drawsy's bundled parser.
 - Use `render_diagram_code` to create a whole diagram. Fast Mode still supports normal canvas management: use `apply_canvas_changes` to update existing elements or delete existing elements, including failed or intermediate work you created; never delete unrelated content. Use `create_or_update_connector` and `set_container_label` for existing objects, and image insertion/replacement, canvas capture, and live preview when requested. The runtime checks raw upserts against the live canvas; never use them to create new shapes or diagram structures. The diagram result includes `outputKind`, `diagramType`, `elementCount`, inserted `elementIds`, and `bounds`; use those IDs and bounds to review the inserted group.
 - Do not use native pointer gestures or another canvas path to bypass the diagram converter when creating a whole diagram. Preserve the user's visual choices when managing existing content.
 - A syntax correction is for a request that failed conversion: make at most one focused correction and retry with a new `operationId`; reuse an id only to retry the same unchanged request. A post-render correction follows a successful conversion after inspection: read the canvas again, make a focused correction, and set `replaceOperationId` to the prior successful operation id so only that converter-created group is replaced.