@officexapp/catalogs-cli 0.1.0

package/README.md

@@ -0,0 +1,92 @@
+# @officexapp/catalogs-cli
+
+CLI for Catalog Funnel — upload videos, push catalog schemas, manage assets.
+
+## Setup
+
+```bash
+npm install -g @officexapp/catalogs-cli
+```
+
+Configure authentication:
+
+```bash
+export CATALOGS_API_URL="https://catalog-funnel-api-staging.cloud.zoomgtm.com"
+export CATALOGS_TOKEN="cfk_your_api_key_here"
+```
+
+Or create `~/.catalogs-cli/config.json`:
+
+```json
+{
+  "api_url": "https://catalog-funnel-api-staging.cloud.zoomgtm.com",
+  "token": "cfk_your_api_key_here"
+}
+```
+
+## Commands
+
+### Video
+
+Upload a video, transcode to HLS, and get the streaming URL:
+
+```bash
+catalogs video upload ./demo.mp4
+```
+
+Skip transcoding (upload only):
+
+```bash
+catalogs video upload ./demo.mp4 --no-transcode
+```
+
+Check transcode status:
+
+```bash
+catalogs video status <videoId>
+```
+
+### Catalog
+
+Push a catalog schema (creates or updates):
+
+```bash
+catalogs catalog push ./my-funnel.json
+catalogs catalog push ./my-funnel.json --publish
+```
+
+List all catalogs:
+
+```bash
+catalogs catalog list
+```
+
+### Auth
+
+Check your current config:
+
+```bash
+catalogs whoami
+```
+
+## Using HLS URLs in Catalog Schemas
+
+After uploading a video, use the returned `hls_url` in your catalog schema:
+
+```json
+{
+  "id": "comp_intro_video",
+  "type": "video",
+  "props": {
+    "hls_url": "https://d1k9qtz75bfygl.cloudfront.net/media/transcoded/user123/video456/index.m3u8",
+    "poster": "https://example.com/thumb.jpg",
+    "chapters": [
+      { "time": 0, "label": "Intro" },
+      { "time": 120, "label": "Demo" },
+      { "time": 300, "label": "Pricing" }
+    ],
+    "skippable": false,
+    "require_watch_percent": 80
+  }
+}
+```

package/dist/index.js

