npm - @mentio-dev/cli - Versions diffs - 0.1.0 → 0.2.0 - Mend

@mentio-dev/cli 0.1.0 → 0.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/README.md CHANGED Viewed

@@ -4,7 +4,7 @@
 ```bash
 npm install -g @mentio-dev/cli
-mentio auth:set --key mk_live_...
+mentio auth:login
 mentio keywords:create --term "acme" --kind brand
 mentio mentions:search --relevant true --sentiment negative --limit 20
 mentio mentions:update mm_7f3a... --status done
@@ -12,4 +12,4 @@ mentio analytics:summary --range 7d --compare true
 mentio mentions:watch --platform reddit | jq -r '.post.url'
 ```
-JSON out, compact when piped and indented on a terminal; `--table` for lists. Keys come from `--api-key`, `MENTIO_API_KEY`, or `~/.mentio/config.json`. The full command list is at [docs.mentio.dev/cli/commands](https://docs.mentio.dev/cli/commands).
+JSON out, compact when piped and indented on a terminal; `--table` for lists. `mentio auth:login` signs in through the browser; keys also come from `--api-key`, `MENTIO_API_KEY`, or `mentio auth:set`. Every command, by area, is at [docs.mentio.dev/cli](https://docs.mentio.dev/cli).

package/dist/index.js CHANGED Viewed

@@ -8,11 +8,12 @@ var __export = (target, all) => {
 // src/index.ts
 import { Command, Option } from "commander";
 import { writeFileSync as writeFileSync2 } from "fs";
+import { hostname } from "os";
 // package.json
 var package_default = {
   name: "@mentio-dev/cli",
-  version: "0.1.0",
+  version: "0.2.0",
   description: "Command-line client for the Mentio API: one command per endpoint, plus watch and MCP helpers.",
   license: "MIT",
   homepage: "https://docs.mentio.dev/cli",
@@ -132,6 +133,7 @@ function coerceScalar(field, raw, type) {
     case "integer":
     case "number": {
       const n = Number(raw);
+      if (!Number.isFinite(n) && /^\d{4}-\d{2}-\d{2}/.test(raw) && Number.isFinite(Date.parse(raw))) return raw;
       if (raw.trim() === "" || !Number.isFinite(n)) throw new UsageError(`--${field.name} expects a number, got "${raw}"`);
       if (type === "integer" && !Number.isInteger(n)) throw new UsageError(`--${field.name} expects a whole number, got "${raw}"`);
       return n;
@@ -224,6 +226,94 @@ function buildRequest(op, positional, flags, jsonBody) {
   return { path, query, body };
 }
+// src/login.ts
+import { randomBytes } from "crypto";
+import { spawn } from "child_process";
+import { createServer } from "http";
+var DEFAULT_APP_URL = "https://app.mentio.dev";
+var LoginError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "LoginError";
+  }
+};
+var newState = () => randomBytes(24).toString("base64url");
+function loginUrl(appUrl, params) {
+  const url = new URL("/cli/authorize", `${appUrl.replace(/\/+$/, "")}/`);
+  url.searchParams.set("port", String(params.port));
+  url.searchParams.set("state", params.state);
+  url.searchParams.set("name", params.name);
+  url.searchParams.set("scope", params.scope);
+  return url.toString();
+}
+var page = (title, body) => `<!doctype html><meta charset="utf-8"><title>${title}</title><body style="font:16px system-ui;padding:3rem;max-width:36rem;margin:auto"><h1 style="font-size:1.25rem">${title}</h1><p>${body}</p></body>`;
+function startCallbackServer(state, timeoutMs) {
+  return new Promise((resolveServer, rejectServer) => {
+    let settle = null;
+    const key = new Promise((resolve, reject) => {
+      settle = { resolve, reject };
+    });
+    const server = createServer((req, res) => {
+      const url = new URL(req.url ?? "/", "http://127.0.0.1");
+      if (url.pathname !== "/callback") {
+        res.writeHead(404, { "content-type": "text/html; charset=utf-8" }).end(page("Not found", "Nothing here."));
+        return;
+      }
+      const error = url.searchParams.get("error");
+      if (error) {
+        res.writeHead(200, { "content-type": "text/html; charset=utf-8" }).end(page("Cancelled", "The CLI was not authorized. You can close this tab."));
+        finish(() => settle?.reject(new LoginError(error === "denied" ? "Authorization was declined in the browser." : `Authorization failed: ${error}`)));
+        return;
+      }
+      if (url.searchParams.get("state") !== state) {
+        res.writeHead(400, { "content-type": "text/html; charset=utf-8" }).end(page("State mismatch", "This callback does not belong to the running login. Run mentio auth:login again."));
+        return;
+      }
+      const issued = url.searchParams.get("key");
+      if (!issued) {
+        res.writeHead(400, { "content-type": "text/html; charset=utf-8" }).end(page("Missing key", "The callback carried no key. Run mentio auth:login again."));
+        return;
+      }
+      res.writeHead(200, { "content-type": "text/html; charset=utf-8" }).end(page("Mentio CLI connected", "The key is stored on this computer. You can close this tab and go back to the terminal."));
+      finish(() => settle?.resolve(issued));
+    });
+    const timer = setTimeout(() => finish(() => settle?.reject(new LoginError(`No authorization arrived within ${Math.round(timeoutMs / 1e3)} seconds.`))), timeoutMs);
+    const close = () => {
+      clearTimeout(timer);
+      server.close();
+    };
+    const finish = (outcome) => {
+      setTimeout(() => {
+        outcome();
+        close();
+      }, 50);
+    };
+    server.on("error", (err) => rejectServer(err));
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      if (!address || typeof address === "string") {
+        rejectServer(new LoginError("Could not open a loopback port."));
+        return;
+      }
+      key.catch(() => {
+      });
+      resolveServer({ port: address.port, key, close });
+    });
+  });
+}
+function openBrowser(url) {
+  try {
+    const [command, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["cmd", ["/c", "start", "", url]] : ["xdg-open", [url]];
+    const child = spawn(command, args, { detached: true, stdio: "ignore" });
+    child.on("error", () => {
+    });
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
 // src/mcp.ts
 var DEFAULT_MCP_URL = "https://mcp.mentio.dev/mcp";
 function mcpConfig(kind, url, apiKey) {
@@ -3662,8 +3752,8 @@ async function watchMentions(options) {
     if (result.error !== void 0 || !result.response?.ok) {
       options.warn(JSON.stringify({ error: result.error ?? { code: `http_${result.response?.status ?? 0}`, message: "poll failed" } }));
     } else {
-      const page = result.data?.data ?? [];
-      const fresh = takeNew(seen, page);
+      const page2 = result.data?.data ?? [];
+      const fresh = takeNew(seen, page2);
       if (!first || options.fromStart) for (const item of fresh) options.write(JSON.stringify(item));
     }
     first = false;
@@ -3743,6 +3833,30 @@ async function readStdin() {
   return Buffer.concat(chunks).toString("utf8");
 }
 function registerAuth() {
+  program.command("auth:login").description("Sign in through the browser: the dashboard mints an API key and hands it to this terminal").option("--app-url <url>", "Dashboard URL", DEFAULT_APP_URL).option("--name <label>", "Name of the key the dashboard creates", `CLI on ${hostname()}`).addOption(new Option("--scope <scope>", "read: GET only. write: everything.").choices(["read", "write"]).default("write")).option("--timeout <seconds>", "How long to wait for the browser", "300").option("--no-open", "Print the URL instead of opening the browser").action(async (flags) => {
+    const globals = program.opts();
+    const seconds = Number(flags.timeout);
+    if (!Number.isFinite(seconds) || seconds < 10) fail({ error: { code: "usage", message: "--timeout must be at least 10 seconds" } }, 2);
+    const state = newState();
+    const server = await startCallbackServer(state, seconds * 1e3);
+    const url = loginUrl(flags.appUrl, { port: server.port, state, name: flags.name, scope: flags.scope });
+    const opened = flags.open ? openBrowser(url) : false;
+    process.stderr.write(`${opened ? "Opening your browser to authorize the CLI. If it does not open, visit:" : "Open this URL to authorize the CLI:"}
+  ${url}
+Waiting for the browser (${seconds}s)...
+`);
+    let key;
+    try {
+      key = await server.key;
+    } catch (err) {
+      fail({ error: { code: "login_failed", message: err instanceof LoginError ? err.message : String(err) } });
+    }
+    const path = writeConfig({ apiKey: key, ...globals.apiUrl ? { apiUrl: globals.apiUrl } : {} });
+    const settings = resolveSettings({ apiKey: key, apiUrl: globals.apiUrl });
+    const result = await clientFor(settings).request({ method: "GET", url: "/v1/company", security: BEARER, throwOnError: false });
+    const company = result.error === void 0 && result.response?.ok ? result.data : void 0;
+    print({ ok: true, workspace: company?.name ?? null, key: keyPrefix(key), scope: flags.scope, file: path }, globals);
+  });
   program.command("auth:set").description("Store an API key (and optionally the API host) in ~/.mentio/config.json").requiredOption("--key <key>", "API key from the dashboard or POST /v1/api-keys (mk_live_...)").option("--url <url>", "API host for a self-hosted deployment").action((flags) => {
     const path = writeConfig({ apiKey: flags.key, ...flags.url ? { apiUrl: flags.url } : {} });
     print({ ok: true, file: path, key: keyPrefix(flags.key) }, program.opts());