@rankigi/cli 1.0.0

package/dist/index.js

@@ -0,0 +1,275 @@
+#!/usr/bin/env node
+/**
+ * @rankigi/cli
+ *
+ * One command: `npx @rankigi/cli init`
+ *
+ * Prompts for an API key and an agent name, calls /api/agents/birth,
+ * and writes RANKIGI_* credentials to .env in the current directory.
+ *
+ * The signing private key is returned exactly once by the birth endpoint.
+ * The CLI writes it to .env on the developer's machine. RANKIGI never
+ * stores it server side.
+ */
+import { createInterface } from "node:readline/promises";
+import { stdin, stdout } from "node:process";
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+const DEFAULT_BASE_URL = process.env.RANKIGI_BASE_URL || "https://rankigi.com";
+async function resolveCanonByFlag(baseUrl, apiKey, slugOrName) {
+    try {
+        const res = await fetch(baseUrl + "/api/v1/canons?status=active", {
+            headers: { Authorization: "Bearer " + apiKey },
+        });
+        if (!res.ok)
+            return null;
+        const body = (await res.json());
+        if (!body.ok || !Array.isArray(body.canons))
+            return null;
+        const needle = slugOrName.toLowerCase();
+        return (body.canons.find((c) => c.name.toLowerCase() === needle) ??
+            body.canons.find((c) => c.name.toLowerCase().includes(needle)) ??
+            body.canons.find((c) => c.id === slugOrName) ??
+            null);
+    }
+    catch {
+        return null;
+    }
+}
+async function ask(question, opts = {}) {
+    if (opts.mask && stdin.isTTY && typeof stdin.setRawMode === "function") {
+        stdout.write(question);
+        const answer = await readMasked();
+        return answer.trim();
+    }
+    const rl = createInterface({ input: stdin, output: stdout, terminal: true });
+    try {
+        const answer = await rl.question(question);
+        return answer.trim();
+    }
+    finally {
+        rl.close();
+    }
+}
+function readMasked() {
+    return new Promise((resolve) => {
+        let buf = "";
+        const onData = (chunk) => {
+            const s = chunk.toString("utf8");
+            for (const ch of s) {
+                if (ch === "\n" || ch === "\r") {
+                    stdin.removeListener("data", onData);
+                    stdin.setRawMode(false);
+                    stdin.pause();
+                    stdout.write("\n");
+                    resolve(buf);
+                    return;
+                }
+                if (ch === "\u0003") {
+                    process.exit(130);
+                }
+                if (ch === "\u007f" || ch === "\b") {
+                    if (buf.length > 0) {
+                        buf = buf.slice(0, -1);
+                        stdout.write("\b \b");
+                    }
+                    continue;
+                }
+                buf += ch;
+                stdout.write("*");
+            }
+        };
+        stdin.setRawMode(true);
+        stdin.resume();
+        stdin.on("data", onData);
+    });
+}
+function mergeEnv(existing, updates) {
+    const lines = existing.length > 0 ? existing.split(/\r?\n/) : [];
+    const seen = new Set();
+    const out = [];
+    for (const line of lines) {
+        const match = /^([A-Z0-9_]+)=/.exec(line);
+        if (match && Object.prototype.hasOwnProperty.call(updates, match[1])) {
+            out.push(`${match[1]}=${updates[match[1]]}`);
+            seen.add(match[1]);
+        }
+        else {
+            out.push(line);
+        }
+    }
+    if (out.length > 0 && out[out.length - 1] !== "")
+        out.push("");
+    for (const [key, value] of Object.entries(updates)) {
+        if (!seen.has(key))
+            out.push(`${key}=${value}`);
+    }
+    if (out[out.length - 1] !== "")
+        out.push("");
+    return out.join("\n");
+}
+async function init(canonSlug) {
+    console.log("RANKIGI agent enrollment");
+    console.log("");
+    console.log("Get your API key from https://app.rankigi.com/dashboard/keys");
+    console.log("");
+    const apiKey = await ask("RANKIGI_API_KEY: ", { mask: true });
+    if (!apiKey) {
+        console.error("Error: API key is required.");
+        process.exit(1);
+    }
+    const agentName = await ask("Agent name: ");
+    if (!agentName) {
+        console.error("Error: agent name is required.");
+        process.exit(1);
+    }
+    const baseUrl = DEFAULT_BASE_URL.replace(/\/$/, "");
+    const url = `${baseUrl}/api/agents/birth`;
+    // Optional canon resolution. If --canon was supplied, look the slug up
+    // against the public registry before enrollment so we can include
+    // default_canon_id in the birth body and surface the canon name in the
+    // success message. Resolution failures are non-fatal; org default applies.
+    let canonResolved = null;
+    if (canonSlug) {
+        canonResolved = await resolveCanonByFlag(baseUrl, apiKey, canonSlug);
+        if (!canonResolved) {
+            console.error(`Warning: canon "${canonSlug}" not found in registry. Falling back to org default.`);
+        }
+    }
+    const birthBody = { name: agentName };
+    if (canonResolved)
+        birthBody.default_canon_id = canonResolved.id;
+    let res;
+    try {
+        res = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${apiKey}`,
+            },
+            body: JSON.stringify(birthBody),
+        });
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        console.error(`Error: request to ${url} failed: ${msg}`);
+        process.exit(1);
+        return;
+    }
+    const text = await res.text();
+    let body;
+    try {
+        body = JSON.parse(text);
+    }
+    catch {
+        console.error(`Error: non JSON response from server (HTTP ${res.status}).`);
+        console.error(text.slice(0, 500));
+        process.exit(1);
+        return;
+    }
+    if (!res.ok || !body.ok || !body.agent || !body.passport || !body.signing_private_key_b64) {
+        const reason = body.error || `HTTP ${res.status}`;
+        console.error(`Error: agent birth failed: ${reason}`);
+        process.exit(1);
+        return;
+    }
+    const credentialJson = JSON.stringify({
+        v: 1,
+        typ: "rankigi_agent_credential",
+        env: "live",
+        apiKey,
+        agentId: body.agent.id,
+        passportId: body.passport.id,
+        signingPrivateKey: body.signing_private_key_b64,
+        alg: "Ed25519",
+        issuedAt: new Date().toISOString(),
+    });
+    const credentialToken = "rnk_live_cred_v1." +
+        Buffer.from(credentialJson, "utf8")
+            .toString("base64")
+            .replace(/\+/g, "-")
+            .replace(/\//g, "_")
+            .replace(/=+$/, "");
+    const envPath = join(process.cwd(), ".env");
+    const existing = existsSync(envPath) ? readFileSync(envPath, "utf8") : "";
+    const updated = mergeEnv(existing, {
+        RANKIGI_CREDENTIAL: credentialToken,
+        ANTHROPIC_API_KEY: "",
+    });
+    writeFileSync(envPath, updated, { mode: 0o600 });
+    console.log("");
+    console.log("Agent enrolled successfully.");
+    console.log("RANKIGI_CREDENTIAL written to .env");
+    console.log("");
+    console.log(`Your agent: ${body.agent.name}`);
+    console.log(`Agent ID: ${body.agent.id}`);
+    if (canonResolved) {
+        console.log(`Governing standard: ${canonResolved.name} v${canonResolved.version}`);
+    }
+    console.log("");
+    console.log("Add ANTHROPIC_API_KEY to your .env and run:");
+    console.log("npx ts-node examples/anthropic_demo.ts");
+}
+function resolveDemoAgentPath() {
+    // Try repo-relative paths so `rankigi run` works whether invoked from the
+    // monorepo root or from the installed CLI's dist directory.
+    const here = dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+        join(process.cwd(), "scripts", "demo-agent.ts"),
+        resolve(here, "..", "..", "..", "..", "scripts", "demo-agent.ts"),
+        resolve(here, "..", "..", "..", "scripts", "demo-agent.ts"),
+    ];
+    for (const p of candidates)
+        if (existsSync(p))
+            return p;
+    return null;
+}
+async function run(model) {
+    if (model !== "claude" && model !== undefined) {
+        console.error(`Unsupported model: ${model}. Supported: claude`);
+        process.exit(1);
+    }
+    const scriptPath = resolveDemoAgentPath();
+    if (!scriptPath) {
+        console.error("Could not locate scripts/demo-agent.ts. Run from the rankigi repo.");
+        process.exit(1);
+    }
+    const child = spawn("npx", ["tsx", scriptPath], {
+        stdio: "inherit",
+        env: process.env,
+    });
+    child.on("exit", (code) => process.exit(code ?? 0));
+}
+function parseFlag(argv, flag) {
+    const eqPrefix = flag + "=";
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === flag)
+            return argv[i + 1];
+        if (a.startsWith(eqPrefix))
+            return a.slice(eqPrefix.length);
+    }
+    return undefined;
+}
+async function main() {
+    const cmd = process.argv[2];
+    if (cmd === "init" || cmd === undefined) {
+        const canon = parseFlag(process.argv.slice(2), "--canon");
+        await init(canon);
+        return;
+    }
+    if (cmd === "run") {
+        await run(process.argv[3]);
+        return;
+    }
+    console.error(`Unknown command: ${cmd}`);
+    console.error("Usage: rankigi init [--canon <slug>] | rankigi run claude");
+    process.exit(1);
+}
+main().catch((e) => {
+    const msg = e instanceof Error ? e.message : String(e);
+    console.error(`Error: ${msg}`);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@rankigi/cli",
+  "version": "1.0.0",
+  "description": "RANKIGI CLI. One command to enroll an agent and write credentials to .env.",
+  "license": "MIT",
+  "author": "Rankigi <hello@rankigi.com>",
+  "type": "module",
+  "main": "./dist/index.js",
+  "bin": {
+    "rankigi": "./dist/index.js"
+  },
+  "files": ["dist", "README.md"],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc"
+  },
+  "devDependencies": {
+    "@types/node": "^20",
+    "typescript": "^5.4"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}