chirpie 1.1.2 → 1.1.3

package/README.md

@@ -130,6 +130,10 @@ chirpie posts --group 550e8400-e29b-41d4-a716-446655440000
 
 One line is printed per account, with a group ID above them. An account the platform refused is shown with its error while the others stay published, and the command leaves with a non-zero status when any account failed. An override says only what differs, and naming media replaces the shared media for that account.
 
+## IDs
+
+Listings print a short ID, the first eight characters of the full one, and every command that takes an account, post, key or comment ID accepts it: `chirpie accounts disconnect 90208e20`, `chirpie posts delete 2e7e8e95`, `-a 90208e20` when posting. A short ID has to name exactly one of your accounts, posts, keys or comments; when it matches none or several, the command stops and says so, and the full ID from `--json` always works.
+
 ## JSON output
 
 Every command accepts `--json` and prints the raw API response, which is what you want in a script:

package/dist/index.js

@@ -278,6 +278,151 @@ function printFanOut(groupId, lines) {
   return failed.length;
 }
 
+// src/lib/ids.ts
+var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var MAX_SEARCHED = 1e3;
+var IdResolutionError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "IdResolutionError";
+  }
+};
+function isFullUuid(value) {
+  return UUID.test(value);
+}
+var UUID_PREFIX = /^[0-9a-f-]+$/i;
+function needsLookup(value) {
+  const trimmed = value.trim();
+  return UUID_PREFIX.test(trimmed) && !isFullUuid(trimmed);
+}
+async function resolveId(input, kind, pages) {
+  const wanted = input.trim();
+  if (!wanted) {
+    throw new IdResolutionError(`Pass the ${kind.noun} ID.`);
+  }
+  if (!needsLookup(wanted)) return wanted;
+  const needle = wanted.toLowerCase();
+  const matches = /* @__PURE__ */ new Set();
+  for await (const ids of pages()) {
+    for (const id of ids) {
+      if (id === wanted) return id;
+      if (id.toLowerCase().startsWith(needle)) matches.add(id);
+    }
+  }
+  if (matches.size === 1) return [...matches][0];
+  if (matches.size > 1) {
+    const list = [...matches].sort().join(", ");
+    throw new IdResolutionError(
+      `"${wanted}" matches ${matches.size} ${kind.noun}s (${list}). Use more characters of the ID.`
+    );
+  }
+  throw new IdResolutionError(
+    `No ${kind.noun} ID starts with "${wanted}". Run \`${kind.listCommand}\` to see them, or pass the full ID.`
+  );
+}
+function resolveIdIn(input, kind, ids) {
+  return resolveId(input, kind, async function* () {
+    yield ids;
+  });
+}
+var ACCOUNT = { noun: "account", listCommand: "chirpie accounts" };
+var POST = { noun: "post", listCommand: "chirpie posts" };
+var KEY = { noun: "API key", listCommand: "chirpie keys" };
+function accountIdResolver(client) {
+  let listing = null;
+  return async (input) => {
+    if (!needsLookup(input) && input.trim()) return input.trim();
+    listing ??= client.listAccounts().then((accounts) => accounts.map((a) => a.id));
+    return resolveIdIn(input, ACCOUNT, await listing);
+  };
+}
+function resolveAccountId(client, input) {
+  return accountIdResolver(client)(input);
+}
+async function resolveAccountKeys(resolve2, byAccount) {
+  if (!byAccount) return void 0;
+  const out = {};
+  for (const [key, value] of Object.entries(byAccount)) {
+    const id = await resolve2(key);
+    if (id in out) {
+      throw new IdResolutionError(
+        `--config names account ${id} twice. Give each account one entry.`
+      );
+    }
+    out[id] = value;
+  }
+  return out;
+}
+function resolvePostId(client, input) {
+  const pageSize = 100;
+  return resolveId(
+    input,
+    POST,
+    async function* () {
+      for (const status of [void 0, "draft"]) {
+        for (let offset = 0; offset < MAX_SEARCHED; offset += pageSize) {
+          const page = await client.listPosts({
+            ...status ? { status } : {},
+            limit: pageSize,
+            offset,
+            include_hidden: true
+          });
+          yield page.map((p) => p.id);
+          if (page.length < pageSize) break;
+        }
+      }
+    }
+  );
+}
+async function resolveKeyId(client, input) {
+  if (!needsLookup(input) && input.trim()) return input.trim();
+  const keys = await client.listKeys();
+  return resolveIdIn(
+    input,
+    KEY,
+    keys.map((k) => k.id)
+  );
+}
+function resolveCommentId(client, postId, input) {
+  const pageSize = 100;
+  return resolveId(
+    input,
+    {
+      noun: "comment",
+      listCommand: `chirpie comments list ${postId}`
+    },
+    async function* () {
+      let cursor;
+      for (let read = 0; read < MAX_SEARCHED; read += pageSize) {
+        const page = await client.listComments(postId, {
+          limit: pageSize,
+          ...cursor ? { cursor } : {},
+          sync: false,
+          include_hidden: true,
+          include_deleted: true
+        });
+        yield page.comments.map((c) => c.id);
+        if (!page.next_cursor) break;
+        cursor = page.next_cursor;
+      }
+    }
+  );
+}
+async function resolveCommentIds(client, postInput, commentInput) {
+  const postId = await resolvePostId(client, postInput);
+  const commentId = await resolveCommentId(client, postId, commentInput);
+  return { postId, commentId };
+}
+async function resolveNamedAccounts(client, named, configurations) {
+  const resolve2 = accountIdResolver(client);
+  const accountIds = [];
+  for (const input of named) accountIds.push(await resolve2(input));
+  return {
+    accountIds,
+    configurations: await resolveAccountKeys(resolve2, configurations)
+  };
+}
+
 // src/lib/placement.ts
 var INSTAGRAM_PLACEMENT_HELP = 'Where the post goes on Instagram: feed (the default), story or reel. A story takes exactly one image or video, no caption (pass "" as the text) and no first comment. A reel takes exactly one video. Only pass this when the post is going to an Instagram account';
 var FACEBOOK_PLACEMENT_HELP = "Where the post goes on a Facebook Page: feed (the default) or story. A story takes exactly one image or video, no text and no first comment. Only pass this when the post is going to a Facebook Page";
