agnes-ai-cli 0.1.0 → 0.1.1

package/README.md

@@ -4,28 +4,16 @@ CLI and JS API for Agnes text, image, and video workflows.
 
 ## Install
 
-Current verified distribution path:
+Install globally:
 
 ```bash
-npm install -g github:jomeswang/agnes-ai-cli
-```
-
-Ad hoc execution without a global install:
-
-```bash
-npx -y github:jomeswang/agnes-ai-cli --help
-```
-
-Planned npm package name:
-
-```bash
-agnes-ai-cli
+npm install -g agnes-ai-cli
 ```
 
-Once the npm publish path is cleared, the package will also be installable as:
+Run without installing:
 
 ```bash
-npm install -g agnes-ai-cli
+npx -y agnes-ai-cli --help
 ```
 
 ## CLI

package/dist/media/toPublicUrl.js

@@ -1,21 +1,112 @@
-import { access } from "node:fs/promises";
+import { access, mkdtemp, rm, writeFile } from "node:fs/promises";
 import { constants } from "node:fs";
+import { tmpdir } from "node:os";
+import { extname, join } from "node:path";
 import { LitterboxMediaUrlProvider } from "./litterbox.js";
 import { resolveConfig } from "../config.js";
 import { AgnesCliError } from "../errors.js";
+const MIME_EXTENSIONS = {
+    "image/jpeg": ".jpg",
+    "image/png": ".png",
+    "image/webp": ".webp",
+    "image/gif": ".gif",
+    "video/mp4": ".mp4",
+    "video/quicktime": ".mov",
+    "video/webm": ".webm",
+};
 export async function toPublicUrl(input, options = {}, config = {}) {
-    if (/^https?:\/\//.test(input)) {
+    if (isPublicHttpUrl(input)) {
         return { ok: true, url: input, source: "passthrough" };
     }
+    const resolved = resolveConfig(config);
+    const provider = resolved.mediaProvider ??
+        new LitterboxMediaUrlProvider(resolved.fetchImpl);
+    const materialized = await materializeUploadInput(input, resolved.fetchImpl);
+    try {
+        const url = await provider.upload(materialized.path, { ttl: options.ttl ?? resolved.defaultMediaTtl });
+        return { ok: true, url, source: resolved.mediaProvider ? "provider" : "litterbox" };
+    }
+    finally {
+        if (materialized.cleanupDir) {
+            await rm(materialized.cleanupDir, { recursive: true, force: true });
+        }
+    }
+}
+function isPublicHttpUrl(input) {
+    if (!/^https?:\/\//.test(input))
+        return false;
+    const url = new URL(input);
+    const host = url.hostname.toLowerCase().replace(/^\[|\]$/g, "");
+    return !isPrivateHost(host);
+}
+function isPrivateHost(host) {
+    if (host === "localhost" || host.endsWith(".localhost") || host === "::1") {
+        return true;
+    }
+    if (/^127\./.test(host) || /^10\./.test(host) || /^192\.168\./.test(host) || /^169\.254\./.test(host)) {
+        return true;
+    }
+    const match = host.match(/^172\.(\d{1,3})\./);
+    if (match) {
+        const secondOctet = Number(match[1]);
+        return secondOctet >= 16 && secondOctet <= 31;
+    }
+    return host === "0.0.0.0" || (host.includes(":") && (host.startsWith("fc") || host.startsWith("fd") || host.startsWith("fe80:")));
+}
+async function materializeUploadInput(input, fetchImpl) {
+    if (input.startsWith("data:")) {
+        return writeTempMedia(await decodeDataUrl(input));
+    }
+    if (/^https?:\/\//.test(input)) {
+        return writeTempMedia(await fetchPrivateUrl(input, fetchImpl));
+    }
     try {
         await access(input, constants.R_OK);
     }
     catch {
-        throw new AgnesCliError("INPUT_NOT_FOUND", `Input must be an existing file path or an http(s) URL: ${input}`);
+        throw new AgnesCliError("INPUT_NOT_FOUND", `Input must be an existing file path, a data URL, or an http(s) URL: ${input}`);
     }
-    const resolved = resolveConfig(config);
-    const provider = resolved.mediaProvider ??
-        new LitterboxMediaUrlProvider(resolved.fetchImpl);
-    const url = await provider.upload(input, { ttl: options.ttl ?? resolved.defaultMediaTtl });
-    return { ok: true, url, source: resolved.mediaProvider ? "provider" : "litterbox" };
+    return { path: input };
+}
+async function fetchPrivateUrl(input, fetchImpl) {
+    const response = await fetchImpl(input);
+    if (!response.ok) {
+        throw new AgnesCliError("INPUT_FETCH_FAILED", `Input URL fetch failed with HTTP ${response.status}: ${input}`, {
+            status: response.status,
+            url: input,
+        });
+    }
+    const bytes = Buffer.from(await response.arrayBuffer());
+    const mimeType = normalizeMimeType(response.headers.get("content-type") ?? undefined);
+    const extension = extname(new URL(input).pathname);
+    return { bytes, mimeType, extension };
+}
+function decodeDataUrl(input) {
+    const match = input.match(/^data:([^;,]+)?((?:;[^,]+)*?),(.*)$/s);
+    if (!match) {
+        throw new AgnesCliError("INPUT_INVALID", "Data URL input is malformed.");
+    }
+    const mimeType = normalizeMimeType(match[1]);
+    const metadata = match[2] ?? "";
+    const body = match[3] ?? "";
+    const bytes = metadata.includes(";base64")
+        ? Buffer.from(body, "base64")
+        : Buffer.from(decodeURIComponent(body));
+    return { bytes, mimeType };
+}
+async function writeTempMedia(input) {
+    const cleanupDir = await mkdtemp(join(tmpdir(), "agnes-media-"));
+    const extension = normalizeExtension(input.extension) ?? (input.mimeType ? MIME_EXTENSIONS[input.mimeType] : undefined) ?? ".bin";
+    const path = join(cleanupDir, `input${extension}`);
+    await writeFile(path, input.bytes);
+    return { path, cleanupDir };
+}
+function normalizeMimeType(value) {
+    return value?.split(";")[0]?.trim().toLowerCase() || undefined;
+}
+function normalizeExtension(value) {
+    if (!value)
+        return undefined;
+    const normalized = value.toLowerCase();
+    return /^\.[a-z0-9]+$/.test(normalized) ? normalized : undefined;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agnes-ai-cli",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "CLI and JS API for Agnes text, image, and video workflows.",
   "type": "module",
   "bin": {