@neta-art/cohub-cli 10.4.3 → 10.5.0

package/README.md

@@ -282,6 +282,20 @@ cohub -s <spaceId> spaces activity 7
 cohub -s <spaceId> spaces activity 365 --json
 ```
 
+## Space wallet
+
+```bash
+cohub -s <spaceId> spaces wallet balance
+cohub -s <spaceId> spaces wallet catalog
+cohub -s <spaceId> spaces wallet recharge <productKey> --request-id <uuid>
+cohub -s <spaceId> spaces wallet confirm <orderId>
+cohub -s <spaceId> spaces wallet activity --page 1 --json
+```
+
+Recharge prints a payment URL. Reuse the request UUID when retrying the same
+recharge. Any signed-in user with access to the Space may contribute; payment
+does not grant additional permissions. Transfers and withdrawals are not supported.
+
 ## Boards
 
 A Board is one JSON document with three parts — `board` settings, an `items` map,

package/dist/commands/space-wallet.d.ts

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

package/dist/commands/space-wallet.js

@@ -0,0 +1,64 @@
+import { createClient } from "../client.js";
+import { handleHttp, json as outJson, jsonRequested, table } from "../output.js";
+import { resolveSpace } from "../space.js";
+export function registerSpaceWallet(spaces) {
+    const wallet = spaces.command("wallet").description("Space wallet balance, recharge, and activity");
+    wallet.command("balance").option("--json", "Output as JSON").action(async (opts) => {
+        try {
+            const value = await createClient().space(await resolveSpace(spaces)).wallet.get();
+            if (jsonRequested(opts))
+                return outJson(value);
+            table([{ balance: `$${value.balanceUsd.toFixed(8)}`, usable: value.usable }], [{ key: "balance", label: "Balance" }, { key: "usable", label: "Usable" }]);
+        }
+        catch (cause) {
+            handleHttp(cause);
+        }
+    });
+    wallet.command("catalog").option("--json", "Output as JSON").action(async (opts) => {
+        try {
+            const value = await createClient().space(await resolveSpace(spaces)).wallet.catalog();
+            if (jsonRequested(opts))
+                return outJson(value);
+            table(value.products.map((product) => ({ key: product.key, name: product.name, price: product.pricing.amountUsd })), [{ key: "key", label: "Product" }, { key: "name", label: "Name" }, { key: "price", label: "Price (USD)" }]);
+        }
+        catch (cause) {
+            handleHttp(cause);
+        }
+    });
+    wallet.command("activity").option("--page <page>", "Page number", "1").option("--json", "Output as JSON").action(async (opts) => {
+        try {
+            const page = Number(opts.page);
+            if (!Number.isInteger(page) || page < 1 || page > 10_000)
+                throw new Error("Page must be an integer between 1 and 10000");
+            const value = await createClient().space(await resolveSpace(spaces)).wallet.activities(page);
+            if (jsonRequested(opts))
+                return outJson(value);
+            table(value.items, [{ key: "kind", label: "Activity" }, { key: "amountUsd", label: "Amount (USD)" }, { key: "actorUserId", label: "User" }, { key: "createdAt", label: "Date" }]);
+        }
+        catch (cause) {
+            handleHttp(cause);
+        }
+    });
+    wallet.command("recharge <product>").requiredOption("--request-id <uuid>", "Stable UUID; reuse when retrying this recharge").option("--json", "Output as JSON").action(async (productKey, opts) => {
+        try {
+            const value = await createClient().space(await resolveSpace(spaces)).wallet.createOrder({ id: opts.requestId, productKey });
+            if (jsonRequested(opts))
+                return outJson(value);
+            if (!value.checkout.checkoutUsable || !value.checkout.checkoutUrl)
+                throw new Error(value.checkout.message ?? "Checkout is unavailable");
+            console.log(value.checkout.checkoutUrl);
+            console.log(`Order: ${value.orderId}`);
+        }
+        catch (cause) {
+            handleHttp(cause);
+        }
+    });
+    wallet.command("confirm <order>").action(async (orderId) => {
+        try {
+            outJson(await createClient().space(await resolveSpace(spaces)).wallet.confirmOrder(orderId));
+        }
+        catch (cause) {
+            handleHttp(cause);
+        }
+    });
+}

package/dist/commands/spaces.d.ts

@@ -1,10 +1,12 @@
 import type { CohubHttpClient, CreateSpaceInput } from "@neta-art/cohub";
 import type { Command } from "commander";
+import { createClient } from "../client.js";
 import { type LocalUploadEntry } from "../space-files/upload.js";
 export type SpaceCreateOptions = {
     name: string;
     description?: string;
     checkpoint?: string;
+    image?: string;
     autoDestroy?: string;
     idleTtl?: string;
     spec?: string;
@@ -17,4 +19,7 @@ export declare function registerPrompt(program: Command): void;
 export declare function registerSpaceCreate(spacesCmd: Command, dependencies?: {
     createClient?: () => CohubHttpClient;
 }): Command;
+export declare function registerSpaceSetup(spacesCmd: Command, deps?: {
+    createClient?: typeof createClient;
+}): void;
 export declare function registerSpaces(program: Command): void;

package/dist/commands/spaces.js

@@ -11,13 +11,14 @@ import { uploadLocalFiles } from "../space-files/upload.js";
 import { registerDecisionCommand } from "./decision.js";
 import { registerSpaceCommerce } from "./space-commerce.js";
 import { registerSpaceFileTransfer } from "./space-files.js";
+import { registerSpaceWallet } from "./space-wallet.js";
 import { registerSpaceActivity } from "./space-activity.js";
 import { registerSpaceDisplays } from "./space-displays.js";
 import { registerSpaceInvitations } from "./space-invitations.js";
 import { registerSpaceTurns } from "./space-turns.js";
 import { registerSpaceWebhooks } from "./space-webhooks.js";
 const cliEnv = resolveCohubEnvironment();
-const defaultIdleTtlSeconds = cliEnv === "prod" ? 12 * 60 * 60 : 10 * 60;
+const defaultIdleTtlSeconds = cliEnv === "prod" ? 60 * 60 : 5 * 60;
 const SPACE_ROLES = ["host", "builder", "guest"];
 const SANDBOX_SPEC_IDS = ["standard", "boost", "ultra"];
 const LABEL_RESOURCE_TYPES = ["session", "checkpoint", "file"];
@@ -75,6 +76,7 @@ const parseSandboxSpec = (value) => value ? parseChoice(value, "sandbox spec", S
 export function buildSpaceCreateInput(opts) {
     const autoDestroy = parseAutoDestroy(opts);
     const spec = parseSandboxSpec(opts.spec);
+    const image = opts.image ? parseChoice(opts.image, "sandbox image", ["default", "game"]) : undefined;
     const checkpointId = opts.checkpoint?.trim();
     if (opts.checkpoint !== undefined && !checkpointId) {
         return error("Invalid checkpoint", "Checkpoint ID is required");
@@ -85,12 +87,13 @@ export function buildSpaceCreateInput(opts) {
         ...(checkpointId
             ? { bootstrapSource: { type: "checkpoint", checkpointId } }
             : {}),
-        ...((autoDestroy || spec)
+        ...((autoDestroy || spec || image)
             ? {
                 config: {
                     sandbox: {
                         ...(autoDestroy ? { autoDestroy } : {}),
                         ...(spec ? { spec } : {}),
+                        ...(image ? { image } : {}),
                     },
                 },
             }
@@ -376,6 +379,7 @@ export function registerSpaceCreate(spacesCmd, dependencies = {}) {
         .requiredOption("-n, --name <name>", "Space name")
         .option("-d, --description <desc>", "Space description")
         .option("--checkpoint <id>", "Create from a checkpoint")
+        .option("--image <image>", "Sandbox image: default or game")
         .option("--auto-destroy <mode>", "Sandbox auto destroy mode: idle or never")
         .option("--idle-ttl <seconds>", "Idle auto destroy TTL in seconds, max 2592000 (30d)")
         .option("--spec <spec>", "Sandbox spec: standard, boost, or ultra")
@@ -454,6 +458,40 @@ function registerUserLabels(program) {
         }
     });
 }
+export function registerSpaceSetup(spacesCmd, deps = {}) {
+    spacesCmd
+        .command("setup [id]")
+        .description("Show cloud sandbox startup scripts, results, and log paths")
+        .option("--json", "Output as JSON")
+        .action(async (id, opts) => {
+        try {
+            const spaceId = id ?? await resolveSpace(spacesCmd);
+            const { sandbox } = await (deps.createClient ?? createClient)().space(spaceId).sandbox.get();
+            const setup = sandbox?.meta?.setup ?? null;
+            if (jsonRequested(opts))
+                return outJson({ provider: sandbox?.provider ?? null, setup });
+            if (sandbox?.provider === "local")
+                return ok("Setup is disabled for local spaces.");
+            if (!setup)
+                return ok("No setup report is available.");
+            table([
+                { key: "Status", value: setup.status ?? (setup.error || setup.exitCode ? "failed" : "succeeded") },
+                { key: "Duration", value: setup.duration || "—" },
+                ...(setup.error ? [{ key: "Error", value: setup.error }] : []),
+            ], [{ key: "key", label: "Key" }, { key: "value", label: "Value" }]);
+            if (setup.steps?.length)
+                table(setup.steps.map((step) => ({
+                    script: step.path, status: step.status, duration: step.duration || "—", logs: step.logDir,
+                })), [
+                    { key: "script", label: "Script" }, { key: "status", label: "Status" },
+                    { key: "duration", label: "Duration" }, { key: "logs", label: "Logs" },
+                ]);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+}
 export function registerSpaces(program) {
     const spacesCmd = program.command("spaces").description("Space management");
     registerSpaceInvitations(spacesCmd);
@@ -615,21 +653,24 @@ export function registerSpaces(program) {
             handleHttp(e);
         }
     });
+    registerSpaceSetup(spacesCmd);
     // ── spaces config ──
     spacesCmd
         .command("config <id>")
         .description("Show or update space configuration")
         .option("--auto-destroy <mode>", "Sandbox auto destroy mode: idle or never")
         .option("--idle-ttl <seconds>", "Idle auto destroy TTL in seconds, max 2592000 (30d)")
-        .option("--spec <spec>", "Sandbox spec: standard, boost, or ultra")
+        .option("--spec <spec>", "Sandbox spec: standard, boost, ultra, or auto")
+        .option("--image <image>", "Sandbox image: default, game, or auto")
         .option("--json", "Output as JSON")
         .action(async (id, opts) => {
         const client = createClient();
         try {
             const autoDestroy = parseAutoDestroy(opts);
-            const spec = parseSandboxSpec(opts.spec);
-            if (autoDestroy || spec) {
-                const result = await client.space(id).updateConfig({ sandbox: { ...(autoDestroy ? { autoDestroy } : {}), ...(spec ? { spec } : {}) } });
+            const spec = opts.spec === "auto" ? null : parseSandboxSpec(opts.spec);
+            const image = opts.image === "auto" ? null : opts.image ? parseChoice(opts.image, "sandbox image", ["default", "game"]) : undefined;
+            if (autoDestroy || spec !== undefined || image !== undefined) {
+                const result = await client.space(id).updateConfig({ sandbox: { ...(autoDestroy ? { autoDestroy } : {}), ...(spec !== undefined ? { spec } : {}), ...(image !== undefined ? { image } : {}) } });
                 if (jsonRequested(opts))
                     return outJson(result);
                 ok(`Space config updated${autoDestroy ? ` — sandbox auto destroy: ${formatAutoDestroy(autoDestroy)}` : ""}${spec ? ` — sandbox spec: ${spec}` : ""}${result.sandbox?.pendingRestart ? " — restart the sandbox to apply" : ""}`);
@@ -640,6 +681,11 @@ export function registerSpaces(program) {
                 return outJson(result);
             table([
                 { key: "sandbox.autoDestroy", value: formatAutoDestroy(result.config.sandbox.autoDestroy) },
+                { key: "sandbox.image", value: result.config.sandbox.image ?? "default" },
+                { key: "sandbox.imageSource", value: result.config.sandbox.preferences?.origins.image ?? "platform" },
+                { key: "sandbox.specSource", value: result.config.sandbox.preferences?.origins.spec ?? "platform" },
+                { key: "sandbox.warnings", value: result.config.sandbox.preferences?.warnings.join(", ") || "—" },
+                { key: "sandbox.pendingRestart", value: String(result.config.sandbox.preferences?.pendingRestart ?? false) },
                 { key: "sandbox.spec", value: result.config.sandbox.spec ?? "standard" },
                 { key: "sandbox.appliedSpec", value: result.config.sandbox.appliedSpec ?? "—" },
                 { key: "sandbox.allowedSpec", value: result.config.sandbox.allowedSpec ?? "standard" },
@@ -737,6 +783,7 @@ export function registerSpaces(program) {
     // ── spaces commerce ──
     registerSpaceCommerce(spacesCmd);
     // ── spaces activity ──
+    registerSpaceWallet(spacesCmd);
     registerSpaceActivity(spacesCmd);
     // ── spaces usage ──
     spacesCmd

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neta-art/cohub-cli",
-  "version": "10.4.3",
+  "version": "10.5.0",
   "description": "CLI for Cohub — spaces, sessions, and agent collaboration.",
   "type": "module",
   "engines": {
@@ -18,7 +18,7 @@
     "NOTICE"
   ],
   "dependencies": {
-    "@neta-art/cohub": "11.3.3",
+    "@neta-art/cohub": "11.4.0",
     "@neta-art/generation": "^0.1.39",
     "commander": "^15.0.0",
     "sharp": "^0.35.4",