@@ -329,7 +474,19 @@ var postCommand = new Command3("post").description("Create a post").argument("<t
     error("--config names accounts, so pass --account <id> for each of them");
     process.exit(1);
   }
-  const accountIds = named.length > 0 ? named : [await resolveSingleAccountId(client)];
+  const givenConfigurations = parseAccountConfigurations(opts.config);
+  let resolved;
+  try {
+    resolved = await resolveNamedAccounts(
+      client,
+      named,
+      givenConfigurations
+    );
+  } catch (err) {
+    error(err instanceof Error ? err.message : "Failed to find the accounts");
+    process.exit(1);
+  }
+  const accountIds = named.length > 0 ? resolved.accountIds : [await resolveSingleAccountId(client)];
   const fanOut = named.length > 1 || Boolean(opts.config);
   const configuration = placementConfiguration(opts);
   try {
@@ -341,11 +498,7 @@ var postCommand = new Command3("post").description("Create a post").argument("<t
         ...media ? { media } : {},
         ...opts.firstComment ? { first_comment: opts.firstComment } : {},
         ...configuration ? { configuration } : {},
-        ...opts.config ? {
-          account_configurations: parseAccountConfigurations(
-            opts.config
-          )
-        } : {},
+        ...resolved.configurations ? { account_configurations: resolved.configurations } : {},
         schedule_at: opts.schedule,
         ...opts.timezone ? { timezone: opts.timezone } : {},
         ...opts.draft ? { draft: true } : {}
@@ -501,13 +654,21 @@ var threadCommand = new Command4("thread").description("Create a thread").argume
       }
     }
   }
-  const configurations = parseAccountConfigurations(opts.config) ?? fileConfigurations;
+  const givenConfigurations = parseAccountConfigurations(opts.config) ?? fileConfigurations;
   const named = opts.account ?? fileAccountIds ?? [];
