@ishlabs/cli 0.8.1

package/dist/lib/types.d.ts

@@ -0,0 +1,179 @@
+/**
+ * TypeScript interfaces for Ish API entities.
+ */
+export interface Product {
+    id: string;
+    name: string;
+    description?: string;
+    color?: string;
+    base_url?: string;
+    product_type?: string;
+    created_at: string;
+    updated_at: string;
+}
+export interface ProductCreateInput {
+    name: string;
+    description?: string;
+    color?: string;
+    base_url?: string;
+}
+export interface ProductUpdateInput {
+    name?: string;
+    description?: string;
+    color?: string;
+    base_url?: string;
+}
+export interface Assignment {
+    id?: string;
+    name: string;
+    instructions: string;
+}
+export interface InterviewQuestion {
+    id?: string;
+    question: string;
+    type?: string;
+    timing?: string;
+    min?: number;
+    max?: number;
+    step?: number;
+    labels?: string[];
+    options?: string[];
+}
+export interface Study {
+    id: string;
+    product_id: string;
+    name: string;
+    description?: string;
+    modality?: string;
+    content_type?: string;
+    status?: string;
+    start_frame_id?: string;
+    source_study_id?: string;
+    assignments?: Assignment[];
+    interview_questions?: InterviewQuestion[];
+    frames?: unknown[];
+    iterations?: Iteration[];
+    created_at: string;
+    updated_at: string;
+    created_by?: string;
+}
+export interface StudyCreateInput {
+    product_id: string;
+    name: string;
+    description?: string;
+    modality?: string;
+    content_type?: string;
+    assignments?: Assignment[];
+    interview_questions?: InterviewQuestion[];
+    start_frame_id?: string;
+}
+export interface StudyUpdateInput {
+    name?: string;
+    description?: string;
+    status?: string;
+    modality?: string;
+    content_type?: string;
+    assignments?: Assignment[];
+    interview_questions?: InterviewQuestion[];
+    start_frame_id?: string;
+}
+export interface StudyGenerateInput {
+    problem_description: string;
+    target_url?: string;
+}
+export interface Iteration {
+    id: string;
+    study_id: string;
+    name?: string;
+    description?: string;
+    label?: string;
+    details?: Record<string, unknown>;
+    testers?: Tester[];
+    created_at: string;
+    updated_at: string;
+}
+export interface IterationCreateInput {
+    name: string;
+    description?: string;
+    details?: Record<string, unknown>;
+}
+export interface IterationUpdateInput {
+    name?: string;
+    description?: string;
+    details?: Record<string, unknown>;
+    label?: string;
+}
+export interface TesterProfile {
+    id: string;
+    name: string;
+    [key: string]: unknown;
+}
+export interface Tester {
+    id: string;
+    iteration_id: string;
+    tester_profile_id: string;
+    instance_name?: string;
+    instance_number?: number;
+    status: string;
+    language?: string;
+    platform?: string;
+    tester_type?: string;
+    viewport_width?: number;
+    viewport_height?: number;
+    created_at: string;
+}
+export interface TesterCreateInput {
+    tester_profile_id: string;
+    instance_name?: string;
+    status?: string;
+    language?: string;
+    platform?: string;
+    tester_type?: string;
+}
+export interface SimulationStartResponse {
+    tester_id: string;
+    study_id: string;
+    job_id: string | null;
+    message: string;
+}
+export interface SimulationBatchStartResponse {
+    results: SimulationStartResponse[];
+}
+export interface MediaSimulationStartInput {
+    product_id: string;
+    study_id: string;
+    tester_id: string;
+    config_id: string;
+    max_interactions?: number;
+    language?: string;
+    config_overrides?: Record<string, unknown>;
+}
+export interface MediaBatchStartResponse {
+    results: SimulationStartResponse[];
+}
+export declare const MEDIA_MODALITIES: readonly ["video", "audio", "text", "image", "document"];
+export type MediaModality = typeof MEDIA_MODALITIES[number];
+export declare const VALID_CONTENT_TYPES: Record<string, string[]>;
+export interface SimulationStatus {
+    job_id: string;
+    status: string | null;
+    create_time?: string;
+    completion_time?: string;
+    error?: string;
+}
+export interface SimulationCancelResponse {
+    job_id: string;
+    success: boolean;
+    message: string;
+}
+export interface SimulationConfig {
+    id: string;
+    name: string;
+    model_settings?: Record<string, unknown>;
+    simulation_settings?: Record<string, unknown>;
+    prompts?: Record<string, unknown>;
+    outputs?: Record<string, unknown>;
+    source_type?: string;
+    created_at: string;
+    updated_at: string;
+}

