cue-ai 0.3.0 → 0.4.0

package/src/lib/agent-adapters.ts

@@ -0,0 +1,302 @@
+/**
+ * Agent adapters — materialize skills + MCPs for any AI coding agent.
+ *
+ * Each adapter knows how to write skills and MCP configs in the format
+ * that a specific agent expects.
+ */
+
+import { writeFileSync, mkdirSync, existsSync, readFileSync, symlinkSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { homedir } from "node:os";
+import { spawnSync } from "node:child_process";
+
+// ---------------------------------------------------------------------------
+// Interface
+// ---------------------------------------------------------------------------
+
+export interface AgentAdapter {
+  /** Agent identifier (used in profile.yaml agents field) */
+  id: string;
+  /** Human-readable name */
+  name: string;
+  /** Where this agent reads its config from */
+  configDir(): string;
+  /** Write skills as the agent's rules/instructions file */
+  writeSkills(skills: { id: string; content: string }[], targetDir: string): void;
+  /** Write MCP server configs in the agent's format */
+  writeMcps(mcps: Record<string, unknown>, targetDir: string): void;
+  /** Try to find the agent binary on PATH */
+  detectBinary(): string | null;
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function findBinary(name: string): string | null {
+  const res = spawnSync("which", [name], { encoding: "utf8" });
+  return res.status === 0 ? res.stdout.trim() : null;
+}
+
+function concatSkills(skills: { id: string; content: string }[]): string {
+  return skills.map(s => `<!-- skill: ${s.id} -->\n${s.content}`).join("\n\n---\n\n");
+}
+
+// ---------------------------------------------------------------------------
+// Claude Code adapter (existing behavior)
+// ---------------------------------------------------------------------------
+
+export const claudeCode: AgentAdapter = {
+  id: "claude-code",
+  name: "Claude Code",
+  configDir: () => process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".claude"),
+  writeSkills(skills, targetDir) {
+    const skillsDir = join(targetDir, "skills");
+    mkdirSync(skillsDir, { recursive: true });
+    // Skills are symlinked individually (handled by materializer)
+  },
+  writeMcps(mcps, targetDir) {
+    const settingsPath = join(targetDir, "settings.json");
+    let settings: Record<string, unknown> = {};
+    if (existsSync(settingsPath)) {
+      try { settings = JSON.parse(readFileSync(settingsPath, "utf8")); } catch {}
+    }
+    settings.mcpServers = { ...(settings.mcpServers as Record<string, unknown> ?? {}), ...mcps };
+    writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+  },
+  detectBinary: () => findBinary("claude"),
+};
+
+// ---------------------------------------------------------------------------
+// Codex adapter (existing behavior)
+// ---------------------------------------------------------------------------
+
+export const codex: AgentAdapter = {
+  id: "codex",
+  name: "Codex",
+  configDir: () => process.env.CODEX_HOME ?? join(homedir(), ".codex"),
+  writeSkills(skills, targetDir) {
+    const skillsDir = join(targetDir, "skills");
+    mkdirSync(skillsDir, { recursive: true });
+  },
+  writeMcps(mcps, targetDir) {
+    // Codex uses config.toml
+    const lines: string[] = [];
+    for (const [id, val] of Object.entries(mcps)) {
+      lines.push(`[mcp_servers.${id}]`);
+      for (const [k, v] of Object.entries(val as Record<string, unknown>)) {
+        lines.push(`${k} = ${JSON.stringify(v)}`);
+      }
+      lines.push("");
+    }
+    writeFileSync(join(targetDir, "config.toml"), lines.join("\n"));
+  },
+  detectBinary: () => findBinary("codex"),
+};
+
+// ---------------------------------------------------------------------------
+// Cursor adapter
+// ---------------------------------------------------------------------------
+
+export const cursor: AgentAdapter = {
+  id: "cursor",
+  name: "Cursor",
+  configDir: () => process.cwd(), // project-local
+  writeSkills(skills, targetDir) {
+    // Cursor reads .cursorrules in project root
+    const content = concatSkills(skills);
+    writeFileSync(join(targetDir, ".cursorrules"), content);
+  },
+  writeMcps(mcps, targetDir) {
+    // Cursor reads .cursor/mcp.json
+    const cursorDir = join(targetDir, ".cursor");
+    mkdirSync(cursorDir, { recursive: true });
+    writeFileSync(join(cursorDir, "mcp.json"), JSON.stringify({ mcpServers: mcps }, null, 2));
+  },
+  detectBinary: () => findBinary("cursor"),
+};
+
+// ---------------------------------------------------------------------------
+// Cline adapter
+// ---------------------------------------------------------------------------
+
+export const cline: AgentAdapter = {
+  id: "cline",
+  name: "Cline",
+  configDir: () => process.cwd(),
+  writeSkills(skills, targetDir) {
+    // Cline reads .clinerules in project root
+    const content = concatSkills(skills);
+    writeFileSync(join(targetDir, ".clinerules"), content);
+  },
+  writeMcps(mcps, targetDir) {
+    // Cline reads cline_mcp_settings.json in project root
+    writeFileSync(join(targetDir, "cline_mcp_settings.json"), JSON.stringify({ mcpServers: mcps }, null, 2));
+  },
+  detectBinary: () => null, // VS Code extension, no binary
+};
+
+// ---------------------------------------------------------------------------
+// Windsurf adapter
+// ---------------------------------------------------------------------------
+
+export const windsurf: AgentAdapter = {
+  id: "windsurf",
+  name: "Windsurf",
+  configDir: () => process.cwd(),
+  writeSkills(skills, targetDir) {
+    const content = concatSkills(skills);
+    writeFileSync(join(targetDir, ".windsurfrules"), content);
+  },
+  writeMcps(mcps, targetDir) {
+    // Windsurf uses same format as Cursor
+    const dir = join(targetDir, ".windsurf");
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, "mcp.json"), JSON.stringify({ mcpServers: mcps }, null, 2));
+  },
+  detectBinary: () => findBinary("windsurf"),
+};
+
+// ---------------------------------------------------------------------------
+// Gemini CLI adapter
+// ---------------------------------------------------------------------------
+
+export const gemini: AgentAdapter = {
+  id: "gemini",
+  name: "Gemini CLI",
+  configDir: () => join(homedir(), ".gemini"),
+  writeSkills(skills, targetDir) {
+    // Gemini reads skills from ~/.gemini/skills/ as individual files
+    const skillsDir = join(targetDir, "skills");
+    mkdirSync(skillsDir, { recursive: true });
+    for (const s of skills) {
+      const slug = s.id.split("/").pop() ?? s.id;
+      writeFileSync(join(skillsDir, `${slug}.md`), s.content);
+    }
+  },
+  writeMcps(mcps, targetDir) {
+    // Gemini uses settings.json with mcpServers
+    const settingsPath = join(targetDir, "settings.json");
+    let settings: Record<string, unknown> = {};
+    if (existsSync(settingsPath)) {
+      try { settings = JSON.parse(readFileSync(settingsPath, "utf8")); } catch {}
+    }
+    settings.mcpServers = mcps;
+    writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+  },
+  detectBinary: () => findBinary("gemini"),
+};
+
+// ---------------------------------------------------------------------------
+// GitHub Copilot adapter
+// ---------------------------------------------------------------------------
+
+export const copilot: AgentAdapter = {
+  id: "copilot",
+  name: "GitHub Copilot",
+  configDir: () => process.cwd(),
+  writeSkills(skills, targetDir) {
+    // Copilot reads .github/copilot-instructions.md
+    const ghDir = join(targetDir, ".github");
+    mkdirSync(ghDir, { recursive: true });
+    const content = concatSkills(skills);
+    writeFileSync(join(ghDir, "copilot-instructions.md"), content);
+  },
+  writeMcps(mcps, targetDir) {
+    // Copilot uses .vscode/mcp.json or .github/mcp.json
+    const ghDir = join(targetDir, ".github");
+    mkdirSync(ghDir, { recursive: true });
+    writeFileSync(join(ghDir, "mcp.json"), JSON.stringify({ servers: mcps }, null, 2));
+  },
+  detectBinary: () => null, // VS Code extension
+};
+
+// ---------------------------------------------------------------------------
+// Roo Code adapter
+// ---------------------------------------------------------------------------
+
+export const roo: AgentAdapter = {
+  id: "roo",
+  name: "Roo Code",
+  configDir: () => process.cwd(),
+  writeSkills(skills, targetDir) {
+    // Roo reads .roo/rules/
+    const rulesDir = join(targetDir, ".roo", "rules");
+    mkdirSync(rulesDir, { recursive: true });
+    for (const s of skills) {
+      const slug = s.id.split("/").pop() ?? s.id;
+      writeFileSync(join(rulesDir, `${slug}.md`), s.content);
+    }
+  },
+  writeMcps(mcps, targetDir) {
+    // Roo uses .roo/mcp.json
+    const rooDir = join(targetDir, ".roo");
+    mkdirSync(rooDir, { recursive: true });
+    writeFileSync(join(rooDir, "mcp.json"), JSON.stringify({ mcpServers: mcps }, null, 2));
+  },
+  detectBinary: () => null, // VS Code extension
+};
+
+// ---------------------------------------------------------------------------
+// Amp adapter
+// ---------------------------------------------------------------------------
+
+export const amp: AgentAdapter = {
+  id: "amp",
+  name: "Amp",
+  configDir: () => process.cwd(),
+  writeSkills(skills, targetDir) {
+    // Amp reads AGENTS.md in project root
+    const content = concatSkills(skills);
+    writeFileSync(join(targetDir, "AGENTS.md"), content);
+  },
+  writeMcps(mcps, targetDir) {
+    // Amp uses .amp/mcp.json
+    const ampDir = join(targetDir, ".amp");
+    mkdirSync(ampDir, { recursive: true });
+    writeFileSync(join(ampDir, "mcp.json"), JSON.stringify({ mcpServers: mcps }, null, 2));
+  },
+  detectBinary: () => findBinary("amp"),
+};
+
+// ---------------------------------------------------------------------------
+// Aider adapter
+// ---------------------------------------------------------------------------
+
+export const aider: AgentAdapter = {
+  id: "aider",
+  name: "Aider",
+  configDir: () => process.cwd(),
+  writeSkills(skills, targetDir) {
+    // Aider reads .aider.conf.yml conventions
+    const content = concatSkills(skills);
+    writeFileSync(join(targetDir, ".aider.conventions.md"), content);
+  },
+  writeMcps(_mcps, _targetDir) {
+    // Aider doesn't support MCP
+  },
+  detectBinary: () => findBinary("aider"),
+};
+
+// ---------------------------------------------------------------------------
+// Registry
+// ---------------------------------------------------------------------------
+
+export const ADAPTERS: Record<string, AgentAdapter> = {
+  "claude-code": claudeCode,
+  "codex": codex,
+  "cursor": cursor,
+  "cline": cline,
+  "windsurf": windsurf,
+  "gemini": gemini,
+  "copilot": copilot,
+  "roo": roo,
+  "amp": amp,
+  "aider": aider,
+};
+
+export const AGENT_IDS = Object.keys(ADAPTERS);
+
+export function getAdapter(id: string): AgentAdapter | null {
+  return ADAPTERS[id] ?? null;
+}

