@paradigma-inc/flywheel 0.1.0 → 0.1.4

package/README.md

@@ -1,12 +1,6 @@
 # flywheel setup CLI
 
-This package provides a Context7-style setup workflow for Flywheel MCP.
-
-Design intentionally mirrors Context7's setup implementation patterns from:
-
-- `packages/cli/src/commands/setup.ts`
-- `packages/cli/src/setup/agents.ts`
-- `packages/cli/src/setup/mcp-writer.ts`
+This package provides setup and uninstall workflows for Flywheel MCP.
 
 ## Usage
 
@@ -15,44 +9,31 @@ npx @paradigma-inc/flywheel setup
 npx @paradigma-inc/flywheel uninstall
 ```
 
-## Production vs staging
-
-- `npx @paradigma-inc/flywheel setup` defaults to production
-  (`https://flywheel.paradigma.inc`).
-- To target staging explicitly, pass a staging base URL:
+`--base-url` must be the public Flywheel origin, not a backend URL or an `/api`
+path. Example:
 
 ```bash
-npx @paradigma-inc/flywheel setup --base-url https://flywheel-staging.paradigma.inc
+npx @paradigma-inc/flywheel@staging setup \
+  --name flywheel-staging \
+  --base-url https://flywheel-staging.paradigma.inc
 ```
 
-- Staging remains protected by the existing staging password gate in the WebUI.
-  The browser auth step must pass that gate before key creation can complete.
-- Setup writes one Flywheel server entry per host+scope. Re-running setup for a
-  different base URL in the same host+scope updates that same entry.
-
 ## Commands
 
 - `setup`: interview + browser auth bridge + idempotent host config writes.
 - `uninstall`: remove Flywheel MCP entries from selected host configs.
-
-## Release channels
-
-- Public production installs use npm (`latest`):
-
-```bash
-npx @paradigma-inc/flywheel setup
-```
-
-- Internal staging builds are published to GitHub Packages (`staging` tag) and
-  require npm auth for `npm.pkg.github.com`.
-- Example internal install:
-
-```bash
-npx --registry=https://npm.pkg.github.com @paradigma-inc/flywheel@staging setup
-```
+- Add `--yes` to skip interactive prompts in the Flywheel wizard.
+- `npx --yes` only auto-confirms `npx`; it does not imply `flywheel --yes`.
 
 ## Supported hosts
 
 - Codex (`~/.codex/config.toml` or `.codex/config.toml`)
 - Claude Code (`~/.claude.json` or `.mcp.json`)
 - OpenCode (`~/.config/opencode/opencode.json` or `opencode.json`)
+- Cursor (`~/.cursor/mcp.json` or `.cursor/mcp.json`)
+- Hermes Agent (`~/.hermes/config.yaml` or `.hermes/config.yaml`)
+- OpenClaw (`~/.openclaw/openclaw.json` or `.openclaw/openclaw.json`)
+- Pi (pi-mono) (`~/.pi/agent/settings.json` or `.pi/settings.json`)
+
+Pi (pi-mono) support writes `mcp.servers` into Pi settings. It requires an
+MCP-capable Pi extension/package to consume those entries.

package/package.json

@@ -1,14 +1,31 @@
 {
   "name": "@paradigma-inc/flywheel",
-  "version": "0.1.0",
-  "description": "One-command setup for Flywheel MCP on Codex, Claude Code, and OpenCode",
+  "version": "0.1.4",
+  "description": "One-command setup for Flywheel MCP hosts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/paradigma-inc/paradigma",
+    "directory": "project/flywheel-setup"
+  },
   "type": "module",
+  "files": [
+    "bin/",
+    "src/",
+    "README.md"
+  ],
   "bin": {
     "flywheel": "bin/flywheel.js"
   },
   "scripts": {
     "test": "node --test tests/*.test.mjs"
   },
+  "dependencies": {
+    "@inquirer/prompts": "^8.2.0",
+    "commander": "^14.0.1",
+    "js-yaml": "^4.1.0",
+    "ora": "^9.0.0",
+    "picocolors": "^1.1.1"
+  },
   "engines": {
     "node": ">=20"
   },

package/src/agents.mjs

@@ -1,97 +1,256 @@
+import { access } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 
 export const SERVER_NAME = "flywheel";
