argus-media-cli 0.1.0 → 0.1.2

package/README.md

@@ -0,0 +1,80 @@
+# argus-media-cli
+
+CLI for [Argus](https://argus.build) — AI-native media asset management.
+
+## Install
+
+```bash
+npm install -g argus-media-cli
+```
+
+Or run directly:
+
+```bash
+npx argus-media-cli upload photo.jpg
+```
+
+## Setup
+
+```bash
+argus-media-cli login
+```
+
+Or set your API key as an environment variable:
+
+```bash
+export ARGUS_API_KEY=ak_your_key_here
+```
+
+## Commands
+
+### Upload
+
+```bash
+argus-media-cli upload photo.jpg
+argus-media-cli upload hero.png --project campaign-q2 --tags hero,banner
+```
+
+### Search
+
+```bash
+argus-media-cli search "sunset landscape"
+argus-media-cli search --project website --status ready --json
+```
+
+### List
+
+```bash
+argus-media-cli list
+argus-media-cli list --project website --limit 20
+```
+
+### Get
+
+```bash
+argus-media-cli get <asset-id>
+argus-media-cli get abc12345 --json
+```
+
+### Login
+
+```bash
+argus-media-cli login                     # Interactive prompt
+argus-media-cli login --key ak_xxx       # Non-interactive
+argus-media-cli login --url http://localhost:8787  # Custom API URL
+```
+
+## Options
+
+All commands support `--json` for structured JSON output.
+
+## Environment Variables
+
+| Variable | Description |
+|---|---|
+| `ARGUS_API_KEY` | API key (overrides saved config) |
+| `ARGUS_BASE_URL` | API base URL (default: `https://argus.build`) |
+
+## License
+
+MIT

package/dist/index.js

@@ -1,180 +1,367 @@
 #!/usr/bin/env node
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
-import { join } from "path";
-import { homedir } from "os";
-const BASE_URL = process.env.ARGUS_BASE_URL || "https://argus.build";
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { basename, extname, join } from "node:path";
+import { homedir } from "node:os";
+import * as readline from "node:readline";
+// ─── Config ────────────────────────────────────────────────────────────────
 const CONFIG_DIR = join(homedir(), ".argus");
 const CONFIG_FILE = join(CONFIG_DIR, "config.json");
-// ── Config ────────────────────────────────────────────────────────────────────
-function loadConfig() {
+async function loadConfig() {
     try {
-        return JSON.parse(readFileSync(CONFIG_FILE, "utf8"));
+        const data = await readFile(CONFIG_FILE, "utf-8");
+        return JSON.parse(data);
     }
     catch {
         return {};
     }
 }
-function saveConfig(config) {
-    mkdirSync(CONFIG_DIR, { recursive: true });
-    writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+async function saveConfig(config) {
+    await mkdir(CONFIG_DIR, { recursive: true });
+    await writeFile(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n");
 }
-function getApiKey() {
-    const key = process.env.ARGUS_API_KEY || loadConfig().apiKey;
+// ─── API Client ────────────────────────────────────────────────────────────
+function getBaseUrl(config) {
+    return process.env.ARGUS_BASE_URL || config.baseUrl || "https://argus.build";
+}
+function getApiKey(config) {
+    const key = process.env.ARGUS_API_KEY || config.apiKey;
     if (!key) {
-        console.error("No API key found. Run: argus login <api-key>");
-        console.error("Or set ARGUS_API_KEY in your environment.");
+        console.error("Error: No API key configured.");
+        console.error("Run `argus-media-cli login` to authenticate, or set ARGUS_API_KEY.");
         process.exit(1);
     }
     return key;
 }
-// ── HTTP ──────────────────────────────────────────────────────────────────────
-async function api(method, path, body) {
-    const res = await fetch(`${BASE_URL}${path}`, {
+async function apiRequest(config, method, path, body) {
+    const url = `${getBaseUrl(config)}${path}`;
+    const apiKey = getApiKey(config);
+    const opts = {
         method,
         headers: {
-            Authorization: `Bearer ${getApiKey()}`,
+            Authorization: `Bearer ${apiKey}`,
             ...(body ? { "Content-Type": "application/json" } : {}),
         },
         ...(body ? { body: JSON.stringify(body) } : {}),
-    });
-    const data = await res.json().catch(() => ({}));
+    };
+    const res = await fetch(url, opts);
     if (!res.ok) {
-        const err = data.error || res.statusText;
-        console.error(`Error: ${err}`);
+        const text = await res.text();
+        throw new Error(`API ${method} ${path} failed (${res.status}): ${text}`);
+    }
+    return res.json();
+}
+// ─── MIME Types ────────────────────────────────────────────────────────────
+const MIME_TYPES = {
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".png": "image/png",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".svg": "image/svg+xml",
+    ".mp4": "video/mp4",
+    ".mov": "video/quicktime",
+    ".webm": "video/webm",
+    ".mp3": "audio/mpeg",
+    ".wav": "audio/wav",
+    ".pdf": "application/pdf",
+};
+// ─── Formatting ────────────────────────────────────────────────────────────
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function formatAssetRow(a) {
+    const status = a.status === "ready" ? "\x1b[32m●\x1b[0m" : a.status === "pending" ? "\x1b[33m●\x1b[0m" : "\x1b[31m●\x1b[0m";
+    const size = formatBytes(a.size || 0);
+    const project = a.project ? ` [${a.project}]` : "";
+    const tags = a.tags?.length ? ` (${a.tags.join(", ")})` : "";
+    return `${status} ${a.id.slice(0, 8)}  ${a.filename}  ${size}${project}${tags}`;
+}
+function formatAssetDetail(a) {
+    const lines = [
+        `\x1b[1m${a.filename}\x1b[0m`,
+        `  ID:       ${a.id}`,
+        `  Status:   ${a.status}`,
+        `  Type:     ${a.mimeType}`,
+        `  Size:     ${formatBytes(a.size || 0)}`,
+    ];
+    if (a.project)
+        lines.push(`  Project:  ${a.project}`);
+    if (a.url)
+        lines.push(`  URL:      ${a.url}`);
+    if (a.tags?.length)
+        lines.push(`  Tags:     ${a.tags.join(", ")}`);
+    if (a.uploadedBy)
+        lines.push(`  Uploader: ${a.uploadedBy}`);
+    if (a.uploadedAt)
+        lines.push(`  Uploaded: ${a.uploadedAt}`);
+    if (a.analysis) {
+        lines.push(`  \x1b[1mAnalysis:\x1b[0m`);
+        if (a.analysis.description)
+            lines.push(`    ${a.analysis.description}`);
+        if (a.analysis.mood)
+            lines.push(`    Mood: ${a.analysis.mood}`);
+        if (a.analysis.dominantColors?.length) {
+            const colors = a.analysis.dominantColors.map((c) => `${c.name} (${c.hex})`).join(", ");
+            lines.push(`    Colors: ${colors}`);
+        }
+        if (a.analysis.useCases?.length)
+            lines.push(`    Uses: ${a.analysis.useCases.join(", ")}`);
+        if (a.analysis.tags?.length)
+            lines.push(`    Tags: ${a.analysis.tags.join(", ")}`);
+    }
+    return lines.join("\n");
+}
+// ─── Commands ──────────────────────────────────────────────────────────────
+async function cmdLogin(args, flags) {
+    const config = await loadConfig();
+    if (flags.key) {
+        config.apiKey = flags.key;
+        await saveConfig(config);
+        console.log("API key saved to ~/.argus/config.json");
+        return;
+    }
+    if (flags.url) {
+        config.baseUrl = flags.url;
+        await saveConfig(config);
+        console.log(`Base URL set to ${flags.url}`);
+        return;
+    }
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const ask = (q) => new Promise((resolve) => rl.question(q, resolve));
+    console.log("Argus CLI Login");
+    console.log("Get your API key at https://argus.build/ui\n");
+    const key = await ask("API key: ");
+    rl.close();
+    if (!key.trim()) {
+        console.error("No key provided.");
+        process.exit(1);
+    }
+    config.apiKey = key.trim();
+    await saveConfig(config);
+    // Verify the key works
+    try {
+        const res = await apiRequest(config, "GET", "/usage");
+        console.log(`\nAuthenticated! Workspace tier: ${res.tier}`);
+        console.log(`Assets: ${res.assets?.used ?? 0}/${res.assets?.limit ?? "unlimited"}`);
+    }
+    catch (e) {
+        console.error(`\nWarning: Could not verify key — ${e.message}`);
+        console.log("Key saved anyway. Check it with `argus-media-cli list`.");
+    }
+}
+async function cmdUpload(args, flags) {
+    const filePath = args[0];
+    if (!filePath) {
+        console.error("Usage: argus-media-cli upload <file> [--project NAME] [--tags a,b,c]");
         process.exit(1);
     }
-    return data;
+    const config = await loadConfig();
+    const apiKey = getApiKey(config);
+    const baseUrl = getBaseUrl(config);
+    // Read file
+    const fileData = await readFile(filePath);
+    const fileName = basename(filePath);
+    const ext = extname(fileName).toLowerCase();
+    const mimeType = MIME_TYPES[ext] || "application/octet-stream";
+    // Build multipart form data
+    const blob = new Blob([fileData], { type: mimeType });
+    const form = new FormData();
+    form.append("file", blob, fileName);
+    if (flags.project)
+        form.append("project", flags.project);
+    if (flags.tags)
+        form.append("tags", flags.tags);
+    const res = await fetch(`${baseUrl}/assets/upload`, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${apiKey}` },
+        body: form,
+    });
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`Upload failed (${res.status}): ${text}`);
+    }
+    const data = (await res.json());
+    const asset = data.asset;
+    if (flags.json) {
+        console.log(JSON.stringify(data, null, 2));
+    }
+    else {
+        console.log(`Uploaded: ${asset.filename} (${asset.id})`);
+        console.log(`Status: ${asset.status}`);
+        if (asset.url)
+            console.log(`URL: ${asset.url}`);
+    }
 }
-// ── Output ────────────────────────────────────────────────────────────────────
-function output(data, json) {
-    if (json) {
+async function cmdSearch(args, flags) {
+    const query = args.join(" ");
+    const config = await loadConfig();
+    const params = new URLSearchParams();
+    if (query)
+        params.set("q", query);
+    if (flags.project)
+        params.set("project", flags.project);
+    if (flags.status)
+        params.set("status", flags.status);
+    if (flags.tags)
+        params.set("tags", flags.tags);
+    if (flags.limit)
+        params.set("limit", flags.limit);
+    if (flags.offset)
+        params.set("offset", flags.offset);
+    const qs = params.toString();
+    const data = (await apiRequest(config, "GET", `/assets${qs ? `?${qs}` : ""}`));
+    if (flags.json) {
         console.log(JSON.stringify(data, null, 2));
         return;
     }
-    const asset = data.asset;
-    const assets = data.assets;
-    if (asset)
-        printAsset(asset);
-    else if (assets)
-        assets.forEach(printAsset);
-    else
+    if (!data.assets?.length) {
+        console.log("No assets found.");
+        return;
+    }
+    console.log(`${data.total} asset${data.total === 1 ? "" : "s"} found:\n`);
+    for (const a of data.assets) {
+        console.log(formatAssetRow(a));
+    }
+}
+async function cmdList(_args, flags) {
+    return cmdSearch([], flags);
+}
+async function cmdGet(args, flags) {
+    const id = args[0];
+    if (!id) {
+        console.error("Usage: argus-media-cli get <asset-id>");
+        process.exit(1);
+    }
+    const config = await loadConfig();
+    const data = (await apiRequest(config, "GET", `/assets/${id}`));
+    if (flags.json) {
         console.log(JSON.stringify(data, null, 2));
+        return;
+    }
+    console.log(formatAssetDetail(data.asset));
 }
-function printAsset(a) {
-    const analysis = a.analysis;
-    console.log(`\n${a.id}`);
-    console.log(`  File:   ${a.filename}`);
-    console.log(`  URL:    ${a.url}`);
-    console.log(`  Status: ${a.status}`);
-    if (a.project)
-        console.log(`  Project: ${a.project}`);
-    if (a.tags && Array.isArray(a.tags) && a.tags.length)
-        console.log(`  Tags:   ${a.tags.join(", ")}`);
-    if (analysis?.description)
-        console.log(`  Desc:   ${analysis.description}`);
-    if (analysis?.mood)
-        console.log(`  Mood:   ${analysis.mood}`);
-}
-// ── Commands ──────────────────────────────────────────────────────────────────
-const args = process.argv.slice(2);
-const jsonFlag = args.includes("--json");
-const filteredArgs = args.filter((a) => a !== "--json");
-const [command, ...rest] = filteredArgs;
-async function main() {
-    switch (command) {
-        case "login": {
-            const key = rest[0];
-            if (!key) {
-                console.error("Usage: argus login <api-key>");
-                process.exit(1);
-            }
-            saveConfig({ ...loadConfig(), apiKey: key });
-            console.log("API key saved to ~/.argus/config.json");
-            break;
-        }
-        case "upload": {
-            const file = rest[0];
-            const project = rest[1];
-            if (!file || !existsSync(file)) {
-                console.error("Usage: argus upload <file> [project]");
-                process.exit(1);
-            }
-            const { createReadStream, statSync } = await import("fs");
-            const { basename } = await import("path");
-            const fd = new FormData();
-            const bytes = readFileSync(file);
-            fd.append("file", new Blob([bytes]), basename(file));
-            if (project)
-                fd.append("project", project);
-            const res = await fetch(`${BASE_URL}/assets/upload`, {
-                method: "POST",
-                headers: { Authorization: `Bearer ${getApiKey()}` },
-                body: fd,
-            });
-            const data = await res.json().catch(() => ({}));
-            if (!res.ok) {
-                console.error(`Error: ${data.error || res.statusText}`);
-                process.exit(1);
-            }
-            output(data, jsonFlag);
-            break;
+async function cmdUsage(_args, flags) {
+    const config = await loadConfig();
+    const data = (await apiRequest(config, "GET", "/usage"));
+    if (flags.json) {
+        console.log(JSON.stringify(data, null, 2));
+        return;
+    }
+    console.log(`\x1b[1mWorkspace Usage\x1b[0m`);
+    console.log(`  Tier:     ${data.tier}`);
+    console.log(`  Assets:   ${data.assets?.used ?? 0} / ${data.assets?.limit ?? "unlimited"}`);
+    if (data.credits != null) {
+        console.log(`  Credits:  ${data.credits?.used ?? 0} / ${data.credits?.limit ?? "unlimited"}`);
+    }
+    if (data.storage != null) {
+        console.log(`  Storage:  ${data.storage?.used != null ? formatBytes(data.storage.used) : "0 B"} / ${data.storage?.limit != null ? formatBytes(data.storage.limit) : "unlimited"}`);
+    }
+}
+function parseArgs(argv) {
+    const command = argv[0] || "help";
+    const flags = {};
+    const args = [];
+    for (let i = 1; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === "--json") {
+            flags.json = true;
         }
-        case "search": {
-            const query = rest.join(" ");
-            if (!query) {
-                console.error("Usage: argus search <query>");
-                process.exit(1);
+        else if (arg.startsWith("--")) {
+            const key = arg.slice(2);
+            const next = argv[i + 1];
+            if (next && !next.startsWith("--")) {
+                flags[key] = next;
+                i++;
             }
-            const data = await api("GET", `/assets?q=${encodeURIComponent(query)}`);
-            output(data, jsonFlag);
-            break;
-        }
-        case "list": {
-            const project = rest[0];
-            const qs = project ? `?project=${encodeURIComponent(project)}` : "";
-            const data = await api("GET", `/assets${qs}`);
-            output(data, jsonFlag);
-            break;
-        }
-        case "get": {
-            const id = rest[0];
-            if (!id) {
-                console.error("Usage: argus get <id>");
-                process.exit(1);
+            else {
+                flags[key] = true;
             }
-            const data = await api("GET", `/assets/${id}`);
-            output(data, jsonFlag);
-            break;
         }
-        case "usage": {
-            const data = await api("GET", "/usage");
-            output(data, jsonFlag);
-            break;
+        else {
+            args.push(arg);
         }
-        default:
-            console.log(`argus <command> [options]
+    }
+    return { command, args, flags };
+}
+function printHelp() {
+    console.log(`\x1b[1margus-media-cli\x1b[0m — AI-native media asset management
+
+\x1b[1mUsage:\x1b[0m
+  argus-media-cli <command> [options]
+
+\x1b[1mCommands:\x1b[0m
+  login                   Authenticate with Argus
+  upload <file>           Upload a media file
+  search <query>          Search assets by description, tags, mood
+  list                    List all assets
+  get <id>                Get asset details and analysis
+  usage                   Show workspace usage and limits
+
+\x1b[1mGlobal Options:\x1b[0m
+  --json                  Output raw JSON
 
-Commands:
-  login <api-key>          Save API key to ~/.argus/config.json
-  upload <file> [project]  Upload an image
-  search <query>           Search assets by keyword
-  list [project]           List assets
-  get <id>                 Get asset by ID
-  usage                    Show credit and asset usage
+\x1b[1mUpload Options:\x1b[0m
+  --project NAME          Assign to a project
+  --tags a,b,c            Comma-separated tags
 
-Options:
-  --json                   Output raw JSON
+\x1b[1mSearch/List Options:\x1b[0m
+  --project NAME          Filter by project
+  --status STATUS         Filter by status (pending, ready, error)
+  --tags a,b,c            Filter by tags
+  --limit N               Max results (default 50)
+  --offset N              Pagination offset
 
-Environment:
-  ARGUS_API_KEY            API key (overrides saved config)
-  ARGUS_BASE_URL           API base URL (default: https://argus.build)
+\x1b[1mLogin Options:\x1b[0m
+  --key KEY               Set API key non-interactively
+  --url URL               Set custom API base URL
 
-Get an API key at https://argus.build/ui/settings
+\x1b[1mEnvironment:\x1b[0m
+  ARGUS_API_KEY           API key (overrides saved config)
+  ARGUS_BASE_URL          API base URL (default: https://argus.build)
+
+\x1b[1mExamples:\x1b[0m
+  argus-media-cli login
+  argus-media-cli upload photo.jpg --project campaign-q2 --tags hero,banner
+  argus-media-cli search "sunset landscape" --json
+  argus-media-cli list --project website --limit 20
+  argus-media-cli get abc12345-def6-7890-abcd-ef1234567890
 `);
-            process.exit(command ? 1 : 0);
+}
+// ─── Main ──────────────────────────────────────────────────────────────────
+const COMMANDS = {
+    login: cmdLogin,
+    upload: cmdUpload,
+    search: cmdSearch,
+    list: cmdList,
+    get: cmdGet,
+    usage: cmdUsage,
+};
+async function main() {
+    const { command, args, flags } = parseArgs(process.argv.slice(2));
+    if (command === "help" || command === "--help" || command === "-h") {
+        printHelp();
+        return;
+    }
+    if (command === "version" || command === "--version" || command === "-v") {
+        console.log("argus-media-cli 0.1.2");
+        return;
+    }
+    const handler = COMMANDS[command];
+    if (!handler) {
+        console.error(`Unknown command: ${command}`);
+        console.error('Run "argus-media-cli help" for usage.');
+        process.exit(1);
+    }
+    try {
+        await handler(args, flags);
+    }
+    catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
     }
 }
-main().catch((err) => {
-    console.error(err.message || err);
-    process.exit(1);
-});
+main();

package/package.json

@@ -1,17 +1,33 @@
 {
   "name": "argus-media-cli",
-  "version": "0.1.0",
-  "description": "CLI for Argus — AI-powered media catalog. Upload, search, and manage media assets from the terminal.",
-  "keywords": ["argus", "media", "assets", "cli", "ai", "mcp"],
+  "version": "0.1.2",
+  "description": "CLI for Argus — AI-native media asset management. Upload, search, analyze, and manage media assets from the terminal.",
+  "keywords": [
+    "argus",
+    "media",
+    "assets",
+    "ai",
+    "cli",
+    "upload",
+    "image",
+    "video"
+  ],
   "license": "MIT",
   "author": "Brookfield Digital",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/brookfield-digital/argus"
+  },
   "homepage": "https://argus.build",
   "type": "module",
   "bin": {
-    "argus": "./dist/index.js"
+    "argus-media-cli": "./dist/index.js"
   },
   "main": "./dist/index.js",
-  "files": ["dist", "README.md"],
+  "files": [
+    "dist",
+    "README.md"
+  ],
   "scripts": {
     "build": "tsc",
     "prepublishOnly": "npm run build"
@@ -20,5 +36,7 @@
     "@types/node": "^20.0.0",
     "typescript": "^5.4.0"
   },
-  "engines": { "node": ">=18" }
+  "engines": {
+    "node": ">=18"
+  }
 }