agent-slack 0.2.12 → 0.2.14

package/README.md

@@ -9,7 +9,7 @@ Guiding principle:
 
 ## At a glance
 
-- **Read**: fetch a message, detect threads, list full threads
+- **Read**: fetch a message, browse channel history, list full threads
 - **Search**: messages + files (with filters)
 - **Artifacts**: auto-download snippets/images/files to local paths for agents
 - **Write**: reply in thread, add reactions
@@ -17,10 +17,18 @@ Guiding principle:
 
 ## Installation
 
+Recommended (Bun install script):
+
 ```bash
 curl -fsSL https://raw.githubusercontent.com/stablyai/agent-slack/master/install.sh | sh
 ```
 
+OR npm global install (requires Node >= 22.5):
+
+```bash
+npm i -g agent-slack
+```
+
 ## Agent skill
 
 This repo ships an agent skill at `skills/agent-slack/` compatible with Claude Code, Codex, Cursor, etc
@@ -50,7 +58,7 @@ agent-slack
 │   └── parse-curl
 ├── message
 │   ├── get   <target>             # fetch 1 message (+ thread meta )
-│   ├── list  <target>             # fetch full thread
+│   ├── list  <target>             # fetch thread or recent channel messages
 │   ├── send  <target> <text>      # send / reply (does the right thing)
 │   └── react
 │       ├── add    <target> <emoji>
@@ -138,6 +146,9 @@ agent-slack message get "https://workspace.slack.com/archives/C123/p170000000000
 
 # Full thread for a message
 agent-slack message list "https://workspace.slack.com/archives/C123/p1700000000000000"
+
+# Recent channel messages (browse channel history)
+agent-slack message list "#general" --limit 20
 ```
 
 Optional:
@@ -158,7 +169,7 @@ agent-slack message get "https://workspace.slack.com/archives/C123/p170000000000
 }
 ```
 