package/src/lib/kitty-image.ts

@@ -339,22 +339,25 @@ export function probeKittyTerminal(timeoutMs = 100): Promise<boolean> {
  * Use this from the launch hot path; `isKittyTerminal()` is the env-only
  * sync version kept around for callers that can't await.
  *
- * The probe is the only reliable signal — env vars like KITTY_WINDOW_ID can
- * leak into non-Kitty terminals (e.g. GNOME Terminal launched from a Kitty
- * session). When the probe is available (TTY), we always use it.
+ * Trust strong env signals (KITTY_WINDOW_ID, TERM=xterm-kitty) directly —
+ * these are set by Kitty itself and reliable. Only probe when signals are
+ * ambiguous (e.g. inside tmux with no Kitty env vars).
  */
 export async function detectKittyTerminal(timeoutMs = 100): Promise<boolean> {
   if (process.env.CUE_DISABLE_KITTY_IMAGES === "1") return false;
+  if (process.env.CUE_KITTY === "1") return true;
+
+  // Strong signals — trust directly (Kitty sets these for child processes)
+  if (process.env.TERM === "xterm-kitty") return true;
+  if (process.env.KITTY_WINDOW_ID) return true;
+  if (process.env.KITTY_PID) return true;
 
-  // If we can probe (TTY), always probe — it's the only reliable signal.
-  // Env vars like KITTY_WINDOW_ID leak through tmux/child terminals.
+  // Weak/ambiguous — probe the terminal
   if (process.stdout.isTTY && process.stdin.isTTY) {
     return probeKittyTerminal(timeoutMs);
   }
 
-  // Non-TTY fallback: trust env hints
-  if (process.env.CUE_KITTY === "1") return true;
-  if (process.env.TERM === "xterm-kitty") return true;
-  if (process.env.KITTY_WINDOW_ID) return true;
+  // Non-TTY fallback
+  if (process.env.TERM_PROGRAM === "kitty") return true;
   return false;
 }

package/src/lib/runtime-materializer.ts

@@ -195,6 +195,19 @@ export async function materializeRuntime(input: MaterializeInput): Promise<Mater
   }
 
   // 6. Atomic swap: rm -rf old, rename tmp.