package/dist/lib/types.js

@@ -0,0 +1,12 @@
+/**
+ * TypeScript interfaces for Ish API entities.
+ */
+// --- Modality constants ---
+export const MEDIA_MODALITIES = ["video", "audio", "text", "image", "document"];
+export const VALID_CONTENT_TYPES = {
+    text: ["narrative", "informational", "commercial", "editorial", "reference", "email", "news"],
+    video: ["tutorial", "documentary", "entertainment", "review", "lifestyle", "news", "social_post", "ad"],
+    audio: ["music", "narration", "conversation", "speech", "soundscape", "news", "ad"],
+    image: ["product", "photography", "infographic", "artwork", "interface", "social_post", "ad"],
+    document: ["deck", "presentation", "report", "brochure", "guide"],
+};

package/dist/lib/upload.d.ts

@@ -0,0 +1,47 @@
+/**
+ * File upload utilities for media modalities.
+ *
+ * Implements the same backend-mediated upload flow as the frontend:
+ *   1. POST /studies/{id}/content/upload  → signed URL + content_url
+ *   2. PUT  signed_upload_url             → upload raw bytes
+ *   3. PUT  /studies/{id}/content/upload/complete → mark done
+ *
+ * Detects local file paths vs URLs automatically and handles
+ * MIME type detection, file validation, and progress reporting.
+ */
+import type { ApiClient } from "./api-client.js";
+export declare function detectMimeType(filePath: string): string;
+export declare function isLocalPath(value: string): boolean;
+export declare function validateFile(filePath: string): Promise<{
+    size: number;
+    mime: string;
+}>;
+/**
+ * Upload a local file to Supabase Storage via the backend's signed URL flow.
+ * Returns the public content_url for use in iteration details.
+ */
+export declare function uploadStudyContent(client: ApiClient, studyId: string, filePath: string, opts?: {
+    mimeTypeOverride?: string;
+    quiet?: boolean;
+}): Promise<string>;
+/**
+ * If the value is a URL, return it as-is. If it's a local file path,
+ * upload it and return the resulting content_url.
+ */
+export declare function resolveContentUrl(client: ApiClient, studyId: string, value: string, opts?: {
+    mimeTypeOverride?: string;
+    quiet?: boolean;
+}): Promise<string>;
+/**
+ * Resolve a comma-separated list of URLs or file paths.
+ * Each value is independently resolved (some may be URLs, some files).
+ */
+export declare function resolveContentUrls(client: ApiClient, studyId: string, commaSeparated: string, opts?: {
+    mimeTypeOverride?: string;
+    quiet?: boolean;
+}): Promise<string[]>;
+/**
+ * Resolve text content. If the value starts with '@', read the file at
+ * the path that follows (curl-style convention). Otherwise return as-is.
+ */
+export declare function resolveTextContent(value: string): string;

package/dist/lib/upload.js

