@anaella/cli 0.1.0

package/README.md

@@ -0,0 +1,49 @@
+# @anaella/cli
+
+Command-line tool for anaella.com — schedule and publish social posts via the `/v1` API.
+
+## Install
+
+```bash
+npm i -g @anaella/cli
+# or run without installing:
+npx @anaella/cli --help
+```
+
+## Auth
+
+The API key is resolved with this precedence: `--api-key` flag > `ANAELLA_API_KEY` env var > the
+file saved by `anaella login` (`~/.config/anaella/config.json`, or under `$XDG_CONFIG_HOME` if set).
+
+```bash
+anaella login --api-key ana_xxx     # verifies the key against the API, then saves it
+echo ana_xxx | anaella login        # or pipe it on stdin
+anaella logout                      # remove the saved key
+```
+
+## Commands
+
+```bash
+anaella channels                    # list connected channels
+anaella post -c <channelId> -t "hello" -w now      # publish now
+anaella post -c <channelId> -t "hello"              # -w/--when defaults to "draft"
+anaella post -c c1 -c c2 -m https://x/a.jpg -t hi   # -c and -m are repeatable
+anaella posts --limit 20 --cursor 0 # list recent posts
+anaella get <id>                    # fetch one post
+anaella delete <id>                 # delete a draft / cancel a scheduled post
+```
+
+## Global options
+
+- `--api-key <key>` — override the resolved API key for this invocation.
+- `--api-url <url>` — override the API base URL (default `https://api.anaella.com`).
+- `--json` — print raw JSON instead of a table.
+
+## post options
+
+- `-c, --channel <id>` — channel id, repeatable, required.
+- `-t, --text <text>` — post text.
+- `-w, --when <when>` — `"now"` | `"draft"` | an ISO-8601 timestamp (default `draft`).
+- `-m, --media <url>` — public media URL, repeatable.
+- `--type <type>` — `post` | `reel` | `thread` | `story`.
+- `--first-comment <text>` — first comment text.

package/dist/index.js