+  // Preserve .claude.json and backups/ — Claude Code writes session state here
+  // and resume depends on it surviving across rematerializations.
+  const preserveFiles = [".claude.json", "backups"];
+  for (const name of preserveFiles) {
+    const oldPath = join(runtimeDir, name);
+    const newPath = join(tmpDir, name);
+    try {
+      const st = await lstat(oldPath);
+      if (st.isFile() || st.isDirectory()) {
+        await rename(oldPath, newPath);
+      }
+    } catch { /* doesn't exist — skip */ }
+  }
   await rm(runtimeDir, { recursive: true, force: true });
   await rename(tmpDir, runtimeDir);
 
@@ -255,9 +268,20 @@ async function overlaySourceState(targetDir: string, sourceDir: string): Promise
         await rm(targetPath, { force: true });
       } catch { continue; }
     }
-    try {
-      await symlink(sourcePath, targetPath);
-    } catch { /* race or permission — skip silently */ }
+
+    // .credentials.json must be COPIED (not symlinked) because Claude Code
+    // refreshes tokens via atomic write (write tmp → rename), which replaces
+    // symlinks with regular files, leaving the source stale.
+    if (name === ".credentials.json") {
+      const { copyFile } = await import("node:fs/promises");
+      try {
+        await copyFile(sourcePath, targetPath);
+      } catch { /* skip */ }
+    } else {
+      try {
+        await symlink(sourcePath, targetPath);
+      } catch { /* race or permission — skip silently */ }
+    }
   }
 }
 

