argus-media-cli 0.1.1 → 0.3.0

package/README.md

@@ -17,7 +17,7 @@ npx argus-media-cli upload photo.jpg
 ## Setup
 
 ```bash
-argus login
+argus-media-cli login
 ```
 
 Or set your API key as an environment variable:
@@ -31,37 +31,49 @@ export ARGUS_API_KEY=ak_your_key_here
 ### Upload
 
 ```bash
-argus upload photo.jpg
-argus upload hero.png --project campaign-q2 --tags hero,banner
+argus-media-cli upload photo.jpg
+argus-media-cli upload hero.png --project campaign-q2 --tags hero,banner
 ```
 
 ### Search
 
 ```bash
-argus search "sunset landscape"
-argus search --project website --status ready --json
+argus-media-cli search "sunset landscape"
+argus-media-cli search --project website --status ready --json
 ```
 
 ### List
 
 ```bash
-argus list
-argus list --project website --limit 20
+argus-media-cli list
+argus-media-cli list --project website --limit 20
 ```
 
 ### Get
 
 ```bash
-argus get <asset-id>
-argus get abc12345 --json
+argus-media-cli get <asset-id>
+argus-media-cli get abc12345 --json
 ```
 
 ### Login
 
 ```bash
-argus login                     # Interactive prompt
-argus login --key ak_xxx       # Non-interactive
-argus login --url http://localhost:8787  # Custom API URL
+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
+```
+
+### API Keys
+
+Manage API keys for the current workspace. Works with either a session (from
+`login`) or an existing API key. Use this to rotate a dead or expired key:
+
+```bash
+argus-media-cli login                       # Magic-link session (no key needed)
+argus-media-cli keys list                   # List active keys
+argus-media-cli keys create --name "MCP"    # Mint a new key (shown once)
+argus-media-cli keys revoke <id>            # Revoke a key (admin only)
 ```
 
 ## Options

package/dist/index.js

