@anaella/cli 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,11 +1,109 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { readFileSync as readFileSync2 } from "fs";
+import { readFileSync as readFileSync3 } from "fs";
 import { AnaellaClient } from "@anaella/client";
 import { Command } from "commander";
 
+// src/browser-login.ts
+import { spawn } from "child_process";
+import crypto from "crypto";
+import http from "http";
+var CLIENT_ID = "anaella-cli";
+var DEFAULT_TIMEOUT_MS = 3e5;
+function pkce() {
+  const verifier = crypto.randomBytes(32).toString("base64url");
+  const challenge = crypto.createHash("sha256").update(verifier).digest("base64url");
+  return { verifier, challenge };
+}
+function defaultOpen(url) {
+  const child = process.platform === "darwin" ? spawn("open", [url], { stdio: "ignore", detached: true }) : process.platform === "win32" ? spawn("cmd", ["/c", "start", "", url], { stdio: "ignore", detached: true }) : spawn("xdg-open", [url], { stdio: "ignore", detached: true });
+  child.on("error", () => {
+    process.stderr.write("Couldn't open a browser automatically \u2014 open the URL above manually.\n");
+  });
+  child.unref();
+}
+async function browserLogin(opts) {
+  const { verifier, challenge } = pkce();
+  const state = crypto.randomBytes(16).toString("base64url");
+  const open = opts.openBrowser ?? defaultOpen;
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  return new Promise((resolve, reject) => {
+    const server = http.createServer(async (req, res) => {
+      const url = new URL(req.url ?? "", "http://127.0.0.1");
+      if (url.pathname !== "/callback") {
+        res.writeHead(404);
+        res.end();
+        return;
+      }
+      const returnedState = url.searchParams.get("state");
+      const code = url.searchParams.get("code");
+      const err = url.searchParams.get("error");
+      const port = server.address().port;
+      res.writeHead(200, { "content-type": "text/html" });
+      res.end("<html><body>You can close this tab and return to the terminal.</body></html>");
+      server.close();
+      clearTimeout(timer);
+      if (err) return reject(new Error(`Authorization denied: ${err}`));
+      if (!code || returnedState !== state)
+        return reject(new Error("Invalid authorization response"));
+      try {
+        const tokenRes = await fetch(`${opts.apiUrl}/oauth/token`, {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({
+            grant_type: "authorization_code",
+            code,
+            code_verifier: verifier,
+            client_id: CLIENT_ID,
+            redirect_uri: `http://127.0.0.1:${port}/callback`
+          })
+        });
+        if (!tokenRes.ok) return reject(new Error(`Token exchange failed: HTTP ${tokenRes.status}`));
+        const json = await tokenRes.json();
+        resolve(json.access_token);
+      } catch (e) {
+        reject(e);
+      }
+    });
+    const timer = setTimeout(() => {
+      server.close();
+      reject(
+        new Error(
+          "Timed out waiting for the browser sign-in. Make sure you're signed in at anaella.com, then run 'anaella login' again."
+        )
+      );
+    }, timeoutMs);
+    server.listen(0, "127.0.0.1", () => {
+      const port = server.address().port;
+      const authorizeUrl = new URL("/oauth/authorize", opts.apiUrl);
+      authorizeUrl.searchParams.set("response_type", "code");
+      authorizeUrl.searchParams.set("client_id", CLIENT_ID);
+      authorizeUrl.searchParams.set("redirect_uri", `http://127.0.0.1:${port}/callback`);
+      authorizeUrl.searchParams.set("code_challenge", challenge);
+      authorizeUrl.searchParams.set("code_challenge_method", "S256");
+      authorizeUrl.searchParams.set("state", state);
+      process.stdout.write(`Opening your browser\u2026 if it doesn't open, visit:
+${authorizeUrl}
+`);
+      void open(authorizeUrl.toString());
+    });
+  });
+}
+
 // src/commands.ts
