terminalmarket 0.12.0 → 0.13.0

package/bin/tm.js

@@ -299,6 +299,80 @@ program
     }
   });
 
+// Share a bounty link
+program
+  .command("share <bountyId>")
+  .description("Get a shareable link for a bounty")
+  .action(async (bountyId) => {
+    try {
+      const id = parseInt(bountyId, 10);
+      if (isNaN(id)) {
+        console.log(chalk.red("Invalid bounty ID"));
+        return;
+      }
+      const bounty = await apiGet(`/bounties/${id}`);
+      if (!bounty || !bounty.id) {
+        console.log(chalk.red("Bounty not found"));
+        return;
+      }
+      const base = getApiBase().replace("/api", "");
+      const link = `${base}/bounty/${id}`;
+      console.log();
+      console.log(chalk.bold(`  📋 ${bounty.title}`));
+      console.log(`  💰 ${bounty.reward || "TBD"} · ${bounty.category || "dev"}`);
+      console.log();
+      console.log(chalk.cyan(`  ${link}`));
+      console.log();
+      console.log(chalk.dim("  Send this link to a colleague, or they can respond:"));
+      console.log(chalk.green(`  $ tm ping ${id} --message "I can help"`));
+      console.log();
+    } catch (e) {
+      console.error(chalk.red(e?.message || String(e)));
+      process.exitCode = 1;
+    }
+  });
+
+// Developer leaderboard
+program
+  .command("top")
+  .description("Show top developers by completed bounties")
+  .option("-p, --period <period>", "Time period: all, month, week", "all")
+  .option("-l, --limit <n>", "Number of entries", "15")
+  .action(async (opts) => {
+    try {
+      const limit = parseInt(opts.limit, 10) || 15;
+      const result = await apiGet(`/leaderboard?period=${opts.period}&limit=${limit}`);
+      const leaders = result?.leaders || [];
+
+      if (leaders.length === 0) {
+        console.log(chalk.yellow("\n  No leaderboard data yet. Complete bounties to appear here!\n"));
+        console.log(chalk.dim("  Browse bounties: tm live"));
+        return;
+      }
+
+      console.log();
+      console.log(chalk.bold("  🏆 Developer Leaderboard") + chalk.dim(` (${opts.period === "all" ? "all time" : opts.period})`));
+      console.log();
+
+      for (const leader of leaders) {
+        const medal = leader.rank === 1 ? "🥇" : leader.rank === 2 ? "🥈" : leader.rank === 3 ? "🥉" : chalk.dim(`#${String(leader.rank).padStart(2)}`);
+        const name = chalk.bold(leader.username);
+        const earned = chalk.green(leader.totalEarned);
+        const bounties = chalk.dim(`${leader.completedBounties} bounties`);
+        const rating = leader.avgRating ? chalk.yellow(`★${leader.avgRating}`) : "";
+        const skills = leader.topSkills?.length > 0 ? chalk.dim(` [${leader.topSkills.slice(0, 3).join(", ")}]`) : "";
+
+        console.log(`  ${medal} ${name.padEnd(24)} ${earned.padEnd(14)} ${bounties.padEnd(14)} ${rating}${skills}`);
+      }
+      console.log();
+      console.log(chalk.dim("  Full leaderboard: https://terminalmarket.app/leaderboard"));
+      console.log();
+    } catch (e) {
+      console.error(chalk.red(e?.message || String(e)));
+      process.exitCode = 1;
+    }
+  });
+
 program
   .command("whoami")
   .alias("me")
@@ -381,6 +455,25 @@ async function showProfile() {
     console.log(chalk.dim('    tm profile set telegram @yourusername'));
   }
   console.log();
