@neta-art/cohub-cli 1.1.4 → 1.2.0

package/dist/commands/generations.d.ts

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

package/dist/commands/generations.js

@@ -0,0 +1,164 @@
+import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { basename, extname, join } from "node:path";
+import { resolveToken } from "../auth.js";
+import { createClient } from "../client.js";
+import { table, json as outJson, error, handleHttp } from "../output.js";
+const mimeByExt = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".webp": "image/webp",
+    ".gif": "image/gif",
+    ".mp4": "video/mp4",
+    ".webm": "video/webm",
+    ".mov": "video/quicktime",
+    ".mp3": "audio/mpeg",
+    ".wav": "audio/wav",
+    ".ogg": "audio/ogg",
+};
+function parseValue(value) {
+    const trimmed = value.trim();
+    if (trimmed === "true")
+        return true;
+    if (trimmed === "false")
+        return false;
+    if (/^-?\d+(\.\d+)?$/.test(trimmed))
+        return Number(trimmed);
+    if ((trimmed.startsWith("{") && trimmed.endsWith("}")) || (trimmed.startsWith("[") && trimmed.endsWith("]"))) {
+        try {
+            return JSON.parse(trimmed);
+        }
+        catch {
+            return value;
+        }
+    }
+    return value;
+}
+function parseParams(param, parameters) {
+    const result = parameters ? JSON.parse(parameters) : {};
+    for (const item of param ?? []) {
+        const index = item.indexOf("=");
+        if (index <= 0)
+            throw new Error(`Invalid --param value: ${item}`);
+        result[item.slice(0, index)] = parseValue(item.slice(index + 1));
+    }
+    return Object.keys(result).length > 0 ? result : undefined;
+}
+async function contentFromPathOrUrl(type, value) {
+    if (/^https?:\/\//.test(value))
+        return { type, source: { type: "url", url: value } };
+    const data = await readFile(value);
+    const media_type = mimeByExt[extname(value).toLowerCase()] ?? "application/octet-stream";
+    return { type, source: { type: "base64", media_type, data: data.toString("base64") } };
+}
+async function saveOutputs(output, outputPath) {
+    const files = output.filter((block) => block.type !== "text");
+    if (files.length === 0)
+        return;
+    const info = await stat(outputPath).catch(() => null);
+    const isDir = info?.isDirectory() ?? (!extname(outputPath) && files.length > 1);
+    if (files.length > 1 && !isDir)
+        throw new Error("--output must be a directory when generation returns multiple files");
+    if (isDir)
+        await mkdir(outputPath, { recursive: true });
+    for (const [i, block] of files.entries()) {
+        const source = block.source;
+        const target = isDir ? join(outputPath, outputName(block.type, source.type === "url" ? source.url : undefined, i)) : outputPath;
+        if (source.type === "url") {
+            const response = await fetch(source.url);
+            if (!response.ok)
+                throw new Error(`Failed to download ${source.url}: HTTP ${response.status}`);
+            await writeFile(target, Buffer.from(await response.arrayBuffer()));
+        }
+        else if (source.type === "base64") {
+            await writeFile(target, Buffer.from(source.data, "base64"));
+        }
+    }
+}
+function outputName(type, url, index) {
+    const fromUrl = url ? basename(new URL(url).pathname) : "";
+    if (fromUrl && fromUrl.includes("."))
+        return `generation-${index + 1}-${fromUrl}`;
+    const ext = type === "video" ? "mp4" : type === "audio" ? "bin" : "png";
+    return `generation-${index + 1}.${ext}`;
+}
+function printGeneration(output) {
+    for (const block of output) {
+        if (block.type === "text")
+            console.log(block.text);
+        else if (block.source.type === "url")
+            console.log(`${block.type}: ${block.source.url}`);
+        else if (block.source.type === "base64")
+            console.log(`${block.type}: base64 ${block.source.media_type} (${block.source.data.length} chars)`);
+        else
+            console.log(`${block.type}: ${block.source.space_id}:${block.source.path}`);
+    }
+}
+export function registerGenerations(program) {
+    program
+        .command("generate")
+        .description("Generate multimodal content")
+        .argument("<prompt>", "Prompt text")
+        .requiredOption("--model <model>", "Generation model")
+        .option("--image <path-or-url>", "Image input", collect, [])
+        .option("--video <path-or-url>", "Video input", collect, [])
+        .option("--audio <path-or-url>", "Audio input", collect, [])
+        .option("--param <key=value>", "Generation parameter", collect, [])
+        .option("--parameters <json>", "Generation parameters JSON")
+        .option("--metadata <json>", "Metadata JSON")
+        .option("--output <path>", "Save generated file output")
+        .option("--json", "Output as JSON")
+        .action(async (prompt, opts) => {
+        const token = resolveToken();
+        if (!token)
+            return error("Not authenticated", "Run 'cohub auth login <token>'");
+        try {
+            const content = [{ type: "text", text: prompt }];
+            content.push(...await Promise.all(opts.image.map((value) => contentFromPathOrUrl("image", value))));
+            content.push(...await Promise.all(opts.video.map((value) => contentFromPathOrUrl("video", value))));
+            content.push(...await Promise.all(opts.audio.map((value) => contentFromPathOrUrl("audio", value))));
+            const generation = await createClient(token).generations.create({
+                model: opts.model,
+                content,
+                parameters: parseParams(opts.param, opts.parameters),
+                metadata: opts.metadata ? JSON.parse(opts.metadata) : undefined,
+            });
+            if (opts.output && generation.output)
+                await saveOutputs(generation.output, opts.output);
+            if (opts.json)
+                return outJson(generation);
+            printGeneration(generation.output ?? []);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+    const cmd = program.command("generations").description("Generation model declarations");
+    cmd
+        .command("ls")
+        .alias("list")
+        .description("List generation declarations")
+        .option("--json", "Output as JSON")
+        .action(async (opts) => {
+        const token = resolveToken();
+        if (!token)
+            return error("Not authenticated", "Run 'cohub auth login <token>'");
+        try {
+            const response = await createClient(token).generations.listDeclarations();
+            if (opts.json)
+                return outJson(response);
+            table(response.declarations, [
+                { key: "model", label: "Model" },
+                { key: "title", label: "Title" },
+                { key: "description", label: "Description" },
+            ]);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+}
+function collect(value, previous) {
+    previous.push(value);
+    return previous;
+}

package/dist/index.js

@@ -4,6 +4,7 @@ import { readFileSync } from "node:fs";
 import { registerAuth } from "./commands/auth.js";
 import { registerChannels } from "./commands/channels.js";
 import { registerCronJobs } from "./commands/cron-jobs.js";
+import { registerGenerations } from "./commands/generations.js";
 import { registerModels } from "./commands/models.js";
 import { registerPrompts } from "./commands/prompts.js";
 import { registerSessionAccess } from "./commands/session-access.js";
@@ -28,6 +29,7 @@ program
 registerAuth(program);
 registerSpaces(program);
 registerChannels(program);
+registerGenerations(program);
 registerModels(program);
 registerPrompts(program);
 registerTasks(program);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neta-art/cohub-cli",
-  "version": "1.1.4",
+  "version": "1.2.0",
   "description": "CLI for Cohub — spaces, sessions, and agent collaboration.",
   "type": "module",
   "license": "UNLICENSED",
@@ -14,7 +14,7 @@
   ],
   "dependencies": {
     "commander": "^13.1.0",
-    "@neta-art/cohub": "1.7.1"
+    "@neta-art/cohub": "1.8.0"
   },
   "publishConfig": {
     "access": "public"