@neta-art/cohub-cli 8.4.0 → 9.0.0

package/dist/space.js

@@ -1,15 +1,26 @@
 import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { resolveCohubEnvironment } from "@neta-art/cohub";
+import { HOME_SPACE_SLUG, parseSpaceRef, resolveCohubEnvironment } from "@neta-art/cohub";
 import { readAuthSession } from "./auth.js";
 import { createClient } from "./client.js";
 import { getRuntimeSpaceBinding } from "./runtime/space-binding.js";
 import { error, handleHttp } from "./output.js";
 const CONFIG_DIR = join(homedir(), ".config", "cohub");
-const CACHE_PATH = join(CONFIG_DIR, "default-space.json");
+const CACHE_PATH = join(CONFIG_DIR, "home-space.json");
+/** Legacy cache that may name another user's Home; never read. */
+const LEGACY_CACHE_PATH = join(CONFIG_DIR, "default-space.json");
 /** Home space is stable; a one-day TTL bounds how long a stale hit survives. */
 const CACHE_TTL_MS = 86_400_000;
+const SPACE_REF_HINT = "Use a Space ID, a slug you own such as home, or username/slug.";
+export class SpaceTargetError extends Error {
+    detail;
+    name = "SpaceTargetError";
+    constructor(message, detail) {
+        super(message);
+        this.detail = detail;
+    }
+}
 function jwtClaim(token, key) {
     const payload = token?.split(".")[1];
     if (!payload)
@@ -46,7 +57,7 @@ export function currentIdentityKey() {
     });
 }
 /** Exported for tests; production always uses `CACHE_PATH`. */