package/bin/medusa-dev

@@ -1,240 +0,0 @@
-#!/usr/bin/env bash
-# medusa-dev — run multiple Medusa shops side-by-side without port collisions.
-#
-# Reads ~/Documents/medusa-shops/.dev-ports.yaml as the source of truth.
-# Each shop gets a deterministic backend port + storefront port from that file.
-#
-# Usage:
-#   medusa-dev list                     # show registry + which ports are live now
-#   medusa-dev start <shop> [back|front|both]   # default: both
-#   medusa-dev stop  <shop> [back|front|both]
-#   medusa-dev tail  <shop> [back|front]        # tail the log
-#   medusa-dev status                   # what's running across all shops
-#   medusa-dev cors-fix <shop>          # set STORE_CORS/AUTH_CORS to a regex
-#                                       # that allows any http://localhost:PORT
-#
-# Logs go to ~/.cache/medusa-dev/<shop>.<back|front>.log
-# Pidfiles to ~/.cache/medusa-dev/<shop>.<back|front>.pid
-
-set -euo pipefail
-
-REGISTRY="${MEDUSA_DEV_REGISTRY:-$HOME/Documents/medusa-shops/.dev-ports.yaml}"
-WORKSPACE="${MEDUSA_DEV_WORKSPACE:-$HOME/Documents}"
-CACHE="$HOME/.cache/medusa-dev"
-mkdir -p "$CACHE"
-
-err()  { printf '\033[31m%s\033[0m\n' "$*" >&2; }
-info() { printf '\033[36m%s\033[0m\n' "$*" >&2; }
-ok()   { printf '\033[32m%s\033[0m\n' "$*" >&2; }
-
-# Parse the YAML using inline python3 (always available on the user's machine).
-# Returns a TSV: shop<TAB>path<TAB>backend_port<TAB>storefront_port<TAB>framework<TAB>notes
-registry_tsv() {
-  python3 - "$REGISTRY" <<'PY'
-import sys, re
-path = sys.argv[1]
-with open(path) as f: txt = f.read()
-
-# Tiny YAML walker — no PyYAML dependency. Handles the flat 2-level shape
-# only: `shops:` then `<name>:` with indented `key: value` children.
-out, cur = [], None
-def flush():
-    if cur is not None:
-        out.append((cur["name"], cur.get("path",""), cur.get("backend",""),
-                    cur.get("storefront",""), cur.get("framework",""),
-                    cur.get("notes","").strip('"')))
-for raw in txt.splitlines():
-    line = raw.rstrip()
-    if not line.strip() or line.lstrip().startswith("#"): continue
-    if line == "shops:": continue
-    if re.match(r"^  [A-Za-z0-9_.-]+:\s*$", line):
-        flush()
-        cur = {"name": line.strip().rstrip(":")}
-    elif cur is not None and re.match(r"^    [a-z_]+:", line):
-        k,_,v = line.strip().partition(":")
-        cur[k.strip()] = v.strip()
-flush()
-for row in out:
-    print("\t".join(str(c) for c in row))
-PY
-}
-
-# Look up a single shop. Echoes a TSV line, or returns nonzero if not found.
-shop_row() {
-  local name="$1"
-  registry_tsv | awk -F'\t' -v n="$name" '$1==n {print; found=1} END{exit !found}'
-}
-
-# Process status — is the pidfile alive?
-is_alive() {
-  local pidfile="$1"
-  [[ -f "$pidfile" ]] || return 1
-  local pid; pid="$(cat "$pidfile" 2>/dev/null || true)"
-  [[ -n "$pid" ]] && kill -0 "$pid" 2>/dev/null
-}
-
-# Is a port currently held by *any* process?
-port_held() {
-  ss -lntH "sport = :$1" 2>/dev/null | grep -q LISTEN
-}
-
-cmd_list() {
-  printf "%-16s %-7s %-7s %-7s %-7s %s\n" SHOP BACKEND STATE FRONT STATE PATH
-  while IFS=$'\t' read -r name path back front fw notes; do
-    [[ -z "${name:-}" ]] && continue
-    local bstate fstate
-    if is_alive "$CACHE/$name.back.pid"; then bstate="up"
-    elif port_held "$back"; then bstate="busy"
-    else bstate="-"; fi
-    if is_alive "$CACHE/$name.front.pid"; then fstate="up"
-    elif port_held "$front"; then fstate="busy"
-    else fstate="-"; fi
-    printf "%-16s %-7s %-7s %-7s %-7s %s\n" "$name" "$back" "$bstate" "$front" "$fstate" "$path"
-  done < <(registry_tsv)
-}
-
-cmd_status() { cmd_list; }
-
-# Start one role of one shop.
-start_one() {
-  local shop="$1" role="$2" path="$3" port="$4"
-  local cwd="$WORKSPACE/$path"
-  local pidfile="$CACHE/$shop.$role.pid"
-  local logfile="$CACHE/$shop.$role.log"
-
-  if is_alive "$pidfile"; then
-    info "$shop.$role already running (pid $(cat "$pidfile"))."
-    return 0
-  fi
-  if port_held "$port"; then
-    local owner
-    owner=$(ss -lntpH "sport = :$port" 2>/dev/null | awk -F'"' '{print $2}' | head -1)
-    err "Port $port already in use by '$owner' — won't collide. Stop it or change the registry."
-    return 1
-  fi
-  if [[ ! -d "$cwd" ]]; then
-    err "Path missing: $cwd"
-    return 1
-  fi
-
-  local script
-  case "$role" in
-    back)  script="--filter backend dev" ;;
-    front) script="--filter storefront dev" ;;
-    *) err "unknown role: $role"; return 1 ;;
-  esac
-
-  info "Starting $shop.$role on port $port → $cwd"
-  ( cd "$cwd" && PORT="$port" nohup pnpm $script > "$logfile" 2>&1 & echo $! > "$pidfile" )
-  ok "$shop.$role started (pid $(cat "$pidfile"), log: $logfile)"
-}
-
-cmd_start() {
-  local shop="${1:?shop name required}" which="${2:-both}"
-  local row; row="$(shop_row "$shop")" || { err "unknown shop: $shop"; exit 1; }
-  IFS=$'\t' read -r name path back front _fw _notes <<<"$row"
-  case "$which" in
-    back)  start_one "$shop" back  "$path" "$back"  ;;
-    front) start_one "$shop" front "$path" "$front" ;;
-    both)  start_one "$shop" back  "$path" "$back" || true
-           start_one "$shop" front "$path" "$front" || true ;;
-    *) err "expected back|front|both, got: $which"; exit 1 ;;
-  esac
-}
-
-stop_one() {
-  local shop="$1" role="$2"
-  local pidfile="$CACHE/$shop.$role.pid"
-  if is_alive "$pidfile"; then
-    local pid; pid="$(cat "$pidfile")"
-    info "Stopping $shop.$role (pid $pid)"
-    kill "$pid" 2>/dev/null || true
-    # Give it 5s for graceful, then SIGKILL the whole process group.
-    for _ in 1 2 3 4 5; do kill -0 "$pid" 2>/dev/null || break; sleep 1; done
-    if kill -0 "$pid" 2>/dev/null; then
-      kill -9 -- "-$pid" 2>/dev/null || kill -9 "$pid" 2>/dev/null || true
-    fi
-    rm -f "$pidfile"
-    ok "$shop.$role stopped"
-  else
-    info "$shop.$role not running"
-    rm -f "$pidfile" 2>/dev/null || true
-  fi
-}
-
-cmd_stop() {
-  local shop="${1:?shop name required}" which="${2:-both}"
-  shop_row "$shop" >/dev/null || { err "unknown shop: $shop"; exit 1; }
-  case "$which" in
-    back)  stop_one "$shop" back  ;;
-    front) stop_one "$shop" front ;;
-    both)  stop_one "$shop" back; stop_one "$shop" front ;;
-    *) err "expected back|front|both, got: $which"; exit 1 ;;
-  esac
-}
-
-cmd_tail() {
-  local shop="${1:?shop name required}" role="${2:-back}"
-  local logfile="$CACHE/$shop.$role.log"
-  [[ -f "$logfile" ]] || { err "no log at $logfile"; exit 1; }
-  exec tail -f "$logfile"
-}
-
-# Loosen CORS in a shop's backend .env so any localhost port is accepted.
-cmd_cors_fix() {
-  local shop="${1:?shop name required}"
-  local row; row="$(shop_row "$shop")" || { err "unknown shop: $shop"; exit 1; }
-  IFS=$'\t' read -r name path _back _front _fw _notes <<<"$row"
-  local envfile="$WORKSPACE/$path/apps/backend/.env"
-  [[ -f "$envfile" ]] || { err "no backend .env at $envfile"; exit 1; }
-  cp "$envfile" "$envfile.bak.$(date +%s)"
-  python3 - "$envfile" <<'PY'
-import sys, re
-p = sys.argv[1]
-regex = "^http://localhost:\\d+$"
-with open(p) as f: lines = f.readlines()
-keys = ("STORE_CORS","AUTH_CORS","ADMIN_CORS")
-seen = {k: False for k in keys}
-out = []
-for ln in lines:
-    m = re.match(r"^(STORE_CORS|AUTH_CORS|ADMIN_CORS)=", ln)
-    if m:
-        out.append(f"{m.group(1)}={regex}\n")
-        seen[m.group(1)] = True
-    else:
-        out.append(ln)
-for k, ok in seen.items():
-    if not ok:
-        out.append(f"{k}={regex}\n")
-with open(p, "w") as f: f.writelines(out)
-print("Updated:", ", ".join(seen.keys()))
-PY
-  ok "Backup saved alongside $envfile.bak.<ts>"
-}
-
-usage() {
-  cat <<EOF
-medusa-dev — run multiple Medusa shops side-by-side on stable per-shop ports.
-
-  medusa-dev list                            # show registry + live state
-  medusa-dev status                          # alias for list
-  medusa-dev start <shop> [back|front|both]
-  medusa-dev stop  <shop> [back|front|both]
-  medusa-dev tail  <shop> [back|front]
-  medusa-dev cors-fix <shop>                 # set CORS keys to localhost regex
-
-Registry: $REGISTRY
-Cache:    $CACHE
-EOF
-}
-
-case "${1:-list}" in
-  list|ls)        shift; cmd_list "$@" ;;
-  status)         shift; cmd_status "$@" ;;
-  start|up)       shift; cmd_start "$@" ;;
-  stop|down|kill) shift; cmd_stop "$@" ;;
-  tail|log|logs)  shift; cmd_tail "$@" ;;
-  cors-fix)       shift; cmd_cors_fix "$@" ;;
-  -h|--help|help) usage ;;
-  *) err "unknown command: $1"; usage; exit 1 ;;
-esac

package/bin/soul

@@ -1,4 +0,0 @@
-#!/usr/bin/env bash
-# DEPRECATED — renamed to "cue". This shim forwards all invocations.
-echo "soul: renamed to 'cue'. Update your PATH/alias." >&2
-exec "$(dirname "$0")/cue" "$@"