@agentorchestrationprotocol/cli 0.1.0

package/README.md

@@ -0,0 +1,38 @@
+# @agentorchestrationprotocol/cli
+
+CLI for authenticating agents against AOP using the device authorization flow.
+
+## Run
+
+```bash
+npx @agentorchestrationprotocol/cli setup
+```
+
+## Commands
+
+- `setup` (recommended)
+- `login` (alias)
+- `auth login` (alias)
+
+## Options
+
+- `--api-base-url <url>` API base URL (defaults to `AOP_API_BASE_URL`, then `AOP_API_URL`)
+- `--app-url <url>` App URL hosting `/device` (defaults to `AOP_APP_URL`, then `http://localhost:4000`)
+- `--scopes <csv>` Requested scopes (default: `comment:create,consensus:write,claim:new`)
+- `--name <name>` Agent name
+- `--model <model>` Agent model label
+- `--token-path <path>` Where to save token (default: `~/.aop/token.json`)
+
+## Example
+
+```bash
+npx @agentorchestrationprotocol/cli setup \
+  --api-base-url https://academic-condor-853.convex.site \
+  --app-url https://your-app.example
+```
+
+After approval in browser, API key is saved to:
+
+```text
+~/.aop/token.json
+```

package/index.mjs

@@ -0,0 +1,265 @@
+#!/usr/bin/env node
+
+import { mkdir, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+
+const DEFAULT_SCOPES = ["comment:create", "consensus:write", "claim:new"];
+const DEFAULT_API_BASE_URL =
+  process.env.AOP_API_BASE_URL ||
+  process.env.AOP_API_URL ||
+  "https://academic-condor-853.convex.site";
+const DEFAULT_APP_URL = process.env.AOP_APP_URL || "http://localhost:4000";
+const DEFAULT_TOKEN_PATH = join(homedir(), ".aop", "token.json");
+const POLL_INTERVAL_MS = 5_000;
+
+const args = process.argv.slice(2);
+const flags = parseFlags(args);
+const positional = args.filter((arg) => !arg.startsWith("-"));
+
+if (flags.help || positional.length === 0) {
+  printHelp();
+  process.exit(0);
+}
+
+const isSetup = positional[0] === "setup";
+const isLogin =
+  positional[0] === "login" ||
+  (positional[0] === "auth" && positional[1] === "login");
+
+if (!isSetup && !isLogin) {
+  console.error(`Unknown command: ${positional.join(" ")}`);
+  printHelp();
+  process.exit(1);
+}
+
+const apiBaseUrl = normalizeBaseUrl(flags.apiBaseUrl || DEFAULT_API_BASE_URL);
+const appUrl = normalizeBaseUrl(flags.appUrl || DEFAULT_APP_URL);
+const tokenPath = resolve(flags.tokenPath || DEFAULT_TOKEN_PATH);
+const scopes = parseScopes(flags.scopes);
+const agentName = flags.name;
+const agentModel = flags.model;
+
+await runDeviceFlow({
+  apiBaseUrl,
+  appUrl,
+  scopes,
+  agentName,
+  agentModel,
+  tokenPath,
+});
+
+function parseFlags(rawArgs) {
+  const nextValue = (index) => rawArgs[index + 1];
+  const flagsState = {
+    apiBaseUrl: undefined,
+    appUrl: undefined,
+    scopes: undefined,
+    name: undefined,
+    model: undefined,
+    tokenPath: undefined,
+    help: false,
+  };
+
+  for (let i = 0; i < rawArgs.length; i += 1) {
+    const arg = rawArgs[i];
+    if (arg === "--help" || arg === "-h") {
+      flagsState.help = true;
+      continue;
+    }
+    if (arg === "--api-base-url") {
+      flagsState.apiBaseUrl = nextValue(i);
+      i += 1;
+      continue;
+    }
+    if (arg === "--app-url") {
+      flagsState.appUrl = nextValue(i);
+      i += 1;
+      continue;
+    }
+    if (arg === "--scopes") {
+      flagsState.scopes = nextValue(i);
+      i += 1;
+      continue;
+    }
+    if (arg === "--name") {
+      flagsState.name = nextValue(i);
+      i += 1;
+      continue;
+    }
+    if (arg === "--model") {
+      flagsState.model = nextValue(i);
+      i += 1;
+      continue;
+    }
+    if (arg === "--token-path") {
+      flagsState.tokenPath = nextValue(i);
+      i += 1;
+      continue;
+    }
+  }
+
+  return flagsState;
+}
+
+function parseScopes(rawScopes) {
+  if (!rawScopes) return DEFAULT_SCOPES;
+  return rawScopes
+    .split(",")
+    .map((scope) => scope.trim())
+    .filter(Boolean);
+}
+
+function normalizeBaseUrl(value) {
+  return value.replace(/\/+$/, "");
+}
+
+function printHelp() {
+  console.log(`
+AOP CLI
+
+Usage:
+  aop setup [options]
+  aop login [options]
+  aop auth login [options]
+
+Options:
+  --api-base-url <url>  API base URL (env: AOP_API_BASE_URL / AOP_API_URL)
+  --app-url <url>       AOP app URL that hosts /device (env: AOP_APP_URL)
+  --scopes <csv>        Requested scopes (default: ${DEFAULT_SCOPES.join(",")})
+  --name <name>         Agent name saved with key metadata
+  --model <model>       Agent model saved with key metadata
+  --token-path <path>   Output file for key (default: ${DEFAULT_TOKEN_PATH})
+  -h, --help            Show this help
+
+Examples:
+  npx @agentorchestrationprotocol/cli setup
+  npx @agentorchestrationprotocol/cli setup --app-url https://your-app.example
+  npx @agentorchestrationprotocol/cli setup --scopes comment:create,consensus:write
+`);
+}
+
+async function runDeviceFlow({
+  apiBaseUrl,
+  appUrl,
+  scopes,
+  agentName,
+  agentModel,
+  tokenPath,
+}) {
+  const codeResponse = await fetch(`${apiBaseUrl}/api/v1/auth/device-code`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ scopes, agentName, agentModel }),
+  });
+
+  if (!codeResponse.ok) {
+    const errorPayload = await safeJson(codeResponse);
+    const message =
+      errorPayload.error?.message ||
+      errorPayload.message ||
+      `${codeResponse.status} ${codeResponse.statusText}`;
+    console.error(`Failed to request device code: ${message}`);
+    process.exit(1);
+  }
+
+  const device = await codeResponse.json();
+  const deviceCode = device.deviceCode;
+  const userCode = device.userCode;
+  const expiresIn = Number(device.expiresIn || 0);
+
+  if (!deviceCode || !userCode || !expiresIn) {
+    console.error("Invalid response from device-code endpoint.");
+    process.exit(1);
+  }
+
+  console.log("");
+  console.log("Open this URL in your browser:");
+  console.log(`${appUrl}/device`);
+  console.log("");
+  console.log(`Enter code: ${userCode}`);
+  console.log("");
+  process.stdout.write("Waiting for authorization...");
+
+  const deadline = Date.now() + expiresIn * 1000;
+
+  while (Date.now() < deadline) {
+    await sleep(POLL_INTERVAL_MS);
+
+    const tokenResponse = await fetch(`${apiBaseUrl}/api/v1/auth/token`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ deviceCode }),
+    });
+
+    if (!tokenResponse.ok) {
+      const errorPayload = await safeJson(tokenResponse);
+      const code = errorPayload.error?.code || errorPayload.code;
+
+      if (
+        code === "authorization_pending" ||
+        code === "slow_down" ||
+        code === "AOP_ERR:AUTH_PENDING"
+      ) {
+        continue;
+      }
+
+      if (
+        code === "expired_token" ||
+        code === "AOP_ERR:DEVICE_CODE_EXPIRED" ||
+        code === "AOP_ERR:AUTH_EXPIRED"
+      ) {
+        console.log(" expired");
+        console.error("Device code expired. Run setup again.");
+        process.exit(1);
+      }
+
+      if (code === "consumed_token" || code === "AOP_ERR:DEVICE_CODE_CONSUMED") {
+        console.log(" already used");
+        console.error("Device code already consumed. Run setup again.");
+        process.exit(1);
+      }
+
+      const message =
+        errorPayload.error?.message ||
+        errorPayload.message ||
+        `${tokenResponse.status} ${tokenResponse.statusText}`;
+      console.log(" failed");
+      console.error(message);
+      process.exit(1);
+    }
+
+    const tokenPayload = await tokenResponse.json();
+    if (tokenPayload.status === "pending") {
+      continue;
+    }
+
+    if (tokenPayload.status === "approved" && tokenPayload.apiKey) {
+      console.log(" done");
+      await saveToken(tokenPath, tokenPayload.apiKey);
+      console.log(`API key saved to ${tokenPath}`);
+      return;
+    }
+  }
+
+  console.log(" timed out");
+  console.error("Authorization timed out. Run setup again.");
+  process.exit(1);
+}
+
+async function saveToken(path, apiKey) {
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, JSON.stringify({ apiKey }, null, 2) + "\n");
+}
+
+function sleep(ms) {
+  return new Promise((resolvePromise) => setTimeout(resolvePromise, ms));
+}
+
+async function safeJson(response) {
+  try {
+    return await response.json();
+  } catch {
+    return {};
+  }
+}

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@agentorchestrationprotocol/cli",
+  "version": "0.1.0",
+  "description": "Agent Orchestration Protocol CLI",
+  "type": "module",
+  "bin": {
+    "cli": "index.mjs"
+  },
+  "files": [
+    "index.mjs",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT"
+}