-export function readDefaultSpaceCache(path, key, now = Date.now()) {
+export function readHomeSpaceCache(path, key, now = Date.now()) {
     try {
         const cache = JSON.parse(readFileSync(path, "utf-8"));
         if (cache.key !== key || typeof cache.spaceId !== "string" || typeof cache.cachedAt !== "number")
@@ -59,21 +70,25 @@ export function readDefaultSpaceCache(path, key, now = Date.now()) {
         return null;
     }
 }
-function writeCachedDefaultSpace(key, spaceId) {
+function writeHomeSpaceCache(key, spaceId) {
     try {
         mkdirSync(CONFIG_DIR, { recursive: true });
         const cache = { key, spaceId, cachedAt: Date.now() };
         writeFileSync(CACHE_PATH, `${JSON.stringify(cache, null, 2)}\n`, { encoding: "utf-8", mode: 0o600 });
+        rmSync(LEGACY_CACHE_PATH, { force: true });
     }
     catch {
         // Cache is best-effort; never fail the command over it.
     }
 }
-let defaultSpacePromise = null;
-export function clearDefaultSpaceCache() {
-    defaultSpacePromise = null;
+let homeSpacePromise = null;
+const spaceRefs = new Map();
+export function clearHomeSpaceCache() {
+    homeSpacePromise = null;
+    spaceRefs.clear();
     try {
         rmSync(CACHE_PATH, { force: true });
+        rmSync(LEGACY_CACHE_PATH, { force: true });
     }
     catch {
         // Best-effort, same as writes.
@@ -90,48 +105,80 @@ export function explicitSpace(program) {
     }
     return process.env.COHUB_SPACE_ID?.trim() || null;
 }
-/**
- * Resolve the user's home space when no target is given. Cached locally per
- * identity so repeated invocations skip the network entirely, and memoized
- * in-process so preAction hooks and actions share a single lookup.
- * Network and auth failures propagate so callers can report them faithfully.
- */
-export function resolveDefaultSpace() {
-    defaultSpacePromise ??= (async () => {
+/** Cached per identity and memoized per process. */
+export function resolveHomeSpace() {
+    homeSpacePromise ??= (async () => {
         const key = currentIdentityKey();
-        if (key) {
-            const cached = readDefaultSpaceCache(CACHE_PATH, key);
-            if (cached)
-                return cached;
-        }
-        const space = (await createClient().spaces.getDefault()).space ?? null;
-        // Recent-space fallback from getDefault() is not stable enough to cache.
-        if (space?.id && space.slug === "home" && key)
-            writeCachedDefaultSpace(key, space.id);
-        return space?.id ?? null;
+        const cached = key ? readHomeSpaceCache(CACHE_PATH, key) : null;
+        if (cached)
+            return cached;
+        const space = await createClient().spaces.ensureHome();
+        if (key)
+            writeHomeSpaceCache(key, space.id);
+        return space.id;
     })();
-    return defaultSpacePromise;
+    return homeSpacePromise;
+}
+async function lookupSpaceRef(value) {
+    const ref = parseSpaceRef(value);
+    if (!ref)
+        throw new SpaceTargetError(`Invalid space '${value}'`, SPACE_REF_HINT);
+    if (ref.kind === "id")
+        return ref.id;
+    if (ref.kind === "owned" && ref.slug === HOME_SPACE_SLUG)
+        return resolveHomeSpace();
+    const spaces = createClient().spaces;
+    try {
+        const space = ref.kind === "owned"
+            ? await spaces.getOwnedBySlug(ref.slug)
+            : await spaces.getBySlug(ref.username, ref.slug);
+        return space.id;
+    }
+    catch (e) {
+        if (e.status === 404)
+            throw new SpaceTargetError(`Space '${value}' not found`, SPACE_REF_HINT);
+        throw e;
+    }
+}
+export function resolveSpaceRef(value) {
+    const key = value.trim();
+    let resolved = spaceRefs.get(key);
+    if (!resolved) {
+        resolved = lookupSpaceRef(key);
+        spaceRefs.set(key, resolved);
+    }
+    return resolved;
+}
+export function failSpaceTarget(e) {
+    if (e instanceof SpaceTargetError)
+        return error(e.message, e.detail);
+    return handleHttp(e);
 }
 /** Shared exit for commands that need a space but resolved none. */
 export function missingSpaceError() {
-    return error("No target space", "Add -s, --space <id> or set COHUB_SPACE_ID. Run `cohub auth login` to use your home space.");
+    return error("No target space", "Pass -s <space> (an ID, home, or username/slug), set COHUB_SPACE_ID, or run in a directory bound with `cohub runtime up`.");
 }
-/**
- * Resolve a Space from an optional explicit target, the current directory
- * binding, and finally the user's Home Space.
- */
 export async function resolveBoundSpace(options = {}) {
     const bound = await getRuntimeSpaceBinding(options.cwd ?? process.cwd(), currentIdentityKey(), options.bindingsPath).catch(handleHttp);
     return bound?.spaceId ?? null;
 }
+/** Explicit target or `COHUB_SPACE_ID`, then the directory binding, then Home when allowed. */
 export async function resolveSpaceTarget(target, options = {}) {
     const explicit = target?.trim() || process.env.COHUB_SPACE_ID?.trim() || null;
-    if (explicit)
-        return explicit;
-    return (await resolveBoundSpace(options))
-        ?? (await resolveDefaultSpace().catch(handleHttp))
-        ?? missingSpaceError();
-}
-export async function resolveSpace(program) {
-    return resolveSpaceTarget(explicitSpace(program));
+    try {
+        if (explicit)
+            return await resolveSpaceRef(explicit);
+        const bound = await resolveBoundSpace(options);
+        if (bound)
+            return bound;
+        if (options.home)
+            return await resolveHomeSpace();
+    }
+    catch (e) {
+        return failSpaceTarget(e);
+    }
+    return missingSpaceError();
+}
+export function resolveSpace(command, options = {}) {
+    return resolveSpaceTarget(explicitSpace(command), options);
 }

package/dist/web.d.ts

@@ -0,0 +1 @@
+export declare function webUrl(path: string): string;

package/dist/web.js

@@ -0,0 +1,6 @@
+import { resolveCohubEnvironment } from "@neta-art/cohub";
+export function webUrl(path) {
+    const origin = process.env.COHUB_WEB_URL?.replace(/\/+$/, "") ??
+        `https://${resolveCohubEnvironment() === "prod" ? "" : "dev."}cohub.live`;
+    return `${origin}${path}`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neta-art/cohub-cli",
-  "version": "8.4.0",
+  "version": "9.0.0",
   "description": "CLI for Cohub — spaces, sessions, and agent collaboration.",
   "type": "module",
   "engines": {
@@ -20,25 +20,29 @@
   "dependencies": {
     "@neta-art/generation": "^0.1.30",
     "commander": "^15.0.0",
-    "pixi.js": "^8.20.1",
     "sharp": "^0.35.4",
     "ws": "^8.21.3",
-    "@neta-art/cohub": "8.23.0"
+    "@neta-art/cohub": "9.0.0"
   },
   "publishConfig": {
     "access": "public"
   },
   "devDependencies": {
+    "@fontsource/geist": "^5.3.0",
+    "@fontsource/geist-mono": "^5.3.0",
     "@types/node": "^26.4.0",
     "@types/ws": "^8.18.1",
+    "pixi.js": "^8.20.1",
+    "tsdown": "^0.22.14",
     "typescript": "^7.0.2"
   },
   "optionalDependencies": {
     "@napi-rs/canvas": "^1.0.8"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.build.json",
+    "build": "tsc -p tsconfig.build.json && tsdown",
     "verify:sandboxd": "node --import tsx scripts/verify-sandboxd-release.ts",
+    "verify:board-kernel": "node --import tsx scripts/verify-board-kernel.ts",
     "test": "node ../../scripts/test/run.mjs 'tests/**/*.test.ts'",
     "test:runtime": "node --import tsx --test tests/runtime-*.integration.ts",
     "test:runtime:native": "node --import tsx tests/runtime-native.smoke.ts",

package/dist/commands/board-domain.d.ts

@@ -1,2 +0,0 @@
-import type { Command } from "commander";
-export declare function registerBoardDomainCommands(boards: Command): void;

package/dist/commands/board-domain.js

@@ -1,16 +0,0 @@
-import { registerBoardAnimationCommands } from "./boards/animation.js";
-import { registerBoardAppearanceCommands } from "./boards/appearance.js";
-import { registerBoardExampleCommands } from "./boards/examples.js";
-import { registerBoardBatchCommand } from "./boards/batch.js";
-import { registerBoardConnectionCommands } from "./boards/connections.js";
-import { registerBoardItemCommands } from "./boards/items.js";
-import { registerBoardTransactionCommands } from "./boards/transactions.js";
-export function registerBoardDomainCommands(boards) {
-    registerBoardExampleCommands(boards);
-    registerBoardAppearanceCommands(boards);
-    registerBoardBatchCommand(boards);
-    registerBoardConnectionCommands(boards);
-    registerBoardItemCommands(boards);
-    registerBoardAnimationCommands(boards);
-    registerBoardTransactionCommands(boards);
-}

package/dist/commands/boards/animation.d.ts

@@ -1,2 +0,0 @@
-import type { Command } from "commander";
-export declare function registerBoardAnimationCommands(boards: Command): void;

package/dist/commands/boards/animation.js

@@ -1,171 +0,0 @@
-import { parseBoardEffectInput, parseBoardCompositionInput, } from "@neta-art/cohub";
-import { BOARD_DOMAIN_INPUT_MAX_BYTES, readBoardJsonObject, } from "../../board-command-support.js";
-import { handleHttp, json, jsonRequested, table } from "../../output.js";
-import { mutateSemantic, readInput, readOptions, resolvedBoard, showUpdated, withJson, } from "./context.js";
-export function registerBoardAnimationCommands(boards) {
-    const effects = boards.command("effects").description("Manage Board effects");
-    readOptions(withJson(effects.command("list <board>").alias("ls").description("List effects")))
-        .action(async (target, options) => {
-        try {
-            const board = await resolvedBoard(boards, target);
-            const result = await board.authoring(readInput(options, "effects"));
-            const effects = result.effects ?? [];
-            if (jsonRequested(options))
-                return json(effects);
-            table(effects, [
-                { key: "id", label: "ID" },
-                { key: "kind", label: "KIND" },
-                { key: "enabled", label: "ENABLED" },
-                { key: "layer", label: "LAYER" },
-            ]);
-        }
-        catch (cause) {
-            handleHttp(cause);
-        }
-    });
-    withJson(effects.command("get <board> <effect-id>").description("Get one complete Board effect"))
-        .action(async (target, effectId, options) => {
-        try {
-            const board = await resolvedBoard(boards, target);
-            const result = await board.authoring({ include: ["effects"], effectIds: [effectId] });
-            const effect = result.effects?.[0];
-            if (!effect)
-                throw new Error(`Effect not found: ${effectId}`);
-            if (jsonRequested(options))
-                return json(effect);
-            table([effect], [
-                { key: "id", label: "ID" },
-                { key: "kind", label: "KIND" },
-                { key: "enabled", label: "ENABLED" },
-                { key: "layer", label: "LAYER" },
-            ]);
-        }
-        catch (cause) {
-            handleHttp(cause);
-        }
-    });
-    withJson(effects.command("apply <board>")
-        .description("Atomically create or replace an effect")
-        .requiredOption("-i, --input <file>", "Board effect JSON; use - for stdin")
-        .addHelpText("after", `
-Create a template:
-  cohub boards examples effect pulse > effect.json
-
-Discover supported effect kinds:
-  cohub boards capabilities <board> --json`))
-        .action(async (target, options) => {
-        try {
-            const input = await readBoardJsonObject(options.input, BOARD_DOMAIN_INPUT_MAX_BYTES);
-            const effect = parseBoardEffectInput(input);
-            const board = await resolvedBoard(boards, target);
-            showUpdated(await mutateSemantic(board, [{ type: "effect.apply", effect }]), options);
-        }
-        catch (cause) {
-            handleHttp(cause);
-        }
-    });
-    withJson(effects.command("delete <board> <effect-id>").alias("rm").description("Delete an effect"))
-        .action(async (target, effectId, options) => {
-        try {
-            const board = await resolvedBoard(boards, target);
-            showUpdated(await mutateSemantic(board, [{ type: "effect.delete", effectId }]), options);
-        }
-        catch (cause) {
-            handleHttp(cause);
-        }
-    });
-    const compositions = boards
-        .command("compositions")
-        .description("Manage atomic Board animation compositions");
-    readOptions(withJson(compositions.command("list <board>").alias("ls").description("List compositions")))
-        .action(async (target, options) => {
-        try {
-            const board = await resolvedBoard(boards, target);
-            const result = await board.authoring(readInput(options, "compositions"));
-            const compositions = result.compositions ?? [];
-            if (jsonRequested(options))
-                return json(compositions);
-            table(compositions.map((composition) => ({
-                id: composition.id,
-                name: composition.name,
-                duration: composition.timeline.duration,
-                tracks: composition.timeline.tracks.length,
-                clips: composition.timeline.clips.length,
-                revision: composition.revision,
-            })), [
-                { key: "id", label: "ID" },
-                { key: "name", label: "NAME" },
-                { key: "duration", label: "DURATION" },
-                { key: "tracks", label: "TRACKS" },
-                { key: "clips", label: "CLIPS" },
-                { key: "revision", label: "REVISION" },
-            ]);
-        }
-        catch (cause) {
-            handleHttp(cause);
-        }
-    });
-    withJson(compositions.command("get <board> <composition-id>").description("Get one complete composition"))
-        .action(async (target, compositionId, options) => {
-        try {
-            const board = await resolvedBoard(boards, target);
-            const result = await board.authoring({ include: ["compositions"], compositionIds: [compositionId] });
-            const composition = result.compositions?.[0];
-            if (!composition)
-                throw new Error(`Composition not found: ${compositionId}`);
-            if (jsonRequested(options))
-                return json(composition);
-            table([{
-                    id: composition.id,
-                    name: composition.name,
-                    duration: composition.timeline.duration,
-                    tracks: composition.timeline.tracks.length,
-                    clips: composition.timeline.clips.length,
-                    revision: composition.revision,
-                }], [
-                { key: "id", label: "ID" },
-                { key: "name", label: "NAME" },
-                { key: "duration", label: "DURATION" },
-                { key: "tracks", label: "TRACKS" },
-                { key: "clips", label: "CLIPS" },
-                { key: "revision", label: "REVISION" },
-            ]);
-        }
-        catch (cause) {
-            handleHttp(cause);
-        }
-    });
-    withJson(compositions.command("apply <board>")
-        .description("Atomically create or replace a composition")
-        .requiredOption("-i, --input <file>", "BoardComposition JSON; use - for stdin")
-        .addHelpText("after", `
-Property changes use timeline.tracks with registered channels and keyframes.
-Procedural behavior such as text reveal, particles, and camera focus uses timeline.clips.
-Run boards capabilities to discover channels and clip schemas.
-Create an editable template with:
-  cohub boards examples composition fade > intro.json
-
-Minimal fade composition:
-  {"id":"intro","name":"Intro","timeline":{"duration":800,"tracks":[{"id":"title-opacity","target":{"type":"item","itemId":"title"},"channel":"style.opacity","fill":"both","keyframes":[{"time":0,"value":0},{"time":800,"value":1,"easing":"ease-out-cubic"}]}],"clips":[],"markers":[]},"playback":{"loop":false,"endBehavior":"hold","reducedMotion":{"mode":"base"}}}`))
-        .action(async (target, options) => {
-        try {
-            const input = await readBoardJsonObject(options.input, BOARD_DOMAIN_INPUT_MAX_BYTES);
-            const composition = parseBoardCompositionInput(input);
-            const board = await resolvedBoard(boards, target);
-            showUpdated(await mutateSemantic(board, [{ type: "composition.apply", composition }]), options);
-        }
-        catch (cause) {
-            handleHttp(cause);
-        }
-    });
-    withJson(compositions.command("delete <board> <composition-id>").alias("rm").description("Delete a composition"))
-        .action(async (target, compositionId, options) => {
-        try {
-            const board = await resolvedBoard(boards, target);
-            showUpdated(await mutateSemantic(board, [{ type: "composition.delete", compositionId }]), options);
-        }
-        catch (cause) {
-            handleHttp(cause);
-        }
-    });
-}

package/dist/commands/boards/appearance.d.ts

@@ -1,2 +0,0 @@
-import type { Command } from "commander";
-export declare function registerBoardAppearanceCommands(boards: Command): void;

package/dist/commands/boards/appearance.js

@@ -1,127 +0,0 @@
-import { BoardAppearanceSchema, DEFAULT_BOARD_APPEARANCE, patchBoardAppearance, } from "@neta-art/cohub/board";
-import { handleHttp } from "../../output.js";
-import { finite, mutateSemantic, resolvedBoard, showUpdated, withJson, } from "./context.js";
-function appearanceFrom(metadata) {
-    const parsed = BoardAppearanceSchema.safeParse(metadata.appearance);
-    return parsed.success ? parsed.data : DEFAULT_BOARD_APPEARANCE;
-}
-export function registerBoardAppearanceCommands(boards) {
-    withJson(boards.command("rename <board> <title>").description("Rename a Board"))
-        .action(async (target, title, options) => {
-        try {
-            const board = await resolvedBoard(boards, target);
-            showUpdated(await mutateSemantic(board, [{ type: "board.patch", patch: { title } }]), options);
-        }
-        catch (cause) {
-            handleHttp(cause);
-        }
-    });
-    withJson(boards.command("background <board>")
-        .description("Configure the Board background")
-        .option("--color <color>", "Solid CSS color")
-        .option("--image <url>", "Public image URL")
-        .option("--fit <mode>", "cover, contain, or repeat", "cover")
-        .option("--position <position>", "center, top, bottom, left, or right", "center")
-        .option("--opacity <value>", "Image opacity from 0 to 1", "1")
-        .option("--reset", "Restore the default background")
-        .addHelpText("after", `
-Examples:
-  cohub boards background plan.board --color "#123456"
-  cohub boards background plan.board --image https://example.com/bg.webp --fit cover --opacity 0.8`))
-        .action(async (target, options) => {
-        try {
-            const selected = [options.color, options.image, options.reset ? "reset" : undefined].filter(Boolean);
-            if (selected.length !== 1)
-                throw new Error("Choose one of --color, --image, or --reset");
-            if (!["cover", "contain", "repeat"].includes(options.fit))
-                throw new Error("--fit must be cover, contain, or repeat");
-            if (!["center", "top", "bottom", "left", "right"].includes(options.position))
-                throw new Error("--position must be center, top, bottom, left, or right");
-            const opacity = finite(options.opacity, "opacity");
-            if (opacity < 0 || opacity > 1)
-                throw new Error("opacity must be between 0 and 1");
-            const board = await resolvedBoard(boards, target);
-            const current = await board.summary();
-            const appearance = appearanceFrom(current.board.metadata);
-            const background = options.reset
-                ? { kind: "solid" }
-                : options.color
-                    ? { kind: "solid", color: options.color }
-                    : {
-                        kind: "image",
-                        imageUrl: options.image,
-                        fit: options.fit,
-                        position: options.position,
-                        opacity,
-                        color: appearance.background.color,
-                    };
-            const result = await mutateSemantic(board, [{
-                    type: "board.patch",
-                    patch: { metadataPatch: { appearance: patchBoardAppearance(appearance, { background }) } },
-                }], { baseVersion: current.board.version });
-            showUpdated(result, options);
-        }
-        catch (cause) {
-            handleHttp(cause);
-        }
-    });
-    withJson(boards.command("motion <board>")
-        .description("Configure the default Board motion for newly added nodes")
-        .option("--preset <preset>", "Enter motion preset (deal)")
-        .option("--clear", "Disable the default enter motion")
-        .addHelpText("after", `
-Examples:
-  cohub boards motion plan.board --preset deal
-  cohub boards motion plan.board --clear`))
-        .action(async (target, options) => {
-        try {
-            if (Boolean(options.clear) === Boolean(options.preset))
-                throw new Error("Use --preset or --clear");
-            if (options.preset && options.preset !== "deal")
-                throw new Error("--preset must be deal");
-            const board = await resolvedBoard(boards, target);
-            const current = await board.summary();
-            const appearance = appearanceFrom(current.board.metadata);
-            const next = patchBoardAppearance(appearance, {
-                motion: options.clear
-                    ? undefined
-                    : { enter: { kind: "effects.deal", kindVersion: 1, params: {} } },
-            });
-            showUpdated(await mutateSemantic(board, [{
-                    type: "board.patch",
-                    patch: { metadataPatch: { appearance: next } },
-                }], { baseVersion: current.board.version }), options);
-        }
-        catch (cause) {
-            handleHttp(cause);
-        }
-    });
-    withJson(boards.command("playback-policy <board>")
-        .description("Configure automatic Board playback")
-        .option("--composition <id>", "Composition to play")
-        .option("--delay <ms>", "Delay before playback", "0")
-        .option("--clear", "Remove the playback policy"))
-        .action(async (target, options) => {
-        try {
-            if (options.clear === Boolean(options.composition))
-                throw new Error("Use --composition or --clear");
-            const delayMs = finite(options.delay, "delay");
-            if (delayMs < 0)
-                throw new Error("delay must be non-negative");
-            const policy = options.clear
-                ? null
-                : { compositionId: options.composition, delayMs };
-            const board = await resolvedBoard(boards, target);
-            const current = await board.summary();
-            const patch = policy
-                ? { metadataPatch: { playback: policy } }
-                : { metadata: { ...current.board.metadata, playback: undefined } };
-            if (!policy)
-                delete patch.metadata.playback;
-            showUpdated(await mutateSemantic(board, [{ type: "board.patch", patch }], { baseVersion: current.board.version }), options);
-        }
-        catch (cause) {
-            handleHttp(cause);
-        }
-    });
-}

package/dist/commands/boards/batch.d.ts

@@ -1,4 +0,0 @@
-import { type BoardSemanticCommand } from "@neta-art/cohub";
-import type { Command } from "commander";
-export declare function parseBatchCommands(input: Record<string, unknown>): BoardSemanticCommand[];
-export declare function registerBoardBatchCommand(boards: Command): void;

package/dist/commands/boards/batch.js

@@ -1,62 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { BoardSemanticCommandSchema } from "@neta-art/cohub";
-import { BOARD_TRANSACTION_INPUT_MAX_BYTES, readBoardJsonObject, } from "../../board-command-support.js";
-import { handleHttp, json, jsonRequested, ok } from "../../output.js";
-import { mutateSemantic, resolvedBoard, withJson, } from "./context.js";
-export function parseBatchCommands(input) {
-    if (!Array.isArray(input.commands) || input.commands.length === 0) {
-        throw new Error("batch input must contain a non-empty commands array");
-    }
-    return input.commands.map((command, index) => {
-        const parsed = BoardSemanticCommandSchema.safeParse(command);
-        if (!parsed.success) {
-            const issue = parsed.error.issues[0];
-            const path = issue?.path.length ? `.${issue.path.join(".")}` : "";
-            throw new Error(`commands[${index}]${path}: ${issue?.message ?? "invalid command"}`);
-        }
-        return parsed.data;
-    });
-}
-export function registerBoardBatchCommand(boards) {
-    withJson(boards.command("batch <board>")
-        .description("Apply an atomic batch of semantic Board changes")
-        .requiredOption("-i, --input <file>", "Batch JSON with a commands array; use - for stdin")
-        .option("--base-version <version>", "Expected Board version; defaults to latest")
-        .option("--mutation-id <id>", "Stable id for safe retries")
-        .option("--dry-run", "Validate the whole batch without writing")
-        .addHelpText("after", `
-Input format:
-  {"commands":[{"type":"item.patch","itemId":"title","patch":{"props":{"text":"Updated"}}}]}
-
-Commands are applied atomically. See boards capabilities for supported fields.`))
-        .action(async (target, options) => {
-        try {
-            const input = await readBoardJsonObject(options.input, BOARD_TRANSACTION_INPUT_MAX_BYTES);
-            const commands = parseBatchCommands(input);
-            const parsedVersion = options.baseVersion === undefined ? undefined : Number(options.baseVersion);
-            if (parsedVersion !== undefined && (!Number.isSafeInteger(parsedVersion) || parsedVersion < 0)) {
-                throw new Error("base version must be a non-negative integer");
-            }
-            const board = await resolvedBoard(boards, target);
-            const result = await mutateSemantic(board, commands, {
-                ...(parsedVersion === undefined ? {} : { baseVersion: parsedVersion }),
-                mutationId: options.mutationId?.trim() || randomUUID(),
-                dryRun: Boolean(options.dryRun),
-            });
-            if (jsonRequested(options))
-                return json(result);
-            if (result.outcome === "dry-run") {
-                ok(`Validated ${commands.length} changes; no changes written`);
-            }
-            else if (result.outcome === "noop" || result.status === "validated") {
-                ok(`Board already matches the requested ${commands.length} changes`);
-            }
-            else {
-                ok(`${result.replayed ? "Replayed" : "Applied"} ${commands.length} changes at Board version ${result.board.version}`);
-            }
-        }
-        catch (cause) {
-            handleHttp(cause);
-        }
-    });
-}

package/dist/commands/boards/connections.d.ts

@@ -1,2 +0,0 @@
-import type { Command } from "commander";
-export declare function registerBoardConnectionCommands(boards: Command): void;