@adityaprotocol/cli 0.1.0

package/README.md

@@ -0,0 +1,114 @@
+# @adityaprotocol/cli
+
+Command-line interface for [Aditya Protocol](https://adityaprotocol.com) — manage commands, approvals, and runs from your terminal.
+
+## Installation
+
+```bash
+npm install -g @adityaprotocol/cli
+```
+
+Or run without installing:
+
+```bash
+npx @adityaprotocol/cli health
+```
+
+## Setup
+
+Set your operator token as an environment variable:
+
+```bash
+export ADITYA_TOKEN="apt_user_your_token_here"
+```
+
+Optionally set a default workspace:
+
+```bash
+export ADITYA_WORKSPACE="your-workspace-id"
+```
+
+## Commands
+
+| Command | Description |
+|---|---|
+| `aditya health` | Check API status |
+| `aditya workspaces` | List your workspaces |
+| `aditya nodes <ws-id>` | List nodes in a workspace |
+| `aditya commands <ws-id> [status]` | List commands (optional status filter) |
+| `aditya pending <ws-id>` | List commands awaiting approval |
+| `aditya approve <cmd-id> [reason]` | Approve a pending command |
+| `aditya reject <cmd-id> [reason]` | Reject a pending command |
+| `aditya runs <ws-id>` | List runs |
+| `aditya audit <ws-id>` | Show recent audit trail |
+| `aditya create <ws-id> <node-id> <type>` | Create a new command |
+| `aditya export <ws-id>` | Export all workspace data (JSON) |
+
+## Usage Examples
+
+### Check API health
+
+```bash
+$ aditya health
+API: healthy (2026-04-05T12:00:00.000Z)
+```
+
+### List pending approvals
+
+```bash
+$ aditya pending bd6e32d0-ab21-428e-9e0b-a78cd8dce23c
+
+Pending approval:
+  ID          Type      Node        Created
+  --------    ------    --------    -------
+  a1b2c3d4    deploy    e5f6g7h8    2m ago
+```
+
+### Approve a command
+
+```bash
+$ aditya approve a1b2c3d4-full-uuid "Verified deployment is safe"
+Command a1b2c3d4... approved. Status: approved
+```
+
+### Create a command and wait for approval
+
+```bash
+$ aditya create $ADITYA_WORKSPACE $NODE_ID deploy
+Command created: a1b2c3d4-...
+Status: pending_approval (awaiting approval)
+```
+
+### Export workspace data
+
+```bash
+$ aditya export $ADITYA_WORKSPACE > workspace-backup.json
+```
+
+## Environment Variables
+
+| Variable | Required | Description |
+|---|---|---|
+| `ADITYA_TOKEN` | Yes (except `health`) | Operator token starting with `apt_user_` |
+| `ADITYA_API` | No | API base URL (default: `https://api.adityaprotocol.com`) |
+| `ADITYA_WORKSPACE` | No | Default workspace ID for commands that need one |
+
+## CI/CD Integration
+
+Use the CLI in GitHub Actions:
+
+```yaml
+- name: Check Aditya Protocol health
+  run: npx @adityaprotocol/cli health
+
+- name: Create deployment command
+  env:
+    ADITYA_TOKEN: ${{ secrets.ADITYA_TOKEN }}
+  run: npx @adityaprotocol/cli create $WORKSPACE_ID $NODE_ID deploy
+```
+
+For a full approval gate workflow, see the [Aditya Protocol GitHub Action](https://github.com/rrslt6d3/aditya-protocol/tree/main/packages/github-action).
+
+## License
+
+MIT

package/bin/aditya.mjs

@@ -0,0 +1,251 @@
+#!/usr/bin/env node
+
+const API = process.env.ADITYA_API || "https://api.adityaprotocol.com";
+const TOKEN = process.env.ADITYA_TOKEN || "";
+
+const [, , command, ...args] = process.argv;
+
+const headers = {
+  "Content-Type": "application/json",
+  ...(TOKEN ? { Authorization: `Bearer ${TOKEN}` } : {}),
+};
+
+async function api(method, path, body) {
+  const res = await fetch(`${API}${path}`, {
+    method,
+    headers,
+    ...(body ? { body: JSON.stringify(body) } : {}),
+  });
+  const text = await res.text();
+  let data;
+  try { data = JSON.parse(text); } catch { data = { raw: text }; }
+  if (!res.ok) {
+    console.error(`Error ${res.status}: ${data.error || text}`);
+    process.exit(1);
+  }
+  return data;
+}
+
+function table(rows, columns) {
+  if (!rows.length) { console.log("  (none)"); return; }
+  const widths = columns.map((col) =>
+    Math.max(col.label.length, ...rows.map((r) => String(col.get(r) ?? "").length))
+  );
+  const header = columns.map((col, i) => col.label.padEnd(widths[i])).join("  ");
+  const sep = widths.map((w) => "-".repeat(w)).join("  ");
+  console.log(`  ${header}`);
+  console.log(`  ${sep}`);
+  for (const row of rows) {
+    const line = columns.map((col, i) => String(col.get(row) ?? "").padEnd(widths[i])).join("  ");
+    console.log(`  ${line}`);
+  }
+}
+
+function short(id) { return id ? id.slice(0, 8) + "..." : "-"; }
+function ago(ts) {
+  if (!ts) return "-";
+  const ms = Date.now() - new Date(ts).getTime();
+  if (ms < 60000) return `${Math.floor(ms / 1000)}s ago`;
+  if (ms < 3600000) return `${Math.floor(ms / 60000)}m ago`;
+  if (ms < 86400000) return `${Math.floor(ms / 3600000)}h ago`;
+  return `${Math.floor(ms / 86400000)}d ago`;
+}
+
+async function run() {
+  if (!TOKEN && command !== "health" && command !== "help") {
+    console.error("Set ADITYA_TOKEN environment variable first:");
+    console.error('  export ADITYA_TOKEN="apt_user_..."');
+    process.exit(1);
+  }
+
+  switch (command) {
+    case "health": {
+      const data = await api("GET", "/health");
+      console.log(`API: ${data.ok ? "healthy" : "unhealthy"} (${data.timestamp})`);
+      break;
+    }
+
+    case "workspaces":
+    case "ws": {
+      const data = await api("GET", "/workspaces");
+      console.log("\nWorkspaces:");
+      table(data.workspaces, [
+        { label: "ID", get: (r) => short(r.id) },
+        { label: "Slug", get: (r) => r.slug },
+        { label: "Name", get: (r) => r.name },
+        { label: "Created", get: (r) => ago(r.created_at) },
+      ]);
+      break;
+    }
+
+    case "nodes": {
+      const wsId = args[0] || process.env.ADITYA_WORKSPACE;
+      if (!wsId) { console.error("Usage: aditya nodes <workspace-id>"); process.exit(1); }
+      const data = await api("GET", `/nodes?workspace_id=${wsId}`);
+      console.log("\nNodes:");
+      table(data.nodes, [
+        { label: "ID", get: (r) => short(r.id) },
+        { label: "Name", get: (r) => r.name },
+        { label: "Environment", get: (r) => r.environment },
+        { label: "Status", get: (r) => r.status },
+        { label: "Last seen", get: (r) => ago(r.last_seen_at) },
+      ]);
+      break;
+    }
+
+    case "commands":
+    case "cmds": {
+      const wsId = args[0] || process.env.ADITYA_WORKSPACE;
+      if (!wsId) { console.error("Usage: aditya commands <workspace-id> [status]"); process.exit(1); }
+      const status = args[1] || "";
+      const query = status ? `?workspace_id=${wsId}&status=${status}` : `?workspace_id=${wsId}`;
+      const data = await api("GET", `/commands${query}`);
+      console.log(`\nCommands${status ? ` (${status})` : ""}:`);
+      table(data.commands, [
+        { label: "ID", get: (r) => short(r.id) },
+        { label: "Type", get: (r) => r.command_type },
+        { label: "Status", get: (r) => r.status },
+        { label: "Node", get: (r) => short(r.node_id) },
+        { label: "Created", get: (r) => ago(r.created_at) },
+      ]);
+      break;
+    }
+
+    case "pending": {
+      const wsId = args[0] || process.env.ADITYA_WORKSPACE;
+      if (!wsId) { console.error("Usage: aditya pending <workspace-id>"); process.exit(1); }
+      const data = await api("GET", `/commands?workspace_id=${wsId}&status=pending_approval`);
+      console.log("\nPending approval:");
+      if (!data.commands.length) { console.log("  No commands awaiting approval."); break; }
+      table(data.commands, [
+        { label: "ID", get: (r) => short(r.id) },
+        { label: "Type", get: (r) => r.command_type },
+        { label: "Node", get: (r) => short(r.node_id) },
+        { label: "Created", get: (r) => ago(r.created_at) },
+      ]);
+      break;
+    }
+
+    case "approve": {
+      const cmdId = args[0];
+      const reason = args.slice(1).join(" ") || "Approved via CLI";
+      if (!cmdId) { console.error("Usage: aditya approve <command-id> [reason]"); process.exit(1); }
+      const data = await api("POST", `/commands/${cmdId}/approve`, {
+        reviewer_name: "cli-operator",
+        reason,
+      });
+      console.log(`Command ${short(cmdId)} approved. Status: ${data.command.status}`);
+      break;
+    }
+
+    case "reject": {
+      const cmdId = args[0];
+      const reason = args.slice(1).join(" ") || "Rejected via CLI";
+      if (!cmdId) { console.error("Usage: aditya reject <command-id> [reason]"); process.exit(1); }
+      const data = await api("POST", `/commands/${cmdId}/reject`, {
+        reviewer_name: "cli-operator",
+        reason,
+      });
+      console.log(`Command ${short(cmdId)} rejected. Status: ${data.command.status}`);
+      break;
+    }
+
+    case "runs": {
+      const wsId = args[0] || process.env.ADITYA_WORKSPACE;
+      if (!wsId) { console.error("Usage: aditya runs <workspace-id>"); process.exit(1); }
+      const data = await api("GET", `/runs?workspace_id=${wsId}`);
+      console.log("\nRuns:");
+      table(data.runs, [
+        { label: "ID", get: (r) => short(r.id) },
+        { label: "Status", get: (r) => r.status },
+        { label: "Command", get: (r) => short(r.command_id) },
+        { label: "Node", get: (r) => short(r.node_id) },
+        { label: "Exit", get: (r) => r.exit_code ?? "-" },
+        { label: "Created", get: (r) => ago(r.created_at) },
+      ]);
+      break;
+    }
+
+    case "audit": {
+      const wsId = args[0] || process.env.ADITYA_WORKSPACE;
+      if (!wsId) { console.error("Usage: aditya audit <workspace-id>"); process.exit(1); }
+      const data = await api("GET", `/audit-events?workspace_id=${wsId}`);
+      console.log("\nAudit trail:");
+      table(data.audit_events.slice(0, 20), [
+        { label: "Time", get: (r) => ago(r.created_at) },
+        { label: "Event", get: (r) => r.event_type },
+        { label: "Actor", get: (r) => r.actor_id ? (r.actor_id.length > 20 ? r.actor_id.slice(0, 20) + "..." : r.actor_id) : "-" },
+        { label: "Entity", get: (r) => `${r.entity_type}/${short(r.entity_id)}` },
+      ]);
+      break;
+    }
+
+    case "create-command":
+    case "create": {
+      const wsId = args[0] || process.env.ADITYA_WORKSPACE;
+      const nodeId = args[1];
+      const kind = args[2];
+      if (!wsId || !nodeId || !kind) {
+        console.error("Usage: aditya create <workspace-id> <node-id> <command-type>");
+        process.exit(1);
+      }
+      const data = await api("POST", "/commands", {
+        workspace_id: wsId,
+        node_id: nodeId,
+        kind,
+        payload: {},
+      });
+      console.log(`Command created: ${data.command.id}`);
+      console.log(`Status: ${data.command.status} (awaiting approval)`);
+      break;
+    }
+
+    case "export": {
+      const wsId = args[0] || process.env.ADITYA_WORKSPACE;
+      if (!wsId) { console.error("Usage: aditya export <workspace-id>"); process.exit(1); }
+      const data = await api("GET", `/export/workspace/${wsId}`);
+      console.log(JSON.stringify(data, null, 2));
+      break;
+    }
+
+    case "help":
+    default: {
+      console.log(`
+Aditya Protocol CLI v0.1.0
+
+Usage: aditya <command> [args]
+
+Environment:
+  ADITYA_TOKEN       Operator token (required, starts with apt_user_)
+  ADITYA_API         API base URL (default: https://api.adityaprotocol.com)
+  ADITYA_WORKSPACE   Default workspace ID (optional)
+
+Commands:
+  health                              Check API status
+  workspaces, ws                      List your workspaces
+  nodes <ws-id>                       List nodes in a workspace
+  commands, cmds <ws-id> [status]     List commands (optional status filter)
+  pending <ws-id>                     List commands awaiting approval
+  approve <cmd-id> [reason]           Approve a pending command
+  reject <cmd-id> [reason]            Reject a pending command
+  runs <ws-id>                        List runs
+  audit <ws-id>                       Show recent audit trail
+  create <ws-id> <node-id> <type>     Create a new command
+  export <ws-id>                      Export all workspace data (JSON)
+  help                                Show this help
+
+Examples:
+  aditya health
+  aditya pending bd6e32d0-ab21-428e-9e0b-a78cd8dce23c
+  aditya approve a1b2c3d4-... "Verified deployment is safe"
+  aditya audit bd6e32d0-ab21-428e-9e0b-a78cd8dce23c
+`);
+      break;
+    }
+  }
+}
+
+run().catch((err) => {
+  console.error(`Fatal: ${err.message}`);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@adityaprotocol/cli",
+  "version": "0.1.0",
+  "description": "CLI for Aditya Protocol — manage commands, approvals, and runs from your terminal",
+  "bin": {
+    "aditya": "./bin/aditya.mjs"
+  },
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rrslt6d3/aditya-protocol.git",
+    "directory": "packages/cli"
+  },
+  "homepage": "https://adityaprotocol.com",
+  "bugs": {
+    "url": "https://github.com/rrslt6d3/aditya-protocol/issues"
+  },
+  "keywords": ["aditya-protocol", "cli", "approval", "operations", "control-plane", "human-in-the-loop"],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "bin/",
+    "README.md"
+  ]
+}