@consiliency/agent-board-cli 1.3.0 → 1.5.0

package/dist/cli.d.ts

@@ -1,5 +1,5 @@
 import { Command } from "commander";
-import { type EnrollmentIntent, type PendingEnrollmentStore } from "@consiliency/agent-board-client";
+import { type EnrollKeystore, type EnrollmentIntent, type PendingEnrollmentStore, type OAuthFetchLike, type FetchLike } from "@consiliency/agent-board-client";
 type JsonObject = Record<string, unknown>;
 export interface CliIo {
     writeStdout(message: string): void;
@@ -114,6 +114,7 @@ export interface EnrollmentCommandRunner {
         intent: EnrollmentIntent;
         agentKind?: string;
         requestedScopes?: string[];
+        requestedBoardScopes?: string[];
         oob?: boolean;
     }): Promise<unknown>;
     complete(input: {
@@ -123,7 +124,28 @@ export interface EnrollmentCommandRunner {
         slug?: string;
     }): Promise<unknown>;
 }
-export declare function defaultEnrollmentRunner(env?: NodeJS.ProcessEnv, store?: PendingEnrollmentStore): EnrollmentCommandRunner;
+export interface DefaultEnrollmentRunnerDeps {
+    /** Pending store bridging begin→complete. Default: FilePendingEnrollmentStore(env). */
+    store?: PendingEnrollmentStore;
+    /** OAuth/enroll fetch. Default: nodeFetchAdapter over globalThis.fetch. */
+    fetch?: OAuthFetchLike;
+    /** Board-native fetch for the post-enroll SessionClient. Default: nodeFetchAdapter. */
+    boardFetch?: FetchLike;
+    /** Composed EnrollKeystore. Default: buildEnrollKeystore(descriptor, env) (os_keychain). */
+    keystore?: EnrollKeystore;
+    /** Browser opener for the one-shot loopback flow. Default: makeBrowserOpener. */
+    openAuthorization?: (authorizationUrl: string) => void | Promise<void>;
+    /** The deployed /enroll URL. Default: resolveEnrollEndpoint(env). */
+    enrollEndpoint?: string;
+    /** Clock (tests). Default: wall clock. */
+    now?: () => number;
+    /** Writer for the default browser opener's printed URL. Default: process std streams. */
+    io?: {
+        writeStdout(message: string): void;
+        writeStderr(message: string): void;
+    };
+}
+export declare function defaultEnrollmentRunner(env?: NodeJS.ProcessEnv, deps?: DefaultEnrollmentRunnerDeps): 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,6 @@
 import { Command, Option } from "commander";
-import { createAgentBoardClient, toOperationFailure, beginEnrollment, completeEnrollment, runEnrollment, resolveEnrollmentDescriptor, InMemoryPendingEnrollmentStore, } from "@consiliency/agent-board-client";
+import { createAgentBoardClient, toOperationFailure, beginEnrollment, completeEnrollment, runEnrollment, resolveEnrollmentDescriptor, resolveEnrollEndpoint, nodeFetchAdapter, buildEnrollKeystore, } from "@consiliency/agent-board-client";
+import { FilePendingEnrollmentStore, makeBrowserOpener } from "./enroll_runtime.js";
 function isRuntimeStatus(value) {
     return Boolean(value && typeof value === "object" && "runtime" in value);
 }
@@ -1207,33 +1208,71 @@ function addReadCommands(program, client, io) {
         limit: options.limit,
     })));
 }