-export const HOSTS = ["codex", "claude", "opencode"];
-
-export const HOST_LABELS = {
-  codex: "Codex",
+export const ALL_HOST_NAMES = [
+  "claude",
+  "opencode",
+  "codex",
+  "cursor",
+  "pi-mono",
+  "hermes-agent",
+  "openclaw",
+];
+export const SETUP_HOST_NAMES = {
   claude: "Claude Code",
   opencode: "OpenCode",
+  codex: "Codex",
+  cursor: "Cursor",
+  "pi-mono": "Pi (pi-mono)",
+  "hermes-agent": "Hermes Agent",
+  openclaw: "OpenClaw",
 };
 
 const HOME = os.homedir();
 
-/**
- * Patterns mirrored from Context7's `setup/agents.ts`.
- */
-export const AGENT_CONFIG = {
-  codex: {
-    configType: "toml",
-    projectPath: path.join(".codex", "config.toml"),
-    globalPath: path.join(HOME, ".codex", "config.toml"),
-    buildEntry: ({ serverUrl, apiKey }) => ({
-      type: "http",
-      url: serverUrl,
-      headers: {
-        Authorization: `Bearer ${apiKey}`,
-      },
-    }),
-  },
+const hosts = {
   claude: {
-    configType: "json",
-    projectPath: ".mcp.json",
-    globalPath: path.join(HOME, ".claude.json"),
-    configKey: "mcpServers",
-    buildEntry: ({ serverUrl, apiKey }) => ({
-      type: "http",
-      url: serverUrl,
-      headers: {
-        Authorization: `Bearer ${apiKey}`,
-      },
-    }),
+    name: "claude",
+    displayName: "Claude Code",
+    mcp: {
+      configType: "json",
+      projectPaths: [".mcp.json"],
+      globalPaths: [path.join(HOME, ".claude.json")],
+      configKey: "mcpServers",
+      buildEntry: ({ serverUrl, apiKey }) => ({
+        type: "http",
+        url: serverUrl,
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+        },
+      }),
+    },
+    detect: {
+      projectPaths: [".mcp.json", ".claude"],
+      globalPaths: [
+        path.join(HOME, ".claude.json"),
+        path.join(HOME, ".claude"),
+      ],
+    },
   },
   opencode: {
-    configType: "json",
-    projectPath: "opencode.json",
-    globalPath: path.join(HOME, ".config", "opencode", "opencode.json"),
-    configKey: "mcp",
-    buildEntry: ({ serverUrl, apiKey }) => ({
-      type: "remote",
-      url: serverUrl,
-      enabled: true,
-      headers: {
-        Authorization: `Bearer ${apiKey}`,
-      },
-    }),
+    name: "opencode",
+    displayName: "OpenCode",
+    mcp: {
+      configType: "json",
+      projectPaths: [
+        "opencode.json",
+        "opencode.jsonc",
+        ".opencode.json",
+        ".opencode.jsonc",
+      ],
+      globalPaths: [
+        path.join(HOME, ".config", "opencode", "opencode.json"),
+        path.join(HOME, ".config", "opencode", "opencode.jsonc"),
+        path.join(HOME, ".config", "opencode", ".opencode.json"),
+        path.join(HOME, ".config", "opencode", ".opencode.jsonc"),
+      ],
+      configKey: "mcp",
+      buildEntry: ({ serverUrl, apiKey }) => ({
+        type: "remote",
+        url: serverUrl,
+        enabled: true,
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+        },
+      }),
+    },
+    detect: {
+      projectPaths: [
+        "opencode.json",
+        "opencode.jsonc",
+        ".opencode.json",
+        ".opencode.jsonc",
+      ],
+      globalPaths: [path.join(HOME, ".config", "opencode")],
+    },
+  },
+  codex: {
+    name: "codex",
+    displayName: "Codex",
+    mcp: {
+      configType: "toml",
+      projectPaths: [path.join(".codex", "config.toml")],
+      globalPaths: [path.join(HOME, ".codex", "config.toml")],
+      configKey: "mcp_servers",
+      buildEntry: ({ serverUrl, apiKey }) => ({
+        type: "http",
+        url: serverUrl,
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+        },
+      }),
+    },
+    detect: {
+      projectPaths: [".codex", path.join(".codex", "config.toml")],
+      globalPaths: [path.join(HOME, ".codex")],
+    },
+  },
+  cursor: {
+    name: "cursor",
+    displayName: "Cursor",
+    mcp: {
+      configType: "json",
+      projectPaths: [path.join(".cursor", "mcp.json")],
+      globalPaths: [path.join(HOME, ".cursor", "mcp.json")],
+      configKey: "mcpServers",
+      buildEntry: ({ serverUrl, apiKey }) => ({
+        url: serverUrl,
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+        },
+      }),
+    },
+    detect: {
+      projectPaths: [".cursor", path.join(".cursor", "mcp.json")],
+      globalPaths: [path.join(HOME, ".cursor")],
+    },
+  },
+  "pi-mono": {
+    name: "pi-mono",
+    displayName: "Pi (pi-mono)",
+    mcp: {
+      configType: "json",
+      projectPaths: [path.join(".pi", "settings.json")],
+      globalPaths: [path.join(HOME, ".pi", "agent", "settings.json")],
+      configKey: ["mcp", "servers"],
+      buildEntry: ({ serverUrl, apiKey }) => ({
+        url: serverUrl,
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+        },
+      }),
+    },
+    detect: {
+      projectPaths: [".pi", path.join(".pi", "settings.json")],
+      globalPaths: [path.join(HOME, ".pi"), path.join(HOME, ".pi", "agent")],
+    },
+  },
+  "hermes-agent": {
+    name: "hermes-agent",
+    displayName: "Hermes Agent",
+    mcp: {
+      configType: "yaml",
+      projectPaths: [path.join(".hermes", "config.yaml")],
+      globalPaths: [path.join(HOME, ".hermes", "config.yaml")],
+      configKey: "mcp_servers",
+      buildEntry: ({ serverUrl, apiKey }) => ({
+        url: serverUrl,
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+        },
+      }),
+    },
+    detect: {
+      projectPaths: [".hermes", path.join(".hermes", "config.yaml")],
+      globalPaths: [path.join(HOME, ".hermes"), path.join(HOME, ".hermes", "config.yaml")],
+    },
+  },
+  openclaw: {
+    name: "openclaw",
+    displayName: "OpenClaw",
+    mcp: {
+      configType: "json",
+      projectPaths: [path.join(".openclaw", "openclaw.json")],
+      globalPaths: [path.join(HOME, ".openclaw", "openclaw.json")],
+      configKey: ["mcp", "servers"],
+      buildEntry: ({ serverUrl, apiKey }) => ({
+        url: serverUrl,
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+        },
+      }),
+    },
+    detect: {
+      projectPaths: [".openclaw", path.join(".openclaw", "openclaw.json")],
+      globalPaths: [
+        path.join(HOME, ".openclaw"),
+        path.join(HOME, ".openclaw", "openclaw.json"),
+      ],
+    },
   },
 };
 
