@consiliency/agent-board-cli 1.2.0 → 1.4.0

package/dist/cli.d.ts

@@ -1,4 +1,5 @@
 import { Command } from "commander";
+import { type EnrollmentIntent, type PendingEnrollmentStore } from "@consiliency/agent-board-client";
 type JsonObject = Record<string, unknown>;
 export interface CliIo {
     writeStdout(message: string): void;
@@ -100,6 +101,29 @@ export declare function signingStatusFromEnv(env?: NodeJS.ProcessEnv): {
         redacted: boolean;
     };
 };
-export declare function createProgram(client: ClientLike, io: CliIo): Command;
-export declare function runCli(argv: string[], io?: CliIo, client?: ClientLike): Promise<void>;
+export interface EnrollmentCommandRunner {
+    run(input: {
+        slug: string;
+        intent: EnrollmentIntent;
+        agentKind?: string;
+        requestedScopes?: string[];
+        requestedBoardScopes?: string[];
+    }): Promise<unknown>;
+    begin(input: {
+        slug: string;
+        intent: EnrollmentIntent;
+        agentKind?: string;
+        requestedScopes?: string[];
+        oob?: boolean;
+    }): Promise<unknown>;
+    complete(input: {
+        enrollmentId: string;
+        code?: string;
+        redirectResponse?: string;
+        slug?: string;
+    }): Promise<unknown>;
+}
+export declare function defaultEnrollmentRunner(env?: NodeJS.ProcessEnv, store?: PendingEnrollmentStore): EnrollmentCommandRunner;
+export declare function createProgram(client: ClientLike, io: CliIo, enrollment?: EnrollmentCommandRunner): Command;
+export declare function runCli(argv: string[], io?: CliIo, client?: ClientLike, enrollment?: EnrollmentCommandRunner): Promise<void>;
 export {};

package/dist/cli.js

@@ -1,5 +1,5 @@
 import { Command, Option } from "commander";
-import { createAgentBoardClient, toOperationFailure, } from "@consiliency/agent-board-client";
+import { createAgentBoardClient, toOperationFailure, beginEnrollment, completeEnrollment, runEnrollment, resolveEnrollmentDescriptor, InMemoryPendingEnrollmentStore, } from "@consiliency/agent-board-client";
 function isRuntimeStatus(value) {
     return Boolean(value && typeof value === "object" && "runtime" in value);
 }
@@ -1207,7 +1207,115 @@ function addReadCommands(program, client, io) {
         limit: options.limit,
     })));
 }