-// 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");
-    };
+const processWriter = {
+    writeStdout: (message) => process.stdout.write(message),
+    writeStderr: (message) => process.stderr.write(message),
+};
+// The default runner drives the live enrollment flow: `run` = one-shot loopback +
+// browser opener; `begin`/`complete` = headless OOB two-step bridged by a
+// file-backed store (loopback cannot span two CLI processes). Every seam is
+// injectable so tests assert the wiring against a mock issuer without a live Portal.
+export function defaultEnrollmentRunner(env = process.env, deps = {}) {
+    const fetch = deps.fetch ?? nodeFetchAdapter;
+    const boardFetch = deps.boardFetch ?? nodeFetchAdapter;
     return {
         async run(input) {
-            resolveEnrollmentDescriptor(env);
-            void beginEnrollment;
-            void completeEnrollment;
-            void runEnrollment;
-            void store;
-            void input;
-            return notConfigured();
+            const descriptor = resolveEnrollmentDescriptor(env);
+            const enrollEndpoint = deps.enrollEndpoint ?? resolveEnrollEndpoint(env);
+            const keystore = deps.keystore ?? buildEnrollKeystore(descriptor, env);
+            const openAuthorization = deps.openAuthorization ?? makeBrowserOpener(deps.io ?? processWriter);
+            return runEnrollment(descriptor, input.intent, {
+                slug: input.slug,
+                agentKind: input.agentKind,
+                requestedScopes: input.requestedScopes,
+                requestedBoardScopes: input.requestedBoardScopes,
+            }, {
+                fetch,
+                enrollEndpoint,
+                keystore,
+                boardFetch,
+                keystoreBackends: keystore.backends,
+                openAuthorization,
+                now: deps.now,
+            });
         },
         async begin(input) {
-            resolveEnrollmentDescriptor(env);
-            void input;
-            return notConfigured();
+            // Force OOB: a loopback receiver cannot bridge two separate CLI processes, so
+            // the two-step path is always out-of-band paste (no redirectUri ⇒ OOB).
+            const descriptor = resolveEnrollmentDescriptor(env);
+            const store = deps.store ?? new FilePendingEnrollmentStore(env);
+            return beginEnrollment({
+                descriptor,
+                intent: input.intent,
+                slug: input.slug,
+                agentKind: input.agentKind,
+                requestedScopes: input.requestedScopes,
+                requestedBoardScopes: input.requestedBoardScopes,
+                redirectMode: "oob",
+            }, store, { fetch, clientId: descriptor.issuer.clientId, now: deps.now });
         },
         async complete(input) {
-            void input;
-            return notConfigured();
+            const descriptor = resolveEnrollmentDescriptor(env);
+            const enrollEndpoint = deps.enrollEndpoint ?? resolveEnrollEndpoint(env);
+            const keystore = deps.keystore ?? buildEnrollKeystore(descriptor, env);
+            const store = deps.store ?? new FilePendingEnrollmentStore(env);
+            return completeEnrollment({
+                enrollmentId: input.enrollmentId,
+                code: input.code,
+                redirectResponse: input.redirectResponse,
+                slug: input.slug,
+            }, store, {
+                fetch,
+                enrollEndpoint,
+                keystore,
+                boardFetch,
+                keystoreBackends: keystore.backends,
+                now: deps.now,
+            });
         },
     };
 }