@@ -0,0 +1,175 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { AnaellaClient } from "@anaella/client";
+import { Command } from "commander";
+
+// src/commands.ts
+var cmdChannels = (client) => client.listChannels();
+function cmdPost(client, o) {
+  return client.createPost({
+    channels: o.channel,
+    text: o.text,
+    when: o.when,
+    media: (o.media ?? []).map((url) => ({ url })),
+    type: o.type,
+    firstComment: o.firstComment
+  });
+}
+var cmdPosts = (client, o) => client.listPosts({
+  limit: o.limit === void 0 ? void 0 : Number(o.limit),
+  cursor: o.cursor === void 0 ? void 0 : Number(o.cursor)
+});
+var cmdGet = (client, id) => client.getPost(id);
+var cmdDelete = (client, id) => client.deletePost(id);
+
+// src/config.ts
+import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+var DEFAULT_API_URL = "https://api.anaella.com";
+function configPath(env) {
+  const base = env.XDG_CONFIG_HOME || join(homedir(), ".config");
+  return join(base, "anaella", "config.json");
+}
+function readConfigFile(env) {
+  const path = configPath(env);
+  if (!existsSync(path)) return {};
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    process.stderr.write(`[anaella] warning: could not parse ${path}; ignoring.
+`);
+    return {};
+  }
+}
+function writeConfigFile(env, cfg) {
+  const path = configPath(env);
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(cfg, null, 2)}
+`, { mode: 384 });
+  chmodSync(path, 384);
+}
+function clearConfigFile(env) {
+  rmSync(configPath(env), { force: true });
+}
+function resolveConfig(opts, env) {
+  const file = readConfigFile(env);
+  return {
+    apiKey: opts.apiKey || env.ANAELLA_API_KEY || file.apiKey,
+    apiUrl: (opts.apiUrl || env.ANAELLA_API_URL || file.apiUrl || DEFAULT_API_URL).replace(
+      /\/+$/,
+      ""
+    )
+  };
+}
+
+// src/output.ts
+import { AnaellaApiError } from "@anaella/client";
+function printJson(data) {
+  process.stdout.write(`${JSON.stringify(data, null, 2)}
+`);
+}
+function printTable(rows, columns) {
+  if (rows.length === 0) {
+    process.stdout.write("(none)\n");
+    return;
+  }
+  const widths = columns.map(
+    (c) => Math.max(c.length, ...rows.map((r) => String(r[c] ?? "").length))
+  );
+  const line = (cells) => cells.map((cell, i) => cell.padEnd(widths[i])).join("  ").trimEnd();
+  process.stdout.write(`${line(columns)}
+`);
+  for (const r of rows) {
+    process.stdout.write(`${line(columns.map((c) => String(r[c] ?? "")))}
+`);
+  }
+}
+function printResult(data, json, columns) {
+  if (json || !columns) {
+    printJson(data);
+    return;
+  }
+  const rows = Array.isArray(data) ? data : [data];
+  printTable(rows, columns);
+}
+function printError(err, json) {
+  if (err instanceof AnaellaApiError) {
+    if (json) {
+      process.stderr.write(
+        `${JSON.stringify({ error: { code: err.code, message: err.message, details: err.details } }, null, 2)}
+`
+      );
+    } else {
+      const detail = err.details?.length ? `
+${err.details.map((d) => `  - ${d.field}: ${d.message}`).join("\n")}` : "";
+      process.stderr.write(`Error [${err.code}] (HTTP ${err.status}): ${err.message}${detail}
+`);
+    }
+    return;
+  }
+  process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+}
+
+// src/index.ts
+var collect = (val, acc) => {
+  acc.push(val);
+  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");
+async function withClient(command, fn, columns) {
+  const opts = command.optsWithGlobals();
+  const cfg = resolveConfig({ apiKey: opts.apiKey, apiUrl: opts.apiUrl }, process.env);
+  if (!cfg.apiKey) {
+    process.stderr.write(
+      "No API key. Run 'anaella login', set ANAELLA_API_KEY, or pass --api-key.\n"
+    );
+    process.exitCode = 1;
+    return;
+  }
+  try {
+    const data = await fn(new AnaellaClient({ apiKey: cfg.apiKey, baseUrl: cfg.apiUrl }), opts);
+    printResult(data, Boolean(opts.json), columns);
+  } catch (err) {
+    printError(err, Boolean(opts.json));
+    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) => {
+  const globals = command.optsWithGlobals();
+  const key = opts.apiKey || readFileSync2(0, "utf8").trim();
+  if (!key) {
+    process.stderr.write("No key provided (pass --api-key or pipe it on stdin).\n");
+    process.exitCode = 1;
+    return;
+  }
+  const apiUrl = resolveConfig({ apiUrl: globals.apiUrl }, process.env).apiUrl;
+  try {
+    await new AnaellaClient({ apiKey: key, baseUrl: apiUrl }).listChannels();
+  } catch (err) {
+    process.stderr.write("Key verification failed:\n");
+    printError(err, false);
+    process.exitCode = 1;
+    return;
+  }
+  writeConfigFile(process.env, { apiKey: key, apiUrl });
+  process.stdout.write("Logged in. Key saved.\n");
+});
+program.command("logout").description("Remove the saved API key").action(() => {
+  clearConfigFile(process.env);
+  process.stdout.write("Logged out.\n");
+});
+program.command("channels").description("List connected channels").action(
+  (_opts, command) => withClient(command, (c) => cmdChannels(c), ["id", "platform", "name", "active"])
+);
+program.command("post").description("Create/schedule/publish a post").requiredOption("-c, --channel <id>", "channel id (repeatable)", collect, []).option("-t, --text <text>", "post text").option("-w, --when <when>", '"now" | "draft" | ISO-8601', "draft").option("-m, --media <url>", "public media URL (repeatable)", collect, []).option("--type <type>", "post | reel | thread | story").option("--first-comment <text>", "first comment").action((opts, command) => withClient(command, (c) => cmdPost(c, opts)));
+program.command("posts").description("List recent posts").option("--limit <n>", "max results (1-100)").option("--cursor <n>", "offset").action(
+  (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.parseAsync(process.argv);

package/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "@anaella/cli",
+  "version": "0.1.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" }
+}