+
+  // Bounty earnings badge
+  try {
+    const bountyStats = await apiGet("/my/bounty-stats");
+    if (bountyStats && (bountyStats.completedBounties > 0 || bountyStats.totalEarned)) {
+      console.log(chalk.cyan.bold('  Bounty Earnings'));
+      console.log(`  ${chalk.dim('Completed:')} ${chalk.green.bold(bountyStats.completedBounties || 0)} bounties`);
+      if (bountyStats.totalEarned) {
+        console.log(`  ${chalk.dim('Earned:')}    ${chalk.green.bold('$' + bountyStats.totalEarned)}`);
+      }
+      if (bountyStats.avgRating) {
+        console.log(`  ${chalk.dim('Rating:')}    ${chalk.yellow('★' + bountyStats.avgRating)}`);
+      }
+      console.log();
+    }
+  } catch (_) {
+    // silently skip if not available
+  }
+
   console.log(chalk.dim('  Use: tm profile set <field> <value>'));
   console.log(chalk.dim('  Fields: name, phone, city, country, github, linkedin, skills, bio, available'));
   console.log(chalk.dim('          telegram, whatsapp, viber, discord, teams, contact'));
@@ -2752,6 +2845,7 @@ const commandGroups = {
   'AI Services': ['ai', 'credits', 'topup'],
   'On-Demand Tasks': ['tasks', 'task'],
   'Personalization': ['alias', 'reward'],
+  'Integrations': ['apps'],
   'Info': ['about', 'stats', 'policy', 'privacy', 'faq', 'contact'],
   'System': ['start', 'doctor', 'config', 'help']
 };
