@neta-art/cohub-cli 6.9.1 → 6.11.0

package/README.md

@@ -227,6 +227,8 @@ cohub search "query" --limit 20 --json
 
 ## Models and multimodal generation
 
+`models ls` prints each LLM's per-million-token cost (`$3 /M input · $15 /M output`, with cache rates when declared) and hides models marked `hidden`. `models ls --model-type multimodal` prints each model's unit price (`$0.04 / image`, `$0.10–$0.50 / second`); use `--json` for the raw `pricing` object (`unit`, `amount` or `min`/`max`, optional `note`).
+
 ```bash
 cohub models ls --json
 cohub models ls --model-type multimodal --json

package/dist/commands/desktop.d.ts

@@ -1,10 +1,5 @@
-import { type DesktopSurface } from "@neta-art/cohub";
+import { resolveOpenSurface } 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 { resolveOpenSurface };
 export declare function registerDesktop(program: Command): void;
 export declare function registerLegacyUi(program: Command): void;

package/dist/commands/desktop.js

@@ -1,9 +1,9 @@
 import { readFileSync } from "node:fs";
-import { HttpError, } from "@neta-art/cohub";
-import { parseAppRef, DESKTOP_COMMAND_DEFAULT_TIMEOUT_MS, DESKTOP_COMMAND_MAX_TIMEOUT_MS, } from "@neta-art/cohub";
+import { HttpError, parseAppRef, resolveOpenSurface, DESKTOP_COMMAND_DEFAULT_TIMEOUT_MS, DESKTOP_COMMAND_MAX_TIMEOUT_MS, } from "@neta-art/cohub";
 import { createClient } from "../client.js";
 import { error, handleHttp, json as outJson, jsonRequested, ok } from "../output.js";
 import { getAppByRef } from "../app-ref.js";
+export { resolveOpenSurface };
 const FILE_SCHEME = "file://";
 const APP_SCHEME = "app://";
 const LEGACY_WORK_SCHEME = "work://";
@@ -65,14 +65,6 @@ 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);

package/dist/commands/models.d.ts

@@ -1,2 +1,28 @@
 import type { Command } from "commander";
+import { type PublicGenerationDeclaration } from "@neta-art/cohub";
+type MultimodalModelSummary = Pick<PublicGenerationDeclaration, "model" | "title" | "description" | "pricing">;
+export declare function toMultimodalModelSummary(model: PublicGenerationDeclaration): MultimodalModelSummary;
+export type GenerationModelPricing = NonNullable<PublicGenerationDeclaration["pricing"]>;
+/**
+ * Render a display-only unit price, e.g. `$0.04 / image` or `$0.10–$0.50 / second`,
+ * optionally suffixed with a qualifier note.
+ *
+ * The raw `pricing` object is preserved in `--json` for machines; this string
+ * targets humans and agents reading the table output.
+ */
+export declare function formatGenerationPrice(pricing: GenerationModelPricing): string;
+/**
+ * Render per-million-token LLM cost, e.g. `$3 /M input · $15 /M output`,
+ * appending cache rates only when the model declares them.
+ */
+export declare function formatLlmModelCost(model: Record<string, unknown>): string;
+/**
+ * Drop hidden models from LLM discovery, mirroring generation models and the web
+ * picker. Providers left with no visible model are removed so the catalog shape
+ * matches what is actually shown. Explicit `true` is the only hidden signal.
+ */
+export declare function filterHiddenLlmModels<T extends {
+    model: Record<string, unknown>;
+}>(catalog: Record<string, T[]>): Record<string, T[]>;
 export declare function registerModels(program: Command): void;
+export {};

package/dist/commands/models.js

@@ -1,11 +1,13 @@
 import { filterDiscoverableGenerationModels, filterGenerationDeclarationsByPolicy, getAllowedGenerationModelIds, parseGenerationPolicyFromEnv, } from "@neta-art/cohub";
 import { createClient } from "../client.js";
 import { table, json as outJson, jsonRequested, error, handleHttp } from "../output.js";
-function toMultimodalModelSummary(model) {
+export function toMultimodalModelSummary(model) {
     return {
         model: model.model,
         ...(model.title ? { title: model.title } : {}),
         ...(model.description ? { description: model.description } : {}),
+        // Keep pricing structured for `--json`; the human table formats it separately.
+        ...(model.pricing ? { pricing: model.pricing } : {}),
     };
 }
 function printSection(title, lines) {
@@ -15,6 +17,88 @@ function printSection(title, lines) {
     for (const line of lines)
         console.log(`  ${line}`);
 }
+const PRICE_UNIT_LABELS = {
+    image: "image",
+    second: "second",
+    request: "request",
+    "1m_tokens": "1M tokens",
+};
+/** USD amounts stay compact while preserving the precision the value actually needs. */
+function formatUsdAmount(value) {
+    const magnitude = Math.abs(value);
+    const isWholeDollar = magnitude >= 1 && Number.isInteger(value);
+    const fractionDigits = value === 0 || isWholeDollar ? 0 : magnitude < 0.01 ? 4 : 2;
+    return `$${value.toLocaleString("en-US", { minimumFractionDigits: fractionDigits, maximumFractionDigits: fractionDigits })}`;
+}
+/**
+ * Render a display-only unit price, e.g. `$0.04 / image` or `$0.10–$0.50 / second`,
+ * optionally suffixed with a qualifier note.
+ *
+ * The raw `pricing` object is preserved in `--json` for machines; this string
+ * targets humans and agents reading the table output.
+ */
+export function formatGenerationPrice(pricing) {
+    const unit = PRICE_UNIT_LABELS[pricing.unit];
+    const value = typeof pricing.amount === "number"
+        ? formatUsdAmount(pricing.amount)
+        : pricing.min === pricing.max
+            ? formatUsdAmount(pricing.min)
+            : `${formatUsdAmount(pricing.min)}\u2013${formatUsdAmount(pricing.max)}`;
+    const base = `${value} / ${unit}`;
+    return pricing.note ? `${base} \u00b7 ${pricing.note}` : base;
+}
+/** LLM catalog entries carry cost as an untyped `model.cost` bag; validate it before use. */
+function readLlmModelCost(model) {
+    const cost = model.cost;
+    if (!cost || typeof cost !== "object")
+        return null;
+    const { input, output, cacheRead, cacheWrite } = cost;
+    if (typeof input !== "number" || typeof output !== "number")
+        return null;
+    return {
+        input,
+        output,
+        ...(typeof cacheRead === "number" ? { cacheRead } : {}),
+        ...(typeof cacheWrite === "number" ? { cacheWrite } : {}),
+    };
+}
+/** Zero or absent per-token components carry no signal, so they are omitted. */
+function formatLlmCostValue(value) {
+    return typeof value === "number" && Number.isFinite(value) && value !== 0 ? formatUsdAmount(value) : null;
+}
+/**
+ * Render per-million-token LLM cost, e.g. `$3 /M input · $15 /M output`,
+ * appending cache rates only when the model declares them.
+ */
+export function formatLlmModelCost(model) {
+    const cost = readLlmModelCost(model);
+    if (!cost)
+        return "";
+    const parts = [
+        [cost.input, "input"],
+        [cost.output, "output"],
+        [cost.cacheRead, "cache read"],
+        [cost.cacheWrite, "cache write"],
+    ];
+    return parts.flatMap(([value, label]) => {
+        const formatted = formatLlmCostValue(value);
+        return formatted ? [`${formatted} /M ${label}`] : [];
+    }).join(" \u00b7 ");
+}
+/**
+ * Drop hidden models from LLM discovery, mirroring generation models and the web
+ * picker. Providers left with no visible model are removed so the catalog shape
+ * matches what is actually shown. Explicit `true` is the only hidden signal.
+ */
+export function filterHiddenLlmModels(catalog) {
+    const visible = {};
+    for (const [provider, entries] of Object.entries(catalog)) {
+        const models = entries.filter((entry) => entry.model.hidden !== true);
+        if (models.length > 0)
+            visible[provider] = models;
+    }
+    return visible;
+}
 function formatContentSpec(spec) {
     const details = [];
     const roles = spec.roles;
@@ -58,6 +142,8 @@ function printMultimodalModel(model) {
     printSection("Model", [model.model]);
     if (model.description)
         printSection("Description", [model.description]);
+    if (model.pricing)
+        printSection("Pricing", [formatGenerationPrice(model.pricing)]);
     printSection("Input", model.content.input.map(formatContentSpec));
     const parameterLines = Object.entries(model.parameters ?? {}).flatMap(([name, spec]) => formatParameter(name, spec));
     printSection("Parameters", parameterLines);
@@ -103,6 +189,11 @@ Examples:
                 table(models, [
                     { key: "model", label: "Model" },
                     { key: "title", label: "Title" },
+                    {
+                        key: "pricing",
+                        label: "Price",
+                        format: (value) => (value ? formatGenerationPrice(value) : ""),
+                    },
                     { key: "description", label: "Description" },
                 ]);
                 return;
@@ -111,15 +202,22 @@ Examples:
                 return error("Invalid model type", "Use --model-type llm or --model-type multimodal");
             }
             const catalog = await client.models.list();
+            const visibleCatalog = filterHiddenLlmModels(catalog);
             if (jsonRequested(opts))
-                return outJson(catalog);
-            // catalog is Record<provider, ModelCatalogEntry[]>
-            for (const [provider, entries] of Object.entries(catalog)) {
+                return outJson(visibleCatalog);
+            if (Object.keys(visibleCatalog).length === 0)
+                return console.log("  (empty)");
+            for (const [provider, entries] of Object.entries(visibleCatalog)) {
                 console.log(`\n  ${provider}`);
                 console.log(`  ${"─".repeat(provider.length)}`);
-                table(entries, [
+                table(entries.map((entry) => ({
+                    id: entry.id,
+                    provider: entry.provider,
+                    cost: formatLlmModelCost(entry.model),
+                })), [
                     { key: "id", label: "ID" },
                     { key: "provider", label: "Provider" },
+                    { key: "cost", label: "Cost" },
                 ]);
             }
         }

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

@@ -0,0 +1,7 @@
+import type { Command } from "commander";
+import { createClient } from "../client.js";
+export declare function parseBody(raw: string | undefined): unknown;
+/** `cohub spaces webhooks` — inbound HTTP triggers declared by `.cohub/hooks/<name>` with `on.event: webhook`. */
+export declare function registerSpaceWebhooks(spacesCmd: Command, deps?: {
+    createClient?: typeof createClient;
+}): void;

package/dist/commands/space-webhooks.js

@@ -0,0 +1,73 @@
+import { joinApiUrl, resolveApiBaseUrl } from "@neta-art/cohub";
+import { createClient } from "../client.js";
+import { error, handleHttp, json as outJson, jsonRequested, ok, table } from "../output.js";
+import { resolveSpace } from "../space.js";
+export function parseBody(raw) {
+    if (raw === undefined)
+        return null;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return error("Invalid body", "--body must be JSON");
+    }
+}
+/** `cohub spaces webhooks` — inbound HTTP triggers declared by `.cohub/hooks/<name>` with `on.event: webhook`. */
+export function registerSpaceWebhooks(spacesCmd, deps = {}) {
+    const client = () => (deps.createClient ?? createClient)();
+    const webhooksCmd = spacesCmd
+        .command("webhooks")
+        .description("Inbound webhooks declared by .cohub/hooks/<name> (on.event: webhook)");
+    webhooksCmd
+        .command("ls")
+        .alias("list")
+        .description("List declared webhooks")
+        .option("--json", "Output as JSON")
+        .action(async (opts) => {
+        const spaceId = await resolveSpace(spacesCmd);
+        try {
+            const result = await client().space(spaceId).webhooks.list();
+            if (jsonRequested(opts))
+                return outJson(result.items);
+            table(result.items, [
+                { key: "name", label: "Name" },
+                { key: "action", label: "Action" },
+                { key: "hasSecret", label: "Secret" },
+            ]);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+    webhooksCmd
+        .command("url <name>")
+        .description("Print the URL external services should POST to")
+        .option("--json", "Output as JSON")
+        .action(async (name, opts) => {
+        const spaceId = await resolveSpace(spacesCmd);
+        const sdk = client();
+        const url = joinApiUrl(resolveApiBaseUrl({}), sdk.space(spaceId).webhooks.path(name));
+        if (jsonRequested(opts))
+            return outJson({ name, url });
+        process.stdout.write(`${url}\n`);
+    });
+    webhooksCmd
+        .command("trigger <name>")
+        .description("POST a JSON body to a webhook hook (local testing)")
+        .option("--body <json>", "JSON body", "null")
+        .option("--secret <secret>", "Value for on.secret")
+        .option("--json", "Output as JSON")
+        .action(async (name, opts) => {
+        const spaceId = await resolveSpace(spacesCmd);
+        const body = parseBody(opts.body);
+        try {
+            const result = await client().space(spaceId).webhooks.trigger(name, body, { secret: opts.secret });
+            if (jsonRequested(opts))
+                return outJson(result);
+            ok(`Triggered ${result.hook} — task ${result.taskRunId}`);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+}

package/dist/commands/spaces.js

@@ -11,6 +11,7 @@ import { registerSpaceCommerce } from "./space-commerce.js";
 import { registerSpaceActivity } from "./space-activity.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 SPACE_ROLES = ["host", "builder", "guest"];
@@ -659,6 +660,8 @@ export function registerSpaces(program) {
     registerMods(spacesCmd);
     // ── spaces labels ──
     registerLabels(spacesCmd);
+    // ── spaces webhooks ──
+    registerSpaceWebhooks(spacesCmd);
     // ── spaces pin / unpin (user-scope label convenience) ──
     spacesCmd
         .command("pin <id>")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neta-art/cohub-cli",
-  "version": "6.9.1",
+  "version": "6.11.0",
   "description": "CLI for Cohub — spaces, sessions, and agent collaboration.",
   "type": "module",
   "license": "Apache-2.0",
@@ -15,11 +15,11 @@
     "NOTICE"
   ],
   "dependencies": {
-    "@neta-art/generation": "^0.1.26",
+    "@neta-art/generation": "^0.1.27",
     "commander": "^15.0.0",
     "pixi.js": "^8.20.1",
     "sharp": "^0.35.4",
-    "@neta-art/cohub": "8.12.1"
+    "@neta-art/cohub": "8.14.0"
   },
   "publishConfig": {
     "access": "public"