-  if (configurations && named.length === 0) {
+  if (givenConfigurations && named.length === 0) {
     error("Per-account posts name accounts, so pass --account <id> for each of them");
     process.exit(1);
   }
-  const accountIds = named.length > 0 ? named : [await resolveSingleAccountId(client)];
+  let resolved;
+  try {
+    resolved = await resolveNamedAccounts(client, named, givenConfigurations);
+  } catch (err) {
+    error(err instanceof Error ? err.message : "Failed to find the accounts");
+    process.exit(1);
+  }
+  const configurations = resolved.configurations;
+  const accountIds = named.length > 0 ? resolved.accountIds : [await resolveSingleAccountId(client)];
   const fanOut = named.length > 1 || Boolean(configurations);
   try {
     if (fanOut) {
@@ -569,15 +730,16 @@ import { postFailureReason } from "@chirpie/sdk";
 var postsCommand = new Command5("posts").description("List, get, update, delete, hide or unhide posts").option(
   "--status <status>",
   "Filter by status: draft, scheduled, publishing, published, failed, deleted"
-).option("--account <id>", "Filter by account").option(
+).option("--account <id>", "Filter by account. The short ID from `chirpie accounts` works").option(
   "--group <id>",
   "Only the posts of one fan-out, from the group ID a multi-account post returned"
 ).option("--limit <n>", "Limit results", "20").option("--include-hidden", "Include posts you have hidden").option("--json", "Output raw JSON").action(async (opts, cmd) => {
   const client = getClient();
   try {
+    const accountId = opts.account ? await resolveAccountId(client, opts.account) : void 0;
     const posts = await client.listPosts({
       status: opts.status,
-      account_id: opts.account,
+      account_id: accountId,
       group_id: opts.group,
       limit: parseInt(opts.limit),
       include_hidden: opts.includeHidden
@@ -606,7 +768,8 @@ var postsCommand = new Command5("posts").description("List, get, update, delete,
 postsCommand.command("get <id>").description("Get a post by ID").option("--json", "Output raw JSON").action(async (id, opts, cmd) => {
   const client = getClient();
   try {
-    const post = await client.getPost(id);
+    const postId = await resolvePostId(client, id);
+    const post = await client.getPost(postId);
     if (wantsJson(opts, cmd)) {
       json(post);
     } else {
@@ -673,8 +836,9 @@ postsCommand.command("update <id>").description(
   const configuration = opts.clearPlacement ? {} : placementConfiguration(opts);
   const client = getClient();
   try {
+    const postId = await resolvePostId(client, id);
     const media = await resolveMediaArgs(client, opts.media, opts.alt);
-    const post = await client.updatePost(id, {
+    const post = await client.updatePost(postId, {
       ...opts.text !== void 0 ? { text: opts.text } : {},
       ...opts.clearMedia ? { media: [] } : {},
       ...media ? { media } : {},
@@ -705,14 +869,15 @@ postsCommand.command("update <id>").description(
 postsCommand.command("publish <id>").description("Publish a draft now. Every rule and the monthly quota apply").option("-t, --text <text>", "Final post text, saved before publishing").option("--json", "Output raw JSON").action(async (id, opts, cmd) => {
   const client = getClient();
   try {
-    const post = await client.updatePost(id, {
+    const postId = await resolvePostId(client, id);
+    const post = await client.updatePost(postId, {
       publish: true,
       ...opts.text !== void 0 ? { text: opts.text } : {}
     });
     if (wantsJson(opts, cmd)) {
       json(post);
     } else {
-      success(`Draft ${id} published (${post.id})`);
+      success(`Draft ${postId} published (${post.id})`);
     }
   } catch (err) {
     apiError(err, "Failed to publish draft");
@@ -724,7 +889,8 @@ postsCommand.command("delete <id>").description(
 ).option("--json", "Output raw JSON").action(async (id, opts, cmd) => {
   const client = getClient();
   try {
-    const result = await client.deletePost(id);
+    const postId = await resolvePostId(client, id);
+    const result = await client.deletePost(postId);
     const cancelled = result.cancelled_ids ?? [];
     if (wantsJson(opts, cmd)) {
       json(result);
@@ -733,7 +899,7 @@ postsCommand.command("delete <id>").description(
         `Scheduled thread canceled (${cancelled.length} posts): ${cancelled.join(", ")}`
       );
     } else {
-      success(`Post ${id} deleted`);
+      success(`Post ${postId} deleted`);
     }
   } catch (err) {
     error(err instanceof Error ? err.message : "Failed to delete post");
@@ -748,7 +914,8 @@ postsCommand.command("first-comment <id>").description(
 ).option("--json", "Output raw JSON").action(async (id, opts, cmd) => {
   const client = getClient();
   try {
-    const post = await client.retryFirstComment(id, idempotency(opts));
+    const postId = await resolvePostId(client, id);
+    const post = await client.retryFirstComment(postId, idempotency(opts));
     if (wantsJson(opts, cmd)) {
       json(post);
     } else {
@@ -764,13 +931,14 @@ postsCommand.command("hide <id>").description(
 ).option("--json", "Output raw JSON").action(async (id, opts, cmd) => {
   const client = getClient();
   try {
-    const result = await client.hidePost(id);
+    const postId = await resolvePostId(client, id);
+    const result = await client.hidePost(postId);
     if (wantsJson(opts, cmd)) {
       json(result);
     } else {
       const n = result.hidden_ids.length;
       success(
-        n > 1 ? `Hidden from Chirpie (${n} posts): ${result.hidden_ids.join(", ")}` : `Post ${id} hidden from Chirpie. It is unchanged on the platform.`
+        n > 1 ? `Hidden from Chirpie (${n} posts): ${result.hidden_ids.join(", ")}` : `Post ${postId} hidden from Chirpie. It is unchanged on the platform.`
       );
     }
   } catch (err) {
@@ -781,13 +949,14 @@ postsCommand.command("hide <id>").description(
 postsCommand.command("unhide <id>").description("Put a hidden post back in your Chirpie listings").option("--json", "Output raw JSON").action(async (id, opts, cmd) => {
   const client = getClient();
   try {
-    const result = await client.unhidePost(id);
+    const postId = await resolvePostId(client, id);
+    const result = await client.unhidePost(postId);
     if (wantsJson(opts, cmd)) {
       json(result);
     } else {
       const n = result.hidden_ids.length;
       success(
-        n > 1 ? `Showing again (${n} posts): ${result.hidden_ids.join(", ")}` : `Post ${id} is showing again`
+        n > 1 ? `Showing again (${n} posts): ${result.hidden_ids.join(", ")}` : `Post ${postId} is showing again`
       );
     }
   } catch (err) {
@@ -887,10 +1056,11 @@ function inactiveNote(reason) {
   }
   return "";
 }
-accountsCommand.command("activate").argument("<id>", "Account ID (from `chirpie accounts`)").description("Activate a connected account so it can publish").option("--json", "Output raw JSON").action(async (id, opts, cmd) => {
+accountsCommand.command("activate").argument("<id>", "Account ID, full or the short ID from `chirpie accounts`").description("Activate a connected account so it can publish").option("--json", "Output raw JSON").action(async (id, opts, cmd) => {
   const client = getClient();
   try {
-    const account = await client.activateAccount(id);
+    const accountId = await resolveAccountId(client, id);
+    const account = await client.activateAccount(accountId);
     if (wantsJson(opts, cmd)) {
       json(account);
     } else {
@@ -901,12 +1071,13 @@ accountsCommand.command("activate").argument("<id>", "Account ID (from `chirpie
     process.exit(1);
   }
 });
-accountsCommand.command("deactivate").argument("<id>", "Account ID (from `chirpie accounts`)").description(
+accountsCommand.command("deactivate").argument("<id>", "Account ID, full or the short ID from `chirpie accounts`").description(
   "Deactivate a connected account (stays connected, frees a plan slot, cancels its scheduled posts)"
 ).option("--json", "Output raw JSON").action(async (id, opts, cmd) => {
   const client = getClient();
   try {
-    const account = await client.deactivateAccount(id);
+    const accountId = await resolveAccountId(client, id);
+    const account = await client.deactivateAccount(accountId);
     if (wantsJson(opts, cmd)) {
       json(account);
     } else {
@@ -924,20 +1095,27 @@ accountsCommand.command("deactivate").argument("<id>", "Account ID (from `chirpi
     process.exit(1);
   }
 });
-accountsCommand.command("disconnect").argument("<id>", "Account ID (from `chirpie accounts`)").description(
+accountsCommand.command("disconnect").argument("<id>", "Account ID, full or the short ID from `chirpie accounts`").description(
   "Disconnect a connected account (stops publishing, frees a plan slot, cancels its scheduled posts)"
 ).option("-y, --yes", "Skip the confirmation prompt").option("--json", "Output raw JSON").action(async (id, opts, cmd) => {
-  if (!opts.yes && !await confirm(`Disconnect account ${id}?`)) {
+  const client = getClient();
+  let accountId;
+  try {
+    accountId = await resolveAccountId(client, id);
+  } catch (err) {
+    error(err instanceof Error ? err.message : "Failed to find account");
+    process.exit(1);
+  }
+  if (!opts.yes && !await confirm(`Disconnect account ${accountId}?`)) {
     error("Cancelled");
     process.exit(1);
   }
-  const client = getClient();
   try {
-    const result = await client.disconnectAccount(id);
+    const result = await client.disconnectAccount(accountId);
     if (wantsJson(opts, cmd)) {
       json(result);
     } else {
-      success(`Disconnected account ${id}`);
+      success(`Disconnected account ${accountId}`);
       if (result.canceled_posts > 0) {
         success(
           `Cancelled ${result.canceled_posts} scheduled post${result.canceled_posts === 1 ? "" : "s"} and returned them to your monthly quota. They are not restored if you connect the account again.`
@@ -1270,13 +1448,13 @@ function commentState(comment) {
   return "";
 }
 var commentsCommand = new Command7("comments").description("List, reply to, hide, or delete the comments on a post").option("--json", "Output raw JSON");
-commentsCommand.command("list").description("List the comments on a post you published").argument("<post_id>", "Post ID").option("--limit <n>", "Comments to show (default 25, max 100)").option("--cursor <cursor>", "The next_cursor from the previous page").option("--since <datetime>", "Only comments posted after this ISO 8601 time").option("--no-sync", "Show the stored comments without refreshing them").option("--include-hidden", "Include comments you have hidden").option(
+commentsCommand.command("list").description("List the comments on a post you published").argument("<post_id>", "Post ID, full or the short ID from `chirpie posts`").option("--limit <n>", "Comments to show (default 25, max 100)").option("--cursor <cursor>", "The next_cursor from the previous page").option("--since <datetime>", "Only comments posted after this ISO 8601 time").option("--no-sync", "Show the stored comments without refreshing them").option("--include-hidden", "Include comments you have hidden").option(
   "--include-deleted",
   "Include deleted comments, with the last text Chirpie stored for them"
 ).addOption(new Option("--hidden").hideHelp()).option("--json", "Output raw JSON").action(async (postId, opts, cmd) => {
   const client = getClient();
   try {
-    const result = await client.listComments(postId, {
+    const result = await client.listComments(await resolvePostId(client, postId), {
       limit: opts.limit ? parseInt(opts.limit, 10) : void 0,
       cursor: opts.cursor,
       since: opts.since,
@@ -1312,54 +1490,63 @@ commentsCommand.command("list").description("List the comments on a post you pub
     process.exit(1);
   }
 });
-commentsCommand.command("reply").description("Reply to a comment (counts as one post against your quota)").argument("<post_id>", "Post ID").argument("<comment_id>", "Comment ID from `chirpie comments list`").requiredOption("--text <text>", "The reply text").option(
+commentsCommand.command("reply").description("Reply to a comment (counts as one post against your quota)").argument("<post_id>", "Post ID, full or the short ID from `chirpie posts`").argument("<comment_id>", "Comment ID, full or the short ID from `chirpie comments list`").requiredOption("--text <text>", "The reply text").option(
   "--idempotency-key <key>",
   "Make a retry safe. The same key with the same reply replays the first answer instead of sending it again, for 24 hours"
 ).option("--json", "Output raw JSON").action(async (postId, commentId, opts, cmd) => {
   const client = getClient();
   try {
+    const ids = await resolveCommentIds(client, postId, commentId);
     const reply = await client.replyToComment(
-      postId,
-      commentId,
+      ids.postId,
+      ids.commentId,
       opts.text,
       idempotency(opts)
     );
     if (wantsJson(opts, cmd)) {
       json(reply);
     } else {
-      success(`Replied to ${commentId}`);
+      success(`Replied to ${ids.commentId}`);
     }
   } catch (err) {
     apiError(err, "Failed to reply to comment");
     process.exit(1);
   }
 });
-commentsCommand.command("hide").description("Hide a comment, or show it again with --unhide").argument("<post_id>", "Post ID").argument("<comment_id>", "Comment ID from `chirpie comments list`").option("--unhide", "Show a comment you hid earlier").option("--json", "Output raw JSON").action(async (postId, commentId, opts, cmd) => {
+commentsCommand.command("hide").description("Hide a comment, or show it again with --unhide").argument("<post_id>", "Post ID, full or the short ID from `chirpie posts`").argument("<comment_id>", "Comment ID, full or the short ID from `chirpie comments list`").option("--unhide", "Show a comment you hid earlier").option("--json", "Output raw JSON").action(async (postId, commentId, opts, cmd) => {
   const client = getClient();
   try {
-    const updated = opts.unhide ? await client.unhideComment(postId, commentId) : await client.hideComment(postId, commentId);
+    const ids = await resolveCommentIds(client, postId, commentId);
+    const updated = opts.unhide ? await client.unhideComment(ids.postId, ids.commentId) : await client.hideComment(ids.postId, ids.commentId);
     if (wantsJson(opts, cmd)) {
       json(updated);
     } else {
-      success(`Comment ${commentId} ${opts.unhide ? "shown" : "hidden"}`);
+      success(`Comment ${ids.commentId} ${opts.unhide ? "shown" : "hidden"}`);
     }
   } catch (err) {
     apiError(err, "Failed to hide comment");
     process.exit(1);
   }
 });
-commentsCommand.command("delete").description("Delete a comment from the platform").argument("<post_id>", "Post ID").argument("<comment_id>", "Comment ID from `chirpie comments list`").option("-y, --yes", "Skip the confirmation prompt").option("--json", "Output raw JSON").action(async (postId, commentId, opts, cmd) => {
-  if (!opts.yes && !await confirm2(`Delete comment ${commentId}?`)) {
+commentsCommand.command("delete").description("Delete a comment from the platform").argument("<post_id>", "Post ID, full or the short ID from `chirpie posts`").argument("<comment_id>", "Comment ID, full or the short ID from `chirpie comments list`").option("-y, --yes", "Skip the confirmation prompt").option("--json", "Output raw JSON").action(async (postId, commentId, opts, cmd) => {
+  const client = getClient();
+  let ids;
+  try {
+    ids = await resolveCommentIds(client, postId, commentId);
+  } catch (err) {
+    apiError(err, "Failed to find the comment");
+    process.exit(1);
+  }
+  if (!opts.yes && !await confirm2(`Delete comment ${ids.commentId}?`)) {
     error("Cancelled");
     process.exit(1);
   }
-  const client = getClient();
   try {
-    const result = await client.deleteComment(postId, commentId);
+    const result = await client.deleteComment(ids.postId, ids.commentId);
     if (wantsJson(opts, cmd)) {
       json(result);
     } else {
-      success(`Comment ${commentId} deleted`);
+      success(`Comment ${ids.commentId} deleted`);
     }
   } catch (err) {
     apiError(err, "Failed to delete comment");
@@ -1383,15 +1570,16 @@ async function confirm2(question) {
 
 // src/commands/analytics.ts
 import { Command as Command8 } from "commander";
-var analyticsCommand = new Command8("analytics").description("Get analytics for a post").argument("<post_id>", "Post ID").option(
+var analyticsCommand = new Command8("analytics").description("Get analytics for a post").argument("<post_id>", "Post ID, full or the short ID from `chirpie posts`").option(
   "--refresh",
   "Ask the platform now instead of reading the stored numbers. Allowed once per post every 5 minutes"
 ).option("--json", "Output raw JSON").action(async (postId, opts) => {
   const client = getClient();
   try {
-    const analytics = await client.getPostAnalytics(postId, {
-      refresh: Boolean(opts.refresh)
-    });
+    const analytics = await client.getPostAnalytics(
+      await resolvePostId(client, postId),
+      { refresh: Boolean(opts.refresh) }
+    );
     if (opts.json) {
       json(analytics);
     } else {
@@ -1482,11 +1670,12 @@ keysCommand.command("create").description("Create a new API key").option("-n, --
 keysCommand.command("revoke <id>").description("Revoke an API key").option("--json", "Output raw JSON").action(async (id, opts, cmd) => {
   const client = getClient();
   try {
-    await client.revokeKey(id);
+    const keyId = await resolveKeyId(client, id);
+    await client.revokeKey(keyId);
     if (wantsJson(opts, cmd)) {
-      json({ id, revoked: true });
+      json({ id: keyId, revoked: true });
     } else {
-      success(`Key ${id} revoked`);
+      success(`Key ${keyId} revoked`);
     }
   } catch (err) {
     error(err instanceof Error ? err.message : "Failed to revoke key");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chirpie",
-  "version": "1.1.2",
+  "version": "1.1.3",
   "description": "Chirpie CLI: post to social media from the command line",
   "repository": {
     "type": "git",