@@ -23,22 +23,27 @@ async function saveConfig(config) {
 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("Error: No API key configured.");
-        console.error("Run `argus login` to authenticate, or set ARGUS_API_KEY.");
-        process.exit(1);
+function getAuthHeaders(config) {
+    // API key takes precedence (CI / backward compat)
+    const apiKey = process.env.ARGUS_API_KEY || config.apiKey;
+    if (apiKey) {
+        return { Authorization: `Bearer ${apiKey}` };
+    }
+    // Session-based auth (interactive login)
+    const sessionId = config.sessionId;
+    if (sessionId) {
+        return { Cookie: `session=${sessionId}` };
     }
-    return key;
+    console.error("Error: Not authenticated.");
+    console.error("Run `argus-media-cli login` to sign in, or set ARGUS_API_KEY.");
+    process.exit(1);
 }
 async function apiRequest(config, method, path, body) {
     const url = `${getBaseUrl(config)}${path}`;
-    const apiKey = getApiKey(config);
     const opts = {
         method,
         headers: {
-            Authorization: `Bearer ${apiKey}`,
+            ...getAuthHeaders(config),
             ...(body ? { "Content-Type": "application/json" } : {}),
         },
         ...(body ? { body: JSON.stringify(body) } : {}),
@@ -92,6 +97,8 @@ function formatAssetDetail(a) {
         lines.push(`  Project:  ${a.project}`);
     if (a.url)
         lines.push(`  URL:      ${a.url}`);
+    if (a.displayUrl)
+        lines.push(`  Display:  ${a.displayUrl}`);
     if (a.tags?.length)
         lines.push(`  Tags:     ${a.tags.join(", ")}`);
     if (a.uploadedBy)
@@ -118,6 +125,7 @@ function formatAssetDetail(a) {
 // ─── Commands ──────────────────────────────────────────────────────────────
 async function cmdLogin(args, flags) {
     const config = await loadConfig();
+    // Backward-compat: --key sets API key directly (useful for CI)
     if (flags.key) {
         config.apiKey = flags.key;
         await saveConfig(config);
@@ -132,35 +140,71 @@ async function cmdLogin(args, flags) {
     }
     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: ");
+    const baseUrl = getBaseUrl(config);
+    console.log("\x1b[1mArgus CLI Login\x1b[0m\n");
+    const email = (await ask("Email: ")).trim().toLowerCase();
+    if (!email) {
+        rl.close();
+        console.error("No email provided.");
+        process.exit(1);
+    }
+    // Request magic code
+    console.log("Sending login code...");
+    const magicRes = await fetch(`${baseUrl}/auth/magic`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ email }),
+    });
+    if (!magicRes.ok) {
+        rl.close();
+        const err = await magicRes.json().catch(() => ({ error: "Request failed" }));
+        console.error(`Error: ${err.error || "Could not send login code."}`);
+        process.exit(1);
+    }
+    console.log(`\nCheck your email for a 6-digit code.\n`);
+    const code = (await ask("Code: ")).trim();
     rl.close();
-    if (!key.trim()) {
-        console.error("No key provided.");
+    if (!code) {
+        console.error("No code provided.");
+        process.exit(1);
+    }
+    // Verify code and get session
+    const verifyRes = await fetch(`${baseUrl}/auth/magic/verify`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ email, code, source: "cli" }),
+    });
+    if (!verifyRes.ok) {
+        const err = await verifyRes.json().catch(() => ({ error: "Verification failed" }));
+        console.error(`Error: ${err.error || "Invalid or expired code."}`);
+        process.exit(1);
+    }
+    const data = await verifyRes.json();
+    if (!data.session) {
+        console.error("Error: No session returned from server.");
         process.exit(1);
     }
-    config.apiKey = key.trim();
+    config.sessionId = data.session;
+    delete config.apiKey; // prefer session auth
     await saveConfig(config);
-    // Verify the key works
+    console.log("\nAuthenticated! Session saved to ~/.argus/config.json");
+    // Show usage summary
     try {
         const res = await apiRequest(config, "GET", "/usage");
-        console.log(`\nAuthenticated! Workspace tier: ${res.tier}`);
+        console.log(`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 list`.");
+    catch {
+        // non-fatal
     }
 }
 async function cmdUpload(args, flags) {
     const filePath = args[0];
     if (!filePath) {
-        console.error("Usage: argus upload <file> [--project NAME] [--tags a,b,c]");
+        console.error("Usage: argus-media-cli upload <file> [--project NAME] [--tags a,b,c]");
         process.exit(1);
     }
     const config = await loadConfig();
-    const apiKey = getApiKey(config);
     const baseUrl = getBaseUrl(config);
     // Read file
     const fileData = await readFile(filePath);
@@ -177,7 +221,7 @@ async function cmdUpload(args, flags) {
         form.append("tags", flags.tags);
     const res = await fetch(`${baseUrl}/assets/upload`, {
         method: "POST",
-        headers: { Authorization: `Bearer ${apiKey}` },
+        headers: { ...getAuthHeaders(config) },
         body: form,
     });
     if (!res.ok) {
@@ -194,6 +238,8 @@ async function cmdUpload(args, flags) {
         console.log(`Status: ${asset.status}`);
         if (asset.url)
             console.log(`URL: ${asset.url}`);
+        if (asset.displayUrl)
+            console.log(`Display: ${asset.displayUrl}`);
     }
 }
 async function cmdSearch(args, flags) {
@@ -233,7 +279,7 @@ async function cmdList(_args, flags) {
 async function cmdGet(args, flags) {
     const id = args[0];
     if (!id) {
-        console.error("Usage: argus get <asset-id>");
+        console.error("Usage: argus-media-cli get <asset-id>");
         process.exit(1);
     }
     const config = await loadConfig();
@@ -261,6 +307,234 @@ async function cmdUsage(_args, flags) {
         console.log(`  Storage:  ${data.storage?.used != null ? formatBytes(data.storage.used) : "0 B"} / ${data.storage?.limit != null ? formatBytes(data.storage.limit) : "unlimited"}`);
     }
 }
+// ─── Phase 2: Generative Commands ─────────────────────────────────────────
+async function cmdCreativeDirection(args, flags) {
+    const id = args[0];
+    if (!id) {
+        console.error("Usage: argus-media-cli creative-direction <asset-id> [--purpose TEXT] [--audience TEXT] [--tone TEXT] [--style TEXT]");
+        process.exit(1);
+    }
+    const config = await loadConfig();
+    const body = {};
+    if (flags.purpose)
+        body.purpose = flags.purpose;
+    if (flags.audience)
+        body.audience = flags.audience;
+    if (flags.tone)
+        body.tone = flags.tone;
+    if (flags.style)
+        body.style = flags.style;
+    const data = (await apiRequest(config, "POST", `/assets/${id}/creative-direction`, body));
+    if (flags.json) {
+        console.log(JSON.stringify(data, null, 2));
+        return;
+    }
+    const cd = data.creativeDirection;
+    console.log(`\x1b[1mCreative Direction\x1b[0m${data.cached ? " (cached)" : ""}\n`);
+    console.log(cd.rationale);
+    if (cd.googleFontsUrl)
+        console.log(`\nGoogle Fonts: ${cd.googleFontsUrl}`);
+    if (cd.typography?.length) {
+        console.log(`\n\x1b[1mTypography:\x1b[0m`);
+        for (const t of cd.typography) {
+            console.log(`  ${t.role}: ${t.css.fontFamily} (${t.css.fontWeight}) — ${t.semantic}`);
+        }
+    }
+    if (cd.colors?.length) {
+        console.log(`\n\x1b[1mColors:\x1b[0m`);
+        for (const c of cd.colors) {
+            console.log(`  ${c.role}: ${c.css.color} — ${c.semantic}`);
+        }
+    }
+    if (cd.layout?.length) {
+        console.log(`\n\x1b[1mLayout:\x1b[0m`);
+        for (const l of cd.layout) {
+            console.log(`  ${l.pattern} — ${l.semantic}`);
+        }
+    }
+}
+async function cmdTypography(args, flags) {
+    const id = args[0];
+    if (!id) {
+        console.error("Usage: argus-media-cli typography <asset-id> [--purpose TEXT]");
+        process.exit(1);
+    }
+    const config = await loadConfig();
+    const body = {};
+    if (flags.purpose)
+        body.purpose = flags.purpose;
+    const data = (await apiRequest(config, "POST", `/assets/${id}/typography`, body));
+    if (flags.json) {
+        console.log(JSON.stringify(data, null, 2));
+        return;
+    }
+    const typo = data.typography;
+    console.log(`\x1b[1mTypography Suggestions\x1b[0m${data.cached ? " (cached)" : ""}\n`);
+    if (typo.pairings?.length) {
+        for (const t of typo.pairings) {
+            console.log(`  ${t.role}: ${t.css.fontFamily} (${t.css.fontWeight}) — ${t.semantic}`);
+            if (t.googleFontsUrl)
+                console.log(`    Font: ${t.googleFontsUrl}`);
+        }
+    }
+    if (typo.googleFontsUrl)
+        console.log(`\nGoogle Fonts: ${typo.googleFontsUrl}`);
+    if (typo.rationale)
+        console.log(`\n${typo.rationale}`);
+}
+async function cmdPalette(args, flags) {
+    const id = args[0];
+    if (!id) {
+        console.error("Usage: argus-media-cli palette <asset-id>");
+        process.exit(1);
+    }
+    const config = await loadConfig();
+    const data = (await apiRequest(config, "POST", `/assets/${id}/palette`));
+    if (flags.json) {
+        console.log(JSON.stringify(data, null, 2));
+        return;
+    }
+    const palette = data.palette;
+    console.log(`\x1b[1mColor Palette\x1b[0m${data.cached ? " (cached)" : ""}\n`);
+    if (palette.colors?.length) {
+        for (const c of palette.colors) {
+            console.log(`  ${c.role}: ${c.css.color} — ${c.semantic}`);
+        }
+    }
+    if (palette.rationale)
+        console.log(`\n${palette.rationale}`);
+}
+async function cmdCohesion(args, flags) {
+    if (args.length < 2) {
+        console.error("Usage: argus-media-cli cohesion <asset-id> <asset-id> [<asset-id>...] [--purpose TEXT] [--brand TEXT]");
+        process.exit(1);
+    }
+    const config = await loadConfig();
+    const body = { assetIds: args };
+    if (flags.purpose || flags.brand) {
+        const context = {};
+        if (flags.purpose)
+            context.purpose = flags.purpose;
+        if (flags.brand)
+            context.brandName = flags.brand;
+        body.context = context;
+    }
+    const data = (await apiRequest(config, "POST", "/assets/compare-cohesion", body));
+    if (flags.json) {
+        console.log(JSON.stringify(data, null, 2));
+        return;
+    }
+    const c = data.cohesion;
+    console.log(`\x1b[1mCohesion Report\x1b[0m${data.cached ? " (cached)" : ""}\n`);
+    console.log(`  Overall:    ${c.overallScore}/100`);
+    console.log(`  Typography: ${c.typography.score}/100 — ${c.typography.consistency}`);
+    console.log(`  Color:      ${c.color.score}/100 — ${c.color.harmony}`);
+    console.log(`  Mood:       ${c.mood.score}/100 — ${c.mood.alignment}`);
+    if (c.suggestions?.length) {
+        console.log(`\n\x1b[1mSuggestions:\x1b[0m`);
+        for (const s of c.suggestions) {
+            const sev = s.severity === "high" ? "\x1b[31m" : s.severity === "medium" ? "\x1b[33m" : "\x1b[32m";
+            console.log(`  ${sev}${s.severity}\x1b[0m ${s.asset.slice(0, 8)}: ${s.suggestion}`);
+        }
+    }
+    if (c.rationale)
+        console.log(`\n${c.rationale}`);
+}
+// ─── API Key Management ───────────────────────────────────────────────────
+async function cmdKeys(args, flags) {
+    const sub = args[0];
+    const rest = args.slice(1);
+    if (!sub || sub === "list" || sub === "ls") {
+        return cmdKeysList(rest, flags);
+    }
+    if (sub === "create" || sub === "new") {
+        return cmdKeysCreate(rest, flags);
+    }
+    if (sub === "revoke" || sub === "delete" || sub === "rm") {
+        return cmdKeysRevoke(rest, flags);
+    }
+    console.error(`Unknown keys subcommand: ${sub}`);
+    console.error("Usage: argus-media-cli keys <list|create|revoke>");
+    process.exit(1);
+}
+async function cmdKeysList(_args, flags) {
+    const config = await loadConfig();
+    const data = (await apiRequest(config, "GET", "/keys"));
+    if (flags.json) {
+        console.log(JSON.stringify(data, null, 2));
+        return;
+    }
+    const keys = data.keys || [];
+    if (!keys.length) {
+        console.log("No API keys found.");
+        console.log("Create one with: argus-media-cli keys create --name 'My Key'");
+        return;
+    }
+    console.log(`\x1b[1m${keys.length} API key${keys.length === 1 ? "" : "s"}\x1b[0m\n`);
+    for (const k of keys) {
+        const status = k.revoked_at ? "\x1b[31mrevoked\x1b[0m" : "\x1b[32mactive\x1b[0m ";
+        const lastUsed = k.last_used_at ? `used ${k.last_used_at}` : "never used";
+        console.log(`  ${status}  ${k.key_prefix}…  ${k.name}`);
+        console.log(`    id: ${k.id}`);
+        console.log(`    created ${k.created_at}, ${lastUsed}`);
+    }
+}
+async function cmdKeysCreate(args, flags) {
+    const name = flags.name || args[0] || "API Key";
+    const config = await loadConfig();
+    const data = (await apiRequest(config, "POST", "/keys", { name }));
+    if (flags.json) {
+        console.log(JSON.stringify(data, null, 2));
+        return;
+    }
+    console.log(`\x1b[1mAPI key created\x1b[0m\n`);
+    console.log(`  Name:   ${data.name}`);
+    console.log(`  ID:     ${data.id}`);
+    console.log(`  Prefix: ${data.key_prefix}`);
+    console.log(`\n\x1b[1m\x1b[33mKey (shown once — store it now):\x1b[0m`);
+    console.log(`  ${data.key}\n`);
+    console.log(`Use it by setting:`);
+    console.log(`  export ARGUS_API_KEY=${data.key}`);
+}
+async function cmdKeysRevoke(args, flags) {
+    const id = args[0];
+    if (!id) {
+        console.error("Usage: argus-media-cli keys revoke <id>");
+        process.exit(1);
+    }
+    const config = await loadConfig();
+    const data = (await apiRequest(config, "DELETE", `/keys/${id}`));
+    if (flags.json) {
+        console.log(JSON.stringify(data, null, 2));
+        return;
+    }
+    console.log(`Key ${id} revoked.`);
+}
+async function cmdStyleGuide(args, flags) {
+    if (args.length < 1) {
+        console.error("Usage: argus-media-cli style-guide <asset-id> [<asset-id>...] [--name TEXT] [--guide-id ID]");
+        process.exit(1);
+    }
+    const config = await loadConfig();
+    const body = { assetIds: args };
+    if (flags.name)
+        body.name = flags.name;
+    if (flags["guide-id"])
+        body.guideId = flags["guide-id"];
+    const data = (await apiRequest(config, "POST", "/style-guides", body));
+    if (flags.json) {
+        console.log(JSON.stringify(data, null, 2));
+        return;
+    }
+    const sg = data.styleGuide;
+    console.log(`\x1b[1mStyle Guide: ${sg.name || sg.id}\x1b[0m\n`);
+    console.log(`  ID:      ${sg.id}`);
+    console.log(`  Assets:  ${sg.sourceAssetIds?.length ?? 0}`);
+    if (data.googleFontsUrl)
+        console.log(`  Fonts:   ${data.googleFontsUrl}`);
+    if (data.rationale)
+        console.log(`\n${data.rationale}`);
+}
 function parseArgs(argv) {
     const command = argv[0] || "help";
     const flags = {};
@@ -288,10 +562,10 @@ function parseArgs(argv) {
     return { command, args, flags };
 }
 function printHelp() {
-    console.log(`\x1b[1margus\x1b[0m — AI-native media asset management
+    console.log(`\x1b[1margus-media-cli\x1b[0m — AI-native media asset management
 
 \x1b[1mUsage:\x1b[0m
-  argus <command> [options]
+  argus-media-cli <command> [options]
 
 \x1b[1mCommands:\x1b[0m
   login                   Authenticate with Argus
@@ -300,6 +574,14 @@ function printHelp() {
   list                    List all assets
   get <id>                Get asset details and analysis
   usage                   Show workspace usage and limits
+  creative-direction <id> Generate creative brief for an asset
+  typography <id>         Suggest typography pairings for an asset
+  palette <id>            Generate extended color palette from an asset
+  cohesion <id> <id> ...  Compare visual cohesion across assets
+  style-guide <id> ...    Generate a style guide from assets
+  keys list               List API keys in the current workspace
+  keys create [--name]    Create a new API key (shown once)
+  keys revoke <id>        Revoke an API key (admin only)
 
 \x1b[1mGlobal Options:\x1b[0m
   --json                  Output raw JSON
@@ -315,45 +597,110 @@ function printHelp() {
   --limit N               Max results (default 50)
   --offset N              Pagination offset
 
+\x1b[1mCreative Direction Options:\x1b[0m
+  --purpose TEXT          Intended use (e.g. 'hero banner')
+  --audience TEXT         Target audience
+  --tone TEXT             Desired tone (e.g. 'professional')
+  --style TEXT            Visual style (e.g. 'minimalist')
+
+\x1b[1mTypography Options:\x1b[0m
+  --purpose TEXT          Intended use context
+
+\x1b[1mCohesion Options:\x1b[0m
+  --purpose TEXT          Comparison context
+  --brand TEXT            Brand name for context
+
+\x1b[1mStyle Guide Options:\x1b[0m
+  --name TEXT             Name for the style guide
+  --guide-id ID           Existing guide ID to update
+
 \x1b[1mLogin Options:\x1b[0m
   --key KEY               Set API key non-interactively
   --url URL               Set custom API base URL
 
+\x1b[1mKeys Options:\x1b[0m
+  --name TEXT             Name for the new key (keys create)
+
 \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 login
-  argus upload photo.jpg --project campaign-q2 --tags hero,banner
-  argus search "sunset landscape" --json
-  argus list --project website --limit 20
-  argus get abc12345-def6-7890-abcd-ef1234567890
+  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
 `);
 }
+// ─── Onboarding ───────────────────────────────────────────────────────────
+function isAuthenticated(config) {
+    return !!(process.env.ARGUS_API_KEY || config.apiKey || config.sessionId);
+}
+async function cmdDashboard(_args, flags) {
+    const config = await loadConfig();
+    const res = await apiRequest(config, "GET", "/usage");
+    console.log(`\x1b[1mArgus Dashboard\x1b[0m\n`);
+    console.log(`  Tier:    ${res.tier}`);
+    console.log(`  Assets:  ${res.assets?.used ?? 0} / ${res.assets?.limit ?? "unlimited"}`);
+    if (res.storage != null) {
+        console.log(`  Storage: ${res.storage?.used != null ? formatBytes(res.storage.used) : "0 B"} / ${res.storage?.limit != null ? formatBytes(res.storage.limit) : "unlimited"}`);
+    }
+    console.log(`\nRun \x1b[1margus-media-cli help\x1b[0m for available commands.`);
+}
 // ─── Main ──────────────────────────────────────────────────────────────────
 const COMMANDS = {
+    dashboard: cmdDashboard,
     login: cmdLogin,
     upload: cmdUpload,
     search: cmdSearch,
     list: cmdList,
     get: cmdGet,
     usage: cmdUsage,
+    "creative-direction": cmdCreativeDirection,
+    typography: cmdTypography,
+    palette: cmdPalette,
+    cohesion: cmdCohesion,
+    "style-guide": cmdStyleGuide,
+    keys: cmdKeys,
 };
 async function main() {
-    const { command, args, flags } = parseArgs(process.argv.slice(2));
+    const rawArgs = process.argv.slice(2);
+    // No args: onboarding — show dashboard or prompt login
+    if (rawArgs.length === 0) {
+        const config = await loadConfig();
+        if (isAuthenticated(config)) {
+            try {
+                await cmdDashboard([], {});
+            }
+            catch {
+                console.log("\x1b[1mArgus Media CLI\x1b[0m\n");
+                console.log("Run \x1b[1margus-media-cli help\x1b[0m for available commands.");
+            }
+        }
+        else {
+            console.log("\x1b[1mWelcome to Argus!\x1b[0m\n");
+            console.log("Get started by signing in:\n");
+            console.log("  argus-media-cli login\n");
+            console.log("Or set an API key for CI use:\n");
+            console.log("  argus-media-cli login --key <your-key>\n");
+            console.log("Run \x1b[1margus-media-cli help\x1b[0m for all commands.");
+        }
+        return;
+    }
+    const { command, args, flags } = parseArgs(rawArgs);
     if (command === "help" || command === "--help" || command === "-h") {
         printHelp();
         return;
     }
     if (command === "version" || command === "--version" || command === "-v") {
-        console.log("argus-media-cli 0.1.1");
+        console.log("argus-media-cli 0.3.0");
         return;
     }
     const handler = COMMANDS[command];
     if (!handler) {
         console.error(`Unknown command: ${command}`);
-        console.error('Run "argus help" for usage.');
+        console.error('Run "argus-media-cli help" for usage.');
         process.exit(1);
     }
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "argus-media-cli",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "description": "CLI for Argus — AI-native media asset management. Upload, search, analyze, and manage media assets from the terminal.",
   "keywords": [
     "argus",
@@ -21,7 +21,7 @@
   "homepage": "https://argus.build",
   "type": "module",
   "bin": {
-    "argus": "./dist/index.js"
+    "argus-media-cli": "./dist/index.js"
   },
   "main": "./dist/index.js",
   "files": [