@boole-digital/cli 0.1.1 → 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,20 +372,45 @@ 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("  Trades and strategies go through the gateway gate \u2014 automatically tracked on your dashboard.");
-  log("");
-  log(`  ${c.dim("# buy $100 of BTC (market)")}`);
-  log(c.cyan("  boole strategy spawn --template order_template.js --name btc-buy \\"));
-  log(c.cyan("    --param EXCHANGE=hyperliquid --param MARKET=BTC --param SIDE=buy \\"));
-  log(c.cyan("    --param ORDER_TYPE=market --param TOTAL_USD=100 --param LIMIT_PRICE=0"));
+  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(`  Sell with ${c.dim("SIDE=sell")}. Other templates: ${c.dim("grid, twap, scale, stop, loop")}.`);
-  log(`  Inspect: ${c.cyan("boole balances")} \xB7 ${c.cyan("boole strategy ls")} \xB7 ${c.cyan("boole logs <name>")} \xB7 ${c.cyan('boole ssh "<read cmd>"')}`);
-  log(`  ${c.yellow("Never")} write files or run pm2 by hand \u2014 always use the gate (that is what keeps tracking correct).`);
-  log(`  Drop the full rules into your coding agent: ${c.cyan("boole init")} ${c.dim("\u2192 CLAUDE.md / AGENTS.md / GEMINI.md")}`);
+  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) {
@@ -594,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);
@@ -633,191 +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)
+var OPERATING_RULES = `# Boole Trading Box \u2014 Operating Rules
 
-You operate the customer's **live** crypto trading computer by working ON the box
-(over \`boole ssh\`) and using its on-box **harness** \u2014 the gateway's spawn GATE,
-which places and TRACKS every order and strategy on the dashboard. Real money is
-at risk, so be deliberate \u2014 but the user asked you to operate their computer, so
-OPERATE IT. Place the trades they ask for; don't refuse or interrogate over
-routine orders.
+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.
 
-## What "the harness" is (and why you go through it)
-The box runs a gateway that exposes a spawn GATE. You place trades and run
-strategies by spawning a known-good TEMPLATE through that gate \u2014 NEVER by writing
-files or starting processes yourself. The gate registers the run, wires up
-tracking, sets STRATEGY_NAME/RUN_ID, and starts it, so it always shows on the
-dashboard with accounting. \`boole strategy spawn\` is simply how you call that
-gate over SSH. Going around it (hand-writing a file, raw \`pm2 start\`) makes the
-order **silently** untracked \u2014 that is the one thing you must never do.
+## 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.
 
-## Boot (every session)
-1. \`boole status\` \u2014 see who you're logged in as.
-2. \`boole ssh "whoami"\` \u2014 if it connects, you HAVE a usable box; proceed. A
-   connected session is enough. Do NOT refuse to work just because \`status\`
-   doesn't list a computer for this account \u2014 that only means the web API has
-   none on file, not that you can't operate the connected box. If \`boole ssh\`
-   fails, tell the user to run \`boole connect\`.
+## 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\`.
 
-## Placing a trade \u2014 just do it
-"buy/sell $X of <coin>" is one market order. Place it through the gate with
-order_template. Do NOT quiz the user about venue/leverage for a routine order \u2014
-use the defaults and report the fill:
-
-    boole strategy spawn --template order_template.js --name <coin>-buy \\
-      --param EXCHANGE=hyperliquid --param MARKET=<COIN> --param SIDE=buy \\
-      --param ORDER_TYPE=market --param TOTAL_USD=<X> --param LIMIT_PRICE=0
-
-Defaults when unspecified: EXCHANGE=hyperliquid, ORDER_TYPE=market, LIMIT_PRICE=0,
-no leverage. Sell with SIDE=sell. Limit order: ORDER_TYPE=limit + LIMIT_PRICE=<p>.
-Pick a unique --name (if the gate says it exists, add a suffix). After it returns,
-tell the user what filled. Ask FIRST only if genuinely ambiguous (which coin? which
-account has funds?) or clearly risky (size far beyond their balance, leverage they
-didn't request) \u2014 a plain market buy the user requested is NOT one of those.
-
-## Running a strategy \u2014 same gate, different template
-    boole strategy spawn --template <template.js> --name <name> --param KEY=VALUE ...
-
-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 poll loop / price watcher: EXCHANGE, MARKET, POLL_SEC
-
-If the gate names a missing param, add it and retry. If it says a template is not
-found, that one isn't installed on this box \u2014 pick another or ask.
-
-## Inspect (read-only) anytime
+## Read-only helpers (fine anytime, from your machine)
 - \`boole status\` / \`boole balances [--venue <v>]\` \u2014 identity, equity, positions
-- \`boole strategy ls\` / \`boole strategy doctor <name>\` \u2014 running strategies + tracking
 - \`boole logs <name>\` \u2014 tail a strategy's logs
-- \`boole ssh "<read-only cmd>"\` \u2014 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\`)
+
+## 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.
 
-## The hard lines (protect real money + tracking)
-- Place trades + strategies ONLY through the gate (\`boole strategy spawn\`). NEVER
-  write strategy files over SSH or \`pm2 start\` by hand \u2014 that bypasses tracking and
-  the order won't appear on the dashboard.
-- Never print or exfiltrate .env, keys, or credentials. Never restart the gateway.
-- Ask before genuinely destructive actions (closing positions, stopping a running
-  strategy). A plain market buy the user asked for is NOT destructive \u2014 place it.
+**Now run \`boole ssh "cat /srv/cust/OPERATOR.md"\` and follow it.**
 `;
 var FILES = ["CLAUDE.md", "AGENTS.md", "GEMINI.md"];
 function init(opts = {}) {
@@ -844,33 +700,30 @@ function init(opts = {}) {
 }
 
 // src/index.ts
-var VERSION = "0.1.1";
+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]
@@ -878,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")}
 `;
@@ -907,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 });
@@ -951,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.1",
+  "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" },