@@ -0,0 +1,408 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/video-upload.ts
+import { readFileSync as readFileSync2, statSync } from "fs";
+import { basename } from "path";
+import ora from "ora";
+
+// src/config.ts
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var CONFIG_DIR = join(homedir(), ".catalogs-cli");
+var CONFIG_FILE = join(CONFIG_DIR, "config.json");
+function getConfig() {
+  const envUrl = process.env.CATALOGS_API_URL;
+  const envToken = process.env.CATALOGS_TOKEN;
+  if (envUrl && envToken) {
+    return { api_url: envUrl, token: envToken };
+  }
+  if (existsSync(CONFIG_FILE)) {
+    try {
+      const raw = readFileSync(CONFIG_FILE, "utf-8");
+      const parsed = JSON.parse(raw);
+      return {
+        api_url: envUrl || parsed.api_url || "",
+        token: envToken || parsed.token || ""
+      };
+    } catch {
+    }
+  }
+  const dotenv = join(process.cwd(), ".env");
+  if (existsSync(dotenv)) {
+    const lines = readFileSync(dotenv, "utf-8").split("\n");
+    const env = {};
+    for (const line of lines) {
+      const match = line.match(/^([A-Z_]+)=["']?(.+?)["']?\s*$/);
+      if (match) env[match[1]] = match[2];
+    }
+    if (env.CATALOGS_API_URL || env.CATALOGS_TOKEN) {
+      return {
+        api_url: envUrl || env.CATALOGS_API_URL || "",
+        token: envToken || env.CATALOGS_TOKEN || ""
+      };
+    }
+  }
+  return {
+    api_url: envUrl || "",
+    token: envToken || ""
+  };
+}
+function requireConfig() {
+  const config = getConfig();
+  if (!config.api_url) {
+    console.error(
+      "Missing API URL. Set CATALOGS_API_URL env var or create ~/.catalogs-cli/config.json"
+    );
+    process.exit(1);
+  }
+  if (!config.token) {
+    console.error(
+      "Missing auth token. Set CATALOGS_TOKEN env var or create ~/.catalogs-cli/config.json"
+    );
+    process.exit(1);
+  }
+  return config;
+}
+
+// src/api.ts
+var ApiClient = class {
+  constructor(config) {
+    this.config = config;
+  }
+  get headers() {
+    return {
+      Authorization: `Bearer ${this.config.token}`,
+      "Content-Type": "application/json"
+    };
+  }
+  async get(path) {
+    const res = await fetch(`${this.config.api_url}${path}`, {
+      method: "GET",
+      headers: this.headers
+    });
+    if (!res.ok) {
+      const body = await res.text();
+      throw new Error(`GET ${path} failed (${res.status}): ${body}`);
+    }
+    return res.json();
+  }
+  async post(path, body) {
+    const res = await fetch(`${this.config.api_url}${path}`, {
+      method: "POST",
+      headers: this.headers,
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`POST ${path} failed (${res.status}): ${text}`);
+    }
+    return res.json();
+  }
+  async put(path, body) {
+    const res = await fetch(`${this.config.api_url}${path}`, {
+      method: "PUT",
+      headers: this.headers,
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`PUT ${path} failed (${res.status}): ${text}`);
+    }
+    return res.json();
+  }
+};
+
+// src/commands/video-upload.ts
+var MIME_MAP = {
+  ".mp4": "video/mp4",
+  ".mov": "video/quicktime",
+  ".avi": "video/x-msvideo",
+  ".mkv": "video/x-matroska",
+  ".webm": "video/webm",
+  ".m4v": "video/x-m4v",
+  ".wmv": "video/x-ms-wmv",
+  ".flv": "video/x-flv"
+};
+function getContentType(filename) {
+  const ext = filename.toLowerCase().match(/\.[^.]+$/)?.[0] || "";
+  return MIME_MAP[ext] || "video/mp4";
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
+}
+async function videoUpload(file, opts) {
+  const config = requireConfig();
+  const api = new ApiClient(config);
+  const skipTranscode = opts.transcode === false;
+  let stat;
+  try {
+    stat = statSync(file);
+  } catch {
+    console.error(`File not found: ${file}`);
+    process.exit(1);
+  }
+  const filename = basename(file);
+  const contentType = getContentType(filename);
+  const sizeBytes = stat.size;
+  console.log(`
+File: ${filename} (${formatBytes(sizeBytes)})`);
+  console.log(`Type: ${contentType}
+`);
+  const spinner = ora("Requesting upload URL...").start();
+  let videoId;
+  let uploadUrl;
+  try {
+    const res = await api.post("/api/v1/videos/upload", {
+      filename,
+      content_type: contentType,
+      size_bytes: sizeBytes
+    });
+    videoId = res.data.video_id;
+    uploadUrl = res.data.upload_url;
+    spinner.succeed(
+      `Upload authorized \u2014 video_id: ${videoId} (${res.data.credits_charged} credits)`
+    );
+  } catch (err) {
+    spinner.fail(`Upload request failed: ${err.message}`);
+    process.exit(1);
+  }
+  const uploadSpinner = ora("Uploading to S3...").start();
+  try {
+    const fileBuffer = readFileSync2(file);
+    const res = await fetch(uploadUrl, {
+      method: "PUT",
+      headers: { "Content-Type": contentType },
+      body: fileBuffer
+    });
+    if (!res.ok) {
+      throw new Error(`S3 PUT failed: ${res.status} ${res.statusText}`);
+    }
+    uploadSpinner.succeed("Upload complete");
+  } catch (err) {
+    uploadSpinner.fail(`Upload failed: ${err.message}`);
+    process.exit(1);
+  }
+  if (skipTranscode) {
+    console.log(`
+video_id: ${videoId}`);
+    console.log("Skipped transcoding. Run `catalogs video status` to check later.\n");
+    return;
+  }
+  const transcodeSpinner = ora("Starting HLS transcode...").start();
+  try {
+    const res = await api.post(`/api/v1/videos/${videoId}/transcode`);
+    transcodeSpinner.succeed(
+      `Transcode started \u2014 job_id: ${res.data.job_id} (${res.data.credits_charged} credits)`
+    );
+  } catch (err) {
+    transcodeSpinner.fail(`Transcode request failed: ${err.message}`);
+    console.log(`
+video_id: ${videoId}`);
+    console.log("Upload succeeded but transcode failed. Retry with: catalogs video status\n");
+    process.exit(1);
+  }
+  const pollSpinner = ora("Transcoding (this may take a few minutes)...").start();
+  const startTime = Date.now();
+  const MAX_POLL = 10 * 60 * 1e3;
+  const POLL_INTERVAL = 5e3;
+  while (Date.now() - startTime < MAX_POLL) {
+    await sleep(POLL_INTERVAL);
+    try {
+      const res = await api.get(`/api/v1/videos/${videoId}/status`);
+      const { status, hls_url } = res.data;
+      if (status === "ready" && hls_url) {
+        pollSpinner.succeed("Transcode complete!");
+        console.log(`
+  video_id: ${videoId}`);
+        console.log(`  hls_url:  ${hls_url}`);
+        console.log(
+          `
+Add to your catalog schema:
+  { "type": "video", "props": { "hls_url": "${hls_url}" } }
+`
+        );
+        return;
+      }
+      if (status === "failed") {
+        pollSpinner.fail("Transcode failed");
+        console.log(`
+video_id: ${videoId}`);
+        process.exit(1);
+      }
+      const elapsed = Math.round((Date.now() - startTime) / 1e3);
+      pollSpinner.text = `Transcoding... (${elapsed}s)`;
+    } catch {
+    }
+  }
+  pollSpinner.warn("Transcode still in progress (timed out waiting)");
+  console.log(`
+Check status later: catalogs video status ${videoId}
+`);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/commands/video-status.ts
+import ora2 from "ora";
+async function videoStatus(videoId) {
+  const config = requireConfig();
+  const api = new ApiClient(config);
+  const spinner = ora2(`Checking status for ${videoId}...`).start();
+  try {
+    const res = await api.get(`/api/v1/videos/${videoId}/status`);
+    const { status, hls_url, filename, size_bytes } = res.data;
+    spinner.stop();
+    console.log(`
+  video_id: ${videoId}`);
+    console.log(`  filename: ${filename}`);
+    if (size_bytes) {
+      const mb = (size_bytes / (1024 * 1024)).toFixed(1);
+      console.log(`  size:     ${mb} MB`);
+    }
+    console.log(`  status:   ${status}`);
+    if (hls_url) {
+      console.log(`  hls_url:  ${hls_url}`);
+    }
+    console.log();
+  } catch (err) {
+    spinner.fail(`Failed: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+// src/commands/catalog-push.ts
+import { readFileSync as readFileSync3 } from "fs";
+import ora3 from "ora";
+async function catalogPush(file, opts) {
+  const config = requireConfig();
+  const api = new ApiClient(config);
+  let schema;
+  try {
+    const raw = readFileSync3(file, "utf-8");
+    schema = JSON.parse(raw);
+  } catch (err) {
+    console.error(`Failed to read ${file}: ${err.message}`);
+    process.exit(1);
+  }
+  const slug = schema.slug;
+  const name = schema.catalog_id || schema.slug || file;
+  if (!slug) {
+    console.error("Schema must have a 'slug' field");
+    process.exit(1);
+  }
+  const status = opts.publish ? "published" : "draft";
+  const spinner = ora3(`Pushing catalog "${slug}"...`).start();
+  try {
+    const listRes = await api.get("/api/v1/catalogs");
+    const catalogs = listRes.data || [];
+    const existing = catalogs.find((c) => c.slug === slug);
+    if (existing) {
+      const res = await api.put(`/api/v1/catalogs/${existing.catalog_id}`, {
+        schema,
+        status,
+        name
+      });
+      spinner.succeed(`Updated catalog "${slug}" (${existing.catalog_id})`);
+      if (res.data?.url) {
+        console.log(`  URL: ${res.data.url}`);
+      }
+    } else {
+      const res = await api.post("/api/v1/catalogs", {
+        slug,
+        name,
+        schema,
+        status
+      });
+      spinner.succeed(`Created catalog "${slug}" (${res.data?.catalog_id})`);
+      if (res.data?.url) {
+        console.log(`  URL: ${res.data.url}`);
+      }
+    }
+    console.log(`  Status: ${status}
+`);
+  } catch (err) {
+    spinner.fail(`Push failed: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+// src/commands/catalog-list.ts
+import ora4 from "ora";
+async function catalogList() {
+  const config = requireConfig();
+  const api = new ApiClient(config);
+  const spinner = ora4("Fetching catalogs...").start();
+  try {
+    const res = await api.get("/api/v1/catalogs");
+    const catalogs = res.data || [];
+    spinner.stop();
+    if (catalogs.length === 0) {
+      console.log("\nNo catalogs found.\n");
+      return;
+    }
+    console.log(`
+  Found ${catalogs.length} catalog(s):
+`);
+    for (const c of catalogs) {
+      const statusBadge = c.status === "published" ? "[published]" : "[draft]";
+      console.log(`  ${c.slug} ${statusBadge}`);
+      console.log(`    id: ${c.catalog_id}`);
+      if (c.url) console.log(`    url: ${c.url}`);
+      console.log();
+    }
+  } catch (err) {
+    spinner.fail(`Failed: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+// src/commands/whoami.ts
+async function whoami() {
+  const config = getConfig();
+  if (!config.api_url || !config.token) {
+    console.log("\nNot configured.\n");
+    console.log("Set these environment variables:");
+    console.log("  CATALOGS_API_URL  \u2014 API base URL (e.g. https://catalog-funnel-api-staging.cloud.zoomgtm.com)");
+    console.log("  CATALOGS_TOKEN    \u2014 API key (cfk_... or base64 legacy token)");
+    console.log("\nOr create ~/.catalogs-cli/config.json:");
+    console.log('  { "api_url": "...", "token": "..." }\n');
+    return;
+  }
+  const tokenPreview = config.token.length > 12 ? config.token.slice(0, 8) + "..." + config.token.slice(-4) : "***";
+  console.log(`
+  api_url: ${config.api_url}`);
+  console.log(`  token:   ${tokenPreview}`);
+  try {
+    const res = await fetch(`${config.api_url}/health`);
+    if (res.ok) {
+      const data = await res.json();
+      console.log(`  stage:   ${data.stage || "unknown"}`);
+      console.log(`  status:  connected`);
+    } else {
+      console.log(`  status:  error (${res.status})`);
+    }
+  } catch (err) {
+    console.log(`  status:  unreachable (${err.message})`);
+  }
+  console.log();
+}
+
+// src/index.ts
+var program = new Command();
+program.name("catalogs").description("CLI for Catalog Funnel \u2014 upload videos, push catalogs, manage assets").version("0.1.0");
+var video = program.command("video").description("Video upload & transcoding");
+video.command("upload <file>").description("Upload a video file \u2192 transcode to HLS \u2192 return hls_url").option("--no-transcode", "Skip transcoding (upload only)").action(videoUpload);
+video.command("status <videoId>").description("Check transcode status for a video").action(videoStatus);
+var catalog = program.command("catalog").description("Catalog schema management");
+catalog.command("push <file>").description("Create or update a catalog from a JSON schema file").option("--publish", "Set status to published (default: draft)").action(catalogPush);
+catalog.command("list").description("List all catalogs").action(catalogList);
+program.command("whoami").description("Show current authentication info").action(whoami);
+program.parse();

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@officexapp/catalogs-cli",
+  "version": "0.1.0",
+  "description": "CLI for Catalog Funnel — upload videos, push catalogs, manage assets",
+  "type": "module",
+  "bin": {
+    "catalogs": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsx src/index.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "catalog-funnel",
+    "officex",
+    "cli",
+    "video",
+    "hls"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/OfficeXApp/catalogs-cli.git"
+  },
+  "license": "UNLICENSED",
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "commander": "^12.1.0",
+    "ora": "^8.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsup": "^8.3.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.6.3"
+  }
+}