@@ -0,0 +1,178 @@
+/**
+ * File upload utilities for media modalities.
+ *
+ * Implements the same backend-mediated upload flow as the frontend:
+ *   1. POST /studies/{id}/content/upload  → signed URL + content_url
+ *   2. PUT  signed_upload_url             → upload raw bytes
+ *   3. PUT  /studies/{id}/content/upload/complete → mark done
+ *
+ * Detects local file paths vs URLs automatically and handles
+ * MIME type detection, file validation, and progress reporting.
+ */
+import { readFile } from "node:fs/promises";
+import { access, stat, constants } from "node:fs/promises";
+import { readFileSync } from "node:fs";
+import { extname, basename, resolve as resolvePath } from "node:path";
+// ---------------------------------------------------------------------------
+// MIME type detection (inline map — zero dependencies)
+// ---------------------------------------------------------------------------
+const MIME_MAP = {
+    // Video
+    ".mp4": "video/mp4",
+    ".webm": "video/webm",
+    ".mov": "video/quicktime",
+    ".avi": "video/x-msvideo",
+    // Audio
+    ".mp3": "audio/mpeg",
+    ".wav": "audio/wav",
+    ".ogg": "audio/ogg",
+    ".m4a": "audio/mp4",
+    ".flac": "audio/flac",
+    // Image
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".svg": "image/svg+xml",
+    ".bmp": "image/bmp",
+    // Document
+    ".pdf": "application/pdf",
+    ".doc": "application/msword",
+    ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    ".ppt": "application/vnd.ms-powerpoint",
+    ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    // Text
+    ".txt": "text/plain",
+    ".html": "text/html",
+    ".htm": "text/html",
+    ".csv": "text/csv",
+    ".json": "application/json",
+    ".md": "text/markdown",
+};
+export function detectMimeType(filePath) {
+    const ext = extname(filePath).toLowerCase();
+    return MIME_MAP[ext] || "application/octet-stream";
+}
+// ---------------------------------------------------------------------------
+// Path detection
+// ---------------------------------------------------------------------------
+export function isLocalPath(value) {
+    // URLs have a scheme followed by "://"; anything else is a local path
+    if (value.startsWith("http://") || value.startsWith("https://"))
+        return false;
+    if (/^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(value)) {
+        throw new Error(`Unsupported URL scheme: ${value.split("://")[0]}. Use http(s):// URLs or local file paths.`);
+    }
+    return true;
+}
+// ---------------------------------------------------------------------------
+// File validation
+// ---------------------------------------------------------------------------
+const MAX_FILE_SIZE = 500 * 1024 * 1024; // 500 MB
+export async function validateFile(filePath) {
+    const resolved = resolvePath(filePath);
+    try {
+        await access(resolved, constants.R_OK);
+    }
+    catch {
+        throw new Error(`File not found or not readable: ${filePath}`);
+    }
+    const info = await stat(resolved);
+    if (!info.isFile()) {
+        throw new Error(`Not a regular file: ${filePath}`);
+    }
+    if (info.size === 0) {
+        throw new Error(`File is empty: ${filePath}`);
+    }
+    if (info.size > MAX_FILE_SIZE) {
+        const sizeMB = (info.size / (1024 * 1024)).toFixed(1);
+        throw new Error(`File too large (${sizeMB} MB). Maximum is ${MAX_FILE_SIZE / (1024 * 1024)} MB.`);
+    }
+    return { size: info.size, mime: detectMimeType(filePath) };
+}
+// ---------------------------------------------------------------------------
+// Core upload: 3-step backend-mediated flow
+// ---------------------------------------------------------------------------
+/**
+ * Upload a local file to Supabase Storage via the backend's signed URL flow.
+ * Returns the public content_url for use in iteration details.
+ */
+export async function uploadStudyContent(client, studyId, filePath, opts) {
+    const resolved = resolvePath(filePath);
+    const { size, mime: detectedMime } = await validateFile(filePath);
+    const mime = opts?.mimeTypeOverride || detectedMime;
+    const name = basename(filePath);
+    const sizeMB = (size / (1024 * 1024)).toFixed(1);
+    const log = (msg) => { if (!opts?.quiet)
+        process.stderr.write(msg); };
+    // Step 1: Request a signed upload URL from the backend
+    log(`Uploading ${name} (${sizeMB} MB)...`);
+    const uploadResp = await client.post(`/studies/${studyId}/content/upload`, { content_type: mime, file_size_bytes: size });
+    // Step 2: PUT the raw file bytes to the signed URL
+    const fileBuffer = await readFile(resolved);
+    const putResp = await fetch(uploadResp.upload_info.signed_upload_url, {
+        method: "PUT",
+        headers: {
+            "Content-Type": mime,
+            "Content-Length": String(fileBuffer.byteLength),
+        },
+        body: fileBuffer,
+        signal: AbortSignal.timeout(300_000), // 5 min timeout for large files
+    });
+    if (!putResp.ok) {
+        const body = await putResp.text().catch(() => "");
+        throw new Error(`Upload failed (HTTP ${putResp.status}): ${body}`);
+    }
+    // Step 3: Mark the upload as complete
+    await client.put(`/studies/${studyId}/content/upload/complete`, {
+        file_path: uploadResp.upload_info.file_path,
+        is_uploaded: true,
+    });
+    log(" done.\n");
+    return uploadResp.content_url;
+}
+// ---------------------------------------------------------------------------
+// High-level resolvers (URL passthrough or upload)
+// ---------------------------------------------------------------------------
+/**
+ * If the value is a URL, return it as-is. If it's a local file path,
+ * upload it and return the resulting content_url.
+ */
+export async function resolveContentUrl(client, studyId, value, opts) {
+    if (!isLocalPath(value))
+        return value;
+    return uploadStudyContent(client, studyId, value, opts);
+}
+/**
+ * Resolve a comma-separated list of URLs or file paths.
+ * Each value is independently resolved (some may be URLs, some files).
+ */
+export async function resolveContentUrls(client, studyId, commaSeparated, opts) {
+    const values = commaSeparated.split(",").map((s) => s.trim()).filter(Boolean);
+    const results = [];
+    for (const v of values) {
+        results.push(await resolveContentUrl(client, studyId, v, opts));
+    }
+    return results;
+}
+/**
+ * Resolve text content. If the value starts with '@', read the file at
+ * the path that follows (curl-style convention). Otherwise return as-is.
+ */
+export function resolveTextContent(value) {
+    if (!value.startsWith("@"))
+        return value;
+    const filePath = value.slice(1);
+    if (!filePath) {
+        throw new Error("Missing file path after @. Usage: --content-text @./file.txt");
+    }
+    const resolved = resolvePath(filePath);
+    try {
+        return readFileSync(resolved, "utf-8");
+    }
+    catch {
+        throw new Error(`Cannot read text file: ${filePath}`);
+    }
+}