-**`message list`** fetches all messages in a thread (or channel history if no thread). Use this when you need the full conversation:
+**`message list`** fetches all replies in a thread, or recent channel messages when no thread is specified. Use this when you need the full conversation:
 
 ```json
 {
@@ -173,6 +184,7 @@ When to use which:
 
 - Use `get` to check a single message or see if there's a thread worth expanding
 - Use `list` to read an entire thread conversation
+- Use `list` on a channel (without `--thread-ts`) to browse recent channel messages
 
 ### Files (snippets/images/attachments)
 

package/dist/index.js

@@ -176,9 +176,9 @@ function parseSlackCurlCommand(curlInput) {
 // src/auth/desktop.ts
 import { cp, mkdir, rm, unlink } from "node:fs/promises";
 import { existsSync as existsSync2 } from "node:fs";
-import { execFileSync, execSync as execSync2 } from "node:child_process";
+import { execFileSync } from "node:child_process";
 import { pbkdf2Sync, createDecipheriv } from "node:crypto";
-import { homedir } from "node:os";
+import { homedir, platform as platform2 } from "node:os";
 import { join as join3 } from "node:path";
 
 // src/lib/leveldb-reader.ts
@@ -441,6 +441,21 @@ async function findKeysContaining(dir, substring) {
 }
 
 // src/auth/desktop.ts
+function isMissingBunSqliteModule(error) {
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  const err = error;
+  const code = typeof err.code === "string" ? err.code : "";
+  const message = typeof err.message === "string" ? err.message : "";
+  if (code === "ERR_MODULE_NOT_FOUND" || code === "ERR_UNSUPPORTED_ESM_URL_SCHEME") {
+    return true;
+  }
+  if (!message.includes("bun:sqlite")) {
+    return false;
+  }
+  return message.includes("Cannot find module") || message.includes("Unknown builtin module") || message.includes("unsupported URL scheme") || message.includes("Only URLs with a scheme in");
+}
 async function queryReadonlySqlite(dbPath, sql) {
   try {
     const { Database } = await import("bun:sqlite");
@@ -450,7 +465,10 @@ async function queryReadonlySqlite(dbPath, sql) {
     } finally {
       db.close();
     }
-  } catch {
+  } catch (error) {
+    if (!isMissingBunSqliteModule(error)) {
+      throw error;
+    }
     const { DatabaseSync } = await import("node:sqlite");
     const db = new DatabaseSync(dbPath, { readOnly: true });
     try {
@@ -460,14 +478,24 @@ async function queryReadonlySqlite(dbPath, sql) {
     }
   }
 }
+var PLATFORM = platform2();
+var IS_MACOS2 = PLATFORM === "darwin";
+var IS_LINUX = PLATFORM === "linux";
 var SLACK_SUPPORT_DIR_ELECTRON = join3(homedir(), "Library", "Application Support", "Slack");
 var SLACK_SUPPORT_DIR_APPSTORE = join3(homedir(), "Library", "Containers", "com.tinyspeck.slackmacgap", "Data", "Library", "Application Support", "Slack");
+var SLACK_SUPPORT_DIR_LINUX = join3(homedir(), ".config", "Slack");
+var SLACK_SUPPORT_DIR_LINUX_FLATPAK = join3(homedir(), ".var", "app", "com.slack.Slack", "config", "Slack");
 function getSlackPaths() {
-  const candidates = [SLACK_SUPPORT_DIR_ELECTRON, SLACK_SUPPORT_DIR_APPSTORE];
+  const candidates = IS_MACOS2 ? [SLACK_SUPPORT_DIR_ELECTRON, SLACK_SUPPORT_DIR_APPSTORE] : IS_LINUX ? [SLACK_SUPPORT_DIR_LINUX_FLATPAK, SLACK_SUPPORT_DIR_LINUX] : [];
+  if (candidates.length === 0) {
+    throw new Error(`Slack Desktop extraction is not supported on ${PLATFORM}.`);
+  }
   for (const dir of candidates) {
     const leveldbDir = join3(dir, "Local Storage", "leveldb");
     if (existsSync2(leveldbDir)) {
-      return { leveldbDir, cookiesDb: join3(dir, "Cookies") };
+      const cookiesDbCandidates = [join3(dir, "Network", "Cookies"), join3(dir, "Cookies")];
+      const cookiesDb = cookiesDbCandidates.find((candidate) => existsSync2(candidate)) || cookiesDbCandidates[0];
+      return { leveldbDir, cookiesDb };
     }
   }
   throw new Error(`Slack Desktop data not found. Checked:
