npm - @reepl/cli - Versions diffs - 0.1.0 - Mend

@reepl/cli 0.1.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 (11) hide show

package/README.md +104 -0
package/dist/chunk-QSNFNE5Z.js +719 -0
package/dist/chunk-QSNFNE5Z.js.map +1 -0
package/dist/cli/index.d.ts +1 -0
package/dist/cli/index.js +982 -0
package/dist/cli/index.js.map +1 -0
package/dist/core/index.d.ts +525 -0
package/dist/core/index.js +57 -0
package/dist/core/index.js.map +1 -0
package/package.json +49 -0
package/scripts/postinstall.mjs +56 -0

package/dist/cli/index.js ADDED Viewed

@@ -0,0 +1,982 @@
+#!/usr/bin/env node
+import {
+  MCP_CONNECT_PATH,
+  REEPL_WEB_APP_URL,
+  ReeplClient,
+  ReeplError,
+  TokenManager,
+  calendar_exports,
+  carousel_exports,
+  decodeJwt,
+  dms_exports,
+  jwtExpiryMs,
+  linkedin_exports,
+  profile_exports,
+  reddit_exports,
+  resolvePostRef,
+  signals_exports,
+  twitter_exports,
+  voice_exports,
+  workspaces_exports,
+  writingStyle_exports
+} from "../chunk-QSNFNE5Z.js";
+// src/cli/index.ts
+import { Command } from "commander";
+// src/cli/banner.ts
+var BRAND = { r: 109, g: 66, b: 204 };
+var WORDMARK = [
+  "\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557     ",
+  "\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551     ",
+  "\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551     ",
+  "\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u255D  \u2588\u2588\u2554\u2550\u2550\u255D  \u2588\u2588\u2554\u2550\u2550\u2550\u255D \u2588\u2588\u2551     ",
+  "\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551     \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557",
+  "\u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D     \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D"
+];
+var SPARKLE = "        \u2726  \xB7  \u2726";
+function supportsColor(stream) {
+  if (process.env.NO_COLOR) return false;
+  if (process.env.FORCE_COLOR) return true;
+  return Boolean(stream.isTTY) && process.env.TERM !== "dumb";
+}
+function purple(text, on) {
+  if (!on) return text;
+  return `\x1B[38;2;${BRAND.r};${BRAND.g};${BRAND.b}m${text}\x1B[0m`;
+}
+function dim(text, on) {
+  return on ? `\x1B[2m${text}\x1B[0m` : text;
+}
+function renderBanner(opts = {}, color = true) {
+  const v = opts.version ? ` v${opts.version}` : "";
+  const lines = [
+    "",
+    ...WORDMARK.map((l) => purple(l, color)),
+    purple(SPARKLE, color),
+    "",
+    `  ${purple("Reepl CLI", color)}${dim(v, color)} \u2014 your content workflow, in the terminal.`,
+    `  ${dim("LinkedIn \xB7 X \xB7 Reddit \xB7 carousels \xB7 signals \xB7 writing styles", color)}`,
+    "",
+    `  ${dim("Get started:", color)} reepl login   ${dim("\xB7", color)}   reepl --help   ${dim("\xB7", color)}   reepl schema`
+  ];
+  if (opts.footer) lines.push("", `  ${opts.footer}`);
+  lines.push("");
+  return lines.join("\n");
+}
+function printBanner(opts = {}, stream = process.stdout) {
+  stream.write(renderBanner(opts, supportsColor(stream)) + "\n");
+}
+// src/cli/commands/auth.ts
+import open from "open";
+// src/cli/auth-flow.ts
+import { randomBytes } from "crypto";
+import { createServer } from "http";
+var DONE_HTML = `<!doctype html><meta charset="utf-8"><title>Reepl CLI</title>
+<body style="font-family:system-ui;background:#0b0b0f;color:#eaeaf0;display:grid;place-items:center;height:100vh;margin:0">
+<div style="text-align:center"><h1 style="font-weight:600">You're signed in.</h1>
+<p style="color:#9a9aa8">Return to your terminal \u2014 you can close this tab.</p></div></body>`;
+async function loginViaBrowser(opts) {
+  const state = randomBytes(16).toString("hex");
+  const timeoutMs = opts.timeoutMs ?? 5 * 60 * 1e3;
+  return new Promise((resolve, reject) => {
+    const server = createServer((req, res) => {
+      try {
+        const url = new URL(req.url ?? "/", "http://127.0.0.1");
+        if (url.pathname !== "/callback") {
+          res.writeHead(404).end("Not found");
+          return;
+        }
+        const token = url.searchParams.get("token");
+        const refreshToken = url.searchParams.get("refresh_token");
+        const returnedState = url.searchParams.get("state");
+        if (returnedState !== state) {
+          res.writeHead(400).end("State mismatch");
+          cleanup();
+          reject(new ReeplError("UNAUTHENTICATED", "Login failed: state mismatch (possible CSRF)."));
+          return;
+        }
+        if (!token || !refreshToken) {
+          res.writeHead(400).end("Missing token");
+          cleanup();
+          reject(
+            new ReeplError(
+              "UNAUTHENTICATED",
+              "Login did not return a refresh token. Ensure you are logged in to app.reepl.io and retry."
+            )
+          );
+          return;
+        }
+        res.writeHead(200, { "Content-Type": "text/html" }).end(DONE_HTML);
+        cleanup();
+        const expiresAt = jwtExpiryMs(token) ?? Date.now() + 3600 * 1e3;
+        resolve({ tokens: { idToken: token, refreshToken, expiresAt } });
+      } catch (err) {
+        cleanup();
+        reject(err);
+      }
+    });
+    const timer = setTimeout(() => {
+      cleanup();
+      reject(new ReeplError("UNAUTHENTICATED", "Login timed out. Run `reepl login` again."));
+    }, timeoutMs);
+    function cleanup() {
+      clearTimeout(timer);
+      server.close();
+    }
+    server.on("error", (err) => {
+      cleanup();
+      reject(new ReeplError("NETWORK", `Could not start local login listener: ${err.message}`));
+    });
+    server.listen(0, "127.0.0.1", () => {
+      const { port } = server.address();
+      const callback = `http://127.0.0.1:${port}/callback`;
+      const handoff = new URL(REEPL_WEB_APP_URL + MCP_CONNECT_PATH);
+      handoff.searchParams.set("state", state);
+      handoff.searchParams.set("callback", callback);
+      handoff.searchParams.set("app", "cli");
+      const href = handoff.toString();
+      opts.onUrl?.(href);
+      opts.openBrowser(href).catch(() => {
+      });
+    });
+  });
+}
+// src/cli/config.ts
+import { chmod, mkdir, readFile, rm, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { dirname, join } from "path";
+function configDir() {
+  return process.env.REEPL_CONFIG_DIR || join(homedir(), ".reepl");
+}
+var credentialsPath = () => join(configDir(), "credentials.json");
+var configPath = () => join(configDir(), "config.json");
+async function readJson(path) {
+  try {
+    return JSON.parse(await readFile(path, "utf8"));
+  } catch (err) {
+    if (err?.code === "ENOENT") return null;
+    throw err;
+  }
+}
+async function writeJson(path, value, mode) {
+  await mkdir(dirname(path), { recursive: true, mode: 448 });
+  await writeFile(path, JSON.stringify(value, null, 2), { mode: mode ?? 384 });
+  if (mode) await chmod(path, mode).catch(() => {
+  });
+}
+async function readConfig() {
+  return await readJson(configPath()) ?? {};
+}
+async function writeConfig(patch) {
+  const next = { ...await readConfig(), ...patch };
+  await writeJson(configPath(), next, 384);
+  return next;
+}
+var FileTokenStore = class {
+  async load() {
+    return readJson(credentialsPath());
+  }
+  async save(tokens) {
+    await writeJson(credentialsPath(), tokens, 384);
+  }
+  async clear() {
+    await rm(credentialsPath(), { force: true });
+  }
+};
+// src/cli/context.ts
+async function getContext(overrideWorkspaceId) {
+  const store = new FileTokenStore();
+  const tokens = new TokenManager(store, {
+    cognitoDomain: process.env.REEPL_COGNITO_DOMAIN || void 0,
+    clientId: process.env.REEPL_COGNITO_CLIENT_ID || void 0
+  });
+  const config = await readConfig();
+  const workspaceId = overrideWorkspaceId ?? config.currentWorkspaceId;
+  const client = new ReeplClient({
+    getToken: () => tokens.getIdToken(),
+    workspaceId: workspaceId ?? null,
+    apiBaseUrl: process.env.REEPL_API_BASE_URL || void 0,
+    publicBaseUrl: process.env.REEPL_PUBLIC_API_BASE_URL || void 0
+  });
+  return { client, tokens, store, workspaceId };
+}
+async function currentUserId(ctx) {
+  const token = await ctx.tokens.getIdToken();
+  const sub = decodeJwt(token)?.sub;
+  if (!sub) throw new ReeplError("UNAUTHENTICATED", "Could not read user id from token. Run `reepl login`.");
+  return String(sub);
+}
+async function ensureWorkspaceId(ctx) {
+  if (ctx.workspaceId) return ctx.workspaceId;
+  const def = await workspaces_exports.getDefaultWorkspaceId(ctx.client);
+  if (!def) {
+    throw new ReeplError("CONFIG", "No workspace selected and no default found. Run `reepl workspace list`.");
+  }
+  return def;
+}
+// src/cli/output.ts
+var forceJson;
+function setJsonMode(value) {
+  forceJson = value;
+}
+function isJsonMode() {
+  if (forceJson !== void 0) return forceJson;
+  return !process.stdout.isTTY;
+}
+function success(data, render) {
+  if (isJsonMode()) {
+    process.stdout.write(JSON.stringify({ ok: true, data }, null, 2) + "\n");
+    return;
+  }
+  if (render) {
+    process.stdout.write(render(data) + "\n");
+    return;
+  }
+  process.stdout.write(prettyValue(data) + "\n");
+}
+function fail(err) {
+  const reepl = err instanceof ReeplError ? err : new ReeplError("API_ERROR", err instanceof Error ? err.message : String(err));
+  if (isJsonMode()) {
+    process.stdout.write(
+      JSON.stringify({ ok: false, error: reepl.toJSON() }, null, 2) + "\n"
+    );
+  } else {
+    process.stderr.write(`Error [${reepl.code}]: ${reepl.message}
+`);
+  }
+  process.exit(reepl.exitCode);
+}
+function prettyValue(data) {
+  if (typeof data === "string") return data;
+  return JSON.stringify(data, null, 2);
+}
+function table(rows, columns) {
+  if (rows.length === 0) return "(none)";
+  const widths = columns.map(
+    (c) => Math.max(c.length, ...rows.map((r) => String(r[c] ?? "").length))
+  );
+  const header = columns.map((c, i) => c.padEnd(widths[i])).join("  ");
+  const sep = widths.map((w) => "-".repeat(w)).join("  ");
+  const body = rows.map((r) => columns.map((c, i) => String(r[c] ?? "").padEnd(widths[i])).join("  ")).join("\n");
+  return `${header}
+${sep}
+${body}`;
+}
+// src/cli/commands/auth.ts
+function registerAuthCommands(program2) {
+  program2.command("login").description("Authenticate with Reepl via your browser (or --token/--refresh for headless)").option("--token <idToken>", "Provide a Cognito ID token directly (skips the browser)").option("--refresh <refreshToken>", "Provide a Cognito refresh token directly").action(async (opts) => {
+    try {
+      const store = new FileTokenStore();
+      let tokens;
+      if (opts.token && opts.refresh) {
+        tokens = {
+          idToken: opts.token,
+          refreshToken: opts.refresh,
+          expiresAt: jwtExpiryMs(opts.token) ?? Date.now() + 3600 * 1e3
+        };
+      } else if (opts.token || opts.refresh) {
+        throw new Error("--token and --refresh must be provided together.");
+      } else {
+        const result = await loginViaBrowser({
+          openBrowser: (url) => open(url),
+          onUrl: (url) => {
+            if (!isJsonMode()) {
+              process.stderr.write(
+                `Opening your browser to sign in...
+If it doesn't open, visit:
+  ${url}
+`
+              );
+            }
+          }
+        });
+        tokens = result.tokens;
+      }
+      await store.save(tokens);
+      const { client } = await getContext();
+      const me = await profile_exports.getProfile(client);
+      await writeConfig({ email: me.email });
+      success(
+        { email: me.email, name: me.name, plan: me.subscriptionType },
+        (d) => `Logged in as ${d.email ?? "unknown"}${d.plan ? ` (${d.plan})` : ""}.`
+      );
+    } catch (err) {
+      fail(err);
+    }
+  });
+  program2.command("logout").description("Remove stored Reepl credentials from this machine").action(async () => {
+    try {
+      await new FileTokenStore().clear();
+      await writeConfig({ email: void 0 });
+      success({ loggedOut: true }, () => "Logged out. Credentials removed.");
+    } catch (err) {
+      fail(err);
+    }
+  });
+  program2.command("whoami").description("Show the currently authenticated account and plan").action(async () => {
+    try {
+      const { client } = await getContext();
+      const me = await profile_exports.getProfile(client);
+      const paid = profile_exports.hasActivePlan(me);
+      success(
+        {
+          userID: me.userID,
+          email: me.email,
+          name: me.name,
+          plan: me.subscriptionType,
+          hasActivePlan: paid,
+          creditsAvailable: me.credits_available
+        },
+        (d) => `${d.email ?? "unknown"}${d.name ? ` (${d.name})` : ""}
+Plan: ${d.plan ?? "free"}${d.hasActivePlan ? "" : " (no active purchase)"}
+Credits: ${d.creditsAvailable ?? "n/a"}`
+      );
+    } catch (err) {
+      fail(err);
+    }
+  });
+}
+// src/cli/commands/calendar.ts
+function registerCalendarCommands(program2) {
+  program2.command("calendar").alias("schedule").description("Show the content calendar (scheduled posts across LinkedIn and X)").option("-p, --platform <platform>", "linkedin | x | all", "all").option("--limit <n>", "Max results per platform", (v) => parseInt(v, 10)).action(async (opts) => {
+    try {
+      const platform = (opts.platform ?? "all").toLowerCase();
+      const { client } = await getContext();
+      const items = await calendar_exports.getSchedule(client, {
+        platform: platform === "twitter" ? "x" : platform,
+        limit: opts.limit
+      });
+      success(
+        items,
+        (rows) => table(
+          rows.map((i) => ({
+            platform: i.platform,
+            id: i.id,
+            scheduledFor: i.scheduledFor ?? "",
+            content: i.content
+          })),
+          ["platform", "id", "scheduledFor", "content"]
+        )
+      );
+    } catch (err) {
+      fail(err);
+    }
+  });
+}
+// src/cli/commands/carousel.ts
+import { readFile as readFile2 } from "fs/promises";
+async function loadSlides(opts) {
+  const raw = opts.slidesFile ? await readFile2(opts.slidesFile, "utf8") : opts.slides;
+  if (!raw) throw new Error("Provide slides via --slides <json> or --slides-file <path>.");
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error("--slides must be a JSON array of { headline, body, layout? } objects.");
+  }
+  if (!Array.isArray(parsed)) throw new Error("Slides JSON must be an array.");
+  return parsed;
+}
+function registerCarouselCommands(program2) {
+  const cmd = program2.command("carousel").description("Manage carousel drafts");
+  cmd.command("list").description("List carousel drafts").option("--limit <n>", "Max results", (v) => parseInt(v, 10)).option("--search <q>", "Search query").action(async (opts) => {
+    try {
+      const { client } = await getContext();
+      const result = await carousel_exports.listDrafts(client, { limit: opts.limit, search: opts.search });
+      success(result, (d) => {
+        const drafts = Array.isArray(d) ? d : d?.drafts ?? [];
+        if (!drafts.length) return "(none)";
+        return table(
+          drafts.map((x) => ({
+            id: x.draft_id ?? x.id ?? "",
+            slides: x.slide_count ?? x.carousels?.length ?? "",
+            title: String(x.title ?? "").slice(0, 50)
+          })),
+          ["id", "slides", "title"]
+        );
+      });
+    } catch (err) {
+      fail(err);
+    }
+  });
+  cmd.command("get <draftId>").description("Get a carousel draft").action(async (draftId) => {
+    try {
+      const { client } = await getContext();
+      success(await carousel_exports.getDraft(client, draftId));
+    } catch (err) {
+      fail(err);
+    }
+  });
+  cmd.command("create").description("Create a carousel draft from slides JSON").requiredOption("--title <title>", "Draft title").option("--slides <json>", "Slides as a JSON array").option("--slides-file <path>", "Read slides JSON from a file").option("--theme <theme>", "Theme id").action(async (opts) => {
+    try {
+      const slides = await loadSlides(opts);
+      const { client } = await getContext();
+      const result = await carousel_exports.createDraft(client, { title: opts.title, slides, theme: opts.theme });
+      success(result, (d) => `Created carousel draft ${d?.draft?.draft_id ?? d?.draft_id ?? ""}.`);
+    } catch (err) {
+      fail(err);
+    }
+  });
+  cmd.command("update <draftId>").description("Update a carousel draft (title, slides, theme, fonts)").option("--title <title>", "New title").option("--slides <json>", "Replacement slides as a JSON array").option("--slides-file <path>", "Read replacement slides JSON from a file").option("--theme <theme>", "Theme id").option("--title-font <size>", "Title font size").option("--body-font <size>", "Body font size").action(async (draftId, opts) => {
+    try {
+      const slides = opts.slides || opts.slidesFile ? await loadSlides(opts) : void 0;
+      const { client } = await getContext();
+      const result = await carousel_exports.updateDraft(client, draftId, {
+        title: opts.title,
+        slides,
+        theme: opts.theme,
+        titleFontSize: opts.titleFont,
+        bodyFontSize: opts.bodyFont
+      });
+      success(result, () => `Updated carousel draft ${draftId}.`);
+    } catch (err) {
+      fail(err);
+    }
+  });
+  cmd.command("delete <draftId>").description("Delete a carousel draft").action(async (draftId) => {
+    try {
+      const { client } = await getContext();
+      await carousel_exports.deleteDraft(client, draftId);
+      success({ draftId, deleted: true }, () => `Deleted carousel draft ${draftId}.`);
+    } catch (err) {
+      fail(err);
+    }
+  });
+  cmd.command("generate").description("AI-generate carousel slides from a topic or URL").option("--topic <topic>", "Topic to generate from").option("--url <url>", "Article/YouTube URL to generate from").option("--slides <n>", "Number of slides (1-10)", (v) => parseInt(v, 10)).option("--instructions <text>", "Extra AI instructions").action(async (opts) => {
+    try {
+      const ctx = await getContext();
+      const userID = await currentUserId(ctx);
+      const result = await carousel_exports.generate(ctx.client, userID, {
+        topic: opts.topic,
+        url: opts.url,
+        numberOfSlides: opts.slides,
+        aiInstructions: opts.instructions
+      });
+      success(result);
+    } catch (err) {
+      fail(err);
+    }
+  });
+}
+// src/cli/input.ts
+import { readFile as readFile3 } from "fs/promises";
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(chunk);
+  return Buffer.concat(chunks).toString("utf8");
+}
+async function resolveContent(opts) {
+  if (opts.file) return (await readFile3(opts.file, "utf8")).trim();
+  if (opts.content === "-") return (await readStdin()).trim();
+  if (opts.content !== void 0) return opts.content;
+  if (!process.stdin.isTTY) {
+    const piped = (await readStdin()).trim();
+    if (piped) return piped;
+  }
+  throw new Error("No content provided. Use -c/--content, --file <path>, or pipe via stdin.");
+}
+function parseList(value) {
+  if (!value) return void 0;
+  return value.split(",").map((s) => s.trim()).filter(Boolean);
+}
+// src/cli/commands/comment.ts
+function coercePlatform(p) {
+  if (!p) return void 0;
+  const v = p.toLowerCase();
+  if (v === "x" || v === "twitter") return "x";
+  if (v === "linkedin" || v === "li") return "linkedin";
+  if (v === "reddit") return "reddit";
+  throw new Error(`Unknown platform "${p}". Use linkedin, x, or reddit.`);
+}
+function registerCommentCommands(program2) {
+  program2.command("comment").description("Comment on / reply to a post by URL or id (LinkedIn, X, Reddit)").argument("[urlOrId]", "Post URL or id (alternatively use --url)").option("--url <url>", "Post URL or id").option("-t, --text <text>", "Comment text (use '-' to read stdin)").option("--file <path>", "Read comment text from a file").option("-p, --platform <platform>", "Force platform: linkedin | x | reddit").action(async (urlOrIdArg, opts) => {
+    try {
+      const ref = opts.url ?? urlOrIdArg;
+      if (!ref) throw new Error("Provide a post URL or id (positional arg or --url).");
+      const text = await resolveContent({ content: opts.text, file: opts.file });
+      const target = resolvePostRef(ref, coercePlatform(opts.platform));
+      const { client } = await getContext();
+      let result;
+      if (target.platform === "linkedin") {
+        result = await linkedin_exports.addComment(client, target.id, text);
+      } else if (target.platform === "reddit") {
+        result = await reddit_exports.comment(client, target.id, text);
+      } else {
+        result = await twitter_exports.reply(client, target.id, text);
+      }
+      success(
+        { platform: target.platform, id: target.id, result },
+        (d) => `Comment posted on ${d.platform} (${d.id}).`
+      );
+    } catch (err) {
+      fail(err);
+    }
+  });
+}
+// src/cli/commands/dm.ts
+function registerDmCommands(program2) {
+  const cmd = program2.command("dm").description("X (Twitter) direct messages \u2014 Premium plan required");
+  cmd.command("list").description("List DM conversations").option("--limit <n>", "Max results", (v) => parseInt(v, 10)).option("--offset <n>", "Offset", (v) => parseInt(v, 10)).action(async (opts) => {
+    try {
+      const { client } = await getContext();
+      const result = await dms_exports.listConversations(client, { limit: opts.limit, offset: opts.offset });
+      success(result, (d) => {
+        const convs = Array.isArray(d) ? d : d?.conversations ?? [];
+        if (!convs.length) return "(no conversations)";
+        return table(
+          convs.map((c) => ({
+            id: c.participantId ?? c.conversationId ?? c.id ?? "",
+            with: c.username ?? c.name ?? c.handle ?? "",
+            last: String(c.lastMessage?.text ?? c.lastMessageText ?? "").slice(0, 50)
+          })),
+          ["id", "with", "last"]
+        );
+      });
+    } catch (err) {
+      fail(err);
+    }
+  });
+  cmd.command("messages <conversationId>").description("Show messages in a conversation").action(async (conversationId) => {
+    try {
+      const { client } = await getContext();
+      success(await dms_exports.getMessages(client, conversationId));
+    } catch (err) {
+      fail(err);
+    }
+  });
+  cmd.command("refresh").description("Pull the latest DMs from X (Premium)").action(async () => {
+    try {
+      const { client } = await getContext();
+      success(await dms_exports.refresh(client), () => "DM inbox refreshed.");
+    } catch (err) {
+      fail(err);
+    }
+  });
+  cmd.command("reply <conversationId>").description("Send a reply into a DM conversation (Premium)").option("-t, --text <text>", "Message text (use '-' to read stdin)").option("--file <path>", "Read message text from a file").action(async (conversationId, opts) => {
+    try {
+      const text = await resolveContent({ content: opts.text, file: opts.file });
+      const { client } = await getContext();
+      const result = await dms_exports.sendMessage(client, conversationId, text);
+      success({ conversationId, result }, () => `Sent DM to ${conversationId}.`);
+    } catch (err) {
+      fail(err);
+    }
+  });
+}
+// src/cli/commands/post.ts
+function platformOf(opt) {
+  const p = (opt ?? "linkedin").toLowerCase();
+  if (p === "x" || p === "twitter") return "x";
+  if (p === "linkedin" || p === "li") return "linkedin";
+  throw new Error(`Unknown platform "${opt}". Use linkedin or x.`);
+}
+function registerPostCommands(program2) {
+  const post = program2.command("post").description("Create, list, update, and delete posts");
+  post.command("create").description("Create a post as a draft, scheduled, or published now").option("-p, --platform <platform>", "linkedin or x", "linkedin").option("-c, --content <text>", "Post text (use '-' to read stdin)").option("--file <path>", "Read post text from a file").option("--title <title>", "Draft title (LinkedIn)").option("--media <urls>", "Comma-separated media URLs").option("--schedule <iso>", "Schedule for an ISO-8601 timestamp").option("--publish", "Publish immediately instead of saving a draft").option("--draft", "Save as a draft (default)").action(async (opts) => {
+    try {
+      const platform = platformOf(opts.platform);
+      const content = await resolveContent(opts);
+      const media = parseList(opts.media);
+      const { client } = await getContext();
+      let result;
+      if (platform === "linkedin") {
+        if (opts.schedule) {
+          result = await linkedin_exports.schedulePost(client, {
+            content,
+            scheduledFor: opts.schedule,
+            title: opts.title,
+            mediaUrls: media
+          });
+        } else if (opts.publish) {
+          result = await linkedin_exports.publishNow(client, { content, title: opts.title, mediaUrls: media });
+        } else {
+          result = await linkedin_exports.createDraft(client, { content, title: opts.title, mediaUrls: media });
+        }
+      } else {
+        const threadTweets = [{ text: content, mediaUrls: media }];
+        if (opts.schedule) {
+          result = await twitter_exports.createPost(client, { threadTweets, scheduledFor: opts.schedule });
+        } else if (opts.publish) {
+          result = await twitter_exports.createPost(client, { threadTweets });
+        } else {
+          result = await twitter_exports.createDraft(client, { threadTweets, title: opts.title });
+        }
+      }
+      const mode = opts.schedule ? "scheduled" : opts.publish ? "published" : "draft";
+      success({ platform, mode, result }, (d) => `Created ${d.platform} ${d.mode}.`);
+    } catch (err) {
+      fail(err);
+    }
+  });
+  post.command("list").description("List posts or drafts").option("-p, --platform <platform>", "linkedin or x", "linkedin").option("-s, --status <status>", "scheduled | published | failed | drafts", "scheduled").option("--limit <n>", "Max results", (v) => parseInt(v, 10)).option("--search <q>", "Search query").action(async (opts) => {
+    try {
+      const platform = platformOf(opts.platform);
+      const { client } = await getContext();
+      const isDrafts = opts.status === "drafts";
+      let result;
+      if (platform === "linkedin") {
+        result = isDrafts ? await linkedin_exports.listDrafts(client, { limit: opts.limit, search: opts.search }) : await linkedin_exports.listPosts(client, { status: opts.status, limit: opts.limit, search: opts.search });
+      } else {
+        result = isDrafts ? await twitter_exports.listDrafts(client, { limit: opts.limit, search: opts.search }) : await twitter_exports.listPosts(client, { status: opts.status, limit: opts.limit, search: opts.search });
+      }
+      success(result, (d) => renderPostList(d));
+    } catch (err) {
+      fail(err);
+    }
+  });
+  post.command("update <id>").description("Update a scheduled post or draft").option("-p, --platform <platform>", "linkedin or x", "linkedin").option("-c, --content <text>", "New text (use '-' to read stdin)").option("--file <path>", "Read new text from a file").option("--schedule <iso>", "Reschedule to an ISO-8601 timestamp").option("--draft", "Target a draft instead of a scheduled post (LinkedIn)").action(async (id, opts) => {
+    try {
+      const platform = platformOf(opts.platform);
+      const content = opts.content !== void 0 || opts.file ? await resolveContent(opts) : void 0;
+      const { client } = await getContext();
+      let result;
+      if (platform === "linkedin") {
+        result = opts.draft ? await linkedin_exports.updateDraft(client, id, {
+          ...content !== void 0 ? { content } : {}
+        }) : await linkedin_exports.updateScheduledPost(client, id, {
+          ...content !== void 0 ? { content } : {},
+          ...opts.schedule ? { scheduledFor: opts.schedule } : {}
+        });
+      } else {
+        result = await twitter_exports.updatePost(client, id, {
+          ...content !== void 0 ? { threadTweets: [{ text: content }] } : {},
+          ...opts.schedule ? { scheduledFor: opts.schedule } : {}
+        });
+      }
+      success({ id, result }, () => `Updated ${platform} post ${id}.`);
+    } catch (err) {
+      fail(err);
+    }
+  });
+  post.command("delete <id>").description("Delete a scheduled post or draft").option("-p, --platform <platform>", "linkedin or x", "linkedin").option("--draft", "Delete a draft instead of a scheduled post").action(async (id, opts) => {
+    try {
+      const platform = platformOf(opts.platform);
+      const { client } = await getContext();
+      if (platform === "linkedin") {
+        await (opts.draft ? linkedin_exports.deleteDraft(client, id) : linkedin_exports.deletePost(client, id));
+      } else {
+        await (opts.draft ? twitter_exports.deleteDraft(client, id) : twitter_exports.deletePost(client, id));
+      }
+      success({ id, deleted: true }, () => `Deleted ${platform} ${opts.draft ? "draft" : "post"} ${id}.`);
+    } catch (err) {
+      fail(err);
+    }
+  });
+}
+function renderPostList(raw) {
+  const arr = Array.isArray(raw) ? raw : raw?.posts ?? raw?.drafts ?? raw?.items ?? [];
+  if (!arr.length) return "(none)";
+  return table(
+    arr.map((p) => ({
+      id: p.postId ?? p.post_id ?? p.draft_id ?? p.id ?? "",
+      status: p.status ?? (p.draft_id ? "draft" : ""),
+      when: p.scheduledFor ?? p.publishedAt ?? "",
+      text: String(p.content ?? p.title ?? "").replace(/\s+/g, " ").slice(0, 60)
+    })),
+    ["id", "status", "when", "text"]
+  );
+}
+// src/cli/commands/reddit.ts
+function registerRedditCommands(program2) {
+  const cmd = program2.command("reddit").description("Search Reddit and reply to submissions");
+  cmd.command("search <keyword>").description("Search Reddit for signals by keyword (Pro plan required)").action(async (keyword) => {
+    try {
+      const { client } = await getContext();
+      const result = await reddit_exports.search(client, keyword);
+      success(result, (d) => {
+        const posts = Array.isArray(d) ? d : d?.results ?? d?.posts ?? [];
+        if (!posts.length) return "(no results)";
+        return table(
+          posts.map((p) => ({
+            subreddit: p.subreddit ?? "",
+            score: p.score ?? p.opportunityScore ?? "",
+            title: String(p.title ?? "").slice(0, 70),
+            url: p.url ?? p.permalink ?? ""
+          })),
+          ["subreddit", "score", "title", "url"]
+        );
+      });
+    } catch (err) {
+      fail(err);
+    }
+  });
+  cmd.command("status").description("Show remaining Reddit search quota").action(async () => {
+    try {
+      const { client } = await getContext();
+      success(await reddit_exports.searchStatus(client));
+    } catch (err) {
+      fail(err);
+    }
+  });
+  cmd.command("reply <postUrlOrId>").description("Reply to a Reddit submission").option("-t, --text <text>", "Reply text (use '-' to read stdin)").option("--file <path>", "Read reply text from a file").action(async (postUrlOrId, opts) => {
+    try {
+      const text = await resolveContent({ content: opts.text, file: opts.file });
+      const target = resolvePostRef(postUrlOrId, "reddit");
+      const { client } = await getContext();
+      const result = await reddit_exports.comment(client, target.id, text);
+      success({ id: target.id, result }, (d) => `Replied to Reddit submission ${d.id}.`);
+    } catch (err) {
+      fail(err);
+    }
+  });
+}
+// src/cli/commands/schema.ts
+function serialize(cmd) {
+  const args = (cmd.registeredArguments ?? []).map((a) => ({
+    name: a.name(),
+    required: Boolean(a.required),
+    description: a.description || void 0
+  }));
+  return {
+    name: cmd.name(),
+    description: cmd.description(),
+    arguments: args,
+    options: cmd.options.map((o) => ({
+      flags: o.flags,
+      description: o.description,
+      ...o.defaultValue !== void 0 ? { defaultValue: o.defaultValue } : {}
+    })),
+    subcommands: cmd.commands.filter((c) => c.name() !== "help").map((c) => serialize(c))
+  };
+}
+function registerSchemaCommand(program2) {
+  program2.command("schema").description("Print the full command/flag tree as JSON (for agents and tooling)").action(() => {
+    success(serialize(program2));
+  });
+}
+// src/cli/commands/signals.ts
+function registerSignalsCommands(program2) {
+  const cmd = program2.command("signals").description("Your signals inbox (Reddit / YouTube / RSS / trends)");
+  cmd.command("list").description("List signals in your inbox").action(async () => {
+    try {
+      const { client } = await getContext();
+      const result = await signals_exports.getInbox(client);
+      success(result, (d) => {
+        const items = Array.isArray(d) ? d : d?.signals ?? d?.items ?? [];
+        if (!items.length) return "(no signals)";
+        return table(
+          items.map((s) => ({
+            source: s.source ?? s.type ?? "",
+            title: String(s.title ?? s.text ?? "").slice(0, 70),
+            url: s.url ?? s.link ?? ""
+          })),
+          ["source", "title", "url"]
+        );
+      });
+    } catch (err) {
+      fail(err);
+    }
+  });
+}
+// src/cli/commands/style.ts
+async function styleContext() {
+  const base = await getContext();
+  if (base.workspaceId) return base;
+  const workspaceId = await ensureWorkspaceId(base);
+  return getContext(workspaceId);
+}
+function registerStyleCommands(program2) {
+  const cmd = program2.command("style").description("View and train your writing styles");
+  cmd.command("get").description("Show writing-style summary for all facets").action(async () => {
+    try {
+      const { client } = await styleContext();
+      success(await writingStyle_exports.get(client));
+    } catch (err) {
+      fail(err);
+    }
+  });
+  cmd.command("set").description("Save override instructions for a facet").requiredOption("--facet <facet>", "posts | comments | messages").option("-i, --instructions <text>", "Override instructions (use '-' for stdin)").option("--file <path>", "Read instructions from a file").action(async (opts) => {
+    try {
+      const instructions = await resolveContent({ content: opts.instructions, file: opts.file });
+      const { client } = await styleContext();
+      const result = await writingStyle_exports.override(client, opts.facet, instructions);
+      success(result, () => `Saved ${opts.facet} style override.`);
+    } catch (err) {
+      fail(err);
+    }
+  });
+  cmd.command("train").description("(Re)synthesize a facet's writing style (Pro+; posts/comments only)").requiredOption("--facet <facet>", "posts | comments").action(async (opts) => {
+    try {
+      const { client } = await styleContext();
+      const result = await writingStyle_exports.train(client, opts.facet);
+      success(result, () => `Training started for ${opts.facet}.`);
+    } catch (err) {
+      fail(err);
+    }
+  });
+  cmd.command("test").description("Playground: compare baseline vs styled generation for a facet").requiredOption("--facet <facet>", "posts | comments | messages").option("-i, --input <text>", "Prompt input (use '-' for stdin)").option("--file <path>", "Read input from a file").action(async (opts) => {
+    try {
+      const input = await resolveContent({ content: opts.input, file: opts.file });
+      const { client } = await styleContext();
+      success(await writingStyle_exports.testVoiceStyle(client, opts.facet, input));
+    } catch (err) {
+      fail(err);
+    }
+  });
+}
+// src/cli/commands/voice.ts
+import { readFile as readFile4 } from "fs/promises";
+function registerVoiceCommands(program2) {
+  const cmd = program2.command("voice").description("View and update your voice profile");
+  cmd.command("get").description("Show the current voice profile").action(async () => {
+    try {
+      const { client } = await getContext();
+      success(await voice_exports.get(client));
+    } catch (err) {
+      fail(err);
+    }
+  });
+  cmd.command("update").description("Update the voice profile from a JSON file or flags").option("--file <path>", "JSON body to deep-merge (allowAutoUpdate, userInstructions, ...)").option("--active", "Set isActive true").option("--inactive", "Set isActive false").option("--allow-auto-update", "Allow the generated profile to auto-update").action(async (opts) => {
+    try {
+      let body = {};
+      if (opts.file) {
+        const parsed = JSON.parse(await readFile4(opts.file, "utf8"));
+        if (parsed && typeof parsed === "object") body = parsed;
+      }
+      if (opts.active) body.isActive = true;
+      if (opts.inactive) body.isActive = false;
+      if (opts.allowAutoUpdate) body.allowAutoUpdate = true;
+      if (Object.keys(body).length === 0) {
+        throw new Error("Nothing to update. Pass --file <json> or a flag (--active/--inactive/--allow-auto-update).");
+      }
+      const { client } = await getContext();
+      success(await voice_exports.update(client, body), () => "Voice profile updated.");
+    } catch (err) {
+      fail(err);
+    }
+  });
+}
+// src/cli/commands/workspace.ts
+function registerWorkspaceCommands(program2) {
+  const workspace = program2.command("workspace").alias("ws").description("List and switch the active workspace (organization)");
+  workspace.command("list").description("List your workspaces").action(async () => {
+    try {
+      const { client } = await getContext();
+      const list = await workspaces_exports.listWorkspaces(client);
+      const current = (await readConfig()).currentWorkspaceId;
+      success(
+        list.map((w) => ({ ...w, isCurrent: w.id === current })),
+        (rows) => table(
+          rows.map((w) => ({
+            current: w.isCurrent ? "*" : w.isDefault ? "d" : "",
+            id: w.id,
+            name: w.name ?? ""
+          })),
+          ["current", "id", "name"]
+        )
+      );
+    } catch (err) {
+      fail(err);
+    }
+  });
+  workspace.command("switch <workspaceId>").description("Set the active workspace used by subsequent commands").action(async (workspaceId) => {
+    try {
+      const { client } = await getContext();
+      const list = await workspaces_exports.listWorkspaces(client);
+      const match = list.find((w) => w.id === workspaceId);
+      if (!match) {
+        throw new Error(
+          `Workspace "${workspaceId}" not found. Run \`reepl workspace list\` to see valid ids.`
+        );
+      }
+      await writeConfig({ currentWorkspaceId: workspaceId });
+      success(
+        { currentWorkspaceId: workspaceId, name: match.name },
+        (d) => `Switched to workspace ${d.currentWorkspaceId}${d.name ? ` (${d.name})` : ""}.`
+      );
+    } catch (err) {
+      fail(err);
+    }
+  });
+  workspace.command("current").description("Show the active workspace").action(async () => {
+    try {
+      const config = await readConfig();
+      if (!config.currentWorkspaceId) {
+        success({ currentWorkspaceId: null }, () => "No workspace selected (using account default).");
+        return;
+      }
+      success(
+        { currentWorkspaceId: config.currentWorkspaceId },
+        (d) => `Current workspace: ${d.currentWorkspaceId}`
+      );
+    } catch (err) {
+      fail(err);
+    }
+  });
+}
+// src/cli/commands/x.ts
+function registerXCommands(program2) {
+  const cmd = program2.command("x").description("X (Twitter) engagement actions");
+  cmd.command("reply <tweetUrlOrId>").description("Publish a reply to a tweet (Premium)").option("-t, --text <text>", "Reply text (use '-' to read stdin)").option("--file <path>", "Read reply text from a file").action(async (tweetUrlOrId, opts) => {
+    try {
+      const text = await resolveContent({ content: opts.text, file: opts.file });
+      const { id } = resolvePostRef(tweetUrlOrId, "x");
+      const { client } = await getContext();
+      const result = await twitter_exports.reply(client, id, text);
+      success({ tweetId: id, result }, (d) => `Replied to tweet ${d.tweetId}.`);
+    } catch (err) {
+      fail(err);
+    }
+  });
+}
+// src/cli/index.ts
+var program = new Command();
+program.name("reepl").description("Reepl CLI \u2014 manage LinkedIn / X / Reddit content, carousels, signals, and more.").version("0.1.0").option("--json", "Output machine-readable JSON (auto-enabled when piped)").option("--no-json", "Force human-readable output even when piped").hook("preAction", (thisCommand) => {
+  const opts = thisCommand.opts();
+  setJsonMode(opts.json === void 0 ? void 0 : Boolean(opts.json));
+});
+program.exitOverride();
+program.configureOutput({
+  writeOut: (str) => process.stdout.write(str),
+  writeErr: () => {
+  }
+  // suppress commander's default error text; we emit the envelope
+});
+registerAuthCommands(program);
+registerWorkspaceCommands(program);
+registerPostCommands(program);
+registerCalendarCommands(program);
+registerCommentCommands(program);
+registerRedditCommands(program);
+registerSignalsCommands(program);
+registerCarouselCommands(program);
+registerStyleCommands(program);
+registerVoiceCommands(program);
+registerDmCommands(program);
+registerXCommands(program);
+registerSchemaCommand(program);
+if (process.argv.length <= 2) {
+  printBanner({ version: program.version() });
+  process.stdout.write("Run `reepl --help` to see all commands.\n");
+  process.exit(0);
+}
+program.parseAsync(process.argv).catch((err) => {
+  const code = err?.code;
+  if (code === "commander.helpDisplayed" || code === "commander.help" || code === "commander.version") {
+    process.exit(0);
+  }
+  const message = String(err?.message ?? "Invalid command usage.").replace(/^error:\s*/i, "");
+  fail(new ReeplError("VALIDATION", message));
+});
+//# sourceMappingURL=index.js.map