-export function createProgram(client, io) {
+// The default runner resolves the env descriptor (proving configuration) and then
+// requires a host-provided keystore integration. Live enrollment (generating the
+// agent key in an OS keychain/TPM/HSM and opening the browser) is gated on the
+// external Portal integration (E1/E2); the command + wiring exist here.
+export function defaultEnrollmentRunner(env = process.env, store = new InMemoryPendingEnrollmentStore()) {
+    const notConfigured = () => {
+        throw new Error("live enrollment requires a configured keystore backend (os_keychain/tpm/agent_socket/hsm) " +
+            "and browser opener; the environment descriptor resolved but no keystore integration is wired");
+    };
+    return {
+        async run(input) {
+            resolveEnrollmentDescriptor(env);
+            void beginEnrollment;
+            void completeEnrollment;
+            void runEnrollment;
+            void store;
+            void input;
+            return notConfigured();
+        },
+        async begin(input) {
+            resolveEnrollmentDescriptor(env);
+            void input;
+            return notConfigured();
+        },
+        async complete(input) {
+            void input;
+            return notConfigured();
+        },
+    };
+}
+function intentFromOptions(options) {
+    if (options.joinBoard) {
+        return { kind: "join_board", boardId: options.joinBoard };
+    }
+    const slug = options.createBoard ?? options.slug ?? "";
+    return {
+        kind: "create_board",
+        slug,
+        name: options.boardName ?? slug,
+        description: options.boardDescription,
+        visibility: options.visibility,
+    };
+}
+function csv(value) {
+    return value
+        ? String(value)
+            .split(",")
+            .map((v) => v.trim())
+            .filter(Boolean)
+        : undefined;
+}
+function addEnrollCommands(program, io, enrollment) {
+    const enroll = program
+        .command("enroll")
+        .description("enroll this agent via OAuth auth-code+PKCE and provision a board");
+    // One-shot loopback flow. It is a DEFAULT subcommand (isDefault) so bare
+    // `enroll ...` runs it, while keeping its options off the parent — otherwise a
+    // parent-level --slug shadows the begin/complete subcommands' own --slug.
+    enroll
+        .command("run", { isDefault: true })
+        .description("one-shot enrollment over an RFC 8252 loopback receiver")
+        .requiredOption("--slug <slug>", "desired agent slug")
+        .option("--agent-kind <kind>", "agent kind (default 'agent')")
+        .option("--create-board <slug>", "create-board intent slug")
+        .option("--board-name <name>", "board name for create-board")
+        .option("--board-description <description>", "board description")
+        .option("--visibility <visibility>", "board visibility")
+        .option("--join-board <boardId>", "join-board intent board id")
+        .option("--requested-scopes <csv>", "requested scopes (comma-separated)")
+        .option("--requested-board-scopes <csv>", "requested board scopes (comma-separated)")
+        .action((options) => runHandler(io, "agent_board.enroll", () => enrollment.run({
+        slug: options.slug,
+        agentKind: options.agentKind,
+        intent: intentFromOptions(options),
+        requestedScopes: csv(options.requestedScopes),
+        requestedBoardScopes: csv(options.requestedBoardScopes),
+    })));
+    enroll
+        .command("begin")
+        .description("begin an enrollment; prints the authorization URL (no code_verifier/state)")
+        .requiredOption("--slug <slug>", "desired agent slug")
+        .option("--agent-kind <kind>", "agent kind")
+        .option("--create-board <slug>", "create-board intent slug")
+        .option("--board-name <name>", "board name for create-board")
+        .option("--join-board <boardId>", "join-board intent board id")
+        .option("--requested-scopes <csv>", "requested scopes (comma-separated)")
+        .option("--oob", "use the out-of-band paste flow instead of loopback")
+        .action((options) => runHandler(io, "agent_board.begin_enrollment", () => enrollment.begin({
+        slug: options.slug,
+        agentKind: options.agentKind,
+        intent: intentFromOptions(options),
+        requestedScopes: csv(options.requestedScopes),
+        oob: Boolean(options.oob),
+    })));
+    enroll
+        .command("complete")
+        .description("complete an enrollment with the authorization code")
+        .requiredOption("--enrollment-id <id>", "the enrollment id from begin")
+        .option("--code <code>", "the authorization code (OOB paste)")
+        .option("--redirect-response <url>", "the full redirect response URL")
+        .option("--slug <slug>", "override the agent slug")
+        .action((options) => runHandler(io, "agent_board.complete_enrollment", () => enrollment.complete({
+        enrollmentId: options.enrollmentId,
+        code: options.code,
+        redirectResponse: options.redirectResponse,
+        slug: options.slug,
+    })));
+}
+export function createProgram(client, io, enrollment = defaultEnrollmentRunner()) {
     const program = new Command()
         .name("agent-board")
         .description("Thin CLI surface for the agent_board RPC and canonical read contracts")
@@ -1228,12 +1336,13 @@ export function createProgram(client, io) {
         .action((options) => runRuntimeDoctor(io, client, Boolean(options.requireRuntime)));
     addWriteCommands(program, client, io);
     addReadCommands(program, client, io);
+    addEnrollCommands(program, io, enrollment);
     return program;
 }
 export async function runCli(argv, io = {
     writeStdout: (message) => process.stdout.write(message),
     writeStderr: (message) => process.stderr.write(message),
-}, client = createAgentBoardClient()) {
-    const program = createProgram(client, io);
+}, client = createAgentBoardClient(), enrollment = defaultEnrollmentRunner()) {
+    const program = createProgram(client, io, enrollment);
     await program.parseAsync(argv, { from: "user" });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@consiliency/agent-board-cli",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "repository": "https://github.com/Consiliency/message-board.git",
   "type": "module",
   "main": "./dist/index.js",
@@ -20,18 +20,19 @@
     "LICENSE",
     "NOTICE"
   ],
+  "scripts": {
+    "build": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\" && tsc -p tsconfig.build.json",
+    "prepack": "pnpm run build",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run"
+  },
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org"
   },
   "dependencies": {
-    "commander": "^14.0.1",
-    "@consiliency/agent-board-client": "1.2.0"
+    "@consiliency/agent-board-client": "1.6.0",
+    "commander": "^14.0.1"
   },
-  "license": "Apache-2.0",
-  "scripts": {
-    "build": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\" && tsc -p tsconfig.build.json",
-    "typecheck": "tsc -p tsconfig.json --noEmit",
-    "test": "vitest run"
-  }
-}
+  "license": "Apache-2.0"
+}