@@ -493,11 +521,17 @@ async function snapshotLevelDb(srcDir) {
   const base = join3(homedir(), ".config", "agent-slack", "cache", "leveldb-snapshots");
   const dest = join3(base, `${Date.now()}`);
   await mkdir(base, { recursive: true });
-  try {
-    execFileSync("cp", ["-cR", srcDir, dest], {
-      stdio: ["ignore", "ignore", "ignore"]
-    });
-  } catch {
+  let useNodeCopy = !IS_MACOS2;
+  if (IS_MACOS2) {
+    try {
+      execFileSync("cp", ["-cR", srcDir, dest], {
+        stdio: ["ignore", "ignore", "ignore"]
+      });
+    } catch {
+      useNodeCopy = true;
+    }
+  }
+  if (useNodeCopy) {
     await cp(srcDir, dest, { recursive: true, force: true });
   }
   try {
@@ -552,11 +586,18 @@ async function extractTeamsFromSlackLevelDb(leveldbDir) {
     const localConfigV3 = Buffer.from("localConfig_v3");
     const entries = await findKeysContaining(snap, Buffer.from("localConfig_v"));
     let configBuf = null;
+    let configRank = -1n;
     for (const entry of entries) {
       if (entry.key.includes(localConfigV2) || entry.key.includes(localConfigV3)) {
         if (entry.value && entry.value.length > 0) {
-          configBuf = entry.value;
-          break;
+          let rank = 0n;
+          if (entry.key.length >= 8) {
+            rank = entry.key.readBigUInt64LE(entry.key.length - 8);
+          }
+          if (!configBuf || rank >= configRank) {
+            configBuf = entry.value;
+            configRank = rank;
+          }
         }
       }
     }
@@ -577,30 +618,59 @@ async function extractTeamsFromSlackLevelDb(leveldbDir) {
     } catch {}
   }
 }
-function getSafeStoragePassword() {
-  const services = ["Slack Safe Storage", "Chrome Safe Storage", "Chromium Safe Storage"];
-  for (const svc of services) {
-    try {
-      const out = execSync2(`security find-generic-password -w -s ${JSON.stringify(svc)} 2>/dev/null`, {
-        encoding: "utf8",
-        stdio: ["ignore", "pipe", "ignore"]
-      }).trim();
-      if (out) {
-        return out;
-      }
-    } catch {}
+function getSafeStoragePasswords(prefix) {
+  if (IS_MACOS2) {
+    const services = ["Slack Safe Storage", "Chrome Safe Storage", "Chromium Safe Storage"];
+    const passwords = [];
+    for (const service of services) {
+      try {
+        const out = execFileSync("security", ["find-generic-password", "-w", "-s", service], {
+          encoding: "utf8",
+          stdio: ["ignore", "pipe", "ignore"]
+        }).trim();
+        if (out) {
+          passwords.push(out);
+        }
+      } catch {}
+    }
+    if (passwords.length > 0) {
+      return passwords;
+    }
+  }
+  if (IS_LINUX) {
+    const attributes = [
+      ["application", "com.slack.Slack"],
+      ["application", "Slack"],
+      ["application", "slack"],
+      ["service", "Slack Safe Storage"]
+    ];
+    const passwords = [];
+    for (const pair of attributes) {
+      try {
+        const out = execFileSync("secret-tool", ["lookup", ...pair], {
+          encoding: "utf8",
+          stdio: ["ignore", "pipe", "ignore"]
+        }).trim();
+        if (out) {
+          passwords.push(out);
+        }
+      } catch {}
+    }
+    if (prefix === "v11") {
+      passwords.push("");
+    }
+    passwords.push("peanuts");
+    return [...new Set(passwords)];
   }
-  throw new Error('Could not read Safe Storage password from Keychain (tried "Slack Safe Storage").');
+  throw new Error("Could not read Safe Storage password from desktop keychain.");
 }
-function decryptChromiumCookieValue(encrypted, password) {
-  if (!encrypted || encrypted.length === 0) {
+function decryptChromiumCookieValue(data, password) {
+  if (!data || data.length === 0) {
     return "";
   }
-  const prefix = encrypted.subarray(0, 3).toString("utf8");
-  const data = prefix === "v10" || prefix === "v11" ? encrypted.subarray(3) : encrypted;
   const salt = Buffer.from("saltysalt", "utf8");
   const iv = Buffer.alloc(16, " ");
-  const key = pbkdf2Sync(password, salt, 1003, 16, "sha1");
+  const key = pbkdf2Sync(password, salt, IS_LINUX ? 1 : 1003, 16, "sha1");
   const decipher = createDecipheriv("aes-128-cbc", key, iv);
   decipher.setAutoPadding(true);
   const plain = Buffer.concat([decipher.update(data), decipher.final()]);
@@ -640,13 +710,19 @@ async function extractCookieDFromSlackCookiesDb(cookiesPath) {
   if (encrypted.length === 0) {
     throw new Error("Slack 'd' cookie had no encrypted_value");
   }
-  const password = getSafeStoragePassword();
-  const decrypted = decryptChromiumCookieValue(encrypted, password);
-  const match = decrypted.match(/xoxd-[A-Za-z0-9%/+_=.-]+/);
-  if (!match) {
-    throw new Error("Could not locate xoxd-* in decrypted Slack cookie");
+  const prefix = encrypted.subarray(0, 3).toString("utf8");
+  const data = prefix === "v10" || prefix === "v11" ? encrypted.subarray(3) : encrypted;
+  const passwords = getSafeStoragePasswords(prefix);
+  for (const password of passwords) {
+    try {
+      const decrypted = decryptChromiumCookieValue(data, password);
+      const match = decrypted.match(/xoxd-[A-Za-z0-9%/+_=.-]+/);
+      if (match) {
+        return match[0];
+      }
+    } catch {}
   }
-  return match[0];
+  throw new Error("Could not locate xoxd-* in decrypted Slack cookie");
 }
 async function extractFromSlackDesktop() {
   const { leveldbDir, cookiesDb } = getSlackPaths();
@@ -720,11 +796,11 @@ var CredentialsSchema = z.object({
 });
 
 // src/auth/keychain.ts
-import { platform as platform2 } from "node:os";
+import { platform as platform3 } from "node:os";
 import { execFileSync as execFileSync2 } from "node:child_process";
-var IS_MACOS2 = platform2() === "darwin";
+var IS_MACOS3 = platform3() === "darwin";
 function keychainGet(account, service) {
-  if (!IS_MACOS2) {
+  if (!IS_MACOS3) {
     return null;
   }
   try {
@@ -735,7 +811,7 @@ function keychainGet(account, service) {
   }
 }
 function keychainSet(input) {
-  if (!IS_MACOS2) {
+  if (!IS_MACOS3) {
     return false;
   }
   const { account, value, service } = input;
@@ -755,9 +831,9 @@ function keychainSet(input) {
 }
 
 // src/auth/store.ts
-import { platform as platform3 } from "node:os";
+import { platform as platform4 } from "node:os";
 var KEYCHAIN_PLACEHOLDER = "__KEYCHAIN__";
-var IS_MACOS3 = platform3() === "darwin";
+var IS_MACOS4 = platform4() === "darwin";
 function normalizeWorkspaceUrl(workspaceUrl) {
   const u = new URL(workspaceUrl);
   return `${u.protocol}//${u.host}`;
@@ -811,7 +887,7 @@ async function saveCredentials(credentials) {
     }))
   };
   const filePayload = structuredClone(payload);
-  if (IS_MACOS3) {
+  if (IS_MACOS4) {
     const firstBrowser = payload.workspaces.find((w) => w.auth.auth_type === "browser");
     let xoxdStored = false;
     if (firstBrowser?.auth.auth_type === "browser" && !isPlaceholderSecret(firstBrowser.auth.xoxd_cookie)) {
@@ -941,8 +1017,24 @@ async function resolveChannelId(client, input) {
   if (!name) {
     throw new Error("Channel name is empty");
   }
+  try {
+    const searchResp = await client.api("search.messages", {
+      query: `in:#${name}`,
+      count: 1,
+      sort: "timestamp",
+      sort_dir: "desc"
+    });
+    const messages = isRecord4(searchResp) ? searchResp.messages : null;
+    const matches = isRecord4(messages) ? asArray(messages.matches).filter(isRecord4) : [];
+    if (matches.length > 0) {
+      const channel = isRecord4(matches[0].channel) ? matches[0].channel : null;
+      const channelId = channel ? getString(channel.id) : undefined;
+      if (channelId) {
+        return channelId;
+      }
+    }
+  } catch {}
   let cursor;
-  const matches = [];
   for (;; ) {
     const resp = await client.api("conversations.list", {
       exclude_archived: true,
@@ -953,11 +1045,7 @@ async function resolveChannelId(client, input) {
     const chans = asArray(resp.channels).filter(isRecord4);
     for (const c of chans) {
       if (getString(c.name) === name && getString(c.id)) {
-        matches.push({
-          id: getString(c.id) ?? "",
-          name: getString(c.name) ?? undefined,
-          is_private: typeof c.is_private === "boolean" ? c.is_private : undefined
-        });
+        return getString(c.id);
       }
     }
     const meta = isRecord4(resp.response_metadata) ? resp.response_metadata : null;
@@ -967,13 +1055,7 @@ async function resolveChannelId(client, input) {
     }
     cursor = next;
   }
-  if (matches.length === 1) {
-    return matches[0].id;
-  }
-  if (matches.length === 0) {
-    throw new Error(`Could not resolve channel name: #${name}`);
-  }
-  throw new Error(`Ambiguous channel name: #${name} (matched ${matches.length} channels: ${matches.map((m) => m.id).join(", ")})`);
+  throw new Error(`Could not resolve channel name: #${name}`);
 }
 function isRecord4(value) {
   return typeof value === "object" && value !== null;
@@ -1099,7 +1181,7 @@ function normalizeUrl(u) {
   return `${url.protocol}//${url.host}`;
 }
 async function refreshFromDesktopIfPossible() {
-  if (process.platform !== "darwin") {
+  if (process.platform !== "darwin" && process.platform !== "linux") {
     return false;
   }
   try {
@@ -2123,6 +2205,43 @@ async function findMessageInThread(client, input) {
   }
   return;
 }
+async function fetchChannelHistory(client, input) {
+  const raw = input.limit ?? 25;
+  const limit = Number.isFinite(raw) ? Math.min(Math.max(raw, 1), 200) : 25;
+  const out = [];
+  const resp = await client.api("conversations.history", {
+    channel: input.channelId,
+    limit,
+    latest: input.latest,
+    oldest: input.oldest,
+    include_all_metadata: input.includeReactions ? true : undefined
+  });
+  const messages = asArray2(resp.messages);
+  for (const m of messages) {
+    if (!isRecord8(m)) {
+      continue;
+    }
+    const files = asArray2(m.files).map((f) => toSlackFileSummary(f)).filter((f) => f !== null);
+    const enrichedFiles = files.length > 0 ? await enrichFiles(client, files) : undefined;
+    const text = getString4(m.text) ?? "";
+    out.push({
+      channel_id: input.channelId,
+      ts: getString4(m.ts) ?? "",
+      thread_ts: getString4(m.thread_ts),
+      reply_count: getNumber(m.reply_count),
+      user: getString4(m.user),
+      bot_id: getString4(m.bot_id),
+      text,
+      markdown: slackMrkdwnToMarkdown(text),
+      blocks: Array.isArray(m.blocks) ? m.blocks : undefined,
+      attachments: Array.isArray(m.attachments) ? m.attachments : undefined,
+      files: enrichedFiles,
+      reactions: Array.isArray(m.reactions) ? m.reactions : undefined
+    });
+  }
+  out.sort((a, b) => Number.parseFloat(a.ts) - Number.parseFloat(b.ts));
+  return out;
+}
 async function fetchThread(client, input) {
   const out = [];
   let cursor;
@@ -2286,6 +2405,8 @@ function parseMsgTarget(input) {
 }
 
 // src/cli/message-actions.ts
+import { readFile as readFile4, writeFile as writeFile3 } from "node:fs/promises";
+import { join as join8 } from "node:path";
 function isRecord9(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -2295,6 +2416,16 @@ function asArray3(value) {
 function getNumber2(value) {
   return typeof value === "number" ? value : undefined;
 }
+function parseLimit(raw) {
+  if (raw === undefined) {
+    return;
+  }
+  const n = Number.parseInt(raw, 10);
+  if (!Number.isFinite(n) || n < 1) {
+    throw new Error(`Invalid --limit value "${raw}": must be a positive integer`);
+  }
+  return n;
+}
 async function getThreadSummary(client, input) {
   const replyCount = input.msg.reply_count ?? 0;
   const rootTs = input.msg.thread_ts ?? (replyCount > 0 ? input.msg.ts : null);
@@ -2344,6 +2475,28 @@ function inferExt(file) {
   const m = name.match(/\.([A-Za-z0-9]{1,10})$/);
   return m ? m[1].toLowerCase() : null;
 }
+var CANVAS_MODES = new Set(["canvas", "quip", "docs"]);
+function looksLikeAuthPage(html) {
+  return /<form[^>]+signin|data-qa="signin|<title>[^<]*Sign\s*in/i.test(html);
+}
+async function downloadCanvasAsMarkdown(input) {
+  const htmlPath = await downloadSlackFile({
+    auth: input.auth,
+    url: input.url,
+    destDir: input.destDir,
+    preferredName: `${input.fileId}.html`,
+    options: { allowHtml: true }
+  });
+  const html = await readFile4(htmlPath, "utf8");
+  if (looksLikeAuthPage(html)) {
+    throw new Error("Downloaded auth/login page instead of canvas content (token may be expired)");
+  }
+  const md = htmlToMarkdown(html).trim();
+  const safeName = `${input.fileId.replace(/[\\/<>:"|?*]/g, "_")}.md`;
+  const mdPath = join8(input.destDir, safeName);
+  await writeFile3(mdPath, md, "utf8");
+  return mdPath;
+}
 async function downloadFilesForMessages(input) {
   const downloadedPaths = {};
   const downloadsDir = await ensureDownloadsDir();
@@ -2352,18 +2505,31 @@ async function downloadFilesForMessages(input) {
       if (downloadedPaths[f.id]) {
         continue;
       }
-      const url = f.url_private_download || f.url_private;
+      const isCanvas = f.mode != null && CANVAS_MODES.has(f.mode);
+      const url = isCanvas ? f.url_private || f.url_private_download : f.url_private_download || f.url_private;
       if (!url) {
         continue;
       }
-      const ext = inferExt(f);
-      const path = await downloadSlackFile({
-        auth: input.auth,
-        url,
-        destDir: downloadsDir,
-        preferredName: `${f.id}${ext ? `.${ext}` : ""}`
-      });
-      downloadedPaths[f.id] = path;
+      try {
+        if (isCanvas) {
+          downloadedPaths[f.id] = await downloadCanvasAsMarkdown({
+            auth: input.auth,
+            fileId: f.id,
+            url,
+            destDir: downloadsDir
+          });
+        } else {
+          const ext = inferExt(f);
+          downloadedPaths[f.id] = await downloadSlackFile({
+            auth: input.auth,
+            url,
+            destDir: downloadsDir,
+            preferredName: `${f.id}${ext ? `.${ext}` : ""}`
+          });
+        }
+      } catch (err) {
+        console.error(`Warning: skipping file ${f.id}: ${err instanceof Error ? err.message : String(err)}`);
+      }
     }
   }
   return downloadedPaths;
@@ -2456,7 +2622,21 @@ async function handleMessageList(input) {
       const threadTs = input.options.threadTs?.trim();
       const ts = input.options.ts?.trim();
       if (!threadTs && !ts) {
-        throw new Error('When targeting a channel, you must pass --thread-ts "<seconds>.<micros>" (or --ts to resolve a message to its thread)');
+        const includeReactions2 = Boolean(input.options.includeReactions);
+        const limit = parseLimit(input.options.limit);
+        const channelMessages = await fetchChannelHistory(client, {
+          channelId,
+          limit,
+          latest: input.options.latest?.trim(),
+          oldest: input.options.oldest?.trim(),
+          includeReactions: includeReactions2
+        });
+        const downloadedPaths2 = await downloadFilesForMessages({ auth, messages: channelMessages });
+        const maxBodyChars2 = Number.parseInt(input.options.maxBodyChars, 10);
+        return pruneEmpty({
+          channel_id: channelId,
+          messages: channelMessages.map((m) => toCompactMessage(m, { maxBodyChars: maxBodyChars2, includeReactions: includeReactions2, downloadedPaths: downloadedPaths2 }))
+        });
       }
       const rootTs = threadTs ?? await (async () => {
         const ref = {
@@ -2574,7 +2754,7 @@ function registerMessageCommand(input) {
       process.exitCode = 1;
     }
   });
-  messageCmd.command("list").description("Fetch the full thread for a Slack message URL").argument("<target>", "Slack message URL, #channel, or channel ID").option("--workspace <url>", "Workspace URL (needed when using #channel/channel id and you have multiple workspaces)").option("--thread-ts <ts>", "Thread root ts (required when using #channel/channel id unless you pass --ts)").option("--ts <ts>", "Message ts (optional: resolve message to its thread)").option("--max-body-chars <n>", "Max content characters to include (default 8000, -1 for unlimited)", "8000").option("--include-reactions", "Include reactions + reacting users").action(async (...args) => {
+  messageCmd.command("list").description("List recent channel messages, or fetch a full thread").argument("<target>", "Slack message URL, #channel, or channel ID").option("--workspace <url>", "Workspace URL (needed when using #channel/channel id and you have multiple workspaces)").option("--thread-ts <ts>", "Thread root ts (lists thread replies instead of channel history)").option("--ts <ts>", "Message ts (resolve message to its thread)").option("--limit <n>", "Max messages to return for channel history (default 25, max 200)").option("--oldest <ts>", "Only messages after this ts (channel history mode)").option("--latest <ts>", "Only messages before this ts (channel history mode)").option("--max-body-chars <n>", "Max content characters to include (default 8000, -1 for unlimited)", "8000").option("--include-reactions", "Include reactions + reacting users").action(async (...args) => {
     const [targetInput, options] = args;
     try {
       const payload = await handleMessageList({ ctx: input.ctx, targetInput, options });
@@ -3359,13 +3539,13 @@ function registerSearchCommand(input) {
 
 // src/lib/update.ts
 import { createHash } from "node:crypto";
-import { chmod, copyFile, mkdir as mkdir5, readFile as readFile4, rename, rm as rm2, writeFile as writeFile3 } from "node:fs/promises";
+import { chmod, copyFile, mkdir as mkdir5, readFile as readFile5, rename, rm as rm2, writeFile as writeFile4 } from "node:fs/promises";
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join8 } from "node:path";
+import { join as join9 } from "node:path";
 var REPO = "stablyai/agent-slack";
 var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
 function getCachePath() {
-  return join8(getAppDir(), "update-check.json");
+  return join9(getAppDir(), "update-check.json");
 }
 function compareSemver(a, b) {
   const pa = a.replace(/^v/, "").split(".").map(Number);
@@ -3422,24 +3602,24 @@ async function checkForUpdate(force = false) {
   };
 }
 function detectPlatformAsset() {
-  const platform4 = process.platform === "win32" ? "windows" : process.platform;
+  const platform5 = process.platform === "win32" ? "windows" : process.platform;
   const archMap = { x64: "x64", arm64: "arm64" };
   const arch = archMap[process.arch] ?? process.arch;
-  const ext = platform4 === "windows" ? ".exe" : "";
-  return `agent-slack-${platform4}-${arch}${ext}`;
+  const ext = platform5 === "windows" ? ".exe" : "";
+  return `agent-slack-${platform5}-${arch}${ext}`;
 }
 async function sha256(filePath) {
-  const data = await readFile4(filePath);
+  const data = await readFile5(filePath);
   return createHash("sha256").update(data).digest("hex");
 }
 async function performUpdate(latest) {
   const asset = detectPlatformAsset();
   const tag = `v${latest}`;
   const baseUrl = `https://github.com/${REPO}/releases/download/${tag}`;
-  const tmp = join8(tmpdir2(), `agent-slack-update-${Date.now()}`);
+  const tmp = join9(tmpdir2(), `agent-slack-update-${Date.now()}`);
   await mkdir5(tmp, { recursive: true });
-  const binTmp = join8(tmp, asset);
-  const sumsTmp = join8(tmp, "checksums-sha256.txt");
+  const binTmp = join9(tmp, asset);
+  const sumsTmp = join9(tmp, "checksums-sha256.txt");
   try {
     const [binResp, sumsResp] = await Promise.all([
       fetch(`${baseUrl}/${asset}`, { signal: AbortSignal.timeout(120000) }),
@@ -3451,9 +3631,9 @@ async function performUpdate(latest) {
     if (!sumsResp.ok) {
       return { success: false, message: `Failed to download checksums: HTTP ${sumsResp.status}` };
     }
-    await writeFile3(binTmp, Buffer.from(await binResp.arrayBuffer()));
+    await writeFile4(binTmp, Buffer.from(await binResp.arrayBuffer()));
     const sumsText = await sumsResp.text();
-    await writeFile3(sumsTmp, sumsText);
+    await writeFile4(sumsTmp, sumsText);
     const expected = sumsText.split(`
 `).map((line) => line.trim().split(/\s+/)).find((parts) => parts[1] === asset)?.[0];
     if (!expected) {
@@ -3702,5 +3882,5 @@ if (subcommand && subcommand !== "update") {
   backgroundUpdateCheck();
 }
 
-//# debugId=09DBB443871FCCB664756E2164756E21
+//# debugId=596521D1CCB5DA7164756E2164756E21
 //# sourceMappingURL=index.js.map