@series-a/cli 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,17 @@
+# @series-a/cli
+
+All notable changes to this package are documented here. This project follows
+[Semantic Versioning](https://semver.org/) and uses
+[Changesets](https://github.com/changesets/changesets) to manage releases.
+
+## 0.1.0 — Initial release
+
+- `advisoros login` / `logout` / `whoami` / `profiles` with multi-workspace profile support.
+- `leads` — `list`, `get`, `set-status`, `import` (CSV/JSON/JSONL, auto-chunked), `verify`.
+- `campaigns` — `list`, `show`, `create`, `add-leads`, `launch`, `pause`, `resume`.
+- `sequences` — `list`, `show` (ordered step table).
+- `inbox` — `threads` (read-only).
+- `content` — `list`, `show`, `publish`.
+- `agents` — `list`, `run`, `job`.
+- Global flags: `--json`, `--workspace`, `--profile`, `--api-key`.
+- Programmatic SDK via `@series-a/cli/src/api.mjs`.

package/LICENSE

@@ -0,0 +1,6 @@
+Copyright (c) AdvisorOS / Series A. All rights reserved.
+
+This package is distributed under a proprietary license. Use is permitted only
+by AdvisorOS customers and partners against their own workspace API keys. Do not
+redistribute, sublicense, or use against workspaces you do not own without
+written permission.

package/README.md

@@ -0,0 +1,190 @@
+# @series-a/cli
+
+A command-line interface to the AdvisorOS platform — drive leads, campaigns, sequences and agents from your terminal. Built on top of the [`/agent-api`](https://github.com/series-a/advisoros/blob/main/docs/agent-api.md) M2M router, so anything the CLI does is auditable and workspace-scoped.
+
+---
+
+## Install
+
+```bash
+# Run without installing — always fetches latest
+npx @series-a/cli@latest --help
+
+# Pin a version (recommended for CI)
+npx @series-a/cli@0.1.0 --help
+
+# Or install globally
+npm i -g @series-a/cli
+advisoros --help
+```
+
+Requires **Node.js ≥ 20**.
+
+> Releases are tagged `cli-vX.Y.Z` in the repo and published to npm with [provenance](https://docs.npmjs.com/generating-provenance-statements). See [`CHANGELOG.md`](./CHANGELOG.md).
+
+## 1. Get an API key
+
+1. Sign in to AdvisorOS.
+2. Open **Settings → API Keys**.
+3. Click **New key** → choose **Workspace** scope (recommended).
+4. Copy the key — you won't see it again.
+
+The **CLI quickstart** card on that page shows a copy-paste `npx` command pre-filled with your workspace ID.
+
+> Admin keys (cross-workspace) also work but are intentionally restricted. Default to workspace keys.
+
+## 2. Log in
+
+```bash
+npx @series-a/cli@latest login
+# Prompts for API key + workspace ID (the 6-char slug, e.g. dmw9wj)
+```
+
+Multiple workspaces?
+
+```bash
+advisoros login --profile acme        # save as "acme"
+advisoros leads list --profile acme   # use the named profile
+```
+
+Config is stored at `~/.advisoros/config.json` with mode `0600`. You can also use env vars: `ADVISOROS_API_KEY`, `ADVISOROS_WORKSPACE_ID`, `ADVISOROS_PROFILE`, `ADVISOROS_BASE_URL`.
+
+```bash
+advisoros whoami
+advisoros profiles
+advisoros logout --profile acme
+```
+
+## 3. Command reference
+
+Global flags (work on every subcommand):
+
+| Flag | Description |
+|---|---|
+| `--json` | Emit raw JSON instead of formatted tables. |
+| `-w, --workspace <id>` | Override the workspace from your profile. |
+| `-p, --profile <name>` | Pick a saved profile. |
+| `--api-key <key>` | Override the saved API key. |
+
+### Leads
+
+```bash
+advisoros leads list [--status new] [--persona founder] [--search acme] [--limit 50]
+advisoros leads get <id>
+advisoros leads set-status <id> <new|engaged|won|lost>
+advisoros leads import --file leads.csv [--persona founder]
+advisoros leads verify <id>
+```
+
+`leads import` accepts CSV (header row), JSON array, or JSONL. Upserts on `(workspace_id, linkedin_url)`. Bulk requests are auto-chunked at 200/call (server cap: 500/call).
+
+### Campaigns
+
+```bash
+advisoros campaigns list [--status active]
+advisoros campaigns show <id>
+advisoros campaigns create --name "Founder Pitch Club" \
+                           --sequence <sequenceId> \
+                           --senders acc_a,acc_b \
+                           --daily-limit 25
+advisoros campaigns add-leads <campaignId> --lead-ids id1,id2,id3
+advisoros campaigns add-leads <campaignId> --file lead-ids.txt
+advisoros campaigns launch <id>
+advisoros campaigns pause  <id>
+advisoros campaigns resume <id>
+```
+
+`launch` flips status to `active` — the `enforce_campaign_char_limits` trigger validates every step's copy against LinkedIn limits before allowing the transition.
+
+### Sequences / Inbox / Content / Agents
+
+```bash
+advisoros sequences list
+advisoros sequences show <id>
+
+advisoros inbox threads [--campaign <id>] [--lead <id>] [--needs-attention] [--limit 50]
+
+advisoros content list [--status published] [--type post] [--search ...]
+advisoros content show <id>
+advisoros content publish <id>
+
+advisoros agents list
+advisoros agents run <name> --input '{"foo":"bar"}'
+advisoros agents job <jobId>
+```
+
+> **Heads-up:** `inbox send`/`reply` are intentionally **not** in v1. Outbound goes through `campaigns launch` (sender resolution + char limits + per-sender daily budget). For one-off DMs, use the web inbox.
+
+## Examples
+
+**Spin up a campaign from a fresh CSV:**
+
+```bash
+advisoros leads import --file ./prospects.csv --persona founder
+advisoros leads list --persona founder --limit 200 --json \
+  | jq -r '.leads[].id' > lead-ids.txt
+
+advisoros campaigns create --name "Q3 Founder Outreach" \
+  --sequence 1a2b3c4d-... --senders acc_milan --daily-limit 25
+# → ✓ Created campaign 8297f04d-...
+
+advisoros campaigns add-leads 8297f04d-... --file lead-ids.txt
+advisoros campaigns launch    8297f04d-...
+```
+
+**Tail a long-running agent job:**
+
+```bash
+JOB=$(advisoros agents run lead-intelligence --input '{}' --json | jq -r '.run.job_id')
+watch -n 5 "advisoros agents job $JOB --json | jq '{status,progress}'"
+```
+
+## Exit codes
+
+| Code | Meaning |
+|---|---|
+| 0 | Success |
+| 1 | Generic failure (`error` in JSON response or thrown). Stderr contains the message. |
+
+## Programmatic use
+
+```js
+import { call } from "@series-a/cli/src/api.mjs";
+
+const { campaigns } = await call("campaigns", "list", { status: "active" }, {
+  apiKey: process.env.ADVISOROS_API_KEY,
+  workspaceId: "dmw9wj",
+});
+```
+
+## Troubleshooting
+
+- **401 Unauthorized** — key wrong / revoked / wrong base URL. Re-run `advisoros login`.
+- **403 not authorized for the requested workspace_id** — workspace-scoped key + `--workspace` to a different workspace. Use the matching key.
+- **CHAR_LIMIT_EXCEEDED on launch** — a sequence step exceeds LinkedIn limits (200 invitations / 8000 DMs / 1250 comments). Fix in web app.
+- **Network error** — check `ADVISOROS_BASE_URL` if you're pointing at a non-default deployment.
+
+## Releasing (maintainers)
+
+```bash
+cd tools/cli
+npx changeset                                            # describe the change
+npm run version                                          # bump package.json + CHANGELOG.md
+git commit -am "chore(cli): release v$(node -p "require('./package.json').version")"
+git tag "cli-v$(node -p "require('./package.json').version")"
+git push --follow-tags
+# → .github/workflows/cli-release.yml publishes to npm with provenance
+```
+
+`NPM_TOKEN` must be set in the repo's GitHub Actions secrets (automation token with publish access to the `@series-a` org).
+
+## Roadmap (v1.1)
+
+- `inbox send` / `inbox reply` with explicit `--confirm` + per-sender budget enforcement.
+- `agents tail <jobId>` (SSE).
+- `admin workspaces …` (admin keys only).
+- Single-binary builds via `pkg`.
+
+## Full API reference
+
+See [`docs/agent-api.md`](../../docs/agent-api.md) for the underlying `/agent-api` envelope.

package/bin/advisoros.mjs

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "../src/index.mjs";

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@series-a/cli",
+  "version": "0.1.0",
+  "description": "AdvisorOS command-line interface — drive leads, campaigns, sequences and agents from your terminal.",
+  "type": "module",
+  "bin": {
+    "advisoros": "bin/advisoros.mjs"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "start": "node bin/advisoros.mjs",
+    "smoke": "node bin/advisoros.mjs --help >/dev/null && node bin/advisoros.mjs --version >/dev/null && node -e \"import('node:fs').then(({readFileSync})=>{const s=readFileSync('bin/advisoros.mjs','utf8');if(!s.startsWith('#!/usr/bin/env node')){console.error('Missing shebang in bin/advisoros.mjs');process.exit(1)}})\"",
+    "prepublishOnly": "npm run smoke",
+    "changeset": "changeset",
+    "version": "changeset version",
+    "release": "npm run smoke && changeset publish --access public"
+  },
+  "dependencies": {
+    "commander": "^12.1.0",
+    "chalk": "^5.3.0",
+    "cli-table3": "^0.6.5",
+    "ora": "^8.1.1",
+    "prompts": "^2.4.2"
+  },
+  "devDependencies": {
+    "@changesets/cli": "^2.27.9"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/series-a/advisoros.git",
+    "directory": "tools/cli"
+  },
+  "homepage": "https://advisoros.series-a.co",
+  "bugs": {
+    "url": "https://github.com/series-a/advisoros/issues"
+  },
+  "keywords": [
+    "advisoros",
+    "cli",
+    "linkedin",
+    "campaigns",
+    "leads",
+    "sequences",
+    "agent-api"
+  ],
+  "author": "AdvisorOS",
+  "license": "UNLICENSED"
+}

package/src/api.mjs

@@ -0,0 +1,76 @@
+import { getProfile, DEFAULTS } from "./config.mjs";
+
+export class AdvisorOSApiError extends Error {
+  constructor(message, { status, body } = {}) {
+    super(message);
+    this.name = "AdvisorOSApiError";
+    this.status = status;
+    this.body = body;
+  }
+}
+
+/**
+ * Invoke the AdvisorOS /agent-api router.
+ * Resolves credentials from --profile / env / saved config in that order.
+ */
+export async function call(resource, action, params = {}, opts = {}) {
+  const profileName = opts.profile || process.env.ADVISOROS_PROFILE || "default";
+  const stored = await getProfile(profileName);
+  const apiKey = opts.apiKey || process.env.ADVISOROS_API_KEY || stored?.apiKey;
+  const workspaceId =
+    opts.workspaceId ||
+    process.env.ADVISOROS_WORKSPACE_ID ||
+    stored?.workspaceId;
+  const baseUrl =
+    opts.baseUrl ||
+    process.env.ADVISOROS_BASE_URL ||
+    stored?.baseUrl ||
+    DEFAULTS.baseUrl;
+  const agentName = opts.agentName || stored?.agentName || "advisoros-cli";
+
+  if (!apiKey) {
+    throw new AdvisorOSApiError(
+      "No API key configured. Run `advisoros login` or set ADVISOROS_API_KEY.",
+    );
+  }
+  // workspaces resource doesn't require a workspace_id in the envelope.
+  if (!workspaceId && resource !== "workspaces") {
+    throw new AdvisorOSApiError(
+      "No workspace configured. Run `advisoros login` again or pass --workspace.",
+    );
+  }
+
+  const body = {
+    agent_name: agentName,
+    workspace_id: workspaceId ?? "",
+    resource,
+    action,
+    params,
+  };
+
+  let res;
+  try {
+    res = await fetch(baseUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-service-account-key": apiKey,
+      },
+      body: JSON.stringify(body),
+    });
+  } catch (e) {
+    throw new AdvisorOSApiError(`Network error: ${e.message}`);
+  }
+
+  const text = await res.text();
+  let json;
+  try { json = JSON.parse(text); } catch { json = { raw: text }; }
+
+  if (!res.ok || json?.success === false) {
+    throw new AdvisorOSApiError(
+      json?.error || `HTTP ${res.status}`,
+      { status: res.status, body: json },
+    );
+  }
+  return json;
+}

package/src/commands/auth.mjs

@@ -0,0 +1,87 @@
+import prompts from "prompts";
+import chalk from "chalk";
+import { getProfile, setProfile, listProfiles, deleteProfile, CONFIG_PATH, DEFAULTS } from "../config.mjs";
+import { call } from "../api.mjs";
+import { emit, fail, ctxFrom, withCommonOpts } from "../ui.mjs";
+
+export function registerAuth(program) {
+  program
+    .command("login")
+    .description("Save an API key + workspace to ~/.advisoros/config.json")
+    .option("-p, --profile <name>", "profile name", "default")
+    .option("--api-key <key>", "API key (otherwise prompted)")
+    .option("--workspace <id>", "workspace id (otherwise prompted)")
+    .option("--base-url <url>", "agent-api base URL", DEFAULTS.baseUrl)
+    .action(async (opts) => {
+      try {
+        let { apiKey, workspace, baseUrl, profile } = opts;
+        if (!apiKey) {
+          const r = await prompts({
+            type: "password",
+            name: "v",
+            message: "API key (from Settings → API Keys)",
+            validate: (v) => v && v.length > 10 ? true : "Required",
+          });
+          apiKey = r.v;
+        }
+        if (!apiKey) return fail(new Error("Aborted"));
+        if (!workspace) {
+          const r = await prompts({
+            type: "text",
+            name: "v",
+            message: "Workspace ID (6-char slug, e.g. dmw9wj)",
+            validate: (v) => v && v.length >= 3 ? true : "Required",
+          });
+          workspace = r.v;
+        }
+        if (!workspace) return fail(new Error("Aborted"));
+
+        // Verify the credentials with a cheap round-trip.
+        const verify = await call("agents", "list", {}, {
+          apiKey, workspaceId: workspace, baseUrl,
+        });
+        const count = verify?.agents?.length ?? 0;
+        await setProfile(profile, { apiKey, workspaceId: workspace, baseUrl });
+        process.stdout.write(chalk.green(
+          `\n✓ Logged in as profile "${profile}" — workspace ${workspace} (${count} agents visible)\n` +
+          `  Config: ${CONFIG_PATH}\n`,
+        ));
+      } catch (e) { fail(e); }
+    });
+
+  program
+    .command("whoami")
+    .description("Show the active profile and workspace")
+    .option("-p, --profile <name>", "profile name", "default")
+    .action(async (opts) => {
+      try {
+        const p = await getProfile(opts.profile);
+        if (!p) return fail(new Error(`Profile "${opts.profile}" not found. Run \`advisoros login\`.`));
+        const masked = p.apiKey ? p.apiKey.slice(0, 8) + "…" + p.apiKey.slice(-4) : "(none)";
+        process.stdout.write(
+          `profile:    ${opts.profile}\n` +
+          `workspace:  ${p.workspaceId}\n` +
+          `base url:   ${p.baseUrl || DEFAULTS.baseUrl}\n` +
+          `api key:    ${masked}\n`,
+        );
+      } catch (e) { fail(e); }
+    });
+
+  program
+    .command("profiles")
+    .description("List saved profiles")
+    .action(async () => {
+      const ps = await listProfiles();
+      if (!ps.length) return process.stdout.write("(no profiles — run `advisoros login`)\n");
+      for (const name of ps) process.stdout.write(`- ${name}\n`);
+    });
+
+  program
+    .command("logout")
+    .description("Remove a saved profile")
+    .option("-p, --profile <name>", "profile name", "default")
+    .action(async (opts) => {
+      const ok = await deleteProfile(opts.profile);
+      process.stdout.write(ok ? chalk.green(`✓ Removed profile "${opts.profile}"\n`) : `(no profile "${opts.profile}")\n`);
+    });
+}

package/src/commands/flow.mjs

@@ -0,0 +1,175 @@
+import { readFile } from "node:fs/promises";
+import { call } from "../api.mjs";
+import { emit, fail, ctxFrom, withCommonOpts, table, truncate } from "../ui.mjs";
+
+function parseCsv(text) {
+  const lines = text.split(/\r?\n/).filter((l) => l.trim().length);
+  if (!lines.length) return [];
+  const split = (line) => {
+    const out = []; let cur = ""; let q = false;
+    for (let i = 0; i < line.length; i++) {
+      const c = line[i];
+      if (q) {
+        if (c === '"' && line[i + 1] === '"') { cur += '"'; i++; }
+        else if (c === '"') { q = false; }
+        else cur += c;
+      } else {
+        if (c === ",") { out.push(cur); cur = ""; }
+        else if (c === '"') { q = true; }
+        else cur += c;
+      }
+    }
+    out.push(cur);
+    return out.map((s) => s.trim());
+  };
+  const headers = split(lines[0]).map((h) => h.toLowerCase());
+  return lines.slice(1).map((line) => {
+    const cells = split(line);
+    const row = {};
+    headers.forEach((h, i) => { row[h] = cells[i] ?? ""; });
+    return row;
+  });
+}
+
+async function loadRows(file) {
+  const text = await readFile(file, "utf8");
+  if (file.endsWith(".jsonl")) {
+    return text.split(/\r?\n/).filter(Boolean).map((l) => JSON.parse(l));
+  }
+  if (file.endsWith(".json")) {
+    const parsed = JSON.parse(text);
+    return Array.isArray(parsed) ? parsed : (parsed.leads ?? []);
+  }
+  return parseCsv(text);
+}
+
+export function registerFlow(program) {
+  withCommonOpts(program.command("campaign-flow"))
+    .description("End-to-end: import leads → create/attach sequence → launch → show status")
+    .requiredOption("--name <name>", "campaign name")
+    .requiredOption("--file <path>", "leads CSV / JSON / JSONL")
+    .option("--description <text>", "campaign description")
+    .option("--goal <text>", "campaign goal")
+    .option("--persona <tag>", "default persona_tag for imported leads")
+    .option("--source <s>", "default lead source", "cli-flow")
+    .option("--sequence <id>", "attach an existing sequence (otherwise picks most recent active)")
+    .option("--senders <csv>", "comma-separated sender_account_ids")
+    .option("--daily-limit <n>", "daily send cap", "25")
+    .option("--launch", "activate the campaign immediately after setup", false)
+    .option("--dry-run", "print plan only, do not call the API", false)
+    .action(async function (opts) {
+      const ctx = ctxFrom(this);
+      const steps = [];
+      const log = (msg) => { if (!this.optsWithGlobals().json) process.stdout.write(msg); };
+      try {
+        // 1. Load + import leads
+        const rows = await loadRows(opts.file);
+        if (!rows.length) return fail(new Error(`No leads found in ${opts.file}`));
+        if (opts.persona) rows.forEach((r) => { r.persona_tag = r.persona_tag || opts.persona; });
+        rows.forEach((r) => { r.source = r.source || opts.source; });
+
+        if (opts.dryRun) {
+          log(`DRY RUN — would import ${rows.length} leads and create campaign "${opts.name}"\n`);
+          return emit(this, { dry_run: true, lead_count: rows.length, name: opts.name }, () => {});
+        }
+
+        log(`→ Importing ${rows.length} leads…\n`);
+        let imported = 0;
+        const importedIds = [];
+        for (let i = 0; i < rows.length; i += 200) {
+          const chunk = rows.slice(i, i + 200);
+          const r = await call("leads", "bulk_upsert", { leads: chunk }, ctx);
+          imported += r.count ?? 0;
+          (r.leads || r.upserted || []).forEach((l) => l?.id && importedIds.push(l.id));
+        }
+        steps.push({ step: "import_leads", imported, total: rows.length });
+        log(`  ✓ Upserted ${imported}/${rows.length} leads\n`);
+
+        // Fallback: re-fetch ids if backend didn't return them
+        let leadIds = importedIds;
+        if (!leadIds.length) {
+          const list = await call("leads", "list", {
+            persona_tag: opts.persona, limit: Math.min(rows.length, 500),
+          }, ctx);
+          leadIds = (list.leads || []).map((l) => l.id).filter(Boolean);
+        }
+
+        // 2. Resolve sequence
+        let sequenceId = opts.sequence;
+        if (!sequenceId) {
+          const seqs = await call("sequences", "list", { limit: 50 }, ctx);
+          const active = (seqs.sequences || []).find((s) => s.status === "active")
+                       || (seqs.sequences || [])[0];
+          if (!active) return fail(new Error("No sequence found — pass --sequence <id> or create one first"));
+          sequenceId = active.id;
+          log(`→ Using sequence: ${active.name} (${truncate(sequenceId, 8)})\n`);
+        }
+        steps.push({ step: "resolve_sequence", sequence_id: sequenceId });
+
+        // 3. Create campaign
+        log(`→ Creating campaign "${opts.name}"…\n`);
+        const created = await call("campaigns", "create", {
+          name: opts.name,
+          description: opts.description,
+          goal: opts.goal,
+          sequence_id: sequenceId,
+          sender_accounts: opts.senders ? opts.senders.split(",").map((s) => s.trim()).filter(Boolean) : [],
+          daily_send_limit: Number(opts.dailyLimit),
+        }, ctx);
+        const campaignId = created.campaign?.id;
+        if (!campaignId) return fail(new Error("Campaign create returned no id"));
+        steps.push({ step: "create_campaign", campaign_id: campaignId });
+        log(`  ✓ Campaign ${truncate(campaignId, 8)} created\n`);
+
+        // 4. Attach leads
+        if (leadIds.length) {
+          log(`→ Attaching ${leadIds.length} leads to campaign…\n`);
+          const add = await call("campaigns", "add_leads", {
+            campaign_id: campaignId, lead_ids: leadIds,
+          }, ctx);
+          steps.push({ step: "add_leads", added: add.added, requested: add.requested });
+          log(`  ✓ Added ${add.added}/${add.requested} (${add.valid} valid in workspace)\n`);
+        }
+
+        // 5. Launch (optional)
+        let launched = null;
+        if (opts.launch) {
+          log(`→ Launching campaign…\n`);
+          launched = await call("campaigns", "launch", { campaign_id: campaignId }, ctx);
+          steps.push({ step: "launch", status: launched.campaign?.status });
+          log(`  ✓ Status → ${launched.campaign?.status}\n`);
+        }
+
+        // 6. Final status
+        const finalShow = await call("campaigns", "get", { id: campaignId }, ctx);
+        const c = finalShow.campaign || {};
+        const summary = {
+          campaign_id: campaignId,
+          name: c.name,
+          status: c.status,
+          sequence_id: c.sequence_id,
+          daily_send_limit: c.daily_send_limit,
+          sender_accounts: c.sender_accounts || [],
+          leads_attached: c.lead_count ?? leadIds.length,
+          steps,
+        };
+
+        emit(this, summary, (d) => {
+          process.stdout.write("\n" + table(
+            ["field", "value"],
+            [
+              ["campaign", `${d.name} (${truncate(d.campaign_id, 8)})`],
+              ["status", d.status],
+              ["sequence", truncate(d.sequence_id, 8)],
+              ["leads", d.leads_attached],
+              ["senders", (d.sender_accounts || []).length],
+              ["daily cap", d.daily_send_limit],
+            ],
+          ) + "\n");
+          process.stdout.write(opts.launch
+            ? `✓ Campaign live — monitor with: advisoros campaigns show ${campaignId}\n`
+            : `✓ Campaign ready (draft) — launch with: advisoros campaigns launch ${campaignId}\n`);
+        });
+      } catch (e) { fail(e); }
+    });
+}

package/src/commands/resources.mjs

@@ -0,0 +1,400 @@
+import { readFile } from "node:fs/promises";
+import { call } from "../api.mjs";
+import { emit, fail, ctxFrom, withCommonOpts, table, truncate } from "../ui.mjs";
+
+function parseCsv(text) {
+  // Tiny CSV parser: header row + comma-separated values, quoted fields supported.
+  const lines = text.split(/\r?\n/).filter((l) => l.trim().length);
+  if (!lines.length) return [];
+  const split = (line) => {
+    const out = []; let cur = ""; let q = false;
+    for (let i = 0; i < line.length; i++) {
+      const c = line[i];
+      if (q) {
+        if (c === '"' && line[i+1] === '"') { cur += '"'; i++; }
+        else if (c === '"') { q = false; }
+        else cur += c;
+      } else {
+        if (c === ",") { out.push(cur); cur = ""; }
+        else if (c === '"') { q = true; }
+        else cur += c;
+      }
+    }
+    out.push(cur);
+    return out.map((s) => s.trim());
+  };
+  const headers = split(lines[0]).map((h) => h.toLowerCase());
+  return lines.slice(1).map((line) => {
+    const cells = split(line);
+    const row = {};
+    headers.forEach((h, i) => { row[h] = cells[i] ?? ""; });
+    return row;
+  });
+}
+
+export function registerLeads(program) {
+  const leads = program.command("leads").description("Manage leads");
+
+  withCommonOpts(leads.command("list"))
+    .description("List leads")
+    .option("--status <s>", "filter by status")
+    .option("--persona <p>", "filter by persona_tag")
+    .option("--search <q>", "search name or company")
+    .option("--limit <n>", "max rows", "50")
+    .action(async function () {
+      try {
+        const o = this.optsWithGlobals();
+        const r = await call("leads", "list", {
+          status: o.status, persona_tag: o.persona, search: o.search, limit: Number(o.limit),
+        }, ctxFrom(this));
+        emit(this, r, (d) => {
+          process.stdout.write(table(
+            ["id", "name", "title", "company", "status"],
+            (d.leads || []).map((l) => [
+              truncate(l.id, 8), truncate(l.name, 28), truncate(l.title, 24),
+              truncate(l.company, 22), l.status ?? "",
+            ]),
+          ) + `\n${d.leads?.length ?? 0} rows\n`);
+        });
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(leads.command("get <id>"))
+    .description("Show a single lead")
+    .action(async function (id) {
+      try {
+        const r = await call("leads", "get", { id }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(JSON.stringify(d.lead, null, 2) + "\n"));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(leads.command("set-status <id> <status>"))
+    .description("Update a lead's status")
+    .action(async function (id, status) {
+      try {
+        const r = await call("leads", "update_status", { id, status }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ ${d.lead?.name ?? id} → ${d.lead?.status}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(leads.command("import"))
+    .description("Bulk upsert leads from a CSV or JSON/JSONL file")
+    .requiredOption("--file <path>", "leads.csv | leads.json | leads.jsonl")
+    .option("--persona <tag>", "default persona_tag for all rows")
+    .option("--source <s>", "default source", "cli")
+    .action(async function (opts) {
+      try {
+        const text = await readFile(opts.file, "utf8");
+        let rows;
+        if (opts.file.endsWith(".jsonl")) {
+          rows = text.split(/\r?\n/).filter(Boolean).map((l) => JSON.parse(l));
+        } else if (opts.file.endsWith(".json")) {
+          const parsed = JSON.parse(text);
+          rows = Array.isArray(parsed) ? parsed : (parsed.leads ?? []);
+        } else {
+          rows = parseCsv(text);
+        }
+        if (opts.persona) rows.forEach((r) => { r.persona_tag = r.persona_tag || opts.persona; });
+        rows.forEach((r) => { r.source = r.source || opts.source; });
+
+        // Send in chunks of 200 to respect API limit (500).
+        const chunks = [];
+        for (let i = 0; i < rows.length; i += 200) chunks.push(rows.slice(i, i + 200));
+        let total = 0;
+        for (const chunk of chunks) {
+          const r = await call("leads", "bulk_upsert", { leads: chunk }, ctxFrom(this));
+          total += r.count ?? 0;
+        }
+        emit(this, { upserted: total, total_rows: rows.length }, (d) =>
+          process.stdout.write(`✓ Upserted ${d.upserted}/${d.total_rows} leads\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(leads.command("verify <id>"))
+    .description("Run LinkedIn verification on a lead")
+    .action(async function (id) {
+      try {
+        const r = await call("leads", "verify", { id }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(JSON.stringify(d.verify, null, 2) + "\n"));
+      } catch (e) { fail(e); }
+    });
+}
+
+export function registerCampaigns(program) {
+  const c = program.command("campaigns").description("Manage LinkedIn campaigns");
+
+  withCommonOpts(c.command("list"))
+    .description("List campaigns")
+    .option("--status <s>", "filter by status")
+    .option("--limit <n>", "max rows", "50")
+    .action(async function () {
+      try {
+        const o = this.optsWithGlobals();
+        const r = await call("campaigns", "list", { status: o.status, limit: Number(o.limit) }, ctxFrom(this));
+        emit(this, r, (d) => {
+          process.stdout.write(table(
+            ["id", "name", "status", "sequence", "daily", "senders"],
+            (d.campaigns || []).map((cp) => [
+              truncate(cp.id, 8), truncate(cp.name, 30), cp.status,
+              truncate(cp.sequence_id, 8), cp.daily_send_limit ?? "",
+              (cp.sender_accounts || []).length,
+            ]),
+          ) + `\n${d.campaigns?.length ?? 0} rows\n`);
+        });
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(c.command("show <id>"))
+    .description("Show campaign details + stats")
+    .action(async function (id) {
+      try {
+        const r = await call("campaigns", "get", { id }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(JSON.stringify(d.campaign, null, 2) + "\n"));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(c.command("create"))
+    .description("Create a new draft campaign")
+    .requiredOption("--name <name>", "campaign name")
+    .option("--description <text>", "description")
+    .option("--goal <text>", "campaign goal")
+    .option("--sequence <id>", "attach a sequence")
+    .option("--senders <csv>", "comma-separated sender_account_ids")
+    .option("--daily-limit <n>", "daily send cap", "25")
+    .action(async function (opts) {
+      try {
+        const r = await call("campaigns", "create", {
+          name: opts.name,
+          description: opts.description,
+          goal: opts.goal,
+          sequence_id: opts.sequence,
+          sender_accounts: opts.senders ? opts.senders.split(",").map((s) => s.trim()).filter(Boolean) : [],
+          daily_send_limit: Number(opts.dailyLimit),
+        }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Created campaign ${d.campaign?.id}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(c.command("add-leads <campaignId>"))
+    .description("Attach leads to a campaign")
+    .option("--lead-ids <csv>", "comma-separated lead UUIDs")
+    .option("--file <path>", "file with one lead id per line")
+    .action(async function (campaignId, opts) {
+      try {
+        let ids = [];
+        if (opts.leadIds) ids = opts.leadIds.split(",").map((s) => s.trim()).filter(Boolean);
+        if (opts.file) {
+          const text = await readFile(opts.file, "utf8");
+          ids.push(...text.split(/\r?\n/).map((s) => s.trim()).filter(Boolean));
+        }
+        if (!ids.length) return fail(new Error("--lead-ids or --file required"));
+        const r = await call("campaigns", "add_leads", { campaign_id: campaignId, lead_ids: ids }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Added ${d.added}/${d.requested} leads (${d.valid} valid in workspace)\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(c.command("launch <id>"))
+    .description("Activate a campaign (status → active)")
+    .action(async function (id) {
+      try {
+        const r = await call("campaigns", "launch", { campaign_id: id }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ ${d.campaign?.name ?? id} → ${d.campaign?.status}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(c.command("pause <id>"))
+    .description("Pause a campaign")
+    .action(async function (id) {
+      try {
+        const r = await call("campaigns", "pause", { campaign_id: id }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ ${d.campaign?.name ?? id} → ${d.campaign?.status}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(c.command("resume <id>"))
+    .description("Resume a paused campaign")
+    .action(async function (id) {
+      try {
+        const r = await call("campaigns", "resume", { campaign_id: id }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ ${d.campaign?.name ?? id} → ${d.campaign?.status}\n`));
+      } catch (e) { fail(e); }
+    });
+}
+
+export function registerSequences(program) {
+  const s = program.command("sequences").description("View LinkedIn sequences");
+
+  withCommonOpts(s.command("list"))
+    .description("List sequences")
+    .option("--limit <n>", "max rows", "50")
+    .action(async function () {
+      try {
+        const o = this.optsWithGlobals();
+        const r = await call("sequences", "list", { limit: Number(o.limit) }, ctxFrom(this));
+        emit(this, r, (d) => {
+          process.stdout.write(table(
+            ["id", "name", "status"],
+            (d.sequences || []).map((s) => [truncate(s.id, 8), truncate(s.name, 40), s.status]),
+          ) + `\n${d.sequences?.length ?? 0} rows\n`);
+        });
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(s.command("show <id>"))
+    .description("Show sequence + steps")
+    .action(async function (id) {
+      try {
+        const r = await call("sequences", "get", { id }, ctxFrom(this));
+        emit(this, r, (d) => {
+          process.stdout.write(`Sequence: ${d.sequence?.name} (${d.sequence?.status})\n\n`);
+          process.stdout.write(table(
+            ["#", "action", "channel", "delay", "variant", "preview"],
+            (d.steps || []).map((s) => [
+              s.step_order, s.action, s.channel, `${s.delay_days}d`, s.variant,
+              truncate(s.message_content, 60),
+            ]),
+          ) + "\n");
+        });
+      } catch (e) { fail(e); }
+    });
+}
+
+export function registerInbox(program) {
+  const inbox = program.command("inbox").description("Inspect unified inbox");
+
+  withCommonOpts(inbox.command("threads"))
+    .description("List recent inbox messages")
+    .option("--campaign <id>", "filter by campaign_id")
+    .option("--lead <id>", "filter by lead_id")
+    .option("--needs-attention", "only messages flagged as needing attention")
+    .option("--limit <n>", "max rows", "50")
+    .action(async function () {
+      try {
+        const o = this.optsWithGlobals();
+        const r = await call("inbox", "list_threads", {
+          campaign_id: o.campaign, lead_id: o.lead,
+          needs_attention: o.needsAttention || undefined,
+          limit: Number(o.limit),
+        }, ctxFrom(this));
+        emit(this, r, (d) => {
+          process.stdout.write(table(
+            ["created", "dir", "campaign", "body"],
+            (d.messages || []).map((m) => [
+              (m.created_at || "").slice(0, 16).replace("T", " "),
+              m.direction === "outbound" ? "→" : "←",
+              truncate(m.campaign_name || m.campaign_id, 20),
+              truncate((m.body || "").replace(/\s+/g, " "), 80),
+            ]),
+          ) + `\n${d.messages?.length ?? 0} rows\n`);
+        });
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(inbox.command("send <leadId>"))
+    .description("Send a one-off LinkedIn DM (or first-touch invite note) to a lead")
+    .requiredOption("--text <message>", "message body (auto-truncated to channel limit)")
+    .option("--sender <accountId>", "sender_account_id (defaults to most-recently-updated linkedin_tool sender)")
+    .action(async function (leadId, opts) {
+      try {
+        const r = await call("inbox", "send_dm", {
+          lead_id: leadId,
+          text: opts.text,
+          sender_account_id: opts.sender,
+        }, ctxFrom(this));
+        emit(this, r, (d) => {
+          const s = d.sent || {};
+          const b = s.budget || {};
+          process.stdout.write(
+            `✓ ${s.channel_kind === "linkedin_invite" ? "Invite note" : "DM"} sent to ${s.lead_name || leadId}\n` +
+            `  sender:   ${s.sender_account_id}\n` +
+            `  chars:    ${s.chars}\n` +
+            `  budget:   invites ${b.invites_sent}/${b.invites_cap}, messages ${b.messages_sent}/${b.messages_cap}\n` +
+            (s.external_id ? `  msg id:   ${s.external_id}\n` : ""),
+          );
+        });
+      } catch (e) { fail(e); }
+    });
+}
+
+export function registerContent(program) {
+  const c = program.command("content").description("Browse and publish content");
+
+  withCommonOpts(c.command("list"))
+    .description("List content items")
+    .option("--status <s>", "filter by status")
+    .option("--type <t>", "filter by type")
+    .option("--search <q>", "search title or body")
+    .option("--limit <n>", "max rows", "50")
+    .action(async function () {
+      try {
+        const o = this.optsWithGlobals();
+        const r = await call("content", "list", {
+          status: o.status, type: o.type, search: o.search, limit: Number(o.limit),
+        }, ctxFrom(this));
+        emit(this, r, (d) => {
+          process.stdout.write(table(
+            ["id", "type", "status", "title"],
+            (d.content || []).map((c) => [truncate(c.id, 8), c.type, c.status, truncate(c.title, 60)]),
+          ) + `\n${d.content?.length ?? 0} rows\n`);
+        });
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(c.command("show <id>"))
+    .description("Show a content item")
+    .action(async function (id) {
+      try {
+        const r = await call("content", "get", { id }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(JSON.stringify(d.content, null, 2) + "\n"));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(c.command("publish <id>"))
+    .description("Dispatch publication via agent-content-posting")
+    .action(async function (id) {
+      try {
+        const r = await call("content", "publish", { id }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(JSON.stringify(d.publish, null, 2) + "\n"));
+      } catch (e) { fail(e); }
+    });
+}
+
+export function registerAgents(program) {
+  const a = program.command("agents").description("List and invoke agents");
+
+  withCommonOpts(a.command("list"))
+    .description("List available agents")
+    .action(async function () {
+      try {
+        const r = await call("agents", "list", {}, ctxFrom(this));
+        emit(this, r, (d) => {
+          process.stdout.write(table(
+            ["name", "status", "model"],
+            (d.agents || []).map((a) => [truncate(a.name, 32), a.status ?? "", truncate(a.model, 30)]),
+          ) + `\n${d.agents?.length ?? 0} rows\n`);
+        });
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(a.command("run <name>"))
+    .description("Invoke an agent")
+    .option("--input <json>", "JSON input payload", "{}")
+    .action(async function (name, opts) {
+      try {
+        let input = {};
+        try { input = JSON.parse(opts.input); }
+        catch { return fail(new Error("--input must be valid JSON")); }
+        const r = await call("agents", "run", { agent_name: name, input }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(JSON.stringify(d.run, null, 2) + "\n"));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(a.command("job <id>"))
+    .description("Check agent_jobs status")
+    .action(async function (id) {
+      try {
+        const r = await call("agents", "job_status", { job_id: id }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(JSON.stringify(d.job, null, 2) + "\n"));
+      } catch (e) { fail(e); }
+    });
+}

package/src/config.mjs

@@ -0,0 +1,56 @@
+import { homedir } from "node:os";
+import { join, dirname } from "node:path";
+import { mkdir, readFile, writeFile, chmod } from "node:fs/promises";
+
+const CONFIG_DIR = join(homedir(), ".advisoros");
+const CONFIG_PATH = join(CONFIG_DIR, "config.json");
+
+const DEFAULT_BASE_URL =
+  "https://iwcwydcxbzoenmqcqkcv.supabase.co/functions/v1/agent-api";
+
+export const DEFAULTS = { baseUrl: DEFAULT_BASE_URL };
+
+async function readConfig() {
+  try {
+    const raw = await readFile(CONFIG_PATH, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return { profiles: {} };
+  }
+}
+
+async function writeConfig(cfg) {
+  await mkdir(dirname(CONFIG_PATH), { recursive: true });
+  await writeFile(CONFIG_PATH, JSON.stringify(cfg, null, 2), "utf8");
+  try { await chmod(CONFIG_PATH, 0o600); } catch {}
+}
+
+export async function getProfile(name = "default") {
+  const cfg = await readConfig();
+  return cfg.profiles?.[name] ?? null;
+}
+
+export async function setProfile(name, data) {
+  const cfg = await readConfig();
+  cfg.profiles = cfg.profiles ?? {};
+  cfg.profiles[name] = data;
+  cfg.currentProfile = name;
+  await writeConfig(cfg);
+}
+
+export async function listProfiles() {
+  const cfg = await readConfig();
+  return Object.keys(cfg.profiles ?? {});
+}
+
+export async function deleteProfile(name) {
+  const cfg = await readConfig();
+  if (cfg.profiles?.[name]) {
+    delete cfg.profiles[name];
+    await writeConfig(cfg);
+    return true;
+  }
+  return false;
+}
+
+export { CONFIG_PATH };

package/src/index.mjs

@@ -0,0 +1,29 @@
+import { Command } from "commander";
+import { registerAuth } from "./commands/auth.mjs";
+import {
+  registerLeads, registerCampaigns, registerSequences,
+  registerInbox, registerContent, registerAgents,
+} from "./commands/resources.mjs";
+import { registerFlow } from "./commands/flow.mjs";
+
+const program = new Command();
+
+program
+  .name("advisoros")
+  .description("AdvisorOS CLI — drive leads, campaigns, sequences and agents from your terminal.")
+  .version("0.1.0")
+  .option("--json", "machine-readable JSON output (applies to all subcommands)");
+
+registerAuth(program);
+registerLeads(program);
+registerCampaigns(program);
+registerSequences(program);
+registerInbox(program);
+registerContent(program);
+registerAgents(program);
+registerFlow(program);
+
+program.parseAsync(process.argv).catch((e) => {
+  process.stderr.write(`✖ ${e?.message ?? e}\n`);
+  process.exit(1);
+});

package/src/ui.mjs

@@ -0,0 +1,58 @@
+import chalk from "chalk";
+import Table from "cli-table3";
+
+export function isJsonMode(cmd) {
+  return Boolean(cmd?.optsWithGlobals?.().json ?? cmd?.opts?.().json);
+}
+
+export function emit(cmd, data, renderHuman) {
+  if (isJsonMode(cmd)) {
+    process.stdout.write(JSON.stringify(data, null, 2) + "\n");
+    return;
+  }
+  renderHuman(data);
+}
+
+export function fail(err) {
+  const msg = err?.message ?? String(err);
+  process.stderr.write(chalk.red(`✖ ${msg}\n`));
+  if (err?.body) {
+    try {
+      process.stderr.write(chalk.gray(JSON.stringify(err.body, null, 2)) + "\n");
+    } catch {}
+  }
+  process.exit(1);
+}
+
+export function table(headers, rows) {
+  const t = new Table({
+    head: headers.map((h) => chalk.bold.cyan(h)),
+    style: { head: [], border: ["gray"] },
+    wordWrap: true,
+  });
+  for (const row of rows) t.push(row);
+  return t.toString();
+}
+
+export function truncate(str, n = 40) {
+  if (str == null) return "";
+  const s = String(str);
+  return s.length > n ? s.slice(0, n - 1) + "…" : s;
+}
+
+export function withCommonOpts(cmd) {
+  return cmd
+    .option("--json", "output raw JSON")
+    .option("-w, --workspace <id>", "override workspace_id")
+    .option("-p, --profile <name>", "use a named profile")
+    .option("--api-key <key>", "override API key");
+}
+
+export function ctxFrom(cmd) {
+  const opts = cmd.optsWithGlobals();
+  return {
+    apiKey: opts.apiKey,
+    workspaceId: opts.workspace,
+    profile: opts.profile,
+  };
+}