@neta-art/cohub-cli 6.8.2 → 6.9.0

package/dist/commands/board-domain.js

@@ -4,6 +4,7 @@ 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);
@@ -11,4 +12,5 @@ export function registerBoardDomainCommands(boards) {
     registerBoardConnectionCommands(boards);
     registerBoardItemCommands(boards);
     registerBoardAnimationCommands(boards);
+    registerBoardTransactionCommands(boards);
 }

package/dist/commands/boards/appearance.js

@@ -65,6 +65,37 @@ Examples:
             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")

package/dist/commands/boards/examples.js

@@ -269,6 +269,23 @@ const templates = {
         seed: "float-hero",
         params: { distance: 8, period: 2200 },
     },
+    "effect:deal": {
+        id: "deal-title",
+        target: { type: "item", itemId: "title" },
+        kind: "effects.deal",
+        kindVersion: 1,
+        lifecycle: "on-enter",
+        timeOrigin: "activation",
+        seed: "deal-title",
+        params: {},
+    },
+    "motion:enter-deal": {
+        enter: {
+            kind: "effects.deal",
+            kindVersion: 1,
+            params: {},
+        },
+    },
     "composition:fade": {
         id: "intro",
         name: "Intro",
@@ -392,7 +409,8 @@ Kinds:
   create [workflow|media|animation]
   batch basic
   item text|image|video|audio|file|task|geo|frame|draw|arrow
-  effect pulse|float
+  effect pulse|float|deal
+  motion enter-deal
   composition fade|reveal|draw-reveal|motion-path|trail|impact|flash|particles|camera-shake|camera-focus
 
 Examples:

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

@@ -0,0 +1,12 @@
+import type { BoardTransactionRecord } from "@neta-art/cohub";
+import type { Command } from "commander";
+/** Compact `type×count` summary, e.g. `node.patch×3 connection.create`. */
+export declare function summarizeOperations(operations: BoardTransactionRecord["operations"]): string;
+export declare function transactionRows(transactions: BoardTransactionRecord[]): {
+    version: number;
+    createdAt: string;
+    actor: string;
+    via: import("@neta-art/cohub/board").BoardReplayActorKind;
+    changes: string;
+}[];
+export declare function registerBoardTransactionCommands(boards: Command): void;

package/dist/commands/boards/transactions.js

@@ -0,0 +1,69 @@
+import { boardReplayActorKind } from "@neta-art/cohub/board";
+import { handleHttp, json, jsonRequested, table } from "../../output.js";
+import { finite, resolvedBoard, withJson } from "./context.js";
+const columns = [
+    { key: "version", label: "VERSION" },
+    { key: "createdAt", label: "AT" },
+    { key: "actor", label: "ACTOR" },
+    { key: "via", label: "VIA" },
+    { key: "changes", label: "CHANGES" },
+];
+/** Compact `type×count` summary, e.g. `node.patch×3 connection.create`. */
+export function summarizeOperations(operations) {
+    const counts = new Map();
+    for (const operation of operations)
+        counts.set(operation.type, (counts.get(operation.type) ?? 0) + 1);
+    return [...counts.entries()].map(([type, count]) => (count > 1 ? `${type}×${count}` : type)).join(" ");
+}
+export function transactionRows(transactions) {
+    return transactions.map((transaction) => ({
+        version: transaction.version,
+        createdAt: transaction.createdAt,
+        actor: transaction.actorId,
+        via: boardReplayActorKind(transaction.source),
+        changes: summarizeOperations(transaction.operations),
+    }));
+}
+export function registerBoardTransactionCommands(boards) {
+    withJson(boards
+        .command("transactions <board>")
+        .alias("history")
+        .description("List the Board transaction log, newest first")
+        .option("--before <version>", "Only transactions below this version")
+        .option("--limit <count>", "Page size (max 500)", "50")
+        .option("--operations", "Include full operations and inverses in --json output")
+        .addHelpText("after", `
+Every applied mutation is one transaction. --json prints the page summary; add
+--operations for the full payloads, inverses and (on the newest page) the current
+node and connection rows, which is what the web replay view consumes.`)).action(async (target, options) => {
+        try {
+            const board = await resolvedBoard(boards, target);
+            // The snapshot is only ever printed in full --json --operations output;
+            // every other mode would fetch the whole Board just to drop it.
+            const full = jsonRequested(options) && Boolean(options.operations);
+            const page = await board.transactions({
+                ...(options.before !== undefined ? { before: finite(options.before, "--before") } : {}),
+                limit: finite(options.limit, "--limit", 50),
+                snapshot: full,
+            });
+            if (jsonRequested(options)) {
+                return json(full
+                    ? page
+                    : {
+                        ...page,
+                        transactions: page.transactions.map(({ operations, ...transaction }) => ({
+                            ...transaction,
+                            operationCount: operations.length,
+                        })),
+                    });
+            }
+            table(transactionRows(page.transactions), columns);
+            if (page.nextBefore !== null) {
+                console.log(`\nOlder transactions: --before ${page.nextBefore}`);
+            }
+        }
+        catch (cause) {
+            handleHttp(cause);
+        }
+    });
+}

package/dist/commands/desktop.d.ts

@@ -1,3 +1,10 @@
+import { type DesktopSurface } from "@neta-art/cohub";
 import type { Command } from "commander";
+/**
+ * The surface a desktop.open should request: an explicit `--as` wins, then
+ * whatever the App declared at publish time. `window` is the implicit default
+ * and yields `undefined` so the command stays compact.
+ */
+export declare function resolveOpenSurface(requested: string | undefined, declared: unknown): DesktopSurface | undefined;
 export declare function registerDesktop(program: Command): void;
 export declare function registerLegacyUi(program: Command): void;

package/dist/commands/desktop.js

@@ -65,10 +65,19 @@ function parseTimeout(value) {
     }
     return parsed;
 }
