@inferencesh/app 0.1.2 → 0.1.4

package/dist/file.d.ts

@@ -71,6 +71,7 @@ export declare class File {
     toJSON(): FileData;
     static getCacheDir(): string;
     private _getCachePath;
+    private _decodeDataUri;
     private _downloadUrl;
     private _populateMetadata;
 }

package/dist/file.js

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { createWriteStream, existsSync, mkdirSync, statSync, renameSync, unlinkSync } from "node:fs";
+import { createWriteStream, existsSync, mkdirSync, statSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
 import { basename, resolve, join } from "node:path";
 import { homedir } from "node:os";
 import { get as httpsGet } from "node:https";
@@ -74,7 +74,10 @@ export class File {
         const file = new File(options);
         // Resolve URI
         if (file.uri) {
-            if (isUrl(file.uri)) {
+            if (isDataUri(file.uri)) {
+                file._decodeDataUri(file.uri);
+            }
+            else if (isUrl(file.uri)) {
                 await file._downloadUrl(file.uri);
             }
             else {
@@ -148,6 +151,32 @@ export class File {
         mkdirSync(hashDir, { recursive: true });
         return join(hashDir, fname);
     }
+    // --- Data URI ---
+    _decodeDataUri(uri) {
+        const parsed = parseDataUri(uri);
+        // Create cache path based on hash
+        const hash = createHash("sha256").update(uri).digest("hex").slice(0, 16);
+        const cacheDir = join(File.getCacheDir(), "data_uri", hash);
+        // Check for existing cached file
+        if (existsSync(cacheDir)) {
+            const files = require("node:fs").readdirSync(cacheDir);
+            if (files.length > 0) {
+                this.path = join(cacheDir, files[0]);
+                return;
+            }
+        }
+        // Set content type from data URI
+        if (!this.contentType) {
+            this.contentType = parsed.mediaType;
+        }
+        // Write to cache
+        mkdirSync(cacheDir, { recursive: true });
+        const ext = getExtensionForMimeType(parsed.mediaType);
+        const filename = `file${ext}`;
+        const cachePath = join(cacheDir, filename);
+        writeFileSync(cachePath, parsed.data);
+        this.path = cachePath;
+    }
     // --- Download ---
     async _downloadUrl(url) {
         const cachePath = this._getCachePath(url);
@@ -191,6 +220,60 @@ export class File {
 function isUrl(s) {
     return s.startsWith("http://") || s.startsWith("https://");
 }
+function isDataUri(s) {
+    return s.startsWith("data:");
+}
+/**
+ * Parse a data URI and return the media type and decoded data.
+ *
+ * Supports formats:
+ * - data:image/jpeg;base64,/9j/4AAQ...
+ * - data:text/plain,Hello%20World
+ * - data:;base64,SGVsbG8= (defaults to text/plain)
+ */
+function parseDataUri(uri) {
+    const match = uri.match(/^data:([^;,]*)?(?:;(base64))?,(.*)$/s);
+    if (!match) {
+        throw new Error("Invalid data URI format");
+    }
+    const mediaType = match[1] || "text/plain";
+    const isBase64 = match[2] === "base64";
+    let dataStr = match[3];
+    if (isBase64) {
+        // Handle URL-safe base64 (- and _ instead of + and /)
+        dataStr = dataStr.replace(/-/g, "+").replace(/_/g, "/");
+        // Add padding if needed
+        const padding = 4 - (dataStr.length % 4);
+        if (padding !== 4) {
+            dataStr += "=".repeat(padding);
+        }
+        return { mediaType, data: Buffer.from(dataStr, "base64") };
+    }
+    else {
+        // URL-encoded data
+        return { mediaType, data: Buffer.from(decodeURIComponent(dataStr), "utf-8") };
+    }
+}
+const EXTENSION_MAP = {
+    "image/jpeg": ".jpg",
+    "image/png": ".png",
+    "image/gif": ".gif",
+    "image/webp": ".webp",
+    "image/svg+xml": ".svg",
+    "video/mp4": ".mp4",
+    "video/webm": ".webm",
+    "audio/mpeg": ".mp3",
+    "audio/wav": ".wav",
+    "audio/ogg": ".ogg",
+    "application/pdf": ".pdf",
+    "application/json": ".json",
+    "text/plain": ".txt",
+    "text/html": ".html",
+    "text/csv": ".csv",
+};
+function getExtensionForMimeType(mimeType) {
+    return EXTENSION_MAP[mimeType] || "";
+}
 function downloadToFile(url, destPath) {
     return new Promise((resolve, reject) => {
         const parsed = new URL(url);

package/dist/index.d.ts

@@ -3,5 +3,4 @@ export type { FileOptions, FileData } from "./file.js";
 export { StorageDir, ensureDir } from "./storage.js";
 export type { StorageDirValue } from "./storage.js";
 export { download } from "./download.js";
-export { textMeta, imageMeta, videoMeta, audioMeta, rawMeta } from "./output-meta.js";
-export type { OutputMeta, MetaItem, MetaItemBase, TextMeta, ImageMeta, VideoMeta, AudioMeta, RawMeta, } from "./output-meta.js";
+export * from "./output-meta.js";

package/dist/index.js

@@ -5,4 +5,5 @@ export { StorageDir, ensureDir } from "./storage.js";
 // Download utility
 export { download } from "./download.js";
 // Output metadata for usage-based pricing
-export { textMeta, imageMeta, videoMeta, audioMeta, rawMeta } from "./output-meta.js";
+// (includes generated types + factory functions)
+export * from "./output-meta.js";

package/dist/output-meta.d.ts

@@ -1,9 +1,8 @@
 /**
  * Output metadata types for usage-based pricing.
  *
- * Apps include OutputMeta in their run output to report what was consumed
- * (inputs) and what was produced (outputs). The backend uses this for
- * pricing calculation.
+ * Types are generated from Go source of truth (common-go/pkg/models/usage.go)
+ * via `make types`. Factory functions provide type-safe constructors.
  *
  * @example
  * ```js
@@ -18,45 +17,24 @@
  * };
  * ```
  */
-export interface MetaItemBase {
-    type: string;
-    extra?: Record<string, unknown>;
-}
-export interface TextMeta extends MetaItemBase {
+export * from "./types.js";
+import type { MetaItem } from "./types.js";
+export type TextMeta = MetaItem & {
     type: "text";
     tokens: number;
-}
-export interface ImageMeta extends MetaItemBase {
+};
+export type ImageMeta = MetaItem & {
     type: "image";
-    width?: number;
-    height?: number;
-    resolution_mp?: number;
-    steps?: number;
-    count?: number;
-}
-export interface VideoMeta extends MetaItemBase {
+};
+export type VideoMeta = MetaItem & {
     type: "video";
-    width?: number;
-    height?: number;
-    resolution_mp?: number;
-    resolution?: "480p" | "720p" | "1080p" | "1440p" | "4k";
-    seconds?: number;
-    fps?: number;
-}
-export interface AudioMeta extends MetaItemBase {
+};
+export type AudioMeta = MetaItem & {
     type: "audio";
-    seconds?: number;
-    sample_rate?: number;
-}
-export interface RawMeta extends MetaItemBase {
+};
+export type RawMeta = MetaItem & {
     type: "raw";
-    cost?: number;
-}
-export type MetaItem = TextMeta | ImageMeta | VideoMeta | AudioMeta | RawMeta;
-export interface OutputMeta {
-    inputs?: MetaItem[];
-    outputs?: MetaItem[];
-}
+};
 /** Create a text metadata item. */
 export declare function textMeta(opts: Omit<TextMeta, "type">): TextMeta;
 /** Create an image metadata item. */

package/dist/output-meta.js

@@ -1,9 +1,8 @@
 /**
  * Output metadata types for usage-based pricing.
  *
- * Apps include OutputMeta in their run output to report what was consumed
- * (inputs) and what was produced (outputs). The backend uses this for
- * pricing calculation.
+ * Types are generated from Go source of truth (common-go/pkg/models/usage.go)
+ * via `make types`. Factory functions provide type-safe constructors.
  *
  * @example
  * ```js
@@ -18,6 +17,8 @@
  * };
  * ```
  */
+// Re-export all generated types (MetaItem, MetaItemType, OutputMeta, VideoResolution, constants)
+export * from "./types.js";
 // --- Factories ---
 /** Create a text metadata item. */
 export function textMeta(opts) {

package/dist/types.d.ts

@@ -0,0 +1,68 @@
+export interface AppSDKTypes {
+}
+/**
+ * MetaItemType is the type discriminator for MetaItem
+ */
+export type MetaItemType = string;
+export declare const MetaItemTypeText: MetaItemType;
+export declare const MetaItemTypeImage: MetaItemType;
+export declare const MetaItemTypeVideo: MetaItemType;
+export declare const MetaItemTypeAudio: MetaItemType;
+export declare const MetaItemTypeRaw: MetaItemType;
+/**
+ * VideoResolution represents standard video resolution presets
+ */
+export type VideoResolution = string;
+export declare const VideoRes480P: VideoResolution;
+export declare const VideoRes720P: VideoResolution;
+export declare const VideoRes1080P: VideoResolution;
+export declare const VideoRes1440P: VideoResolution;
+export declare const VideoRes4K: VideoResolution;
+/**
+ * MetaItem represents metadata about an input or output item
+ */
+export interface MetaItem {
+    type: MetaItemType;
+    /**
+     * Text fields
+     */
+    tokens?: number;
+    /**
+     * Image/Video shared fields
+     */
+    width?: number;
+    height?: number;
+    resolution_mp?: number;
+    /**
+     * Image specific fields
+     */
+    steps?: number;
+    count?: number;
+    /**
+     * Video specific fields
+     */
+    resolution?: VideoResolution;
+    seconds?: number;
+    fps?: number;
+    /**
+     * Audio specific fields
+     */
+    sample_rate?: number;
+    /**
+     * Raw specific fields
+     */
+    cost?: number;
+    /**
+     * App-specific key-value pairs for custom pricing factors
+     */
+    extra?: {
+        [key: string]: any;
+    };
+}
+/**
+ * OutputMeta contains structured metadata about task inputs and outputs for pricing calculation
+ */
+export interface OutputMeta {
+    inputs: MetaItem[];
+    outputs: MetaItem[];
+}

package/dist/types.js

@@ -0,0 +1,11 @@
+// Code generated by tygo. DO NOT EDIT.
+export const MetaItemTypeText = "text";
+export const MetaItemTypeImage = "image";
+export const MetaItemTypeVideo = "video";
+export const MetaItemTypeAudio = "audio";
+export const MetaItemTypeRaw = "raw";
+export const VideoRes480P = "480p";
+export const VideoRes720P = "720p";
+export const VideoRes1080P = "1080p";
+export const VideoRes1440P = "1440p";
+export const VideoRes4K = "4k";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inferencesh/app",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "App framework for building inference.sh apps — File handling, output metadata, storage utilities",
   "type": "module",
   "main": "dist/index.js",
@@ -46,6 +46,7 @@
   },
   "files": [
     "dist",
+    "!dist/test",
     "README.md",
     "LICENSE"
   ]

package/dist/test/file.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/test/file.test.js

@@ -1,70 +0,0 @@
-import { describe, it, before, after } from "node:test";
-import assert from "node:assert";
-import { writeFileSync, mkdirSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { File } from "../file.js";
-const TEST_DIR = join(tmpdir(), "inferencesh-app-test-" + Date.now());
-let testFile;
-describe("File", () => {
-    before(() => {
-        mkdirSync(TEST_DIR, { recursive: true });
-        testFile = join(TEST_DIR, "hello.txt");
-        writeFileSync(testFile, "hello world");
-    });
-    after(() => {
-        rmSync(TEST_DIR, { recursive: true, force: true });
-    });
-    it("creates from local path", () => {
-        const file = File.fromPath(testFile);
-        assert.ok(file.path);
-        assert.ok(file.exists());
-        assert.strictEqual(file.filename, "hello.txt");
-        assert.strictEqual(file.contentType, "text/plain");
-        assert.strictEqual(file.size, 11);
-    });
-    it("creates from path via async from()", async () => {
-        const file = await File.from(testFile);
-        assert.ok(file.path);
-        assert.ok(file.exists());
-        assert.strictEqual(file.filename, "hello.txt");
-    });
-    it("creates from options object", async () => {
-        const file = await File.from({ path: testFile, contentType: "text/plain" });
-        assert.ok(file.exists());
-        assert.strictEqual(file.contentType, "text/plain");
-    });
-    it("creates from FileData with content_type (snake_case)", async () => {
-        const file = await File.from({ path: testFile, content_type: "application/octet-stream" });
-        assert.strictEqual(file.contentType, "application/octet-stream");
-    });
-    it("creates from another File", async () => {
-        const original = File.fromPath(testFile);
-        const copy = await File.from(original);
-        assert.strictEqual(copy.path, original.path);
-        assert.strictEqual(copy.filename, original.filename);
-    });
-    it("serializes to JSON with snake_case", () => {
-        const file = File.fromPath(testFile);
-        const json = file.toJSON();
-        assert.ok(json.path);
-        assert.strictEqual(json.content_type, "text/plain");
-        assert.strictEqual(json.size, 11);
-        assert.strictEqual(json.filename, "hello.txt");
-        assert.strictEqual(json.uri, undefined);
-    });
-    it("works with JSON.stringify", () => {
-        const file = File.fromPath(testFile);
-        const str = JSON.stringify({ image: file });
-        const parsed = JSON.parse(str);
-        assert.ok(parsed.image.path);
-        assert.strictEqual(parsed.image.content_type, "text/plain");
-    });
-    it("resolves relative paths to absolute", () => {
-        const file = File.fromPath("./package.json");
-        assert.ok(file.path.startsWith("/"));
-    });
-    it("throws on missing path and uri", async () => {
-        await assert.rejects(() => File.from({}), /Either 'uri' or 'path' must be provided/);
-    });
-});

package/dist/test/output-meta.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/test/output-meta.test.js

@@ -1,48 +0,0 @@
-import { describe, it } from "node:test";
-import assert from "node:assert";
-import { textMeta, imageMeta, videoMeta, audioMeta, rawMeta } from "../output-meta.js";
-describe("OutputMeta", () => {
-    it("creates text meta", () => {
-        const meta = textMeta({ tokens: 150 });
-        assert.strictEqual(meta.type, "text");
-        assert.strictEqual(meta.tokens, 150);
-    });
-    it("creates image meta", () => {
-        const meta = imageMeta({ width: 1024, height: 1024, steps: 20, count: 1 });
-        assert.strictEqual(meta.type, "image");
-        assert.strictEqual(meta.width, 1024);
-        assert.strictEqual(meta.steps, 20);
-    });
-    it("creates video meta", () => {
-        const meta = videoMeta({ resolution: "1080p", seconds: 5.0 });
-        assert.strictEqual(meta.type, "video");
-        assert.strictEqual(meta.resolution, "1080p");
-    });
-    it("creates audio meta", () => {
-        const meta = audioMeta({ seconds: 30.0 });
-        assert.strictEqual(meta.type, "audio");
-        assert.strictEqual(meta.seconds, 30.0);
-    });
-    it("creates raw meta", () => {
-        const meta = rawMeta({ cost: 0.5 });
-        assert.strictEqual(meta.type, "raw");
-        assert.strictEqual(meta.cost, 0.5);
-    });
-    it("supports extra data", () => {
-        const meta = imageMeta({ width: 512, height: 512, extra: { model: "sdxl" } });
-        assert.strictEqual(meta.extra?.model, "sdxl");
-    });
-    it("composes into OutputMeta", () => {
-        const output = {
-            inputs: [textMeta({ tokens: 100 })],
-            outputs: [textMeta({ tokens: 500 }), imageMeta({ width: 1024, height: 1024 })],
-        };
-        assert.strictEqual(output.inputs.length, 1);
-        assert.strictEqual(output.outputs.length, 2);
-        // Serializes cleanly
-        const json = JSON.stringify(output);
-        const parsed = JSON.parse(json);
-        assert.strictEqual(parsed.inputs[0].type, "text");
-        assert.strictEqual(parsed.outputs[1].type, "image");
-    });
-});

package/dist/test/storage.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/test/storage.test.js

@@ -1,10 +0,0 @@
-import { describe, it } from "node:test";
-import assert from "node:assert";
-import { StorageDir } from "../storage.js";
-describe("StorageDir", () => {
-    it("has correct paths", () => {
-        assert.strictEqual(StorageDir.DATA, "/app/data");
-        assert.strictEqual(StorageDir.TEMP, "/app/tmp");
-        assert.strictEqual(StorageDir.CACHE, "/app/cache");
-    });
-});