@harveyrandall/bsky-cli 1.0.0

package/dist/index.js

@@ -0,0 +1,1620 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/config.ts
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { homedir } from "os";
+import { join, dirname } from "path";
+import { existsSync } from "fs";
+import { readdirSync } from "fs";
+function configDir() {
+  return join(homedir(), ".config");
+}
+function bskyDir() {
+  return join(configDir(), "bsky");
+}
+function configPath(profile) {
+  if (profile) {
+    return join(bskyDir(), `config-${profile}.json`);
+  }
+  return join(bskyDir(), "config.json");
+}
+function authPath(handle, prefix = "") {
+  return join(bskyDir(), `${prefix}${handle}.auth`);
+}
+async function loadConfig(profile) {
+  if (profile === "?") {
+    listProfiles();
+    process.exit(0);
+  }
+  const fp = configPath(profile);
+  await mkdir(dirname(fp), { recursive: true });
+  let cfg = {
+    host: "https://bsky.social",
+    bgs: "https://bsky.network",
+    handle: "",
+    password: ""
+  };
+  try {
+    const data = await readFile(fp, "utf-8");
+    const fileCfg = JSON.parse(data);
+    cfg = { ...cfg, ...fileCfg };
+  } catch {
+  }
+  if (process.env.BSKY_HANDLE) cfg.handle = process.env.BSKY_HANDLE;
+  if (process.env.BSKY_PASSWORD) cfg.password = process.env.BSKY_PASSWORD;
+  if (process.env.BSKY_HOST) cfg.host = process.env.BSKY_HOST;
+  if (process.env.BSKY_BGS) cfg.bgs = process.env.BSKY_BGS;
+  if (!cfg.handle || !cfg.password) {
+    throw new Error(
+      "No credentials found. Run 'bsky login' or set BSKY_HANDLE and BSKY_PASSWORD."
+    );
+  }
+  return cfg;
+}
+async function saveConfig(config, profile) {
+  const fp = configPath(profile);
+  await mkdir(dirname(fp), { recursive: true });
+  await writeFile(fp, JSON.stringify(config, null, "  ") + "\n", {
+    mode: 420
+  });
+}
+function listProfiles() {
+  const dir = bskyDir();
+  if (!existsSync(dir)) return;
+  const files = readdirSync(dir);
+  for (const file of files) {
+    if (file.startsWith("config-") && file.endsWith(".json")) {
+      const name = file.slice(7, -5);
+      console.log(name);
+    }
+  }
+}
+
+// src/client.ts
+import { AtpAgent } from "@atproto/api";
+
+// src/auth.ts
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { createInterface } from "readline/promises";
+import { createWriteStream } from "fs";
+import { stdin, stdout, stderr } from "process";
+async function readAuth(handle, prefix = "") {
+  try {
+    const fp = authPath(handle, prefix);
+    const data = await readFile2(fp, "utf-8");
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}
+async function writeAuth(auth, handle, prefix = "") {
+  const fp = authPath(handle, prefix);
+  await writeFile2(fp, JSON.stringify(auth, null, "  ") + "\n", {
+    mode: 384
+  });
+}
+async function promptPassword() {
+  if (stdin.isTTY) {
+    stderr.write("Password: ");
+    const muted = createWriteStream("/dev/null");
+    const rl2 = createInterface({ input: stdin, output: muted });
+    const password2 = await rl2.question("");
+    rl2.close();
+    stderr.write("\n");
+    return password2.trim();
+  }
+  const rl = createInterface({ input: stdin });
+  const password = await rl.question("");
+  rl.close();
+  return password.trim();
+}
+async function prompt2FA() {
+  stderr.write(
+    "2FA is enabled. A sign-in code has been sent to your email.\nEnter the code: "
+  );
+  const rl = createInterface({ input: stdin, output: stdout });
+  const code = await rl.question("");
+  rl.close();
+  return code.trim();
+}
+
+// src/client.ts
+async function createClient(config, prefix = "") {
+  const agent = new AtpAgent({ service: config.host });
+  const auth = await readAuth(config.handle, prefix);
+  if (auth) {
+    try {
+      await agent.resumeSession({
+        did: auth.did,
+        handle: auth.handle,
+        accessJwt: auth.refreshJwt,
+        refreshJwt: auth.refreshJwt,
+        active: true
+      });
+      const refreshed = await agent.com.atproto.server.refreshSession(
+        void 0,
+        {
+          headers: {
+            authorization: `Bearer ${auth.refreshJwt}`
+          }
+        }
+      );
+      await agent.resumeSession({
+        did: refreshed.data.did,
+        handle: refreshed.data.handle,
+        accessJwt: refreshed.data.accessJwt,
+        refreshJwt: refreshed.data.refreshJwt,
+        active: true
+      });
+      await writeAuth(
+        {
+          did: refreshed.data.did,
+          handle: refreshed.data.handle,
+          accessJwt: refreshed.data.accessJwt,
+          refreshJwt: refreshed.data.refreshJwt
+        },
+        config.handle,
+        prefix
+      );
+      return agent;
+    } catch {
+    }
+  }
+  try {
+    const loginResponse = await agent.login({
+      identifier: config.handle,
+      password: config.password
+    });
+    await writeAuth(
+      {
+        did: loginResponse.data.did,
+        handle: loginResponse.data.handle,
+        accessJwt: loginResponse.data.accessJwt,
+        refreshJwt: loginResponse.data.refreshJwt
+      },
+      config.handle,
+      prefix
+    );
+    return agent;
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("AuthFactorTokenRequired")) {
+      const token = await prompt2FA();
+      const loginResponse = await agent.login({
+        identifier: config.handle,
+        password: config.password,
+        authFactorToken: token
+      });
+      await writeAuth(
+        {
+          did: loginResponse.data.did,
+          handle: loginResponse.data.handle,
+          accessJwt: loginResponse.data.accessJwt,
+          refreshJwt: loginResponse.data.refreshJwt
+        },
+        config.handle,
+        prefix
+      );
+      return agent;
+    }
+    throw new Error(`Cannot create session: ${err}`);
+  }
+}
+
+// src/commands/login.ts
+function registerLogin(program2) {
+  program2.command("login").description("Login to Bluesky").argument("<handle>", "Your Bluesky handle").argument("[password]", "Your app password (prompts if omitted)").option("--host <url>", "PDS host URL", "https://bsky.social").option("--bgs <url>", "BGS host URL", "https://bsky.network").action(
+    async (handle, password, opts) => {
+      const resolvedPassword = password ?? process.env.BSKY_PASSWORD ?? await promptPassword();
+      const profile = program2.opts().profile;
+      const config = {
+        host: opts.host,
+        bgs: opts.bgs,
+        handle,
+        password: resolvedPassword
+      };
+      await saveConfig(config, profile);
+    }
+  );
+}
+
+// src/commands/timeline.ts
+import chalk2 from "chalk";
+import WebSocket from "ws";
+
+// src/lib/format.ts
+import chalk from "chalk";
+function printPost(post) {
+  const rec = post.record;
+  process.stdout.write(chalk.redBright(post.author.handle));
+  process.stdout.write(` [${post.author.displayName ?? ""}]`);
+  console.log(` (${formatTime(rec.createdAt)})`);
+  console.log(rec.text);
+  if (post.embed) {
+    const images = post.embed;
+    if (images.images) {
+      for (const img of images.images) {
+        console.log(` {${img.fullsize}}`);
+      }
+    }
+  }
+  console.log(
+    ` \u{1F44D}(${post.likeCount ?? 0})\u26A1(${post.repostCount ?? 0})\u21A9\uFE0F (${post.replyCount ?? 0})`
+  );
+  if (rec.reply?.parent) {
+    process.stdout.write(" > ");
+    console.log(chalk.blue(rec.reply.parent.uri));
+  }
+  process.stdout.write(" - ");
+  console.log(chalk.blue(post.uri));
+  console.log();
+}
+function printActor(actor) {
+  process.stdout.write(chalk.redBright(actor.handle));
+  process.stdout.write(` [${actor.displayName ?? ""}] `);
+  console.log(chalk.blue(actor.did));
+}
+function formatTime(dateStr) {
+  const date = new Date(dateStr);
+  return date.toISOString();
+}
+function printStreamPost(did, handle, text, rkey, collection) {
+  const author = handle ?? did;
+  process.stdout.write(chalk.redBright(author));
+  console.log(`: ${text}`);
+  console.log(`  at://${did}/${collection}/${rkey}`);
+  console.log();
+}
+function outputJson(data) {
+  console.log(JSON.stringify(data));
+}
+
+// src/commands/timeline.ts
+var DEFAULT_JETSTREAM = "wss://jetstream1.us-east.bsky.network/subscribe";
+function registerTimeline(program2) {
+  program2.command("timeline").alias("tl").description("Show timeline").option("-H, --handle <handle>", "User handle").option("-n <count>", "Number of items", "30").action(async (opts) => {
+    const agent = await getClient(program2);
+    const json = isJson(program2);
+    const n = parseInt(opts.n, 10);
+    let feed = [];
+    let cursor;
+    while (true) {
+      if (opts.handle) {
+        const handle = opts.handle === "self" ? agent.session.did : opts.handle;
+        const resp = await agent.getAuthorFeed({
+          actor: handle,
+          cursor,
+          limit: n
+        });
+        feed.push(...resp.data.feed);
+        cursor = resp.data.cursor;
+      } else {
+        const resp = await agent.getTimeline({
+          cursor,
+          limit: n
+        });
+        feed.push(...resp.data.feed);
+        cursor = resp.data.cursor;
+      }
+      if (!cursor || feed.length > n) break;
+    }
+    feed.sort((a, b) => {
+      const ta = new Date(
+        a.post.record.createdAt
+      ).getTime();
+      const tb = new Date(
+        b.post.record.createdAt
+      ).getTime();
+      return ta - tb;
+    });
+    if (feed.length > n) {
+      feed = feed.slice(feed.length - n);
+    }
+    if (json) {
+      for (const p of feed) outputJson(p);
+    } else {
+      for (const p of feed) printPost(p.post);
+    }
+  });
+}
+function registerStream(program2) {
+  program2.command("stream").description("Stream live posts from the network").option("--cursor <cursor>", "Resume cursor (Unix microseconds)").option("-H, --handle <handle>", "Filter to a specific user").option("--pattern <regex>", "Filter post text by regex").option("--pattern-flags <flags>", "Regex flags for --pattern", "gi").option("--jetstream <url>", "Override Jetstream endpoint").action(
+    async (opts) => {
+      const json = isJson(program2);
+      const VALID_FLAGS = /* @__PURE__ */ new Set(["g", "i", "m", "s", "u", "v", "d", "y"]);
+      if (!opts.pattern && opts.patternFlags !== "gi") {
+        program2.error(`${chalk2.bgRed.white("Fatal error:")} --pattern-flags requires --pattern`);
+      }
+      if (opts.pattern) {
+        let flagChars = opts.patternFlags.split("");
+        const unknown = flagChars.filter((f) => !VALID_FLAGS.has(f));
+        if (unknown.length > 0) {
+          program2.error(`unknown regex flag(s): ${unknown.join(", ")}`);
+        }
+        const uniqueFlags = new Set(flagChars);
+        if (uniqueFlags.size !== flagChars.length) {
+          const dupes = flagChars.filter((f, i) => flagChars.indexOf(f) !== i);
+          console.warn(
+            `
+              ${chalk2.bgYellow.black("Warning:")} duplicate regex flag(s) removed: ${[...new Set(dupes)].join(", ")}`
+          );
+          flagChars = [...uniqueFlags];
+          opts.patternFlags = flagChars.join("");
+        }
+        if (flagChars.includes("u") && flagChars.includes("v")) {
+          program2.error(`${chalk2.bgRed.white("Fatal error:")}regex flags u and v cannot be used together`);
+        }
+        if (flagChars.includes("y") && flagChars.includes("g")) {
+          console.warn(`${chalk2.bgYellow.black("Warning:")} sticky flag (y) makes global flag (g) meaningless`);
+        }
+        if (flagChars.includes("u") && flagChars.includes("d")) {
+          console.warn(`${chalk2.bgYellow.black("Warning:")} unicode (u) with hasIndices (d) is valid but rarely needed`);
+        }
+      }
+      const wsUrl = new URL(opts.jetstream ?? DEFAULT_JETSTREAM);
+      wsUrl.searchParams.set("wantedCollections", "app.bsky.feed.post");
+      let filterHandle = null;
+      if (opts.handle) {
+        const agent = await getClient(program2);
+        if (opts.handle === "self") {
+          wsUrl.searchParams.set("wantedDids", agent.session.did);
+          filterHandle = agent.session.handle;
+        } else if (opts.handle.startsWith("did:")) {
+          wsUrl.searchParams.set("wantedDids", opts.handle);
+        } else {
+          const profile = await agent.getProfile({ actor: opts.handle });
+          wsUrl.searchParams.set("wantedDids", profile.data.did);
+          filterHandle = opts.handle;
+        }
+      }
+      if (opts.cursor) {
+        wsUrl.searchParams.set("cursor", opts.cursor);
+      }
+      let re = null;
+      if (opts.pattern) {
+        try {
+          re = new RegExp(opts.pattern, opts.patternFlags);
+        } catch (err) {
+          program2.error(`invalid regex pattern: ${err.message}`);
+        }
+      }
+      let lastCursor = "";
+      const ws = new WebSocket(wsUrl.toString());
+      process.on("SIGINT", () => {
+        if (lastCursor) {
+          console.error(`
+Cursor: ${lastCursor}`);
+        }
+        ws.close();
+        process.exit(0);
+      });
+      ws.on("message", (data) => {
+        try {
+          const event = JSON.parse(data.toString());
+          lastCursor = String(event.time_us);
+          if (event.kind !== "commit") return;
+          const commit = event.commit;
+          if (commit.operation !== "create") return;
+          if (commit.collection !== "app.bsky.feed.post") return;
+          const text = commit.record?.text;
+          if (!text) return;
+          if (re && !re.test(text)) return;
+          if (json) {
+            outputJson(event);
+          } else {
+            printStreamPost(
+              event.did,
+              filterHandle,
+              text,
+              commit.rkey,
+              commit.collection
+            );
+          }
+        } catch {
+        }
+      });
+      ws.on("error", (err) => {
+        console.error("WebSocket error:", err.message);
+        process.exit(1);
+      });
+      ws.on("close", () => {
+        if (lastCursor) {
+          console.error(`Cursor: ${lastCursor}`);
+        }
+        process.exit(0);
+      });
+      await new Promise(() => {
+      });
+    }
+  );
+}
+
+// src/commands/thread.ts
+function normalizeUri(uri) {
+  if (!uri.startsWith("at://did:plc:")) {
+    return "at://did:plc:" + uri;
+  }
+  return uri;
+}
+function registerThread(program2) {
+  program2.command("thread").description("Show thread").argument("<uri>", "Post URI").option("-n <count>", "Number of items", "30").action(async (uri, opts) => {
+    const agent = await getClient(program2);
+    const json = isJson(program2);
+    const depth = parseInt(opts.n, 10);
+    const resp = await agent.getPostThread({
+      uri: normalizeUri(uri),
+      depth
+    });
+    const thread = resp.data.thread;
+    if (json) {
+      outputJson(thread);
+      if (thread.replies) {
+        for (const r of thread.replies) outputJson(r);
+      }
+      return;
+    }
+    const replies = thread.replies ?? [];
+    replies.reverse();
+    printPost(thread.post);
+    for (const r of replies) {
+      if (r.post) printPost(r.post);
+    }
+  });
+}
+
+// src/commands/post.ts
+import { readFile as readFile3 } from "fs/promises";
+import { basename } from "path";
+import { stdin as stdin2 } from "process";
+import { load as cheerioLoad } from "cheerio";
+
+// src/lib/extract.ts
+var URL_PATTERN = /https?:\/\/[-A-Za-z0-9+&@#/%?=~_|!:,.;()]+/g;
+var MENTION_PATTERN = /@[a-zA-Z0-9.]+/g;
+var TAG_PATTERN = /\B#\S+/g;
+function byteLength(str) {
+  return new TextEncoder().encode(str).byteLength;
+}
+function extractWithByteOffsets(text, pattern, stripPrefix) {
+  const results = [];
+  let match;
+  pattern.lastIndex = 0;
+  while ((match = pattern.exec(text)) !== null) {
+    const before = text.slice(0, match.index);
+    const matchText = match[0];
+    const start = byteLength(before);
+    const end = start + byteLength(matchText);
+    const entryText = stripPrefix ? matchText.replace(new RegExp(`^${stripPrefix}`), "") : matchText;
+    results.push({ start, end, text: entryText });
+  }
+  return results;
+}
+function extractLinks(text) {
+  return extractWithByteOffsets(text, URL_PATTERN);
+}
+function extractMentions(text) {
+  return extractWithByteOffsets(text, MENTION_PATTERN, "@");
+}
+function extractTags(text) {
+  return extractWithByteOffsets(text, TAG_PATTERN, "#");
+}
+
+// src/commands/post.ts
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of stdin2) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf-8");
+}
+function detectMimeType(data) {
+  if (data[0] === 255 && data[1] === 216) return "image/jpeg";
+  if (data[0] === 137 && data[1] === 80 && data[2] === 78 && data[3] === 71)
+    return "image/png";
+  if (data[0] === 71 && data[1] === 73 && data[2] === 70)
+    return "image/gif";
+  if (data[0] === 82 && data[1] === 73 && data[2] === 70 && data[3] === 70)
+    return "image/webp";
+  if (data[4] === 102 && data[5] === 116 && data[6] === 121)
+    return "video/mp4";
+  return "application/octet-stream";
+}
+async function buildFacets(agent, text) {
+  const facets = [];
+  for (const entry of extractLinks(text)) {
+    facets.push({
+      index: { byteStart: entry.start, byteEnd: entry.end },
+      features: [
+        { $type: "app.bsky.richtext.facet#link", uri: entry.text }
+      ]
+    });
+  }
+  for (const entry of extractMentions(text)) {
+    try {
+      const profile = await agent.getProfile({ actor: entry.text });
+      facets.push({
+        index: { byteStart: entry.start, byteEnd: entry.end },
+        features: [
+          { $type: "app.bsky.richtext.facet#mention", did: profile.data.did }
+        ]
+      });
+    } catch {
+    }
+  }
+  for (const entry of extractTags(text)) {
+    facets.push({
+      index: { byteStart: entry.start, byteEnd: entry.end },
+      features: [
+        { $type: "app.bsky.richtext.facet#tag", tag: entry.text }
+      ]
+    });
+  }
+  return facets;
+}
+async function fetchLinkCard(agent, url) {
+  try {
+    const resp = await fetch(url);
+    if (!resp.ok) return null;
+    const html = await resp.text();
+    const $ = cheerioLoad(html);
+    let title = $("title").text();
+    let description = $('meta[property="description"]').attr("content") ?? "";
+    const imgURL = $('meta[property="og:image"]').attr("content");
+    if (!title) title = $('meta[property="og:title"]').attr("content") ?? url;
+    if (!description)
+      description = $('meta[property="og:description"]').attr("content") ?? url;
+    const external = {
+      uri: url,
+      title,
+      description
+    };
+    if (imgURL) {
+      try {
+        const imgResp = await fetch(imgURL);
+        if (imgResp.ok) {
+          const imgData = new Uint8Array(await imgResp.arrayBuffer());
+          const uploadResp = await agent.uploadBlob(imgData, {
+            encoding: detectMimeType(imgData)
+          });
+          external.thumb = uploadResp.data.blob;
+        }
+      } catch {
+      }
+    }
+    return { $type: "app.bsky.embed.external", external };
+  } catch {
+    return null;
+  }
+}
+async function createPost(agent, text, opts) {
+  const facets = await buildFacets(agent, text);
+  const post = {
+    $type: "app.bsky.feed.post",
+    text,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    facets: facets.length > 0 ? facets : void 0
+  };
+  if (opts.reply) {
+    post.reply = {
+      root: opts.replyRoot ?? opts.reply,
+      parent: opts.reply
+    };
+  }
+  if (opts.images && opts.images.length > 0) {
+    const images = [];
+    for (let i = 0; i < opts.images.length; i++) {
+      const data = await readFile3(opts.images[i]);
+      const uploadResp = await agent.uploadBlob(data, {
+        encoding: detectMimeType(data)
+      });
+      images.push({
+        alt: opts.imageAlts?.[i] ?? basename(opts.images[i]),
+        image: uploadResp.data.blob
+      });
+    }
+    post.embed = { $type: "app.bsky.embed.images", images };
+  }
+  if (opts.video) {
+    const data = await readFile3(opts.video);
+    const uploadResp = await agent.uploadBlob(data, {
+      encoding: detectMimeType(data)
+    });
+    post.embed = {
+      $type: "app.bsky.embed.video",
+      video: uploadResp.data.blob,
+      alt: opts.videoAlt ?? basename(opts.video)
+    };
+  }
+  if (opts.quote) {
+    post.embed = {
+      $type: "app.bsky.embed.record",
+      record: opts.quote
+    };
+  }
+  if (!post.embed) {
+    const links = extractLinks(text);
+    if (links.length > 0) {
+      const card = await fetchLinkCard(agent, links[0].text);
+      if (card) post.embed = card;
+    }
+  }
+  const resp = await agent.post(post);
+  return resp.uri;
+}
+function registerPost(program2) {
+  program2.command("post").description("Create a new post").argument("[text...]", "Post text").option("--stdin", "Read text from stdin").option("-i, --image <files...>", "Image files to attach").option("--image-alt <alts...>", "Alt text for images").option("--video <file>", "Video file to attach").option("--video-alt <alt>", "Alt text for video").action(
+    async (textParts, opts) => {
+      let text = textParts.join(" ");
+      if (opts.stdin) {
+        text = await readStdin();
+      }
+      if (!text.trim()) {
+        console.error("Error: post text is required");
+        process.exit(1);
+      }
+      const agent = await getClient(program2);
+      const uri = await createPost(agent, text, {
+        images: opts.image,
+        imageAlts: opts.imageAlt,
+        video: opts.video,
+        videoAlt: opts.videoAlt
+      });
+      console.log(uri);
+    }
+  );
+}
+function registerReply(program2) {
+  program2.command("reply").description("Reply to a post").argument("<uri>", "URI of the post to reply to").argument("<text...>", "Reply text").action(async (uri, textParts) => {
+    const text = textParts.join(" ");
+    const agent = await getClient(program2);
+    const atUri = uri.startsWith("at://") ? uri : `at://did:plc:${uri}`;
+    const parts = atUri.split("/");
+    const rkey = parts[parts.length - 1];
+    const collection = parts[parts.length - 2];
+    const did = parts[2];
+    const record = await agent.com.atproto.repo.getRecord({
+      repo: did,
+      collection,
+      rkey
+    });
+    const parent = {
+      uri: record.data.uri,
+      cid: record.data.cid
+    };
+    const parentPost = record.data.value;
+    const root = parentPost.reply?.root ?? parent;
+    const postUri = await createPost(agent, text, {
+      reply: parent,
+      replyRoot: root
+    });
+    console.log(postUri);
+  });
+}
+function registerQuote(program2) {
+  program2.command("quote").description("Quote a post").argument("<uri>", "URI of the post to quote").argument("<text...>", "Quote text").action(async (uri, textParts) => {
+    const text = textParts.join(" ");
+    const agent = await getClient(program2);
+    const atUri = uri.startsWith("at://") ? uri : `at://did:plc:${uri}`;
+    const parts = atUri.split("/");
+    const rkey = parts[parts.length - 1];
+    const collection = parts[parts.length - 2];
+    const did = parts[2];
+    const record = await agent.com.atproto.repo.getRecord({
+      repo: did,
+      collection,
+      rkey
+    });
+    const postUri = await createPost(agent, text, {
+      quote: {
+        uri: record.data.uri,
+        cid: record.data.cid
+      }
+    });
+    console.log(postUri);
+  });
+}
+
+// src/commands/delete.ts
+function registerDelete(program2) {
+  program2.command("delete").description("Delete a post").argument("<uri...>", "Post URI(s) to delete").action(async (uris) => {
+    const agent = await getClient(program2);
+    for (const uri of uris) {
+      const atUri = uri.startsWith("at://") ? uri : `at://did:plc:${uri}`;
+      const parts = atUri.split("/");
+      if (parts.length < 3) {
+        console.error(`Invalid post URI: ${uri}`);
+        continue;
+      }
+      const rkey = parts[parts.length - 1];
+      const collection = parts[parts.length - 2];
+      await agent.com.atproto.repo.deleteRecord({
+        repo: agent.session.did,
+        collection,
+        rkey
+      });
+    }
+  });
+}
+
+// src/commands/like.ts
+import chalk3 from "chalk";
+function registerLike(program2) {
+  program2.command("like").description("Like a post").argument("<uri...>", "Post URI(s) to like").action(async (uris) => {
+    const agent = await getClient(program2);
+    for (const uri of uris) {
+      const atUri = uri.startsWith("at://") ? uri : `at://did:plc:${uri}`;
+      const parts = atUri.split("/");
+      const rkey = parts[parts.length - 1];
+      const collection = parts[parts.length - 2];
+      const did = parts[2];
+      const record = await agent.com.atproto.repo.getRecord({
+        repo: did,
+        collection,
+        rkey
+      });
+      const resp = await agent.like(record.data.uri, record.data.cid);
+      console.log(resp.uri);
+    }
+  });
+}
+function registerLikes(program2) {
+  program2.command("likes").description("Show likes on a post").argument("<uri>", "Post URI").action(async (uri) => {
+    const agent = await getClient(program2);
+    const json = isJson(program2);
+    const atUri = uri.startsWith("at://") ? uri : `at://did:plc:${uri}`;
+    const parts = atUri.split("/");
+    const rkey = parts[parts.length - 1];
+    const collection = parts[parts.length - 2];
+    const did = parts[2];
+    const record = await agent.com.atproto.repo.getRecord({
+      repo: did,
+      collection,
+      rkey
+    });
+    const resp = await agent.getLikes({
+      uri: record.data.uri,
+      cid: record.data.cid,
+      limit: 50
+    });
+    if (json) {
+      for (const v of resp.data.likes) outputJson(v);
+      return;
+    }
+    for (const v of resp.data.likes) {
+      process.stdout.write("\u{1F44D} ");
+      process.stdout.write(chalk3.redBright(v.actor.handle));
+      process.stdout.write(` [${v.actor.displayName ?? ""}]`);
+      console.log(` (${v.createdAt})`);
+    }
+  });
+}
+
+// src/commands/repost.ts
+import chalk4 from "chalk";
+function registerRepost(program2) {
+  program2.command("repost").description("Repost a post").argument("<uri...>", "Post URI(s) to repost").action(async (uris) => {
+    const agent = await getClient(program2);
+    for (const uri of uris) {
+      const atUri = uri.startsWith("at://") ? uri : `at://did:plc:${uri}`;
+      const parts = atUri.split("/");
+      const rkey = parts[parts.length - 1];
+      const collection = parts[parts.length - 2];
+      const did = parts[2];
+      const record = await agent.com.atproto.repo.getRecord({
+        repo: did,
+        collection,
+        rkey
+      });
+      const resp = await agent.repost(record.data.uri, record.data.cid);
+      console.log(resp.uri);
+    }
+  });
+}
+function registerReposts(program2) {
+  program2.command("reposts").description("Show reposts of a post").argument("<uri>", "Post URI").action(async (uri) => {
+    const agent = await getClient(program2);
+    const json = isJson(program2);
+    const atUri = uri.startsWith("at://") ? uri : `at://did:plc:${uri}`;
+    const parts = atUri.split("/");
+    const rkey = parts[parts.length - 1];
+    const collection = parts[parts.length - 2];
+    const did = parts[2];
+    const record = await agent.com.atproto.repo.getRecord({
+      repo: did,
+      collection,
+      rkey
+    });
+    const resp = await agent.getRepostedBy({
+      uri: record.data.uri,
+      cid: record.data.cid,
+      limit: 50
+    });
+    if (json) {
+      for (const r of resp.data.repostedBy) outputJson(r);
+      return;
+    }
+    for (const r of resp.data.repostedBy) {
+      process.stdout.write("\u26A1 ");
+      process.stdout.write(chalk4.redBright(r.handle));
+      console.log(` [${r.displayName ?? ""}]`);
+    }
+  });
+}
+
+// src/commands/social.ts
+async function resolveDid(agent, handleOrDid) {
+  if (handleOrDid.startsWith("did:")) return handleOrDid;
+  const profile = await agent.getProfile({ actor: handleOrDid });
+  return profile.data.did;
+}
+function registerFollow(program2) {
+  program2.command("follow").description("Follow user(s)").argument("<handles...>", "Handle(s) to follow").action(async (handles) => {
+    const agent = await getClient(program2);
+    for (const handle of handles) {
+      const profile = await agent.getProfile({ actor: handle });
+      const resp = await agent.follow(profile.data.did);
+      console.log(resp.uri);
+    }
+  });
+}
+function registerUnfollow(program2) {
+  program2.command("unfollow").description("Unfollow user(s)").argument("<handles...>", "Handle(s) to unfollow").action(async (handles) => {
+    const agent = await getClient(program2);
+    for (const handle of handles) {
+      const profile = await agent.getProfile({ actor: handle });
+      const followUri = profile.data.viewer?.following;
+      if (!followUri) continue;
+      const parts = followUri.split("/");
+      const rkey = parts[parts.length - 1];
+      const collection = parts[parts.length - 2];
+      console.log(followUri);
+      await agent.com.atproto.repo.deleteRecord({
+        repo: agent.session.did,
+        collection,
+        rkey
+      });
+    }
+  });
+}
+function registerFollows(program2) {
+  program2.command("follows").description("Show follows").option("-H, --handle <handle>", "User handle").action(async (opts) => {
+    const agent = await getClient(program2);
+    const json = isJson(program2);
+    const handle = opts.handle ?? agent.session.handle;
+    let cursor;
+    while (true) {
+      const resp = await agent.getFollows({
+        actor: handle,
+        cursor,
+        limit: 100
+      });
+      if (json) {
+        for (const f of resp.data.follows) outputJson(f);
+      } else {
+        for (const f of resp.data.follows) printActor(f);
+      }
+      cursor = resp.data.cursor;
+      if (!cursor) break;
+    }
+  });
+}
+function registerFollowers(program2) {
+  program2.command("followers").description("Show followers").option("-H, --handle <handle>", "User handle").action(async (opts) => {
+    const agent = await getClient(program2);
+    const json = isJson(program2);
+    const handle = opts.handle ?? agent.session.handle;
+    let cursor;
+    while (true) {
+      const resp = await agent.getFollowers({
+        actor: handle,
+        cursor,
+        limit: 100
+      });
+      if (json) {
+        for (const f of resp.data.followers) outputJson(f);
+      } else {
+        for (const f of resp.data.followers) printActor(f);
+      }
+      cursor = resp.data.cursor;
+      if (!cursor) break;
+    }
+  });
+}
+function registerBlock(program2) {
+  program2.command("block").description("Block user(s)").argument("<handles...>", "Handle(s) or DID(s) to block").action(async (handles) => {
+    const agent = await getClient(program2);
+    for (const handle of handles) {
+      const did = await resolveDid(agent, handle);
+      const resp = await agent.com.atproto.repo.createRecord({
+        repo: agent.session.did,
+        collection: "app.bsky.graph.block",
+        record: {
+          $type: "app.bsky.graph.block",
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          subject: did
+        }
+      });
+      console.log(resp.data.uri);
+    }
+  });
+}
+function registerUnblock(program2) {
+  program2.command("unblock").description("Unblock user(s)").argument("<handles...>", "Handle(s) to unblock").action(async (handles) => {
+    const agent = await getClient(program2);
+    for (const handle of handles) {
+      const profile = await agent.getProfile({ actor: handle });
+      const blockUri = profile.data.viewer?.blocking;
+      if (!blockUri) continue;
+      const parts = blockUri.split("/");
+      const rkey = parts[parts.length - 1];
+      const collection = parts[parts.length - 2];
+      console.log(blockUri);
+      await agent.com.atproto.repo.deleteRecord({
+        repo: agent.session.did,
+        collection,
+        rkey
+      });
+    }
+  });
+}
+function registerBlocks(program2) {
+  program2.command("blocks").description("Show blocked users").option("-H, --handle <handle>", "User handle").action(async () => {
+    const agent = await getClient(program2);
+    const json = isJson(program2);
+    let cursor;
+    while (true) {
+      const resp = await agent.app.bsky.graph.getBlocks({
+        cursor,
+        limit: 100
+      });
+      if (json) {
+        for (const b of resp.data.blocks) outputJson(b);
+      } else {
+        for (const b of resp.data.blocks) printActor(b);
+      }
+      cursor = resp.data.cursor;
+      if (!cursor) break;
+    }
+  });
+}
+function registerMute(program2) {
+  program2.command("mute").description("Mute user(s)").argument("<handles...>", "Handle(s) or DID(s) to mute").action(async (handles) => {
+    const agent = await getClient(program2);
+    for (const handle of handles) {
+      const did = await resolveDid(agent, handle);
+      await agent.mute(did);
+    }
+  });
+}
+
+// src/commands/search.ts
+function registerSearch(program2) {
+  program2.command("search").description("Search posts").argument("<terms...>", "Search terms").option("-n <count>", "Number of results", "100").action(async (terms, opts) => {
+    const agent = await getClient(program2);
+    const json = isJson(program2);
+    const n = parseInt(opts.n, 10);
+    const query = terms.join(" ");
+    let results = [];
+    let cursor;
+    while (true) {
+      const resp = await agent.app.bsky.feed.searchPosts({
+        q: query,
+        cursor,
+        limit: 100
+      });
+      results.push(...resp.data.posts);
+      cursor = resp.data.cursor;
+      if (!cursor || results.length > n) break;
+    }
+    results.sort((a, b) => {
+      const ta = new Date(
+        a.record.createdAt
+      ).getTime();
+      const tb = new Date(
+        b.record.createdAt
+      ).getTime();
+      return ta - tb;
+    });
+    if (results.length > n) {
+      results = results.slice(results.length - n);
+    }
+    if (json) {
+      for (const p of results) outputJson(p);
+    } else {
+      for (const p of results) printPost(p);
+    }
+  });
+}
+function registerSearchUsers(program2) {
+  program2.command("search-users").description("Search for users").argument("<terms...>", "Search terms").option("-n <count>", "Number of results", "100").action(async (terms, opts) => {
+    const agent = await getClient(program2);
+    const n = parseInt(opts.n, 10);
+    const query = terms.join(" ");
+    const resp = await agent.searchActors({
+      term: query,
+      limit: n
+    });
+    for (const actor of resp.data.actors) {
+      outputJson(actor);
+    }
+  });
+}
+
+// src/commands/profile.ts
+import { readFile as readFile4 } from "fs/promises";
+function detectMimeType2(data) {
+  if (data[0] === 255 && data[1] === 216) return "image/jpeg";
+  if (data[0] === 137 && data[1] === 80 && data[2] === 78 && data[3] === 71)
+    return "image/png";
+  if (data[0] === 71 && data[1] === 73 && data[2] === 70)
+    return "image/gif";
+  return "application/octet-stream";
+}
+function registerProfile(program2) {
+  program2.command("profile").description("Show profile").option("-H, --handle <handle>", "User handle").action(async (opts) => {
+    const agent = await getClient(program2);
+    const json = isJson(program2);
+    const handle = opts.handle ?? agent.session.handle;
+    const resp = await agent.getProfile({ actor: handle });
+    const profile = resp.data;
+    if (json) {
+      outputJson(profile);
+      return;
+    }
+    console.log(`Did: ${profile.did}`);
+    console.log(`Handle: ${profile.handle}`);
+    console.log(`DisplayName: ${profile.displayName ?? ""}`);
+    console.log(`Description: ${profile.description ?? ""}`);
+    console.log(`Follows: ${profile.followsCount ?? 0}`);
+    console.log(`Followers: ${profile.followersCount ?? 0}`);
+    console.log(`Avatar: ${profile.avatar ?? ""}`);
+    console.log(`Banner: ${profile.banner ?? ""}`);
+  });
+}
+function registerProfileUpdate(program2) {
+  program2.command("profile-update").description("Update profile").argument("[displayname]", "Display name").argument("[description]", "Description").option("--avatar <file>", "Avatar image file").option("--banner <file>", "Banner image file").action(
+    async (displayName, description, opts) => {
+      if (!displayName && !description && !opts.avatar && !opts.banner) {
+        console.error("Error: provide at least one field to update");
+        process.exit(1);
+      }
+      const agent = await getClient(program2);
+      const current = await agent.getProfile({
+        actor: agent.session.handle
+      });
+      const name = displayName ?? current.data.displayName;
+      const desc = description ?? current.data.description;
+      let avatar = void 0;
+      if (opts.avatar) {
+        const data = await readFile4(opts.avatar);
+        const uploadResp = await agent.uploadBlob(data, {
+          encoding: detectMimeType2(data)
+        });
+        avatar = uploadResp.data.blob;
+      }
+      let banner = void 0;
+      if (opts.banner) {
+        const data = await readFile4(opts.banner);
+        const uploadResp = await agent.uploadBlob(data, {
+          encoding: detectMimeType2(data)
+        });
+        banner = uploadResp.data.blob;
+      }
+      const currentRecord = await agent.com.atproto.repo.getRecord({
+        repo: agent.session.did,
+        collection: "app.bsky.actor.profile",
+        rkey: "self"
+      });
+      await agent.com.atproto.repo.putRecord({
+        repo: agent.session.did,
+        collection: "app.bsky.actor.profile",
+        rkey: "self",
+        record: {
+          $type: "app.bsky.actor.profile",
+          displayName: name,
+          description: desc,
+          ...avatar ? { avatar } : {},
+          ...banner ? { banner } : {}
+        },
+        swapRecord: currentRecord.data.cid
+      });
+    }
+  );
+}
+function registerSession(program2) {
+  program2.command("session").description("Show session info").action(async () => {
+    const agent = await getClient(program2);
+    const json = isJson(program2);
+    const resp = await agent.com.atproto.server.getSession();
+    const session = resp.data;
+    if (json) {
+      outputJson(session);
+      return;
+    }
+    console.log(`Did: ${session.did}`);
+    console.log(`Email: ${session.email ?? ""}`);
+    console.log(`Handle: ${session.handle}`);
+  });
+}
+
+// src/commands/notification.ts
+import chalk5 from "chalk";
+function registerNotifs(program2) {
+  program2.command("notifs").alias("notification").description("Show notifications").option("-a, --all", "Show all (including read)").action(async (opts) => {
+    const agent = await getClient(program2);
+    const json = isJson(program2);
+    const resp = await agent.listNotifications({ limit: 50 });
+    const notifs = resp.data.notifications;
+    if (json) {
+      for (const n of notifs) outputJson(n);
+      return;
+    }
+    for (const n of notifs) {
+      if (!opts.all && n.isRead) continue;
+      process.stdout.write(chalk5.redBright(n.author.handle));
+      process.stdout.write(` [${n.author.displayName ?? ""}] `);
+      console.log(chalk5.blue(n.author.did));
+      const record = n.record;
+      switch (record.$type) {
+        case "app.bsky.feed.post":
+          console.log(` ${n.reason} to ${n.uri}`);
+          break;
+        case "app.bsky.feed.repost": {
+          const repost = record;
+          console.log(` reposted ${repost.subject.uri}`);
+          break;
+        }
+        case "app.bsky.feed.like": {
+          const like = record;
+          console.log(` liked ${like.subject.uri}`);
+          break;
+        }
+        case "app.bsky.graph.follow":
+          console.log(" followed you");
+          break;
+      }
+    }
+    await agent.app.bsky.notification.updateSeen({
+      seenAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  });
+}
+
+// src/commands/moderation.ts
+async function resolveDid2(agent, handleOrDid) {
+  if (handleOrDid.startsWith("did:")) return handleOrDid;
+  const profile = await agent.getProfile({ actor: handleOrDid });
+  return profile.data.did;
+}
+function registerReport(program2) {
+  program2.command("report").description("Report a user").argument("<handle>", "Handle or DID to report").option("--comment <text>", "Report comment").action(async (handle, opts) => {
+    const agent = await getClient(program2);
+    const did = await resolveDid2(agent, handle);
+    const resp = await agent.com.atproto.moderation.createReport({
+      reasonType: "com.atproto.moderation.defs#reasonSpam",
+      subject: {
+        $type: "com.atproto.admin.defs#repoRef",
+        did
+      },
+      reason: opts.comment
+    });
+    console.log("Report created successfully:", JSON.stringify(resp.data));
+  });
+}
+function registerModList(program2) {
+  program2.command("mod-list").description("Create a moderation list with user(s)").argument("<handles...>", "Handle(s) or DID(s) to add").option("--name <name>", "List name", "NewList").option("--desc <description>", "List description", "").action(
+    async (handles, opts) => {
+      const agent = await getClient(program2);
+      const listResp = await agent.com.atproto.repo.createRecord({
+        repo: agent.session.did,
+        collection: "app.bsky.graph.list",
+        record: {
+          $type: "app.bsky.graph.list",
+          name: opts.name,
+          purpose: "app.bsky.graph.defs#modlist",
+          description: opts.desc,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      });
+      console.log("List created successfully. URI:", listResp.data.uri);
+      for (const handle of handles) {
+        const did = await resolveDid2(agent, handle);
+        await agent.com.atproto.repo.createRecord({
+          repo: agent.session.did,
+          collection: "app.bsky.graph.listitem",
+          record: {
+            $type: "app.bsky.graph.listitem",
+            subject: did,
+            list: listResp.data.uri,
+            createdAt: (/* @__PURE__ */ new Date()).toISOString()
+          }
+        });
+        console.log("User added to moderation list successfully.");
+      }
+    }
+  );
+}
+
+// src/commands/bookmark.ts
+import { AppBskyFeedDefs } from "@atproto/api";
+function registerBookmarks(program2) {
+  const bookmarks = program2.command("bookmarks").description("Manage bookmarks");
+  bookmarks.command("create").description("Bookmark a post").argument("<uri...>", "Post URI(s) to bookmark").action(async (uris) => {
+    const agent = await getClient(program2);
+    for (const uri of uris) {
+      const atUri = uri.startsWith("at://") ? uri : `at://did:plc:${uri}`;
+      const parts = atUri.split("/");
+      const rkey = parts[parts.length - 1];
+      const collection = parts[parts.length - 2];
+      const did = parts[2];
+      const record = await agent.com.atproto.repo.getRecord({
+        repo: did,
+        collection,
+        rkey
+      });
+      await agent.app.bsky.bookmark.createBookmark({
+        uri: record.data.uri,
+        cid: record.data.cid
+      });
+      console.log(record.data.uri);
+    }
+  });
+  bookmarks.command("delete").description("Remove a bookmark").argument("<uri...>", "Post URI(s) to unbookmark").action(async (uris) => {
+    const agent = await getClient(program2);
+    for (const uri of uris) {
+      const atUri = uri.startsWith("at://") ? uri : `at://did:plc:${uri}`;
+      await agent.app.bsky.bookmark.deleteBookmark({ uri: atUri });
+      console.log(atUri);
+    }
+  });
+  bookmarks.command("get").description("List bookmarked posts").option("-n, --count <number>", "Number of bookmarks to show", "50").action(async (opts) => {
+    const agent = await getClient(program2);
+    const json = isJson(program2);
+    const limit = parseInt(opts.count, 10);
+    let cursor;
+    let remaining = limit;
+    do {
+      const resp = await agent.app.bsky.bookmark.getBookmarks({
+        limit: Math.min(remaining, 50),
+        cursor
+      });
+      for (const bookmark of resp.data.bookmarks) {
+        if (json) {
+          outputJson(bookmark);
+        } else if (AppBskyFeedDefs.isPostView(bookmark.item)) {
+          printPost(bookmark.item);
+        }
+      }
+      remaining -= resp.data.bookmarks.length;
+      cursor = resp.data.cursor;
+    } while (cursor && remaining > 0);
+  });
+}
+
+// src/commands/password.ts
+function registerAppPassword(program2) {
+  const appPw = program2.command("app-password").description("Manage app passwords");
+  appPw.command("list").description("List app passwords").action(async () => {
+    const agent = await getClient(program2);
+    const json = isJson(program2);
+    const resp = await agent.com.atproto.server.listAppPasswords();
+    const passwords = resp.data.passwords;
+    if (json) {
+      for (const pw of passwords) outputJson(pw);
+      return;
+    }
+    for (const pw of passwords) {
+      console.log(`${pw.name} (${pw.createdAt})`);
+    }
+  });
+  appPw.command("add").description("Create an app password").argument("<name>", "Password name").action(async (name) => {
+    const agent = await getClient(program2);
+    const json = isJson(program2);
+    const resp = await agent.com.atproto.server.createAppPassword({
+      name
+    });
+    if (json) {
+      outputJson(resp.data);
+    } else {
+      console.log(`${resp.data.name}: ${resp.data.password}`);
+    }
+  });
+  appPw.command("revoke").description("Revoke an app password").argument("<name>", "Password name").action(async (name) => {
+    const agent = await getClient(program2);
+    await agent.com.atproto.server.revokeAppPassword({ name });
+  });
+}
+
+// src/commands/invite.ts
+import chalk6 from "chalk";
+function registerInviteCodes(program2) {
+  program2.command("invite-codes").description("Show invite codes").option("--used", "Show used codes too").action(async (opts) => {
+    const agent = await getClient(program2);
+    const json = isJson(program2);
+    const resp = await agent.com.atproto.server.getAccountInviteCodes({
+      includeUsed: opts.used ?? false
+    });
+    const codes = resp.data.codes;
+    if (json) {
+      for (const c of codes) outputJson(c);
+      return;
+    }
+    for (const c of codes) {
+      if (c.uses.length >= c.available) {
+        console.log(chalk6.magentaBright(`${c.code} (used)`));
+      } else {
+        console.log(c.code);
+      }
+    }
+  });
+}
+
+// src/commands/completions.ts
+function getCommands(program2) {
+  return program2.commands.map((cmd) => ({
+    name: cmd.name(),
+    aliases: cmd.aliases(),
+    description: cmd.description(),
+    options: cmd.options.map((opt) => ({
+      short: opt.short?.replace(/^-/, "") || void 0,
+      long: opt.long?.replace(/^--/, "") || void 0,
+      description: opt.description
+    }))
+  }));
+}
+function getGlobalOptions(program2) {
+  return program2.options.map((opt) => ({
+    short: opt.short?.replace(/^-/, "") || void 0,
+    long: opt.long?.replace(/^--/, "") || void 0,
+    description: opt.description
+  }));
+}
+function optionFlag(opt) {
+  return opt.long ? `--${opt.long}` : `-${opt.short}`;
+}
+function generateBash(program2) {
+  const commands = getCommands(program2);
+  const globalOpts = getGlobalOptions(program2);
+  const cmdNames = commands.flatMap((c) => [c.name, ...c.aliases]).join(" ");
+  const globalFlags = globalOpts.map((o) => optionFlag(o)).join(" ");
+  const caseClauses = commands.map((cmd) => {
+    const names = [cmd.name, ...cmd.aliases];
+    const opts = cmd.options.map((o) => optionFlag(o)).join(" ");
+    return names.map((n) => `        ${n}) opts="${opts}" ;;`).join("\n");
+  }).join("\n");
+  const subcommandClauses = commands.filter((cmd) => {
+    const programCmd = program2.commands.find((c) => c.name() === cmd.name);
+    return programCmd && programCmd.commands.length > 0;
+  }).map((cmd) => {
+    const programCmd = program2.commands.find((c) => c.name() === cmd.name);
+    const subNames = programCmd.commands.map((sub) => sub.name()).join(" ");
+    return `        ${cmd.name}) opts="${subNames}" ;;`;
+  }).join("\n");
+  return `#!/bin/bash
+
+_bsky_completions() {
+    local cur prev commands global_opts opts
+    COMPREPLY=()
+    cur="\${COMP_WORDS[COMP_CWORD]}"
+    prev="\${COMP_WORDS[COMP_CWORD-1]}"
+    commands="${cmdNames}"
+    global_opts="${globalFlags} --help --version"
+
+    if [[ \${COMP_CWORD} -eq 1 ]]; then
+        COMPREPLY=( $(compgen -W "\${commands} \${global_opts}" -- "\${cur}") )
+        return 0
+    fi
+
+    case "\${COMP_WORDS[1]}" in
+${caseClauses}
+${subcommandClauses}
+        *) opts="" ;;
+    esac
+
+    COMPREPLY=( $(compgen -W "\${opts} --help" -- "\${cur}") )
+    return 0
+}
+
+complete -F _bsky_completions bsky
+`;
+}
+function generateZsh(program2) {
+  const commands = getCommands(program2);
+  const globalOpts = getGlobalOptions(program2);
+  const cmdList = commands.map((c) => {
+    const desc = c.description.replace(/'/g, "'\\''");
+    return `        '${c.name}:${desc}'`;
+  }).join("\n");
+  const globalOptsList = globalOpts.map((o) => {
+    const desc = o.description.replace(/'/g, "'\\''");
+    return `        '${optionFlag(o)}[${desc}]'`;
+  }).join("\n");
+  const subcmdFunctions = commands.map((cmd) => {
+    const opts = cmd.options.map((o) => {
+      const desc = o.description.replace(/'/g, "'\\''");
+      return `            '${optionFlag(o)}[${desc}]'`;
+    }).join("\n");
+    const programCmd = program2.commands.find((c) => c.name() === cmd.name);
+    const subCommands = programCmd?.commands ?? [];
+    if (subCommands.length > 0) {
+      const subList = subCommands.map((sub) => {
+        const desc = sub.description().replace(/'/g, "'\\''");
+        return `            '${sub.name()}:${desc}'`;
+      }).join("\n");
+      return `    ${cmd.name})
+        local -a subcommands
+        subcommands=(
+${subList}
+        )
+        _describe 'subcommand' subcommands
+        ;;`;
+    }
+    if (!opts) return `    ${cmd.name}) ;;`;
+    return `    ${cmd.name})
+        _arguments \\
+${opts}
+        ;;`;
+  }).join("\n");
+  return `#compdef bsky
+
+_bsky() {
+    local -a commands
+    commands=(
+${cmdList}
+    )
+
+    _arguments \\
+${globalOptsList} \\
+        '1:command:->command' \\
+        '*::arg:->args'
+
+    case $state in
+    command)
+        _describe 'command' commands
+        ;;
+    args)
+        case $words[1] in
+${subcmdFunctions}
+        esac
+        ;;
+    esac
+}
+
+_bsky "$@"
+`;
+}
+function generateFish(program2) {
+  const commands = getCommands(program2);
+  const globalOpts = getGlobalOptions(program2);
+  const lines = [
+    "# Fish completions for bsky",
+    "# Generated by: bsky completions fish",
+    "",
+    "# Disable file completions by default",
+    "complete -c bsky -f",
+    ""
+  ];
+  for (const opt of globalOpts) {
+    const desc = opt.description.replace(/'/g, "\\'");
+    const parts = [`complete -c bsky -n '__fish_use_subcommand'`];
+    if (opt.long) parts.push(`-l ${opt.long}`);
+    if (opt.short) parts.push(`-s ${opt.short}`);
+    parts.push(`-d '${desc}'`);
+    lines.push(parts.join(" "));
+  }
+  lines.push("");
+  for (const cmd of commands) {
+    const desc = cmd.description.replace(/'/g, "\\'");
+    lines.push(
+      `complete -c bsky -n '__fish_use_subcommand' -a ${cmd.name} -d '${desc}'`
+    );
+    for (const alias of cmd.aliases) {
+      lines.push(
+        `complete -c bsky -n '__fish_use_subcommand' -a ${alias} -d '${desc}'`
+      );
+    }
+    for (const opt of cmd.options) {
+      const optDesc = opt.description.replace(/'/g, "\\'");
+      const parts = [`complete -c bsky -n '__fish_seen_subcommand_from ${cmd.name}'`];
+      if (opt.long) parts.push(`-l ${opt.long}`);
+      if (opt.short) parts.push(`-s ${opt.short}`);
+      parts.push(`-d '${optDesc}'`);
+      lines.push(parts.join(" "));
+    }
+    const programCmd = program2.commands.find((c) => c.name() === cmd.name);
+    if (programCmd && programCmd.commands.length > 0) {
+      for (const sub of programCmd.commands) {
+        const subDesc = sub.description().replace(/'/g, "\\'");
+        lines.push(
+          `complete -c bsky -n '__fish_seen_subcommand_from ${cmd.name}' -a ${sub.name()} -d '${subDesc}'`
+        );
+      }
+    }
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function registerCompletions(program2) {
+  program2.command("completions").description("Generate shell completion script").argument("<shell>", "Shell type: bash, zsh, or fish").action((shell) => {
+    switch (shell) {
+      case "bash":
+        process.stdout.write(generateBash(program2));
+        break;
+      case "zsh":
+        process.stdout.write(generateZsh(program2));
+        break;
+      case "fish":
+        process.stdout.write(generateFish(program2));
+        break;
+      default:
+        console.error(
+          `Unknown shell: ${shell}. Supported: bash, zsh, fish`
+        );
+        process.exit(1);
+    }
+  });
+}
+
+// src/index.ts
+var program = new Command();
+program.name("bsky").description("A CLI client for Bluesky").version("1.0.0").option("--json", "Output as JSON").option("-p, --profile <name>", "Profile name").option("-v, --verbose", "Verbose output");
+function resolveProfile(program2) {
+  return program2.opts().profile ?? process.env.BSKY_PROFILE;
+}
+async function getClient(program2) {
+  const profile = resolveProfile(program2);
+  const config = await loadConfig(profile);
+  const prefix = profile ? `${profile}-` : "";
+  return createClient(config, prefix);
+}
+async function getConfig(program2) {
+  const profile = resolveProfile(program2);
+  return loadConfig(profile);
+}
+function isJson(program2) {
+  return program2.opts().json === true;
+}
+registerLogin(program);
+registerTimeline(program);
+registerStream(program);
+registerThread(program);
+registerPost(program);
+registerReply(program);
+registerQuote(program);
+registerDelete(program);
+registerLike(program);
+registerLikes(program);
+registerRepost(program);
+registerReposts(program);
+registerFollow(program);
+registerUnfollow(program);
+registerFollows(program);
+registerFollowers(program);
+registerBlock(program);
+registerUnblock(program);
+registerBlocks(program);
+registerMute(program);
+registerSearch(program);
+registerSearchUsers(program);
+registerProfile(program);
+registerProfileUpdate(program);
+registerSession(program);
+registerNotifs(program);
+registerReport(program);
+registerModList(program);
+registerBookmarks(program);
+registerAppPassword(program);
+registerInviteCodes(program);
+registerCompletions(program);
+program.parseAsync(process.argv).catch((err) => {
+  console.error(err.message ?? err);
+  process.exit(1);
+});
+export {
+  getClient,
+  getConfig,
+  isJson
+};
+//# sourceMappingURL=index.js.map