+/**
+ * The surface a desktop.open should request: an explicit `--as` wins, then
+ * whatever the App declared at publish time. `window` is the implicit default
+ * and yields `undefined` so the command stays compact.
+ */
+export function resolveOpenSurface(requested, declared) {
+    return (requested ?? declared) === "overlay" ? "overlay" : undefined;
+}
 async function resolveAppTarget(client, ref) {
     const normalized = hasAppScheme(ref) ? ref.replace(/^[a-zA-Z]+:\/\//, "") : ref;
     const parsed = parseAppRef(normalized);
     const detail = await getAppByRef(client, normalized);
+    const declared = detail.app.meta?.presentation?.surface;
     return {
         kind: "app",
         appId: detail.app.id,
@@ -77,6 +86,7 @@ async function resolveAppTarget(client, ref) {
             ...(parsed.search ? { search: parsed.search } : {}),
             ...(parsed.hash ? { hash: parsed.hash } : {}),
         },
+        ...(declared === "overlay" || declared === "window" ? { surface: declared } : {}),
     };
 }
 async function resolveOpenTarget(client, command, value) {
@@ -122,6 +132,9 @@ async function openWindow(target, opts, command) {
     if (opts.noWait && opts.timeoutMs !== undefined) {
         return error("Conflicting wait options", "Use either --no-wait or --timeout-ms, not both.");
     }
+    if (opts.as !== undefined && opts.as !== "window" && opts.as !== "overlay") {
+        return error("Invalid surface", "--as must be one of: window, overlay.");
+    }
     const timeoutMs = parseTimeout(opts.timeoutMs);
     const client = createClient();
     try {
@@ -129,6 +142,9 @@ async function openWindow(target, opts, command) {
         if (resolved.kind === "file" && opts.call) {
             return error("Unsupported option", "--call only applies to app targets.");
         }
+        if (resolved.kind === "file" && opts.as) {
+            return error("Unsupported option", "--as only applies to app targets.");
+        }
         const call = opts.call
             ? { method: opts.call, ...(callInput === undefined ? {} : { input: callInput }) }
             : undefined;
@@ -142,6 +158,7 @@ async function openWindow(target, opts, command) {
                         appId: resolved.appId,
                         label: resolved.label,
                         ...(resolved.launch.search || resolved.launch.hash ? { launch: resolved.launch } : {}),
+                        ...(resolveOpenSurface(opts.as, resolved.surface) ? { surface: "overlay" } : {}),
                     },
                 ...(call ? { call } : {}),
             },
@@ -173,6 +190,7 @@ Examples:
   cohub desktop open app://alice/studio/launch
   cohub desktop open alice/studio/launch
   cohub desktop open https://cohub.live/alice/studio/w/launch?view=timeline
+  cohub desktop open <app-id> --as overlay
   cohub desktop open <app-id> --call selection.get
   cohub desktop open <app-id> --call board.focus --data '{"nodeId":"n1"}'
 `;
@@ -182,6 +200,9 @@ Notes:
     scheme is still accepted.
   - A plain target checks the current Space for a file before resolving an app.
   - Opening a window is idempotent; repeating it re-activates the same tab.
+  - --as picks the surface: window (a preview tab) or overlay (a transparent
+    layer above the workspace). Without it, an App published with
+    <meta name="cohub:surface" content="overlay"> opens as an overlay.
   - --call waits for the app to announce readiness, then invokes the method.
   - Which methods exist is up to the app author.
 `;
@@ -195,6 +216,7 @@ function registerOpen(parent, deprecated) {
         .option("--client <clientId>", "Target a specific desktop instance of your account")
         .option("--command-id <id>", "Stable id so retries never dispatch twice")
         .option("--no-wait", "Dispatch the command and exit without waiting for a result")
+        .option("--as <surface>", "Surface role for app targets: window (default) or overlay")
         .option("--timeout-ms <ms>", `How long to wait for the desktop (default: ${DESKTOP_COMMAND_DEFAULT_TIMEOUT_MS}; max: ${DESKTOP_COMMAND_MAX_TIMEOUT_MS})`)
         .option("--json", "Output as JSON")
         .action(async (target, opts, thisCommand) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neta-art/cohub-cli",
-  "version": "6.8.2",
+  "version": "6.9.0",
   "description": "CLI for Cohub — spaces, sessions, and agent collaboration.",
   "type": "module",
   "license": "Apache-2.0",
@@ -19,7 +19,7 @@
     "commander": "^15.0.0",
     "pixi.js": "^8.20.1",
     "sharp": "^0.35.4",
-    "@neta-art/cohub": "8.11.0"
+    "@neta-art/cohub": "8.12.0"
   },
   "publishConfig": {
     "access": "public"