@@ -2880,6 +2974,7 @@ function showHelp(commandName = null, mode = 'basic') {
     printGroup('Shop', ['featured', 'deals', 'search', 'products'], '🛒', chalk.green);
     printGroup('Dev Bounties', ['live', 'need', 'ping', 'profile'], '🔥', chalk.red);
     printGroup('Account', ['login', 'register', 'profile'], '👤', chalk.blue);
+    printGroup('Integrations', ['apps'], '🧩', chalk.magenta);
     printGroup('Help', ['doctor', 'help'], '💡', chalk.gray);
     
     console.log(chalk.dim('─'.repeat(45)));
@@ -2920,6 +3015,7 @@ function showHelp(commandName = null, mode = 'basic') {
       'Stores': chalk.cyan,
       'AI Services': chalk.cyan,
       'On-Demand Tasks': chalk.yellow,
+      'Integrations': chalk.magenta,
       'Personalization': chalk.white,
       'Info': chalk.dim,
       'System': chalk.gray
@@ -2936,6 +3032,7 @@ function showHelp(commandName = null, mode = 'basic') {
       'Stores': '🏪',
       'AI Services': '🤖',
       'On-Demand Tasks': '⚡',
+      'Integrations': '🧩',
       'Personalization': '⚙️',
       'Info': 'ℹ️',
       'System': '💻'
@@ -3659,7 +3756,6 @@ program
 
 program
   .command("applications")
-  .alias("apps")
   .description("View your job applications")
   .action(async () => {
     try {
@@ -4300,6 +4396,17 @@ program
       console.log(`  ${chalk.dim("Bounty:")} #${bountyId}`);
       if (data.message) console.log(`  ${chalk.dim("Message:")} ${data.message}`);
       console.log(`\n  ${chalk.cyan("The poster will be notified and can accept your response.")}`);
+
+      // Check if user has completed bounties and suggest invite
+      try {
+        const stats = await apiGet("/my/bounty-stats");
+        if (stats && stats.completedBounties > 0 && stats.completedBounties <= 3) {
+          console.log();
+          console.log(chalk.dim("  ─────────────────────────────────────"));
+          console.log(`  ${chalk.yellow("💡")} Know someone who'd like to earn on bounties?`);
+          console.log(`  ${chalk.cyan("tm invite --email colleague@company.com")}`);
+        }
+      } catch (_) {}
     } catch (e) {
       showError(e?.message || "Failed to respond");
       process.exitCode = 1;
@@ -4485,6 +4592,417 @@ bountyCmd.action(() => {
   bountyCmd.outputHelp();
 });
 
+// -----------------
+// apps — SaaS integrations catalog
+// -----------------
+const appsCmd = program
+  .command("apps")
+  .description("Browse and manage SaaS integrations");
+
+appsCmd
+  .command("list")
+  .description("List available integrations")
+  .action(async () => {
+    const spinner = createSpinner("Loading integrations...");
+    try {
+      const apps = await apiGet("/apps");
+      stopSpinner(spinner);
+      if (!apps || apps.length === 0) {
+        showInfo("No integrations available yet.");
+        return;
+      }
+      console.log();
+      showSection("🧩 Available Integrations");
+      for (const app of apps) {
+        const icon = app.icon || "📦";
+        const cmds = (app.commands || []).map(c => c.name).join(", ");
+        console.log(`  ${icon} ${chalk.bold(app.name)} ${chalk.dim(`(tm ${app.slug})`)}`);
+        if (app.description) console.log(`    ${chalk.dim(app.description)}`);
+        console.log(`    ${chalk.dim(`${app.commands?.length || 0} commands · ${app.totalUsers || 0} users`)}`);
+        if (cmds) console.log(`    ${chalk.dim("Commands:")} ${cmds}`);
+        console.log();
+      }
+    } catch (e) {
+      stopSpinner(spinner);
+      showError(e?.message || "Failed to load integrations");
+    }
+  });
+
+appsCmd
+  .command("info <slug>")
+  .description("View app details and commands")
+  .action(async (slug) => {
+    const spinner = createSpinner(`Loading ${slug}...`);
+    try {
+      const app = await apiGet(`/apps/${slug}`);
+      stopSpinner(spinner);
+      console.log();
+      const icon = app.icon || "📦";
+      showSection(`${icon} ${app.name}`);
+      if (app.description) console.log(`  ${app.description}`);
+      if (app.seller) console.log(`  ${chalk.dim(`by ${app.seller.name}${app.seller.verified ? " ✓" : ""}`)}`);
+      console.log(`  ${chalk.dim(`${app.totalUsers} users · ${app.totalCalls} API calls · Auth: ${app.authType}`)}`);
+
+      const commands = app.manifest?.commands || [];
+      if (commands.length > 0) {
+        console.log();
+        console.log(`  ${chalk.bold("Commands:")}`);
+        for (const cmd of commands) {
+          const args = (cmd.args || cmd.params || [])
+            .map(a => a.required ? `<${a.name}>` : `[${a.name}]`).join(" ");
+          const urlTag = cmd.open_url ? chalk.cyan(" [opens browser]") : "";
+          console.log(`    ${chalk.green(`tm ${slug} ${cmd.name}`)} ${chalk.dim(args)}${urlTag}`);
+          console.log(`      ${chalk.dim(cmd.description)}`);
+        }
+      }
+
+      const plans = app.manifest?.plans;
+      if (plans && plans.length > 0) {
+        console.log();
+        console.log(`  ${chalk.bold("Plans:")}`);
+        for (const p of plans) {
+          const price = p.price?.monthly === 0 ? "Free" : `$${p.price?.monthly}/mo`;
+          console.log(`    ${chalk.yellow(p.key)} — ${price}${p.sites ? ` · ${p.sites} sites` : ""}${p.pagesPerSite ? ` · ${p.pagesPerSite} pages` : ""}`);
+        }
+      }
+
+      console.log();
+      const hasAuthConnect = !!app.manifest?.auth?.connect;
+      if (hasAuthConnect) {
+        showInfo(`Connect: ${chalk.bold(`tm ${slug} connect`)}`);
+      } else {
+        showInfo(`Connect: ${chalk.bold(`tm ${slug} connect <your-api-key>`)}`);
+      }
+    } catch (e) {
+      stopSpinner(spinner);
+      showError(e?.message || "App not found");
+    }
+  });
+
+appsCmd
+  .command("my")
+  .description("List your connected apps")
+  .action(async () => {
+    try {
+      const apps = await apiGet("/my/apps");
+      if (!apps || apps.length === 0) {
+        showInfo("No connected apps. Browse with: tm apps list");
+        return;
+      }
+      console.log();
+      showSection(`🔗 Connected Apps (${apps.length})`);
+      for (const app of apps) {
+        console.log(`  ${app.icon || "📦"} ${chalk.bold(app.name)} ${chalk.dim(`(${app.slug})`)}`);
+      }
+    } catch (e) {
+      showError(e?.message || "Failed to load connected apps");
+    }
+  });
+
+appsCmd.action(() => {
+  appsCmd.commands.find(c => c.name() === "list")?.parseAsync(["list"], { from: "user" });
+});
+
+// -----------------
+// Dynamic namespace handler — intercepts unknown commands and checks if they're app namespaces
+// -----------------
+async function handleDynamicNamespace(namespace, args) {
+  const subCommand = args[0] || "help";
+  const restArgs = args.slice(1);
+
+  // "help" or no args — show app info
+  if (subCommand === "help" || args.length === 0) {
+    await appsCmd.commands.find(c => c.name() === "info")?.parseAsync(["info", namespace], { from: "user" });
+    return;
+  }
+
+  // "connect" flow
+  if (subCommand === "connect") {
+    await handleNamespaceConnect(namespace, restArgs);
+    return;
+  }
+
+  // "disconnect"
+  if (subCommand === "disconnect") {
+    const spinner = createSpinner("Disconnecting...");
+    try {
+      await apiDelete(`/apps/${namespace}/connect`);
+      stopSpinner(spinner);
+      showSuccess(`Disconnected from ${namespace}.`);
+    } catch (e) {
+      stopSpinner(spinner);
+      showError(e?.message || "Failed to disconnect");
+    }
+    return;
+  }
+
+  // Execute a command
+  await handleNamespaceExecute(namespace, subCommand, restArgs);
+}
+
+async function handleNamespaceConnect(namespace, args) {
+  const spinner = createSpinner(`Connecting to ${namespace}...`);
+  try {
+    // First, fetch app detail to check auth type
+    let app;
+    try {
+      app = await apiGet(`/apps/${namespace}`);
+    } catch {
+      stopSpinner(spinner);
+      showError(`App "${namespace}" not found.`);
+      return;
+    }
+    stopSpinner(spinner);
+
+    const hasAuthConnect = !!app.manifest?.auth?.connect;
+    let body;
+
+    if (hasAuthConnect) {
+      // Email-based connect
+      let email = args[0];
+      if (!email) {
+        // Ask for email interactively
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        email = await new Promise(resolve => {
+          rl.question(chalk.cyan("Enter your email for ") + chalk.bold(app.name) + ": ", answer => {
+            rl.close();
+            resolve(answer.trim());
+          });
+        });
+      }
+      if (!email) {
+        showError("Email is required to connect.");
+        return;
+      }
+      body = { email };
+    } else {
+      // Raw API key
+      const token = args[0];
+      if (!token) {
+        showError(`Usage: tm ${namespace} connect <your-api-key>`);
+        return;
+      }
+      body = { token };
+    }
+
+    const spinner2 = createSpinner("Authenticating...");
+    try {
+      const result = await apiPost(`/apps/${namespace}/connect`, body);
+      stopSpinner(spinner2);
+      showSuccess(`Connected to ${app.name}!`);
+      if (result.plan) console.log(`  ${chalk.dim("Plan:")} ${result.plan}`);
+      if (result.isNew) console.log(`  ${chalk.dim("New account created.")}`);
+
+      const commands = app.manifest?.commands || [];
+      if (commands.length > 0) {
+        const first = commands[0];
+        const firstArgs = (first.args || first.params || [])
+          .filter(a => a.required).map(a => `<${a.name}>`).join(" ");
+        console.log();
+        showInfo(`Try: ${chalk.bold(`tm ${namespace} ${first.name} ${firstArgs}`)}`);
+      }
+    } catch (e) {
+      stopSpinner(spinner2);
+      showError(e?.message || "Failed to connect");
+    }
+  } catch (e) {
+    showError(e?.message || "Failed to connect");
+  }
+}
+
+async function handleNamespaceExecute(namespace, command, args) {
+  // Parse args: positional + named (--key value)
+  const positional = [];
+  const named = {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      const eqIdx = arg.indexOf("=");
+      if (eqIdx > 0) {
+        named[arg.slice(2, eqIdx)] = arg.slice(eqIdx + 1);
+      } else {
+        const key = arg.slice(2);
+        if (i + 1 < args.length && !args[i + 1].startsWith("--")) {
+          named[key] = args[++i];
+        } else {
+          named[key] = "true";
+        }
+      }
+    } else {
+      positional.push(arg);
+    }
+  }
+
+  // Fetch app info to resolve positional args
+  let appDetail;
+  try {
+    appDetail = await apiGet(`/apps/${namespace}`);
+  } catch {}
+
+  const cmdDef = appDetail?.manifest?.commands?.find(c => c.name === command);
+  if (!cmdDef && appDetail) {
+    const available = (appDetail.manifest?.commands || []).map(c => c.name).join(", ");
+    showError(`Unknown command: ${command}. Available: ${available || "none"}`);
+    return;
+  }
+
+  // Resolve positional args using command definition
+  const params = { ...named };
+  if (cmdDef) {
+    const argDefs = cmdDef.args || cmdDef.params || [];
+    let posIdx = 0;
+    for (const def of argDefs) {
+      if (params[def.name] !== undefined) continue;
+      if (posIdx < positional.length) {
+        params[def.name] = positional[posIdx++];
+      } else if (def.default !== undefined) {
+        params[def.name] = String(def.default);
+      }
+    }
+  }
+
+  const spinner = createSpinner(`Running ${namespace} ${command}...`);
+  try {
+    const result = await apiPost(`/apps/${namespace}/execute`, { command, params });
+    stopSpinner(spinner);
+
+    // Handle open_url
+    if (result.open_url) {
+      showSuccess(`Opening in browser...`);
+      if (shouldOpenExternal()) {
+        try { await open(result.open_url); } catch {}
+      }
+      console.log(`  ${chalk.dim(result.open_url)}`);
+      return;
+    }
+
+    const data = result.data;
+
+    // Error from upstream
+    if (data?.error) {
+      showError(data.error);
+      if (data.upgradeRequired) {
+        showInfo(`Upgrade: ${chalk.bold(`tm ${namespace} upgrade pro`)}`);
+      }
+      return;
+    }
+
+    // Pretty-format known patterns
+    formatNamespaceResponse(namespace, command, data);
+  } catch (e) {
+    stopSpinner(spinner);
+    const msg = e?.message || "Command failed";
+    if (msg.includes("Not connected") || msg.includes("needsConnect")) {
+      showError(`Not connected to ${namespace}. Run: ${chalk.bold(`tm ${namespace} connect`)}`);
+    } else {
+      showError(msg);
+    }
+  }
+}
+
+function formatNamespaceResponse(namespace, command, data) {
+  if (typeof data === "string") {
+    console.log(data);
+    return;
+  }
+  if (!data || typeof data !== "object") {
+    showSuccess("OK");
+    return;
+  }
+
+  // Sites list
+  if (data.sites && Array.isArray(data.sites)) {
+    if (data.sites.length === 0) {
+      showInfo(`No sites yet. Add one: ${chalk.bold(`tm ${namespace} add <domain>`)}`);
+      return;
+    }
+    showSection(`Your sites (${data.sites.length})`);
+    for (const s of data.sites) {
+      const statusIcon = s.status === "ready" ? "✅" : s.status === "scanning" ? "⏳" : s.status === "error" ? "❌" : "⏸️";
+      console.log(`  ${statusIcon} ${chalk.bold(s.domain)} ${chalk.dim(`[${s.status}]`)} ${chalk.dim(`ID: ${(s.id || "").slice(0, 8)}...`)}`);
+    }
+    return;
+  }
+
+  // Site status with coverage
+  if (data.coveragePct !== undefined) {
+    const pct = data.coveragePct;
+    const filled = Math.round(pct / 5);
+    const bar = chalk.green("█".repeat(filled)) + chalk.dim("░".repeat(20 - filled));
+    console.log();
+    showSection(`${data.domain || "Site"} — ${data.status}`);
+    console.log(`  [${bar}] ${pct}% coverage`);
+    console.log(`  ${data.pagesFound || 0} pages found · ${data.pagesReady || 0} ready`);
+
+    if (data.pageTypes && typeof data.pageTypes === "object") {
+      console.log();
+      console.log(`  ${chalk.bold("Page Types:")}`);
+      for (const [type, count] of Object.entries(data.pageTypes)) {
+        console.log(`    ${chalk.dim(type)}: ${count}`);
+      }
+    }
+
+    if (data.installScript) {
+      console.log();
+      console.log(`  ${chalk.bold("Install Script:")}`);
+      console.log(`  ${chalk.cyan(data.installScript)}`);
+    }
+
+    if (data.upgradeRequired) {
+      console.log();
+      showWarning(`Upgrade needed: ${chalk.bold(`tm ${namespace} upgrade pro`)}`);
+    }
+    return;
+  }
+
+  // Account info
+  if (data.email && data.plan !== undefined) {
+    showSection("Account");
+    console.log(`  ${chalk.dim("Email:")}   ${data.email}`);
+    console.log(`  ${chalk.dim("Plan:")}    ${chalk.bold(data.plan)}`);
+    if (data.usage) {
+      console.log(`  ${chalk.dim("Sites:")}   ${data.usage.sites}/${data.limits?.sites ?? "∞"}`);
+      console.log(`  ${chalk.dim("Pages:")}   ${data.usage.pages}/${data.limits?.pagesPerSite ?? "∞"}`);
+    }
+    if (data.dashboardUrl) {
+      console.log(`  ${chalk.dim("Dashboard:")} ${chalk.bold(`tm ${namespace} dashboard`)}`);
+    }
+    return;
+  }
+
+  // Billing status
+  if (data.active !== undefined && data.plan) {
+    console.log(`  Plan: ${chalk.bold(data.plan)} · ${data.active ? chalk.green("Active") : chalk.dim("Inactive")}${data.nextBilling ? ` · Next: ${data.nextBilling}` : ""}`);
+    return;
+  }
+
+  // Site added
+  if (data.siteId && data.domain) {
+    showSuccess(`Site added: ${data.domain}`);
+    console.log(`  ${chalk.dim("ID:")} ${data.siteId}`);
+    if (data.apiKey) console.log(`  ${chalk.dim("API Key:")} ${data.apiKey}`);
+    showInfo(`Next: ${chalk.bold(`tm ${namespace} scan ${data.siteId}`)}`);
+    return;
+  }
+
+  // Scan started
+  if (data.ok && data.status === "scanning") {
+    showSuccess(data.message || "Scan started!");
+    if (data.scanLogId) console.log(`  ${chalk.dim("Scan log:")} ${data.scanLogId}`);
+    showInfo(`Check progress: ${chalk.bold(`tm ${namespace} status <site_id>`)}`);
+    return;
+  }
+
+  // Generic OK
+  if (data.ok === true) {
+    showSuccess(data.message || "OK");
+    return;
+  }
+
+  // Fallback: JSON output
+  console.log(JSON.stringify(data, null, 2));
+}
+
 program
   .command("help [command]")
   .description("Show help for a command")
@@ -4500,6 +5018,34 @@ program
     }
   });
 
+// Cache for resolved namespaces
+const _namespaceCache = new Map();
+
+async function isAppNamespace(name) {
+  if (!name || typeof name !== "string") return false;
+  if (_namespaceCache.has(name)) return _namespaceCache.get(name);
+  try {
+    await apiGet(`/apps/${name}`);
+    _namespaceCache.set(name, true);
+    return true;
+  } catch {
+    _namespaceCache.set(name, false);
+    return false;
+  }
+}
+
+// Intercept unknown commands to check dynamic namespaces
+program.on("command:*", async (operands) => {
+  const unknownCmd = operands[0];
+  if (await isAppNamespace(unknownCmd)) {
+    const extra = process.argv.slice(process.argv.indexOf(unknownCmd) + 1);
+    await handleDynamicNamespace(unknownCmd, extra);
+  } else {
+    showError(`Unknown command: ${unknownCmd}. Use 'tm help' for usage.`);
+    process.exitCode = 1;
+  }
+});
+
 // Handle no args - show beautiful welcome screen
 if (process.argv.length <= 2) {
   (async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "terminalmarket",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "TerminalMarket CLI — a curated marketplace for developers & founders (client for terminalmarket.app)",
   "bin": {
     "tm": "bin/tm.js"