@@ -1291,29 +1330,55 @@ function addEnrollCommands(program, io, enrollment) {
         .option("--agent-kind <kind>", "agent kind")
         .option("--create-board <slug>", "create-board intent slug")
         .option("--board-name <name>", "board name for create-board")
+        .option("--board-description <description>", "board description for create-board")
+        .option("--visibility <visibility>", "board visibility 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")
+        .option("--requested-board-scopes <csv>", "requested board scopes (comma-separated)")
+        // A6: `begin` is ALWAYS out-of-band (a loopback receiver cannot bridge the two
+        // separate begin/complete CLI processes), so this flag is a vestigial no-op kept
+        // only for backward compatibility. Use `enroll run` for the loopback flow.
+        .option("--oob", "(deprecated, no-op) begin is always out-of-band; kept for compatibility")
         .action((options) => runHandler(io, "agent_board.begin_enrollment", () => enrollment.begin({
         slug: options.slug,
         agentKind: options.agentKind,
         intent: intentFromOptions(options),
         requestedScopes: csv(options.requestedScopes),
+        requestedBoardScopes: csv(options.requestedBoardScopes),
         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("--code <code>", "the authorization code (prefer stdin; argv leaks via /proc/<pid>/cmdline)")
         .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,
-    })));
+        .action(async (options) => {
+        // A5: keep the auth code off argv where practical. When neither --code nor
+        // --redirect-response is supplied and stdin is piped, read the code from stdin.
+        let code = options.code;
+        if (!code && !options.redirectResponse) {
+            code = await readCodeFromStdin();
+        }
+        return runHandler(io, "agent_board.complete_enrollment", () => enrollment.complete({
+            enrollmentId: options.enrollmentId,
+            code,
+            redirectResponse: options.redirectResponse,
+            slug: options.slug,
+        }));
+    });
+}
+/** Read a single-line auth code from a piped stdin (A5). Returns undefined on a TTY. */
+async function readCodeFromStdin() {
+    if (process.stdin.isTTY)
+        return undefined;
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(chunk);
+    }
+    const text = Buffer.concat(chunks).toString("utf8").trim();
+    return text.length > 0 ? text : undefined;
 }
 export function createProgram(client, io, enrollment = defaultEnrollmentRunner()) {
     const program = new Command()

package/dist/enroll_runtime.d.ts

@@ -0,0 +1,59 @@
+import { type PendingEnrollment, type PendingEnrollmentStore } from "@consiliency/agent-board-client";
+export declare class EnrollRuntimeError extends Error {
+    code: string;
+    constructor(code: string, message: string);
+}
+export interface FilePendingEnrollmentStoreOptions {
+    /** Override the state directory (default: $XDG_STATE_HOME/agent-board/pending-enroll). */
+    dir?: string;
+    /** Clock for the TTL sweep (default: Date.now()/1000). */
+    now?: () => number;
+    /** Non-sensitive warning sink (default: console.warn). */
+    warn?: (message: string) => void;
+}
+export declare class FilePendingEnrollmentStore implements PendingEnrollmentStore {
+    private readonly dir;
+    private readonly env;
+    private readonly now?;
+    private readonly warn;
+    constructor(env?: NodeJS.ProcessEnv, options?: FilePendingEnrollmentStoreOptions);
+    private fileFor;
+    private ensureDir;
+    /**
+     * Refuse a dir/file that is not a regular dir/file, not uid-owned, or too permissive.
+     * The pending FILE holds the PKCE `code_verifier` (a secret), so it must be
+     * owner-only (reject ANY group/other bit, 0o077); the dir need only be non-
+     * group/other-writable (0o022).
+     */
+    private guard;
+    put(pending: PendingEnrollment): Promise<void>;
+    get(enrollmentId: string): Promise<PendingEnrollment | undefined>;
+    delete(enrollmentId: string): Promise<void>;
+    /** Opportunistic TTL sweep (A2.5): delete expired files, skipping `exceptId`. */
+    private sweep;
+}
+/** Minimal stdout/stderr sink (structurally compatible with the CLI's CliIo). */
+export interface EnrollWriter {
+    writeStdout(message: string): void;
+    writeStderr(message: string): void;
+}
+/** Injectable spawn seam (tests drive a fake; production wraps child_process.spawn). */
+export type SpawnLike = (command: string, args: readonly string[], options: {
+    shell: false;
+    detached: boolean;
+    stdio: "ignore";
+}) => {
+    unref(): void;
+};
+export interface BrowserOpenerOptions {
+    spawn?: SpawnLike;
+    platform?: NodeJS.Platform;
+}
+/**
+ * Build an `openAuthorization(url)` that (A3): asserts the URL is http(s) BEFORE
+ * doing anything with it; ALWAYS prints the URL first so headless/CI works even
+ * with no browser; then spawns the platform launcher with `shell:false` (no shell
+ * re-parse), detached + unref'd. A spawn failure is logged (message only), NEVER
+ * thrown — the printed URL is the fallback.
+ */
+export declare function makeBrowserOpener(io: EnrollWriter, options?: BrowserOpenerOptions): (url: string) => void;

package/dist/enroll_runtime.js

@@ -0,0 +1,273 @@
+// MBENROLL SL-3 — CLI-only enrollment runtime: file-backed pending store + browser
+// opener. These need node fs / child_process, so they live in the CLI package (the
+// shared, node-agnostic host helpers live in the client's enroll_host.ts). The MCP
+// server uses neither — it bridges begin→complete via an in-process singleton and
+// has no local browser reachable by the remote human.
+import { spawn } from "node:child_process";
+import { constants as FS } from "node:fs";
+import * as fs from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { resolveEnrollmentDescriptor, } from "@consiliency/agent-board-client";
+export class EnrollRuntimeError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = "EnrollRuntimeError";
+        this.code = code;
+    }
+}
+function nowSeconds(now) {
+    return now ? now() : Math.floor(Date.now() / 1000);
+}
+function defaultStateDir(env) {
+    const xdg = env.XDG_STATE_HOME && env.XDG_STATE_HOME.trim().length > 0 ? env.XDG_STATE_HOME.trim() : null;
+    const base = xdg ?? join(homedir(), ".local", "state");
+    return join(base, "agent-board", "pending-enroll");
+}
+const ENR_FILE = /^enr-[A-Za-z0-9-]+\.json$/;
+// Transient write-temp (`<file>.tmp-<pid>-<ts>`); only exists mid-put(). A lingering
+// one is orphaned by a crash between open() and rename() and holds the code_verifier.
+const TEMP_FILE = /^enr-[A-Za-z0-9-]+\.json\.tmp-\d+-\d+$/;
+const ORPHAN_TEMP_MS = 120_000;
+export class FilePendingEnrollmentStore {
+    dir;
+    env;
+    now;
+    warn;
+    constructor(env = process.env, options = {}) {
+        this.env = env;
+        this.dir = options.dir ?? defaultStateDir(env);
+        this.now = options.now;
+        this.warn = options.warn ?? ((m) => console.warn(m));
+    }
+    fileFor(enrollmentId) {
+        return join(this.dir, `${enrollmentId}.json`);
+    }
+    async ensureDir() {
+        await fs.mkdir(this.dir, { recursive: true, mode: 0o700 });
+    }
+    /**
+     * Refuse a dir/file that is not a regular dir/file, not uid-owned, or too permissive.
+     * The pending FILE holds the PKCE `code_verifier` (a secret), so it must be
+     * owner-only (reject ANY group/other bit, 0o077); the dir need only be non-
+     * group/other-writable (0o022).
+     */
+    async guard(path, kind) {
+        const st = await fs.lstat(path);
+        if (kind === "dir" ? !st.isDirectory() : !st.isFile()) {
+            throw new EnrollRuntimeError("insecure_state_path", `refusing ${kind} ${path}: not a regular ${kind} (possible symlink/tamper)`);
+        }
+        if (typeof process.getuid === "function" && st.uid !== process.getuid()) {
+            throw new EnrollRuntimeError("insecure_state_path", `refusing ${kind} ${path}: not owned by the current user`);
+        }
+        const forbidden = kind === "file" ? 0o077 : 0o022;
+        if ((st.mode & forbidden) !== 0) {
+            throw new EnrollRuntimeError("insecure_state_path", kind === "file"
+                ? `refusing ${kind} ${path}: is group/other-accessible (secret must be 0600)`
+                : `refusing ${kind} ${path}: is group/other-writable`);
+        }
+    }
+    async put(pending) {
+        await this.ensureDir();
+        await this.guard(this.dir, "dir");
+        await this.sweep();
+        // Persist ONLY the begin-time binding — NOT the descriptor's endpoint set (A2.1).
+        const record = {
+            enrollmentId: pending.enrollmentId,
+            intent: pending.intent,
+            slug: pending.slug,
+            agentKind: pending.agentKind,
+            requestedScopes: pending.requestedScopes,
+            requestedBoardScopes: pending.requestedBoardScopes,
+            pkce: pending.pkce,
+            state: pending.state,
+            redirectUri: pending.redirectUri,
+            redirectMode: pending.redirectMode,
+            clientId: pending.clientId,
+            expiresAt: pending.expiresAt,
+        };
+        const finalPath = this.fileFor(pending.enrollmentId);
+        const tempPath = `${finalPath}.tmp-${process.pid}-${Date.now()}`;
+        // O_CREAT|O_EXCL|O_WRONLY|O_NOFOLLOW at 0600 — never follow a pre-planted symlink.
+        const handle = await fs.open(tempPath, FS.O_CREAT | FS.O_EXCL | FS.O_WRONLY | FS.O_NOFOLLOW, 0o600);
+        try {
+            await handle.writeFile(JSON.stringify(record), "utf8");
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+        try {
+            await fs.rename(tempPath, finalPath);
+        }
+        catch (err) {
+            // Never orphan a temp file holding the code_verifier if the rename fails.
+            await fs.unlink(tempPath).catch(() => { });
+            throw err;
+        }
+    }
+    async get(enrollmentId) {
+        // Reap OTHER abandoned files, but NEVER the requested id — completeEnrollment
+        // relies on get() returning an expired record so it can raise `enrollment_expired`
+        // (an expired requested id must not degrade to `unknown_enrollment`).
+        await this.sweep(enrollmentId);
+        const path = this.fileFor(enrollmentId);
+        let raw;
+        try {
+            await this.guard(path, "file");
+            const handle = await fs.open(path, FS.O_RDONLY | FS.O_NOFOLLOW);
+            try {
+                raw = await handle.readFile("utf8");
+            }
+            finally {
+                await handle.close();
+            }
+        }
+        catch (err) {
+            const code = err.code;
+            if (code === "ENOENT")
+                return undefined; // absent
+            if (err instanceof EnrollRuntimeError)
+                throw err; // tamper — fail loud
+            if (code === "ELOOP") {
+                throw new EnrollRuntimeError("insecure_state_path", `refusing ${path}: symlink encountered on read`);
+            }
+            throw err;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            return undefined; // corrupt → absent (never log contents)
+        }
+        // A2.1: reconstruct the descriptor FRESH from trusted env — the on-disk value
+        // (if any) is IGNORED so a tampered file cannot redirect the exchange/JWKS/board.
+        const descriptor = resolveEnrollmentDescriptor(this.env);
+        if (parsed.descriptor && typeof parsed.descriptor === "object") {
+            const diskEndpoint = parsed.descriptor.issuer?.tokenEndpoint;
+            if (diskEndpoint && diskEndpoint !== descriptor.issuer.tokenEndpoint) {
+                this.warn(`agent-board: ignoring an on-disk enrollment descriptor that disagrees with the current environment`);
+            }
+        }
+        return {
+            enrollmentId: parsed.enrollmentId,
+            descriptor,
+            intent: parsed.intent,
+            slug: parsed.slug,
+            agentKind: parsed.agentKind,
+            requestedScopes: parsed.requestedScopes,
+            requestedBoardScopes: parsed.requestedBoardScopes,
+            pkce: parsed.pkce,
+            state: parsed.state,
+            redirectUri: parsed.redirectUri,
+            redirectMode: parsed.redirectMode ?? "oob",
+            clientId: parsed.clientId,
+            expiresAt: parsed.expiresAt,
+        };
+    }
+    async delete(enrollmentId) {
+        try {
+            await fs.unlink(this.fileFor(enrollmentId));
+        }
+        catch (err) {
+            if (err.code !== "ENOENT")
+                throw err; // ENOENT-tolerant
+        }
+    }
+    /** Opportunistic TTL sweep (A2.5): delete expired files, skipping `exceptId`. */
+    async sweep(exceptId) {
+        let entries;
+        try {
+            entries = await fs.readdir(this.dir);
+        }
+        catch {
+            return; // dir absent yet — nothing to sweep
+        }
+        const cutoff = nowSeconds(this.now);
+        const wallNow = Date.now();
+        for (const name of entries) {
+            // Reap crash-orphaned write-temps (they carry the code_verifier). Transient by
+            // design, so any older than ORPHAN_TEMP_MS is orphaned; use wall-clock mtime
+            // (independent of the injectable TTL clock).
+            if (TEMP_FILE.test(name)) {
+                try {
+                    const st = await fs.lstat(join(this.dir, name));
+                    if (st.isFile() && wallNow - st.mtimeMs > ORPHAN_TEMP_MS) {
+                        await fs.unlink(join(this.dir, name)).catch(() => { });
+                    }
+                }
+                catch {
+                    /* racing unlink / tamper — skip */
+                }
+                continue;
+            }
+            if (!ENR_FILE.test(name))
+                continue;
+            const id = name.slice(0, -".json".length);
+            if (id === exceptId)
+                continue;
+            const path = join(this.dir, name);
+            try {
+                await this.guard(path, "file");
+                const handle = await fs.open(path, FS.O_RDONLY | FS.O_NOFOLLOW);
+                let raw;
+                try {
+                    raw = await handle.readFile("utf8");
+                }
+                finally {
+                    await handle.close();
+                }
+                const rec = JSON.parse(raw);
+                if (typeof rec.expiresAt === "number" && cutoff > rec.expiresAt) {
+                    await fs.unlink(path).catch(() => { });
+                }
+            }
+            catch {
+                // Corrupt / tampered / racing-unlink file — skip (never throw from a sweep).
+            }
+        }
+    }
+}
+function launcherFor(platform, url) {
+    if (platform === "darwin")
+        return { command: "open", args: [url] };
+    // NON-reparsing on win32: cmd /c start "" re-tokenizes `&` in OAuth URLs, so use
+    // rundll32 FileProtocolHandler which takes the URL as a single, un-split argument.
+    if (platform === "win32")
+        return { command: "rundll32", args: ["url.dll,FileProtocolHandler", url] };
+    return { command: "xdg-open", args: [url] };
+}
+/**
+ * Build an `openAuthorization(url)` that (A3): asserts the URL is http(s) BEFORE
+ * doing anything with it; ALWAYS prints the URL first so headless/CI works even
+ * with no browser; then spawns the platform launcher with `shell:false` (no shell
+ * re-parse), detached + unref'd. A spawn failure is logged (message only), NEVER
+ * thrown — the printed URL is the fallback.
+ */
+export function makeBrowserOpener(io, options = {}) {
+    const spawnImpl = options.spawn ?? ((command, args, opts) => spawn(command, [...args], opts));
+    const platform = options.platform ?? process.platform;
+    return (url) => {
+        let parsed;
+        try {
+            parsed = new URL(url);
+        }
+        catch {
+            throw new EnrollRuntimeError("invalid_authorization_url", "the authorization URL is not a valid URL");
+        }
+        if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
+            throw new EnrollRuntimeError("unsafe_authorization_scheme", `refusing to open a non-http(s) authorization URL (scheme ${parsed.protocol})`);
+        }
+        io.writeStdout(`Open this URL to authorize:\n${url}\n`);
+        const { command, args } = launcherFor(platform, url);
+        try {
+            const child = spawnImpl(command, args, { shell: false, detached: true, stdio: "ignore" });
+            child.unref();
+        }
+        catch (err) {
+            io.writeStderr(`(could not launch a browser automatically: ${err.message}; open the URL above manually)\n`);
+        }
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@consiliency/agent-board-cli",
-  "version": "1.3.0",
+  "version": "1.5.0",
   "repository": "https://github.com/Consiliency/message-board.git",
   "type": "module",
   "main": "./dist/index.js",
@@ -31,7 +31,7 @@
     "registry": "https://registry.npmjs.org"
   },
   "dependencies": {
-    "@consiliency/agent-board-client": "1.3.0",
+    "@consiliency/agent-board-client": "1.7.0",
     "commander": "^14.0.1"
   },
   "license": "Apache-2.0"