@boole-digital/cli 0.1.0 → 0.2.0

package/dist/index.js

@@ -317,8 +317,8 @@ var BooleApi = class {
   // ---- droplets ----------------------------------------------------------
   async listDroplets() {
     const body = await this.request("/api/v1/droplets");
-    const list2 = unwrap(body);
-    return Array.isArray(list2) ? list2 : [];
+    const list = unwrap(body);
+    return Array.isArray(list) ? list : [];
   }
   async getDroplet(id) {
     const body = await this.request(`/api/v1/droplets/${id}`);
@@ -372,6 +372,47 @@ function onboardingNotice() {
   log(`  Deploy your first trading computer there, then come back and run ${c.cyan("boole connect")}.`);
   log("");
 }
+function orient() {
+  const creds = loadCredentials();
+  const sess = loadSession();
+  log("");
+  log(`${c.bold("boole")} \u2014 operate your Boole trading computer from the terminal.`);
+  log("");
+  log(c.bold("How it works"));
+  log("  This CLI is a thin shell; your trading box is the brain. The flow is:");
+  log(`  ${c.cyan("log in")} \u2192 ${c.cyan("connect")} \u2192 ${c.cyan("SSH into the box")} \u2192 ${c.cyan("read its operator guide")} \u2192 ${c.cyan("operate in PLAIN ENGLISH")}.`);
+  log(`  You take the user's request (${c.dim('"buy $100 of BTC"')}) and carry it out on the box through`);
+  log("  its harness, which executes and tracks it on the dashboard. The CLI has no trade commands.");
+  log("");
+  if (!creds) {
+    log(`${c.bold("You are:")} ${c.yellow("not logged in")}.`);
+    log(`${c.bold("Do this next:")}  ${c.cyan("boole login")}`);
+  } else if (!sess) {
+    log(`${c.bold("You are:")} logged in as ${c.bold(creds.user.email || creds.user.id)}, ${c.yellow("no box connected")}.`);
+    log(`${c.bold("Do this next:")}  ${c.cyan("boole connect")}   ${c.dim(`# no trading computer yet? finish onboarding at ${API_BASE}`)}`);
+  } else {
+    log(`${c.bold("You are:")} connected to ${c.bold(sess.agent || sess.ip)} ${c.green("\u2014 ready")}.`);
+    log(c.bold("Do this next:"));
+    log(`  1. ${c.cyan("boole init")}                            ${c.dim("# write the agent rules into this folder (CLAUDE/AGENTS/GEMINI)")}`);
+    log(`  2. ${c.cyan('boole ssh "cat /srv/cust/OPERATOR.md"')}  ${c.dim("# the authoritative guide \u2014 READ IT, then follow it")}`);
+    log(`  3. Operate in plain English. Inspect: ${c.cyan("boole status")} \xB7 ${c.cyan("boole logs <name>")} \xB7 ${c.cyan('boole ssh "pm2 ls"')}`);
+  }
+  log("");
+  log(c.dim("Full command reference: boole help"));
+  log("");
+}
+function operatingBrief() {
+  log("");
+  log(c.bold("How to operate this computer"));
+  log(`  Your coding agent drives the box. Open this folder in ${c.bold("Claude Code")}, ${c.bold("Codex")}, or ${c.bold("Gemini")}`);
+  log(`  (run ${c.cyan("boole init")} here first), then just say what you want \u2014 e.g. ${c.dim('"buy $100 of BTC"')}.`);
+  log("");
+  log(`  The authoritative operating guide lives on the box:`);
+  log(`    ${c.cyan('boole ssh "cat /srv/cust/OPERATOR.md"')}`);
+  log(`  The agent SSHes in, reads it, and drives the on-box harness (which tracks everything on your dashboard).`);
+  log(`  ${c.dim("The CLI has no trade commands \u2014 trading happens on the box, through the harness.")}`);
+  log("");
+}
 function printAgents(droplets) {
   if (!droplets.length) {
     onboardingNotice();
@@ -414,13 +455,27 @@ async function summary() {
   ok(`Logged in as ${c.bold(creds.user.email || creds.user.id)}${creds.user.role ? c.dim(` \xB7 ${creds.user.role}`) : ""}`);
   const api = new BooleApi();
   let droplets = [];
+  let listErr = "";
   try {
     droplets = await api.listDroplets();
   } catch (e) {
-    warn(`Could not list trading computers: ${e.message}`);
-    return;
+    listErr = e?.message || String(e);
   }
   if (!droplets.length) {
+    const sess = loadSession();
+    if (sess?.ip) {
+      log("");
+      ok(`Connected to ${c.bold(sess.agent || sess.ip)} ${c.dim(`(${sess.ip})`)} ${c.dim("\xB7 cached session")}`);
+      if (listErr) log(c.dim(`  (couldn't reach the account API: ${listErr})`));
+      else log(c.dim(`  This account has no computer on file, but \`boole ssh\` + \`boole strategy \u2026\` work against the connected box.`));
+      log(c.dim(`  If you expected a computer here, you may be logged in as a different account than the one that owns it.`));
+      operatingBrief();
+      return;
+    }
+    if (listErr) {
+      warn(`Could not list trading computers: ${listErr}`);
+      return;
+    }
     onboardingNotice();
     return;
   }
@@ -428,17 +483,18 @@ async function summary() {
   log(c.bold(`Trading computers (${droplets.length})`));
   printAgents(droplets);
   const pick = pickAgentId(droplets);
-  if (!pick) return;
-  log("");
-  log(c.bold(`Snapshot \u2014 ${pick.name}`));
-  try {
-    const health = await api.getHealth(pick.id);
-    ok(`online${health.defaultModel ? c.dim(` \xB7 model ${health.defaultModel}`) : ""}`);
-  } catch {
-    warn("trading computer unreachable (tunnel may be waking up \u2014 retry in a moment)");
-    return;
+  if (pick) {
+    log("");
+    log(c.bold(`Snapshot \u2014 ${pick.name}`));
+    try {
+      const health = await api.getHealth(pick.id);
+      ok(`online${health.defaultModel ? c.dim(` \xB7 model ${health.defaultModel}`) : ""}`);
+      await printBalances(api, pick.id, "hyperliquid");
+    } catch {
+      warn("trading computer unreachable (tunnel may be waking up \u2014 retry in a moment)");
+    }
   }
-  await printBalances(api, pick.id, "hyperliquid");
+  operatingBrief();
 }
 async function printBalances(api, id, exchange) {
   try {
@@ -563,28 +619,6 @@ function open(s) {
     });
   });
 }
-async function runRemote(command) {
-  const s = requireSession();
-  const conn = await open(s);
-  try {
-    return await new Promise((resolve2, reject) => {
-      conn.exec(command, (err2, stream) => {
-        if (err2) return reject(new Error(friendly(err2)));
-        let stdout = "";
-        let stderr = "";
-        stream.on("close", (code) => resolve2({ code: code ?? 0, stdout, stderr }));
-        stream.on("data", (d) => {
-          stdout += d.toString();
-        });
-        stream.stderr.on("data", (d) => {
-          stderr += d.toString();
-        });
-      });
-    });
-  } finally {
-    conn.end();
-  }
-}
 async function runRemoteInherit(command) {
   const s = requireSession();
   const conn = await open(s);
@@ -602,196 +636,44 @@ async function runRemoteInherit(command) {
   }
 }
 
-// src/strategy.ts
-var NAME_RE = /^[a-z0-9][a-z0-9_-]{0,48}$/;
-var GATE = "http://localhost:3000";
-function paramLiteral(raw) {
-  const t = raw.trim();
-  if (/^-?\d+(\.\d+)?$/.test(t)) return t;
-  if (t === "true" || t === "false") return t;
-  if (t.startsWith("[") || t.startsWith("{")) return t;
-  return `'${raw.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
-}
-function parseParams(pairs) {
-  const out = {};
-  for (const p of pairs) {
-    const i = p.indexOf("=");
-    if (i < 0) die(`Bad --param "${p}" (expected KEY=VALUE).`);
-    const key = p.slice(0, i).trim();
-    if (!/^[A-Z][A-Z0-9_]*$/.test(key)) die(`Bad param key "${key}" (UPPER_SNAKE_CASE).`);
-    out[key] = paramLiteral(p.slice(i + 1));
-  }
-  return out;
-}
-async function strategySpawn(opts) {
-  const template = opts.template;
-  const name = opts.name;
-  if (!template || !name) {
-    die("Usage: boole strategy spawn --template <template.js> --name <name> [--param KEY=VALUE]...");
-  }
-  if (!template.endsWith("_template.js")) die("--template must be a gateway template ending in _template.js (e.g. order_template.js, grid_template.js, loop_template.js).");
-  if (!NAME_RE.test(name)) die(`Invalid --name "${name}". Use lowercase letters, digits, "-" or "_" (max 49 chars).`);
-  const payload = {
-    templateFile: template,
-    name,
-    params: parseParams(opts.params || []),
-    autoStart: opts.autostart !== false
-  };
-  info(`Spawning ${c.bold(name)} from ${c.bold(template)} through the gateway\u2026`);
-  const b64 = Buffer.from(JSON.stringify(payload), "utf8").toString("base64");
-  const cmd = `printf %s '${b64}' | base64 -d | curl -s --max-time 60 -XPOST ${GATE}/api/strategy/spawn -H 'content-type: application/json' -d @-`;
-  const r = await runRemote(cmd);
-  let res = null;
-  try {
-    res = JSON.parse(r.stdout.trim());
-  } catch {
-  }
-  if (!res) {
-    err("The gateway did not return a valid response.");
-    if (r.stdout.trim()) log(c.dim(`  ${r.stdout.trim().slice(0, 400)}`));
-    if (r.stderr.trim()) log(c.dim(`  ${r.stderr.trim().slice(0, 200)}`));
-    process.exit(1);
-  }
-  if (res.error || res.ok === false) {
-    err(`Spawn rejected: ${res.error || "unknown error"}`);
-    if (res.suggested_name) log(c.dim(`  Try --name ${res.suggested_name}`));
-    process.exit(1);
-  }
-  ok(`Spawned ${c.bold(name)}${res.runId ? c.dim(` \xB7 run ${res.runId}`) : ""} \u2014 it will appear on your dashboard.`);
-  const dropped = Array.isArray(res.skipped) ? res.skipped.filter((k) => k !== "RUN_ID") : [];
-  if (dropped.length) warn(`Ignored param(s) with no matching template field: ${dropped.join(", ")} \u2014 check the template's required params.`);
-  if (typeof res.placed === "number" || typeof res.total === "number") {
-    info(`Orders placed: ${res.placed ?? 0}/${res.total ?? 0}${res.failed ? c.yellow(` \xB7 ${res.failed} failed`) : ""}`);
-  }
-  if (res.firstError) warn(`First error: ${res.firstError}`);
-}
-async function strategyList() {
-  const r = await runRemote("pm2 jlist 2>/dev/null");
-  let procs = [];
-  try {
-    procs = JSON.parse(r.stdout.trim());
-  } catch {
-  }
-  if (!Array.isArray(procs)) {
-    warn("Could not read process list from the box.");
-    return;
-  }
-  if (!procs.length) {
-    info("No strategies running.");
-    return;
-  }
-  log(c.bold("Strategies"));
-  for (const p of procs) {
-    const st = p.pm2_env?.status || "?";
-    const dot = st === "online" ? c.green("\u25CF") : c.dim("\u25CB");
-    const up = p.pm2_env?.pm_uptime && st === "online" ? c.dim(` \xB7 up ${Math.max(0, Math.round((Date.now() - p.pm2_env.pm_uptime) / 6e4))}m`) : "";
-    const restarts = p.pm2_env?.restart_time ? c.dim(` \xB7 \u21BA${p.pm2_env.restart_time}`) : "";
-    log(`  ${dot} ${c.bold(p.name)}  ${st === "online" ? c.green(st) : c.yellow(st)}${up}${restarts}`);
-  }
-}
-async function strategyDoctor(name) {
-  const health = await runRemote(`curl -sf --max-time 15 ${GATE}/health`);
-  if (health.code !== 0) {
-    err("Gateway is not responding on the box.");
-    return;
-  }
-  ok("Gateway healthy.");
-  if (!name) return;
-  if (!NAME_RE.test(name)) die(`Invalid name "${name}".`);
-  const r = await runRemote("pm2 jlist 2>/dev/null");
-  let procs = [];
-  try {
-    procs = JSON.parse(r.stdout.trim());
-  } catch {
-  }
-  const p = procs.find((x) => x.name === name);
-  if (!p) {
-    warn(`No process named "${name}" \u2014 spawn it with \`boole strategy spawn\`.`);
-    return;
-  }
-  if (p.pm2_env?.status === "online") ok(`${c.bold(name)} is online and tracked \u2014 it will show on the dashboard.`);
-  else {
-    warn(`${c.bold(name)} is ${p.pm2_env?.status || "not online"} \u2014 check \`boole logs ${name}\`.`);
-  }
-}
-
 // src/rules.ts
 import { writeFileSync as writeFileSync2, existsSync as existsSync3, mkdirSync as mkdirSync2 } from "node:fs";
 import { join as join2, resolve } from "node:path";
-var OPERATING_RULES = `# Boole Trading Computer \u2014 Operating Rules (READ FIRST, IN FULL)
-
-You operate a customer's **live** crypto trading computer through the \`boole\` CLI.
-**Real money is at risk.** These are STRICT, NON-NEGOTIABLE rules.
-
-> Why they matter: Boole tracks and controls every strategy by HOW it was created.
-> If you create one any other way \u2014 writing files over SSH, starting processes
-> yourself \u2014 it **silently fails**: it won't register, won't appear on the
-> dashboard, can't be controlled, and may mismanage live positions. There is no
-> error message. When in doubt, STOP and ask the user.
-
-## Boot sequence \u2014 every session, before anything else
-1. \`boole status\` \u2014 confirm you are logged in and a trading computer is connected.
-   If not, STOP and tell the user to run \`boole login\` then \`boole connect\`.
-2. Read this entire file.
-3. \`boole strategy ls\` \u2014 see what is already running.
-
-## The one rule: THINK locally, COMMIT through \`boole\`
-- THINK \u2014 research, analyze data, design, draft code \u2014 freely on this machine. No limits.
-- COMMIT \u2014 anything that changes the trading computer \u2014 ONLY through \`boole\` commands.
-
-## Creating / running a strategy \u2014 the ONLY sanctioned path
-Spawn from a known-good template through the gateway gate:
-
-    boole strategy spawn --template <template.js> --name <name> \\
-      --param KEY=VALUE --param KEY=VALUE ...
-
-- This registers the run and starts it tracked, so it appears on the dashboard.
-- \`--name\`: lowercase letters, digits, "-" or "_" (e.g. btc-grid).
-- \`--param\`: pass raw values (EXCHANGE=hyperliquid, TOTAL_USD=50). The CLI quotes them.
-- Verify: \`boole strategy doctor <name>\` \u2192 should report online and tracked.
-
-### Templates (required params)
-- order_template.js  \u2014 single order: EXCHANGE, MARKET, SIDE(buy|sell), ORDER_TYPE(market|limit), TOTAL_USD, LIMIT_PRICE(0 for market)
-- grid_template.js   \u2014 grid: EXCHANGE, SYMBOL, LEVELS_PER_SIDE, ORDER_SIZE_USD, LEVERAGE, MAX_EXPOSURE_USD
-- twap_template.js   \u2014 TWAP: EXCHANGE, MARKET, SIDE, TOTAL_USD, DURATION_MIN, SLICES
-- scale_template.js  \u2014 ladder: EXCHANGE, MARKET, SIDE, TOTAL_USD, PRICE_LOW, PRICE_HIGH, LEVELS
-- stop_template.js   \u2014 conditional (no position yet): EXCHANGE, MARKET, SIDE, STOP_KIND(stop_market|stop_limit|tp_market|tp_limit), TOTAL_USD, TRIGGER_PRICE, LIMIT_PRICE(0 for *_market)
-- loop_template.js   \u2014 generic poll loop / price watcher: EXCHANGE, MARKET, POLL_SEC
-
-Example:
-
-    boole strategy spawn --template loop_template.js --name btc-watch \\
-      --param EXCHANGE=hyperliquid --param MARKET=BTC --param POLL_SEC=10
-
-If you omit a required param, the gate returns an error naming it \u2014 fix and retry.
-If the gate says a template is not found, it is not installed on this box \u2014 pick
-another from the list or ask the user.
-Only use a template above. Do NOT hand-roll custom strategy files. If you need
-something no template covers, STOP and ask the user.
-
-## Allowed \u2014 read-only inspection
+var OPERATING_RULES = `# Boole Trading Box \u2014 Operating Rules
+
+You operate a customer's **live** Boole trading computer. The \`boole\` CLI is just
+the shell that connects you to it. Everything about HOW to operate \u2014 placing
+trades, running strategies, the harness, safety \u2014 lives **ON THE BOX** in an
+authoritative operator guide. Read it FIRST and follow it; it overrides anything
+here.
+
+## Start every session
+1. \`boole status\` \u2014 confirm a box is connected (if not: \`boole login\`, then \`boole connect\`).
+2. Read the on-box operator guide \u2014 **AUTHORITATIVE**:
+   \`\`\`
+   boole ssh "cat /srv/cust/OPERATOR.md"
+   \`\`\`
+3. Operate the box exactly as that guide says.
+
+## The model
+- The box IS the gateway. You SSH into it with \`boole ssh\` and drive its **harness**.
+- You take the user's request **in plain English** ("buy $100 of BTC") and carry
+  it out through the harness, exactly as \`OPERATOR.md\` describes. Real money \u2014 be
+  deliberate, but do what the user asks; don't refuse routine orders.
+- The CLI has **no trade commands**. There is no \`boole buy\`, no \`boole strategy\`.
+  Trading happens on the box, through the harness, per \`OPERATOR.md\`.
+
+## Read-only helpers (fine anytime, from your machine)
 - \`boole status\` / \`boole balances [--venue <v>]\` \u2014 identity, equity, positions
-- \`boole strategy ls\` \u2014 running strategies
-- \`boole strategy doctor <name>\` \u2014 health + tracking check
 - \`boole logs <name>\` \u2014 tail a strategy's logs
-- \`boole ssh "<read-only command>"\` \u2014 inspect only (cat, ls, pm2 list, curl localhost:3000/health)
+- \`boole ssh "<read-only cmd>"\` \u2014 inspect the box (\`pm2 ls\`, \`curl localhost:3000/health\`, \`cat /srv/cust/OPERATOR.md\`)
 
-## Forbidden
-- Do NOT write strategy or interface files over SSH.
-- Do NOT \`pm2 start/restart/stop/delete\` by hand.
-- Do NOT edit gateway files directly.
-- \`boole ssh\` is for READ-ONLY inspection. To change the box, use a \`boole\` verb.
-- If there is no verb for a change you need, STOP and ask. A missing verb is not permission to freelance.
+## Never
+- Never operate the box except through the harness \`OPERATOR.md\` describes
+  (no hand-written strategy files, no \`pm2 start\`) \u2014 that silently breaks tracking.
+- Never print \`.env\` / keys; never restart the gateway.
 
-## Safety (real money)
-- Trading is live. Prefer capital preservation. Confirm exchange state before acting.
-- Never print or exfiltrate .env, API keys, or credentials.
-- Never restart the gateway.
-- Ask the user before destructive actions (closing positions, stopping strategies).
-
-## Notes
-- Some gateway internals are intentionally not readable from your account \u2014 by design. Use the \`boole\` verbs; you don't need them.
-- A commit is not done until \`boole strategy doctor\` confirms it. If it did not register, fix it before moving on.
+**Now run \`boole ssh "cat /srv/cust/OPERATOR.md"\` and follow it.**
 `;
 var FILES = ["CLAUDE.md", "AGENTS.md", "GEMINI.md"];
 function init(opts = {}) {
@@ -818,33 +700,30 @@ function init(opts = {}) {
 }
 
 // src/index.ts
-var VERSION = "0.1.0";
+var VERSION = "0.2.0";
 function parse(argv) {
   const _ = [];
   const flags = {};
-  const add = (k, v) => {
-    if (k in flags) {
-      const cur = flags[k];
-      flags[k] = Array.isArray(cur) ? [...cur, String(v)] : [String(cur), String(v)];
-    } else flags[k] = v;
-  };
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
     if (a.startsWith("--")) {
       const key = a.slice(2);
       if (key.includes("=")) {
         const [k, v] = key.split(/=(.*)/s);
-        add(k, v);
+        flags[k] = v;
       } else if (i + 1 < argv.length && !argv[i + 1].startsWith("--")) {
-        add(key, argv[++i]);
-      } else add(key, true);
+        flags[key] = argv[++i];
+      } else flags[key] = true;
     } else _.push(a);
   }
   return { _, flags };
 }
-var str = (f) => typeof f === "string" ? f : Array.isArray(f) ? f[f.length - 1] : void 0;
-var list = (f) => f === void 0 ? [] : Array.isArray(f) ? f : typeof f === "string" ? [f] : [];
-var HELP = `${c.bold("boole")} \u2014 operate your Boole trading computer from the terminal.
+var str = (f) => typeof f === "string" ? f : void 0;
+var HELP = `${c.bold("boole")} \u2014 the shell for your Boole trading computer.
+
+Log in and connect; your coding agent (${c.bold("Claude Code")} / ${c.bold("Codex")} / ${c.bold("Gemini")}) then operates the
+box over SSH. Trading happens ON the box, through its harness \u2014 the authoritative
+guide lives there: ${c.cyan('boole ssh "cat /srv/cust/OPERATOR.md"')}.
 
 ${c.bold("Usage")}
   boole <command> [options]
@@ -852,25 +731,19 @@ ${c.bold("Usage")}
 ${c.bold("Getting started")}
   login [--paste]          Sign in (opens the browser; --paste for manual code)
   provision [--name <n>]   Create a new trading computer (requires app onboarding)
-  connect [name]           Connect to an existing trading computer (caches SSH access)
+  connect [name]           Connect to a trading computer (caches SSH access)
   init [dir] [--force]     Scaffold an agent workspace (CLAUDE.md / AGENTS.md / GEMINI.md)
-  computers                List your trading computers
-  status                   Who you are + your trading computers + a live snapshot
-  balances [--venue <v>]   Equity + open positions for the connected trading computer
+  status                   Who you are + your trading computer + how to operate it
   logout                   Sign out and clear the cached session
 
-${c.bold("Operate")}
-  ssh "<command>"          Run a read-only command on the connected box
+${c.bold("Operate the box")}
+  ssh "<command>"          Run a command on the connected box (this is how you operate it)
   logs [name]              Tail a strategy's logs
-
-${c.bold("Strategies")} ${c.dim("(go through the gateway \u2014 always tracked on the dashboard)")}
-  strategy spawn --template <t.js> --name <n> [--param KEY=VALUE]... [--no-autostart]
-  strategy ls              List running strategies
-  strategy doctor [name]   Gateway health + a strategy's tracking status
+  balances [--venue <v>]   Equity + open positions
+  computers                List your trading computers
 
 ${c.bold("Other")}
-  help, --help             Show this help
-  version, --version       Show version
+  help, --help  \xB7  version, --version
 
 Env: ${c.dim("BOOLE_API_BASE")} (default https://trade.boole.markets), ${c.dim("BOOLE_HOME")}
 `;
@@ -881,10 +754,14 @@ async function main() {
     log(`boole ${VERSION}`);
     return;
   }
-  if (!cmd || cmd === "help" || flags.help) {
+  if (cmd === "help" || flags.help) {
     log(HELP);
     return;
   }
+  if (!cmd) {
+    orient();
+    return;
+  }
   switch (cmd) {
     case "login":
       await login({ paste: !!flags.paste });
@@ -925,24 +802,6 @@ async function main() {
       const remote = proc ? `pm2 logs '${proc.replace(/'/g, "")}' --lines 50 --nostream` : "pm2 logs --lines 40 --nostream";
       process.exit(await runRemoteInherit(remote));
     }
-    case "strategy": {
-      const sub = _[1];
-      if (sub === "spawn") {
-        await strategySpawn({
-          template: str(flags.template),
-          name: str(flags.name),
-          params: list(flags.param),
-          autostart: !flags["no-autostart"]
-        });
-      } else if (sub === "ls" || sub === "list") {
-        await strategyList();
-      } else if (sub === "doctor") {
-        await strategyDoctor(_[2]);
-      } else {
-        die("Usage: boole strategy <spawn|ls|doctor> \u2026 (see `boole help`)");
-      }
-      break;
-    }
     default:
       err(`Unknown command: ${cmd}`);
       log(HELP);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@boole-digital/cli",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Boole — install, sign in, and operate your trading computer from the terminal (Claude Code, Codex, Gemini).",
   "type": "module",
   "bin": { "boole": "dist/index.js" },
@@ -8,7 +8,7 @@
   "files": ["dist/index.js", "README.md", "LICENSE"],
   "license": "SEE LICENSE IN LICENSE",
   "engines": { "node": ">=18" },
-  "repository": { "type": "git", "url": "github:Boole-Digital/portara-desktop" },
+  "repository": { "type": "git", "url": "git+https://github.com/Boole-Digital/portara-desktop.git" },
   "homepage": "https://trade.boole.markets",
   "publishConfig": { "access": "public" },
   "keywords": ["boole", "trading", "cli", "claude-code", "codex", "gemini"],