+import { readFileSync } from "fs";
+import { basename, extname } from "path";
+var EXT_MIME = {
+  ".mp4": "video/mp4",
+  ".mov": "video/quicktime",
+  ".webm": "video/webm",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".gif": "image/gif",
+  ".webp": "image/webp"
+};
 var cmdChannels = (client) => client.listChannels();
 function cmdPost(client, o) {
   return client.createPost({
@@ -23,9 +121,26 @@ var cmdPosts = (client, o) => client.listPosts({
 });
 var cmdGet = (client, id) => client.getPost(id);
 var cmdDelete = (client, id) => client.deletePost(id);
+var cmdAnalytics = (client, o) => o.post ? client.getPostAnalytics(o.post, { period: o.period }) : client.getAnalytics({ period: o.period });
+function cmdUpload(client, o) {
+  const urls = o.url ?? [];
+  const files = o.files ?? [];
+  if (urls.length && files.length) {
+    throw new Error("Pass either local file path(s) or --url, not both.");
+  }
+  if (urls.length) return client.uploadUrls(urls);
+  if (!files.length) throw new Error("Provide file path(s) to upload, or --url <url> to register.");
+  return client.uploadFiles(
+    files.map((p) => ({
+      filename: basename(p),
+      data: readFileSync(p),
+      contentType: EXT_MIME[extname(p).toLowerCase()]
+    }))
+  );
+}
 
 // src/config.ts
-import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { chmodSync, existsSync, mkdirSync, readFileSync as readFileSync2, rmSync, writeFileSync } from "fs";
 import { homedir } from "os";
 import { dirname, join } from "path";
 var DEFAULT_API_URL = "https://api.anaella.com";
@@ -37,7 +152,7 @@ function readConfigFile(env) {
   const path = configPath(env);
   if (!existsSync(path)) return {};
   try {
-    return JSON.parse(readFileSync(path, "utf8"));
+    return JSON.parse(readFileSync2(path, "utf8"));
   } catch {
     process.stderr.write(`[anaella] warning: could not parse ${path}; ignoring.
 `);
@@ -120,7 +235,7 @@ var collect = (val, acc) => {
   return acc;
 };
 var program = new Command();
-program.name("anaella").description("CLI for anaella.com \u2014 schedule and publish social posts via the /v1 API.").version("0.1.0").option("--api-key <key>", "ana_ API key (overrides env + config)").option("--api-url <url>", "API base URL").option("--json", "output raw JSON");
+program.name("anaella").description("CLI for anaella.com \u2014 schedule and publish social posts via the /v1 API.").version("0.1.1").option("--api-key <key>", "ana_ API key (overrides env + config)").option("--api-url <url>", "API base URL").option("--json", "output raw JSON");
 async function withClient(command, fn, columns) {
   const opts = command.optsWithGlobals();
   const cfg = resolveConfig({ apiKey: opts.apiKey, apiUrl: opts.apiUrl }, process.env);
@@ -139,15 +254,31 @@ async function withClient(command, fn, columns) {
     process.exitCode = 1;
   }
 }
-program.command("login").description("Save an API key (verified against the API) to ~/.config/anaella/config.json").option("--api-key <key>", "the key (else read from stdin)").action(async (opts, command) => {
+program.command("login").description("Sign in via the browser (or pass --api-key for headless).").option("--api-key <key>", "skip the browser and save this key directly").action(async (opts, command) => {
   const globals = command.optsWithGlobals();
-  const key = opts.apiKey || readFileSync2(0, "utf8").trim();
+  const apiUrl = resolveConfig({ apiUrl: globals.apiUrl }, process.env).apiUrl;
+  let key = opts.apiKey;
   if (!key) {
-    process.stderr.write("No key provided (pass --api-key or pipe it on stdin).\n");
-    process.exitCode = 1;
-    return;
+    if (!process.stdin.isTTY) {
+      key = readFileSync3(0, "utf8").trim();
+      if (!key) {
+        process.stderr.write(
+          "No key provided (pass --api-key, pipe it on stdin, or run 'anaella login' in an interactive terminal).\n"
+        );
+        process.exitCode = 1;
+        return;
+      }
+    } else {
+      try {
+        key = await browserLogin({ apiUrl });
+      } catch (err) {
+        process.stderr.write("Browser login failed:\n");
+        printError(err, false);
+        process.exitCode = 1;
+        return;
+      }
+    }
   }
-  const apiUrl = resolveConfig({ apiUrl: globals.apiUrl }, process.env).apiUrl;
   try {
     await new AnaellaClient({ apiKey: key, baseUrl: apiUrl }).listChannels();
   } catch (err) {
@@ -171,5 +302,9 @@ program.command("posts").description("List recent posts").option("--limit <n>",
   (opts, command) => withClient(command, (c) => cmdPosts(c, opts), ["id", "type", "status", "scheduledAt"])
 );
 program.command("get <id>").description("Get one post by id").action((id, _opts, command) => withClient(command, (c) => cmdGet(c, id)));
-program.command("delete <id>").description("Delete a draft or cancel a scheduled post").option("--yes", "skip confirmation").action((id, opts, command) => withClient(command, (c) => cmdDelete(c, id)));
+program.command("delete <id>").description("Delete a draft or cancel a scheduled post").action((id, _opts, command) => withClient(command, (c) => cmdDelete(c, id)));
+program.command("analytics").description("Organization analytics, or one post with --post").option("--post <id>", "post id (omit for org-wide analytics)").option("--period <p>", "24h | 7d | 30d | 90d | 1y").action((opts, command) => withClient(command, (c) => cmdAnalytics(c, opts)));
+program.command("upload [files...]").description("Upload local media files, or register public URLs with --url").option("--url <url>", "public media URL to register (repeatable)", collect, []).action(
+  (files, opts, command) => withClient(command, (c) => cmdUpload(c, { files, url: opts.url }), ["id", "url", "type"])
+);
 program.parseAsync(process.argv);

package/package.json

@@ -1,12 +1,29 @@
 {
   "name": "@anaella/cli",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Command-line tool for anaella.com — schedule and publish social posts.",
   "type": "module",
-  "bin": { "anaella": "dist/index.js" },
-  "files": ["dist"],
-  "publishConfig": { "access": "public" },
-  "scripts": { "build": "tsup", "prepublishOnly": "npm run build", "test": "bun test" },
-  "dependencies": { "@anaella/client": "^0.1.0", "commander": "^12.0.0" },
-  "devDependencies": { "tsup": "^8.0.0", "typescript": "^5", "bun-types": "^1.1.0" }
+  "bin": {
+    "anaella": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup",
+    "prepublishOnly": "npm run build",
+    "test": "bun test"
+  },
+  "dependencies": {
+    "@anaella/client": "^0.1.6",
+    "commander": "^12.0.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5",
+    "@types/node": "^22"
+  }
 }