package/dist/upgrade.d.ts

@@ -0,0 +1 @@
+export declare function upgrade(currentVersion: string, targetVersion?: string): Promise<void>;

package/dist/upgrade.js

@@ -0,0 +1,94 @@
+import { createWriteStream, renameSync, unlinkSync, chmodSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { pipeline } from "node:stream/promises";
+import { Readable } from "node:stream";
+const BASE_URL = "https://ishlabs.io";
+function getPlatformTarget() {
+    const platform = process.platform;
+    const arch = process.arch;
+    const targets = {
+        darwin: { arm64: "darwin-arm64", x64: "darwin-x64" },
+        linux: { arm64: "linux-arm64", x64: "linux-x64" },
+        win32: { x64: "windows-x64" },
+    };
+    const target = targets[platform]?.[arch];
+    if (!target) {
+        throw new Error(`Unsupported platform: ${platform}-${arch}`);
+    }
+    return target;
+}
+async function getLatestVersion() {
+    const res = await fetch(`${BASE_URL}/api/releases/latest`);
+    if (!res.ok)
+        throw new Error(`Failed to fetch latest version: ${res.statusText}`);
+    const data = (await res.json());
+    return data.version;
+}
+export async function upgrade(currentVersion, targetVersion) {
+    if (targetVersion && !/^\d+\.\d+\.\d+/.test(targetVersion)) {
+        throw new Error(`Invalid version format: ${targetVersion}`);
+    }
+    const latest = targetVersion || (await getLatestVersion());
+    if (latest === currentVersion) {
+        console.log(`Already up to date (v${currentVersion}).`);
+        return;
+    }
+    console.log(`Updating ish v${currentVersion} → v${latest}...`);
+    const target = getPlatformTarget();
+    const ext = process.platform === "win32" ? ".exe" : "";
+    const assetName = `ish-${target}${ext}`;
+    const url = `${BASE_URL}/api/releases/v${latest}/${assetName}`;
+    const res = await fetch(url, { redirect: "follow" });
+    if (!res.ok) {
+        throw new Error(`Download failed: ${res.statusText} (${url})`);
+    }
+    if (!res.body) {
+        throw new Error(`Download failed: empty response body (${url})`);
+    }
+    const execPath = process.execPath;
+    // Use same directory as the binary to avoid cross-device rename issues
+    const tmpPath = join(dirname(execPath), `.ish-upgrade-${Date.now()}${ext}`);
+    const fileStream = createWriteStream(tmpPath);
+    try {
+        await pipeline(Readable.fromWeb(res.body), fileStream);
+    }
+    catch (err) {
+        try {
+            unlinkSync(tmpPath);
+        }
+        catch { }
+        throw err;
+    }
+    if (process.platform === "win32") {
+        const oldPath = execPath + ".old";
+        try {
+            unlinkSync(oldPath);
+        }
+        catch { }
+        renameSync(execPath, oldPath);
+        try {
+            renameSync(tmpPath, execPath);
+            try {
+                unlinkSync(oldPath);
+            }
+            catch { }
+        }
+        catch (err) {
+            // Restore original binary on failure
+            try {
+                renameSync(oldPath, execPath);
+            }
+            catch { }
+            try {
+                unlinkSync(tmpPath);
+            }
+            catch { }
+            throw err;
+        }
+    }
+    else {
+        chmodSync(tmpPath, 0o755);
+        renameSync(tmpPath, execPath);
+    }
+    console.log(`Updated to v${latest}.`);
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@ishlabs/cli",
+  "version": "0.8.1",
+  "description": "The command-line interface for Ish",
+  "type": "module",
+  "bin": {
+    "ish": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "build:binary": "bun build --compile --external playwright-core --external chromium-bidi --external electron src/index.ts --outfile ish",
+    "dev": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "keywords": [
+    "ish",
+    "connect",
+    "localhost",
+    "testing"
+  ],
+  "author": "Ish Labs",
+  "license": "SEE LICENSE IN LICENSE",
+  "homepage": "https://ishlabs.io",
+  "bugs": {
+    "email": "support@ishlabs.io"
+  },
+  "dependencies": {
+    "commander": "^13.0.0",
+    "playwright-core": "^1.58.2"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.7.0"
+  }
+}