-export function normalizeScope(scope) {
-  if (scope === "global" || scope === "project") return scope;
-  return "global";
+export function getHost(name) {
+  const host = hosts[name];
+  if (!host) {
+    throw new Error(`Unsupported host: ${name}`);
+  }
+  return host;
 }
 
-export function resolveHostConfigPath(host, scope) {
-  const hostConfig = AGENT_CONFIG[host];
-  if (!hostConfig) {
-    throw new Error(`Unsupported host: ${host}`);
+async function pathExists(filePath) {
+  try {
+    await access(filePath);
+    return true;
+  } catch {
+    return false;
   }
-  if (scope === "project") {
-    return path.join(process.cwd(), hostConfig.projectPath);
+}
+
+export async function detectHosts(scope) {
+  const detected = [];
+  for (const hostName of ALL_HOST_NAMES) {
+    const host = getHost(hostName);
+    const candidates =
+      scope === "global" ? host.detect.globalPaths : host.detect.projectPaths;
+    for (const candidate of candidates) {
+      const fullPath =
+        scope === "global" ? candidate : path.join(process.cwd(), candidate);
+      // eslint-disable-next-line no-await-in-loop
+      if (await pathExists(fullPath)) {
+        detected.push(hostName);
+        break;
+      }
+    }
   }
-  return hostConfig.globalPath;
+  return detected;
+}
+
+export function normalizeScope(scope) {
+  if (scope === "global" || scope === "project") return scope;
+  return "global";
 }
 
 export function normalizeHosts(rawHosts) {
   if (!Array.isArray(rawHosts) || rawHosts.length === 0) {
-    return [...HOSTS];
+    return [...ALL_HOST_NAMES];
   }
   const normalized = [];
   for (const host of rawHosts) {
-    const candidate = String(host || "").trim().toLowerCase();
+    const candidate = String(host || "")
+      .trim()
+      .toLowerCase();
     if (!candidate) continue;
-    if (!HOSTS.includes(candidate)) {
+    if (!ALL_HOST_NAMES.includes(candidate)) {
       throw new Error(
-        `Unsupported host '${candidate}'. Supported: ${HOSTS.join(", ")}`,
+        `Unsupported host '${candidate}'. Supported: ${ALL_HOST_NAMES.join(", ")}`,
       );
     }
     if (!normalized.includes(candidate)) {
       normalized.push(candidate);
     }
   }
-  if (normalized.length === 0) {
-    return [...HOSTS];
-  }
-  return normalized;
+  return normalized.length > 0 ? normalized : [...ALL_HOST_NAMES];
 }