agent-slack 0.2.12

package/dist/index.js

@@ -0,0 +1,3706 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/lib/version.ts
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+var cachedVersion;
+function getPackageVersion() {
+  if (cachedVersion !== undefined) {
+    return cachedVersion;
+  }
+  if (typeof AGENT_SLACK_BUILD_VERSION === "string" && AGENT_SLACK_BUILD_VERSION) {
+    cachedVersion = AGENT_SLACK_BUILD_VERSION;
+    return cachedVersion;
+  }
+  const envVersion = process.env.AGENT_SLACK_VERSION?.trim() || process.env.npm_package_version?.trim();
+  if (envVersion) {
+    cachedVersion = envVersion;
+    return cachedVersion;
+  }
+  try {
+    let dir = dirname(fileURLToPath(import.meta.url));
+    for (let i = 0;i < 6; i++) {
+      const candidate = join(dir, "package.json");
+      if (existsSync(candidate)) {
+        const raw = readFileSync(candidate, "utf8");
+        const pkg = JSON.parse(raw);
+        const v = typeof pkg.version === "string" ? pkg.version.trim() : "";
+        cachedVersion = v || "0.0.0";
+        return cachedVersion;
+      }
+      const next = dirname(dir);
+      if (next === dir) {
+        break;
+      }
+      dir = next;
+    }
+  } catch {}
+  cachedVersion = "0.0.0";
+  return cachedVersion;
+}
+function getUserAgent() {
+  return `agent-slack/${getPackageVersion()}`;
+}
+
+// src/auth/chrome.ts
+import { execSync } from "node:child_process";
+import { platform } from "node:os";
+var IS_MACOS = platform() === "darwin";
+function escapeOsaScript(script) {
+  return script.replace(/'/g, `'"'"'`);
+}
+function osascript(script) {
+  return execSync(`osascript -e '${escapeOsaScript(script)}'`, {
+    encoding: "utf8",
+    timeout: 7000,
+    stdio: ["ignore", "pipe", "pipe"]
+  }).trim();
+}
+function cookieScript() {
+  return `
+    tell application "Google Chrome"
+      repeat with w in windows
+        repeat with t in tabs of w
+          if URL of t contains "slack.com" then
+            return execute t javascript "document.cookie.split('; ').find(c => c.startsWith('d='))?.split('=')[1] || ''"
+          end if
+        end repeat
+      end repeat
+      return ""
+    end tell
+  `;
+}
+var TEAM_JSON_PATHS = [
+  "JSON.stringify(JSON.parse(localStorage.localConfig_v2).teams)",
+  "JSON.stringify(JSON.parse(localStorage.localConfig_v3).teams)",
+  "JSON.stringify(JSON.parse(localStorage.getItem('reduxPersist:localConfig'))?.teams || {})",
+  "JSON.stringify(window.boot_data?.teams || {})"
+];
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function toChromeTeam(value) {
+  if (!isRecord(value)) {
+    return null;
+  }
+  const token = typeof value.token === "string" ? value.token : null;
+  const url = typeof value.url === "string" ? value.url : null;
+  if (!token || !url || !token.startsWith("xoxc-")) {
+    return null;
+  }
+  const name = typeof value.name === "string" ? value.name : undefined;
+  return { url, name, token };
+}
+function teamsScript() {
+  const tryPaths = TEAM_JSON_PATHS.map((expr) => `try { var v = ${expr}; if (v && v !== '{}' && v !== 'null') return v; } catch(e) {}`);
+  return `
+    tell application "Google Chrome"
+      repeat with w in windows
+        repeat with t in tabs of w
+          if URL of t contains "slack.com" then
+            return execute t javascript "(function(){ ${tryPaths.join(" ")} return '{}'; })()"
+          end if
+        end repeat
+      end repeat
+      return "{}"
+    end tell
+  `;
+}
+function extractFromChrome() {
+  if (!IS_MACOS) {
+    return null;
+  }
+  try {
+    const cookie = osascript(cookieScript());
+    if (!cookie || !cookie.startsWith("xoxd-")) {
+      return null;
+    }
+    const teamsRaw = osascript(teamsScript());
+    let teamsObj = {};
+    try {
+      teamsObj = JSON.parse(teamsRaw || "{}");
+    } catch {
+      teamsObj = {};
+    }
+    const teamsRecord = isRecord(teamsObj) ? teamsObj : {};
+    const teams = Object.values(teamsRecord).map((t) => toChromeTeam(t)).filter((t) => t !== null);
+    if (teams.length === 0) {
+      return null;
+    }
+    return { cookie_d: cookie, teams };
+  } catch {
+    return null;
+  }
+}
+
+// src/auth/curl.ts
+function parseSlackCurlCommand(curlInput) {
+  const urlMatch = curlInput.match(/curl\s+['"]?(https?:\/\/([^.]+)\.slack\.com[^'"\s]*)/i);
+  if (!urlMatch) {
+    throw new Error("Could not find Slack workspace URL in cURL command");
+  }
+  const workspace_url = `https://${urlMatch[2]}.slack.com`;
+  const cookieMatch = curlInput.match(/(?:-b|--cookie)\s+\$?'([^']+)'|(?:-b|--cookie)\s+\$?"([^"]+)"|-H\s+\$?'[Cc]ookie:\s*([^']+)'|-H\s+\$?"[Cc]ookie:\s*([^"]+)"/);
+  const cookieHeader = cookieMatch ? cookieMatch[1] || cookieMatch[2] || cookieMatch[3] || cookieMatch[4] || "" : "";
+  const xoxdMatch = cookieHeader.match(/(?:^|;\s*)d=(xoxd-[^;]+)/);
+  if (!xoxdMatch) {
+    throw new Error("Could not find xoxd cookie (d=xoxd-...) in cURL command");
+  }
+  const xoxd_cookie = decodeURIComponent(xoxdMatch[1]);
+  const tokenPatterns = [
+    /(?:^|[?&\s])token=(xoxc-[A-Za-z0-9-]+)/,
+    /"token"\s*:\s*"(xoxc-[A-Za-z0-9-]+)"/,
+    /name="token"[^x]*?(xoxc-[A-Za-z0-9-]+)/,
+    /\b(xoxc-[A-Za-z0-9-]+)\b/
+  ];
+  let xoxc_token = null;
+  for (const re of tokenPatterns) {
+    const m = curlInput.match(re);
+    if (m?.[1]) {
+      const [, token] = m;
+      xoxc_token = token ?? null;
+      break;
+    }
+  }
+  if (!xoxc_token) {
+    throw new Error("Could not find xoxc token in cURL command");
+  }
+  return { workspace_url, xoxc_token, xoxd_cookie };
+}
+
+// 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 { pbkdf2Sync, createDecipheriv } from "node:crypto";
+import { homedir } from "node:os";
+import { join as join3 } from "node:path";
+
+// src/lib/leveldb-reader.ts
+import { readdir, readFile } from "node:fs/promises";
+import { join as join2 } from "node:path";
+import { snappyUncompress } from "hysnappy";
+var LEVELDB_MAGIC = Buffer.from([87, 251, 128, 139, 36, 117, 71, 219]);
+var COMPRESSION_NONE = 0;
+var COMPRESSION_SNAPPY = 1;
+var LOG_RECORD_FULL = 1;
+var LOG_RECORD_FIRST = 2;
+var LOG_RECORD_MIDDLE = 3;
+var LOG_RECORD_LAST = 4;
+function readVarint(buf, offset) {
+  let result = 0;
+  let shift = 0;
+  let bytesRead = 0;
+  while (offset + bytesRead < buf.length) {
+    const byte = buf[offset + bytesRead];
+    bytesRead++;
+    result |= (byte & 127) << shift;
+    if ((byte & 128) === 0) {
+      return [result, bytesRead];
+    }
+    shift += 7;
+    if (shift >= 35) {
+      throw new Error("Varint too long");
+    }
+  }
+  throw new Error("Unexpected end of buffer reading varint");
+}
+function readVarint64(buf, offset) {
+  let result = 0;
+  let shift = 0;
+  let bytesRead = 0;
+  while (offset + bytesRead < buf.length && bytesRead < 10) {
+    const byte = buf[offset + bytesRead];
+    bytesRead++;
+    if (shift < 32) {
+      result |= (byte & 127) << shift;
+    }
+    if ((byte & 128) === 0) {
+      return [result >>> 0, bytesRead];
+    }
+    shift += 7;
+  }
+  throw new Error("Unexpected end of buffer reading varint64");
+}
+function getSnappyUncompressedLength(compressed) {
+  const [length] = readVarint(compressed, 0);
+  return length;
+}
+function parseBlockHandle(buf, offset) {
+  const [blockOffset, n1] = readVarint64(buf, offset);
+  const [blockSize, n2] = readVarint64(buf, offset + n1);
+  return { offset: blockOffset, size: blockSize, bytesRead: n1 + n2 };
+}
+function decompressBlock(blockData, compressionType) {
+  if (compressionType === COMPRESSION_NONE) {
+    return blockData;
+  }
+  if (compressionType === COMPRESSION_SNAPPY) {
+    const uncompressedLength = getSnappyUncompressedLength(blockData);
+    const result = snappyUncompress(blockData, uncompressedLength);
+    return Buffer.from(result);
+  }
+  throw new Error(`Unknown compression type: ${compressionType}`);
+}
+function parseDataBlock(block) {
+  const entries = [];
+  if (block.length < 4) {
+    return entries;
+  }
+  const numRestarts = block.readUInt32LE(block.length - 4);
+  const restartsStart = block.length - 4 - numRestarts * 4;
+  if (restartsStart < 0) {
+    return entries;
+  }
+  let offset = 0;
+  let prevKey = Buffer.alloc(0);
+  while (offset < restartsStart) {
+    try {
+      const [shared, n1] = readVarint(block, offset);
+      offset += n1;
+      const [nonShared, n2] = readVarint(block, offset);
+      offset += n2;
+      const [valueLen, n3] = readVarint(block, offset);
+      offset += n3;
+      if (offset + nonShared + valueLen > restartsStart) {
+        break;
+      }
+      const keyDelta = block.subarray(offset, offset + nonShared);
+      offset += nonShared;
+      const key = Buffer.concat([prevKey.subarray(0, shared), keyDelta]);
+      const value = block.subarray(offset, offset + valueLen);
+      offset += valueLen;
+      entries.push({ key: Buffer.from(key), value: Buffer.from(value) });
+      prevKey = key;
+    } catch {
+      break;
+    }
+  }
+  return entries;
+}
+async function parseSSTable(filePath) {
+  const entries = [];
+  let data;
+  try {
+    data = await readFile(filePath);
+  } catch {
+    return entries;
+  }
+  if (data.length < 48) {
+    return entries;
+  }
+  const footer = data.subarray(-48);
+  const magic = footer.subarray(40, 48);
+  if (!magic.equals(LEVELDB_MAGIC)) {
+    return entries;
+  }
+  try {
+    const { bytesRead: metaBytes } = parseBlockHandle(footer, 0);
+    const indexHandle = parseBlockHandle(footer, metaBytes);
+    const indexBlockStart = indexHandle.offset;
+    const indexBlockEnd = indexHandle.offset + indexHandle.size + 5;
+    if (indexBlockEnd > data.length - 48) {
+      return entries;
+    }
+    const indexBlockRaw = data.subarray(indexBlockStart, indexBlockEnd);
+    const indexCompressionType = indexBlockRaw.at(-5);
+    const indexBlockData = indexBlockRaw.subarray(0, -5);
+    const indexBlock = decompressBlock(indexBlockData, indexCompressionType);
+    const indexEntries = parseDataBlock(indexBlock);
+    for (const indexEntry of indexEntries) {
+      try {
+        const blockHandle = parseBlockHandle(indexEntry.value, 0);
+        const blockStart = blockHandle.offset;
+        const blockEnd = blockHandle.offset + blockHandle.size + 5;
+        if (blockEnd > data.length) {
+          continue;
+        }
+        const blockRaw = data.subarray(blockStart, blockEnd);
+        const compressionType = blockRaw.at(-5);
+        const blockData = blockRaw.subarray(0, -5);
+        const block = decompressBlock(blockData, compressionType);
+        const blockEntries = parseDataBlock(block);
+        entries.push(...blockEntries);
+      } catch {
+        continue;
+      }
+    }
+  } catch {
+    return entries;
+  }
+  return entries;
+}
+async function parseLogFile(filePath) {
+  const entries = [];
+  let data;
+  try {
+    data = await readFile(filePath);
+  } catch {
+    return entries;
+  }
+  const BLOCK_SIZE = 32768;
+  let offset = 0;
+  let pendingRecord = [];
+  while (offset < data.length) {
+    const blockOffset = offset % BLOCK_SIZE;
+    const remaining = BLOCK_SIZE - blockOffset;
+    if (remaining < 7) {
+      offset += remaining;
+      continue;
+    }
+    if (offset + 7 > data.length) {
+      break;
+    }
+    const length = data.readUInt16LE(offset + 4);
+    const type = data[offset + 6];
+    if (length === 0 || offset + 7 + length > data.length) {
+      offset += remaining;
+      pendingRecord = [];
+      continue;
+    }
+    const recordData = data.subarray(offset + 7, offset + 7 + length);
+    offset += 7 + length;
+    if (type === LOG_RECORD_FULL) {
+      pendingRecord = [];
+      parseLogBatch(recordData, entries);
+    } else if (type === LOG_RECORD_FIRST) {
+      pendingRecord = [recordData];
+    } else if (type === LOG_RECORD_MIDDLE) {
+      if (pendingRecord.length > 0) {
+        pendingRecord.push(recordData);
+      }
+    } else if (type === LOG_RECORD_LAST) {
+      if (pendingRecord.length > 0) {
+        pendingRecord.push(recordData);
+        const fullRecord = Buffer.concat(pendingRecord);
+        parseLogBatch(fullRecord, entries);
+      }
+      pendingRecord = [];
+    }
+  }
+  return entries;
+}
+function parseLogBatch(batch, entries) {
+  if (batch.length < 12) {
+    return;
+  }
+  let offset = 12;
+  while (offset < batch.length) {
+    try {
+      const recordType = batch[offset];
+      offset++;
+      if (recordType === 1) {
+        const [keyLen, n1] = readVarint(batch, offset);
+        offset += n1;
+        const key = batch.subarray(offset, offset + keyLen);
+        offset += keyLen;
+        const [valueLen, n2] = readVarint(batch, offset);
+        offset += n2;
+        const value = batch.subarray(offset, offset + valueLen);
+        offset += valueLen;
+        entries.push({ key: Buffer.from(key), value: Buffer.from(value) });
+      } else if (recordType === 0) {
+        const [keyLen, n1] = readVarint(batch, offset);
+        offset += n1 + keyLen;
+      } else {
+        break;
+      }
+    } catch {
+      break;
+    }
+  }
+}
+async function readChromiumLevelDB(dir) {
+  const entries = [];
+  let files;
+  try {
+    files = await readdir(dir);
+  } catch {
+    return entries;
+  }
+  const sstFiles = files.filter((f) => f.endsWith(".ldb") || f.endsWith(".sst"));
+  for (const file of sstFiles) {
+    const fileEntries = await parseSSTable(join2(dir, file));
+    entries.push(...fileEntries);
+  }
+  const logFiles = files.filter((f) => f.endsWith(".log"));
+  for (const file of logFiles) {
+    const fileEntries = await parseLogFile(join2(dir, file));
+    entries.push(...fileEntries);
+  }
+  return entries;
+}
+async function findKeysContaining(dir, substring) {
+  const allEntries = await readChromiumLevelDB(dir);
+  return allEntries.filter((entry) => entry.key.includes(substring));
+}
+
+// src/auth/desktop.ts
+async function queryReadonlySqlite(dbPath, sql) {
+  try {
+    const { Database } = await import("bun:sqlite");
+    const db = new Database(dbPath, { readonly: true });
+    try {
+      return db.query(sql).all();
+    } finally {
+      db.close();
+    }
+  } catch {
+    const { DatabaseSync } = await import("node:sqlite");
+    const db = new DatabaseSync(dbPath, { readOnly: true });
+    try {
+      return db.prepare(sql).all();
+    } finally {
+      db.close();
+    }
+  }
+}
+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");
+function getSlackPaths() {
+  const candidates = [SLACK_SUPPORT_DIR_ELECTRON, SLACK_SUPPORT_DIR_APPSTORE];
+  for (const dir of candidates) {
+    const leveldbDir = join3(dir, "Local Storage", "leveldb");
+    if (existsSync2(leveldbDir)) {
+      return { leveldbDir, cookiesDb: join3(dir, "Cookies") };
+    }
+  }
+  throw new Error(`Slack Desktop data not found. Checked:
+  - ${candidates.map((d) => join3(d, "Local Storage", "leveldb")).join(`
+  - `)}`);
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+function toDesktopTeam(value) {
+  if (!isRecord2(value)) {
+    return null;
+  }
+  const url = typeof value.url === "string" ? value.url : null;
+  const token = typeof value.token === "string" ? value.token : null;
+  if (!url || !token) {
+    return null;
+  }
+  const name = typeof value.name === "string" ? value.name : undefined;
+  return { url, name, token };
+}
+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 {
+    await cp(srcDir, dest, { recursive: true, force: true });
+  }
+  try {
+    await unlink(join3(dest, "LOCK"));
+  } catch {}
+  return dest;
+}
+function parseLocalConfig(raw) {
+  if (!raw || raw.length === 0) {
+    throw new Error("localConfig is empty");
+  }
+  const [first] = raw;
+  const data = first === 0 || first === 1 || first === 2 ? raw.subarray(1) : raw;
+  let nulCount = 0;
+  for (const b of data) {
+    if (b === 0) {
+      nulCount++;
+    }
+  }
+  const encodings = nulCount > data.length / 4 ? ["utf16le", "utf8"] : ["utf8", "utf16le"];
+  let lastErr;
+  for (const enc of encodings) {
+    try {
+      const text = data.toString(enc);
+      try {
+        return JSON.parse(text);
+      } catch (err1) {
+        lastErr = err1;
+      }
+      const start = text.indexOf("{");
+      const end = text.lastIndexOf("}");
+      if (start !== -1 && end !== -1 && end > start) {
+        try {
+          return JSON.parse(text.slice(start, end + 1));
+        } catch (err2) {
+          lastErr = err2;
+        }
+      }
+    } catch (err) {
+      lastErr = err;
+    }
+  }
+  throw lastErr || new Error("localConfig not parseable");
+}
+async function extractTeamsFromSlackLevelDb(leveldbDir) {
+  if (!existsSync2(leveldbDir)) {
+    throw new Error(`Slack LevelDB not found: ${leveldbDir}`);
+  }
+  const snap = await snapshotLevelDb(leveldbDir);
+  try {
+    const localConfigV2 = Buffer.from("localConfig_v2");
+    const localConfigV3 = Buffer.from("localConfig_v3");
+    const entries = await findKeysContaining(snap, Buffer.from("localConfig_v"));
+    let configBuf = null;
+    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;
+        }
+      }
+    }
+    if (!configBuf) {
+      throw new Error("Slack LevelDB did not contain localConfig_v2/v3");
+    }
+    const cfg = parseLocalConfig(configBuf);
+    const teamsValue = isRecord2(cfg) ? cfg.teams : undefined;
+    const teamsObj = isRecord2(teamsValue) ? teamsValue : {};
+    const teams = Object.values(teamsObj).map((t) => toDesktopTeam(t)).filter((t) => t !== null).filter((t) => t.token.startsWith("xoxc-"));
+    if (teams.length === 0) {
+      throw new Error("No xoxc tokens found in Slack localConfig");
+    }
+    return teams;
+  } finally {
+    try {
+      await rm(snap, { recursive: true, force: true });
+    } 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 {}
+  }
+  throw new Error('Could not read Safe Storage password from Keychain (tried "Slack Safe Storage").');
+}
+function decryptChromiumCookieValue(encrypted, password) {
+  if (!encrypted || encrypted.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 decipher = createDecipheriv("aes-128-cbc", key, iv);
+  decipher.setAutoPadding(true);
+  const plain = Buffer.concat([decipher.update(data), decipher.final()]);
+  const marker = Buffer.from("xoxd-");
+  const idx = plain.indexOf(marker);
+  if (idx === -1) {
+    return plain.toString("utf8");
+  }
+  let end = idx;
+  while (end < plain.length) {
+    const b = plain[end];
+    if (b < 33 || b > 126) {
+      break;
+    }
+    end++;
+  }
+  const rawToken = plain.subarray(idx, end).toString("utf8");
+  try {
+    return decodeURIComponent(rawToken);
+  } catch {
+    return rawToken;
+  }
+}
+async function extractCookieDFromSlackCookiesDb(cookiesPath) {
+  if (!existsSync2(cookiesPath)) {
+    throw new Error(`Slack Cookies DB not found: ${cookiesPath}`);
+  }
+  const rows = await queryReadonlySqlite(cookiesPath, "select host_key, name, value, encrypted_value from cookies where name = 'd' and host_key like '%slack.com' order by length(encrypted_value) desc");
+  if (!rows || rows.length === 0) {
+    throw new Error("No Slack 'd' cookie found");
+  }
+  const row = rows[0];
+  if (row.value && row.value.startsWith("xoxd-")) {
+    return row.value;
+  }
+  const encrypted = Buffer.from(row.encrypted_value || []);
+  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");
+  }
+  return match[0];
+}
+async function extractFromSlackDesktop() {
+  const { leveldbDir, cookiesDb } = getSlackPaths();
+  const teams = await extractTeamsFromSlackLevelDb(leveldbDir);
+  const cookie_d = await extractCookieDFromSlackCookiesDb(cookiesDb);
+  return {
+    cookie_d,
+    teams,
+    source: { leveldb_path: leveldbDir, cookies_path: cookiesDb }
+  };
+}
+
+// src/auth/paths.ts
+import { homedir as homedir2 } from "node:os";
+import { join as join4 } from "node:path";
+var AGENT_SLACK_DIR = join4(homedir2(), ".config", "agent-slack");
+var CREDENTIALS_FILE = join4(AGENT_SLACK_DIR, "credentials.json");
+var KEYCHAIN_SERVICE = "agent-slack";
+
+// src/lib/fs.ts
+import { mkdir as mkdir2, readFile as readFile2, writeFile } from "node:fs/promises";
+import { dirname as dirname2 } from "node:path";
+async function readJsonFile(path) {
+  try {
+    const raw = await readFile2(path, "utf8");
+    return JSON.parse(raw);
+  } catch (err) {
+    if (isRecord3(err) && err.code === "ENOENT") {
+      return null;
+    }
+    if (err instanceof SyntaxError) {
+      return null;
+    }
+    throw err;
+  }
+}
+async function writeJsonFile(path, data) {
+  await mkdir2(dirname2(path), { recursive: true });
+  await writeFile(path, `${JSON.stringify(data, null, 2)}
+`, { mode: 384 });
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null;
+}
+
+// src/auth/schema.ts
+import { z } from "zod";
+var WorkspaceAuthSchema = z.union([
+  z.object({
+    auth_type: z.literal("standard"),
+    token: z.string().min(1)
+  }),
+  z.object({
+    auth_type: z.literal("browser"),
+    xoxc_token: z.string().min(1),
+    xoxd_cookie: z.string().min(1)
+  })
+]);
+var WorkspaceSchema = z.object({
+  workspace_url: z.string().url(),
+  workspace_name: z.string().optional(),
+  team_id: z.string().optional(),
+  team_domain: z.string().optional(),
+  auth: WorkspaceAuthSchema
+});
+var CredentialsSchema = z.object({
+  version: z.literal(1),
+  updated_at: z.string().optional(),
+  default_workspace_url: z.string().url().optional(),
+  workspaces: z.array(WorkspaceSchema).default([])
+});
+
+// src/auth/keychain.ts
+import { platform as platform2 } from "node:os";
+import { execFileSync as execFileSync2 } from "node:child_process";
+var IS_MACOS2 = platform2() === "darwin";
+function keychainGet(account, service) {
+  if (!IS_MACOS2) {
+    return null;
+  }
+  try {
+    const result = execFileSync2("security", ["find-generic-password", "-s", service, "-a", account, "-w"], { encoding: "utf8", stdio: ["pipe", "pipe", "ignore"] });
+    return result.trim() || null;
+  } catch {
+    return null;
+  }
+}
+function keychainSet(input) {
+  if (!IS_MACOS2) {
+    return false;
+  }
+  const { account, value, service } = input;
+  try {
+    try {
+      execFileSync2("security", ["delete-generic-password", "-s", service, "-a", account], {
+        stdio: ["pipe", "pipe", "ignore"]
+      });
+    } catch {}
+    execFileSync2("security", ["add-generic-password", "-s", service, "-a", account, "-w", value], {
+      stdio: "pipe"
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/auth/store.ts
+import { platform as platform3 } from "node:os";
+var KEYCHAIN_PLACEHOLDER = "__KEYCHAIN__";
+var IS_MACOS3 = platform3() === "darwin";
+function normalizeWorkspaceUrl(workspaceUrl) {
+  const u = new URL(workspaceUrl);
+  return `${u.protocol}//${u.host}`;
+}
+function isPlaceholderSecret(value) {
+  return !value || value === KEYCHAIN_PLACEHOLDER;
+}
+async function loadCredentials() {
+  const fromFile = await readJsonFile(CREDENTIALS_FILE);
+  const parsed = CredentialsSchema.safeParse(fromFile ?? { version: 1, workspaces: [] });
+  if (!parsed.success) {
+    return { version: 1, workspaces: [] };
+  }
+  const creds = parsed.data;
+  const hydrated = creds.workspaces.map((w) => {
+    if (w.auth.auth_type === "browser") {
+      const account = `xoxc:${normalizeWorkspaceUrl(w.workspace_url)}`;
+      const xoxc = keychainGet(account, KEYCHAIN_SERVICE);
+      const xoxd = keychainGet("xoxd", KEYCHAIN_SERVICE);
+      return {
+        ...w,
+        auth: {
+          auth_type: "browser",
+          xoxc_token: xoxc ?? w.auth.xoxc_token,
+          xoxd_cookie: xoxd ?? w.auth.xoxd_cookie
+        }
+      };
+    }
+    if (w.auth.auth_type === "standard") {
+      const account = `token:${normalizeWorkspaceUrl(w.workspace_url)}`;
+      const token = keychainGet(account, KEYCHAIN_SERVICE);
+      return {
+        ...w,
+        auth: {
+          auth_type: "standard",
+          token: token ?? w.auth.token
+        }
+      };
+    }
+    return w;
+  });
+  return { ...creds, workspaces: hydrated };
+}
+async function saveCredentials(credentials) {
+  const payload = {
+    ...credentials,
+    updated_at: new Date().toISOString(),
+    workspaces: credentials.workspaces.map((w) => ({
+      ...w,
+      workspace_url: normalizeWorkspaceUrl(w.workspace_url)
+    }))
+  };
+  const filePayload = structuredClone(payload);
+  if (IS_MACOS3) {
+    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)) {
+      const existing = keychainGet("xoxd", KEYCHAIN_SERVICE);
+      xoxdStored = existing === firstBrowser.auth.xoxd_cookie || keychainSet({
+        account: "xoxd",
+        value: firstBrowser.auth.xoxd_cookie,
+        service: KEYCHAIN_SERVICE
+      });
+    }
+    for (const w of filePayload.workspaces) {
+      if (w.auth.auth_type === "browser") {
+        const account = `xoxc:${normalizeWorkspaceUrl(w.workspace_url)}`;
+        const tokenStored = isPlaceholderSecret(w.auth.xoxc_token) || keychainGet(account, KEYCHAIN_SERVICE) === w.auth.xoxc_token || keychainSet({ account, value: w.auth.xoxc_token, service: KEYCHAIN_SERVICE });
+        if (tokenStored) {
+          w.auth.xoxc_token = KEYCHAIN_PLACEHOLDER;
+        }
+        if (xoxdStored) {
+          w.auth.xoxd_cookie = KEYCHAIN_PLACEHOLDER;
+        }
+      }
+      if (w.auth.auth_type === "standard") {
+        const account = `token:${normalizeWorkspaceUrl(w.workspace_url)}`;
+        const tokenStored = isPlaceholderSecret(w.auth.token) || keychainGet(account, KEYCHAIN_SERVICE) === w.auth.token || keychainSet({ account, value: w.auth.token, service: KEYCHAIN_SERVICE });
+        if (tokenStored) {
+          w.auth.token = KEYCHAIN_PLACEHOLDER;
+        }
+      }
+    }
+  }
+  await writeJsonFile(CREDENTIALS_FILE, filePayload);
+}
+async function upsertWorkspace(workspace) {
+  const creds = await loadCredentials();
+  const normalizedUrl = normalizeWorkspaceUrl(workspace.workspace_url);
+  const next = { ...workspace, workspace_url: normalizedUrl };
+  const idx = creds.workspaces.findIndex((w) => normalizeWorkspaceUrl(w.workspace_url) === normalizedUrl);
+  if (idx === -1) {
+    creds.workspaces.push(next);
+  } else {
+    creds.workspaces[idx] = {
+      ...creds.workspaces[idx],
+      ...next,
+      auth: next.auth
+    };
+  }
+  if (!creds.default_workspace_url) {
+    creds.default_workspace_url = normalizedUrl;
+  }
+  await saveCredentials(creds);
+  return next;
+}
+async function upsertWorkspaces(workspaces) {
+  if (workspaces.length === 0) {
+    return;
+  }
+  const creds = await loadCredentials();
+  for (const workspace of workspaces) {
+    const normalizedUrl = normalizeWorkspaceUrl(workspace.workspace_url);
+    const next = { ...workspace, workspace_url: normalizedUrl };
+    const idx = creds.workspaces.findIndex((w) => normalizeWorkspaceUrl(w.workspace_url) === normalizedUrl);
+    if (idx === -1) {
+      creds.workspaces.push(next);
+    } else {
+      creds.workspaces[idx] = {
+        ...creds.workspaces[idx],
+        ...next,
+        auth: next.auth
+      };
+    }
+    if (!creds.default_workspace_url) {
+      creds.default_workspace_url = normalizedUrl;
+    }
+  }
+  await saveCredentials(creds);
+}
+async function setDefaultWorkspace(workspaceUrl) {
+  const creds = await loadCredentials();
+  creds.default_workspace_url = normalizeWorkspaceUrl(workspaceUrl);
+  await saveCredentials(creds);
+}
+async function removeWorkspace(workspaceUrl) {
+  const creds = await loadCredentials();
+  const normalized = normalizeWorkspaceUrl(workspaceUrl);
+  creds.workspaces = creds.workspaces.filter((w) => normalizeWorkspaceUrl(w.workspace_url) !== normalized);
+  if (creds.default_workspace_url === normalized) {
+    creds.default_workspace_url = creds.workspaces[0]?.workspace_url;
+  }
+  await saveCredentials(creds);
+}
+async function resolveWorkspaceForUrl(workspaceUrl) {
+  const creds = await loadCredentials();
+  const normalized = normalizeWorkspaceUrl(workspaceUrl);
+  return creds.workspaces.find((w) => normalizeWorkspaceUrl(w.workspace_url) === normalized) ?? null;
+}
+async function resolveDefaultWorkspace() {
+  const creds = await loadCredentials();
+  if (creds.default_workspace_url) {
+    const byDefault = creds.workspaces.find((w) => w.workspace_url === creds.default_workspace_url);
+    if (byDefault) {
+      return byDefault;
+    }
+  }
+  return creds.workspaces[0] ?? null;
+}
+
+// src/slack/channels.ts
+function isChannelId(input) {
+  return /^[CDG][A-Z0-9]{8,}$/.test(input);
+}
+function normalizeChannelInput(input) {
+  const trimmed = input.trim();
+  if (trimmed.startsWith("#")) {
+    return { kind: "name", value: trimmed.slice(1) };
+  }
+  if (isChannelId(trimmed)) {
+    return { kind: "id", value: trimmed };
+  }
+  return { kind: "name", value: trimmed };
+}
+async function resolveChannelId(client, input) {
+  const normalized = normalizeChannelInput(input);
+  if (normalized.kind === "id") {
+    return normalized.value;
+  }
+  const name = normalized.value;
+  if (!name) {
+    throw new Error("Channel name is empty");
+  }
+  let cursor;
+  const matches = [];
+  for (;; ) {
+    const resp = await client.api("conversations.list", {
+      exclude_archived: true,
+      limit: 200,
+      cursor,
+      types: "public_channel,private_channel"
+    });
+    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
+        });
+      }
+    }
+    const meta = isRecord4(resp.response_metadata) ? resp.response_metadata : null;
+    const next = meta ? getString(meta.next_cursor) : undefined;
+    if (!next) {
+      break;
+    }
+    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(", ")})`);
+}
+function isRecord4(value) {
+  return typeof value === "object" && value !== null;
+}
+function asArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+function getString(value) {
+  return typeof value === "string" ? value : undefined;
+}
+
+// src/slack/client.ts
+import { WebClient } from "@slack/web-api";
+class SlackApiClient {
+  auth;
+  web;
+  workspaceUrl;
+  constructor(auth, options) {
+    this.auth = auth;
+    this.workspaceUrl = options?.workspaceUrl;
+    if (auth.auth_type === "standard") {
+      this.web = new WebClient(auth.token);
+    }
+  }
+  async api(method, params = {}) {
+    if (this.auth.auth_type === "standard") {
+      if (!this.web) {
+        throw new Error("WebClient not initialized");
+      }
+      return await this.web.apiCall(method, params);
+    }
+    if (!this.workspaceUrl) {
+      throw new Error("Browser auth requires workspace URL. Provide --workspace-url or set SLACK_WORKSPACE_URL, or call via a Slack message URL.");
+    }
+    const { auth } = this;
+    if (auth.auth_type !== "browser") {
+      throw new Error("Browser API requires browser auth");
+    }
+    return this.browserApi({
+      workspaceUrl: this.workspaceUrl,
+      auth,
+      method,
+      params
+    });
+  }
+  async browserApi(input) {
+    const attempt = input.attempt ?? 0;
+    const url = `${input.workspaceUrl.replace(/\/$/, "")}/api/${input.method}`;
+    const cleanedEntries = Object.entries(input.params).filter(([, v]) => v !== undefined).map(([k, v]) => [k, String(v)]);
+    const formBody = new URLSearchParams({
+      token: input.auth.xoxc_token,
+      ...Object.fromEntries(cleanedEntries)
+    });
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        Cookie: `d=${encodeURIComponent(input.auth.xoxd_cookie)}`,
+        "Content-Type": "application/x-www-form-urlencoded",
+        Origin: "https://app.slack.com",
+        "User-Agent": getUserAgent()
+      },
+      body: formBody
+    });
+    if (response.status === 429 && attempt < 3) {
+      const retryAfter = Number(response.headers.get("Retry-After") ?? "5");
+      const delayMs = Math.min(Math.max(retryAfter, 1) * 1000, 30000);
+      await new Promise((r) => setTimeout(r, delayMs));
+      return this.browserApi({
+        ...input,
+        attempt: attempt + 1
+      });
+    }
+    const data = await response.json().catch(() => ({}));
+    if (!response.ok) {
+      throw new Error(`Slack HTTP ${response.status} calling ${input.method}`);
+    }
+    if (!isRecord5(data) || data.ok !== true) {
+      const error = isRecord5(data) && typeof data.error === "string" ? data.error : null;
+      throw new Error(error || `Slack API error calling ${input.method}`);
+    }
+    return data;
+  }
+}
+function isRecord5(value) {
+  return typeof value === "object" && value !== null;
+}
+
+// src/cli/context.ts
+function isEnvAuthConfigured() {
+  return Boolean(process.env.SLACK_TOKEN?.trim());
+}
+function effectiveWorkspaceUrl(flag) {
+  return flag?.trim() || process.env.SLACK_WORKSPACE_URL?.trim() || undefined;
+}
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function parseContentType(value) {
+  const raw = String(value ?? "any").toLowerCase();
+  if (raw === "text" || raw === "image" || raw === "snippet" || raw === "file") {
+    return raw;
+  }
+  return "any";
+}
+async function assertWorkspaceSpecifiedForChannelNames(input) {
+  const hasName = input.channels.some((c) => normalizeChannelInput(c).kind === "name");
+  if (!hasName) {
+    return;
+  }
+  const creds = await loadCredentials();
+  if ((creds.workspaces?.length ?? 0) <= 1) {
+    return;
+  }
+  if (!input.workspaceUrl) {
+    throw new Error('Ambiguous channel name across multiple workspaces. Pass --workspace "https://...slack.com" (or set SLACK_WORKSPACE_URL).');
+  }
+}
+function isAuthErrorMessage(message) {
+  return /(?:^|[^a-z])(invalid_auth|token_expired)(?:$|[^a-z])/i.test(message);
+}
+function normalizeUrl(u) {
+  const url = new URL(u);
+  return `${url.protocol}//${url.host}`;
+}
+async function refreshFromDesktopIfPossible() {
+  if (process.platform !== "darwin") {
+    return false;
+  }
+  try {
+    const extracted = await extractFromSlackDesktop();
+    await upsertWorkspaces(extracted.teams.map((team) => ({
+      workspace_url: normalizeUrl(team.url),
+      workspace_name: team.name,
+      auth: {
+        auth_type: "browser",
+        xoxc_token: team.token,
+        xoxd_cookie: extracted.cookie_d
+      }
+    })));
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function withAutoRefresh(input) {
+  try {
+    return await input.work();
+  } catch (err) {
+    const message = errorMessage(err);
+    if (isEnvAuthConfigured()) {
+      throw err;
+    }
+    if (!isAuthErrorMessage(message)) {
+      throw err;
+    }
+    const refreshed = await refreshFromDesktopIfPossible();
+    if (!refreshed) {
+      throw err;
+    }
+    return await input.work();
+  }
+}
+function pickAuthFromEnv() {
+  const token = process.env.SLACK_TOKEN?.trim();
+  if (!token) {
+    return null;
+  }
+  if (token.startsWith("xoxc-")) {
+    const cookie = (process.env.SLACK_COOKIE_D || process.env.SLACK_COOKIE || "").trim();
+    if (!cookie) {
+      throw new Error("SLACK_TOKEN looks like xoxc- but SLACK_COOKIE_D is missing");
+    }
+    return { auth_type: "browser", xoxc_token: token, xoxd_cookie: cookie };
+  }
+  return { auth_type: "standard", token };
+}
+async function getClientForWorkspace(workspaceUrl) {
+  const env = pickAuthFromEnv();
+  if (env) {
+    const envWorkspaceUrl = process.env.SLACK_WORKSPACE_URL?.trim();
+    const urlForBrowser = workspaceUrl || envWorkspaceUrl;
+    return {
+      client: new SlackApiClient(env, { workspaceUrl: urlForBrowser }),
+      auth: env,
+      workspace_url: urlForBrowser
+    };
+  }
+  if (workspaceUrl) {
+    const ws = await resolveWorkspaceForUrl(workspaceUrl);
+    if (ws) {
+      return {
+        client: new SlackApiClient(ws.auth, {
+          workspaceUrl: ws.workspace_url
+        }),
+        auth: ws.auth,
+        workspace_url: ws.workspace_url
+      };
+    }
+  }
+  const def = await resolveDefaultWorkspace();
+  if (def) {
+    return {
+      client: new SlackApiClient(def.auth, {
+        workspaceUrl: def.workspace_url
+      }),
+      auth: def.auth,
+      workspace_url: def.workspace_url
+    };
+  }
+  try {
+    const extracted = await extractFromSlackDesktop();
+    await upsertWorkspaces(extracted.teams.map((team) => ({
+      workspace_url: normalizeUrl(team.url),
+      workspace_name: team.name,
+      auth: {
+        auth_type: "browser",
+        xoxc_token: team.token,
+        xoxd_cookie: extracted.cookie_d
+      }
+    })));
+    const desired = workspaceUrl ? await resolveWorkspaceForUrl(workspaceUrl) : await resolveDefaultWorkspace();
+    const chosen = desired ?? await resolveDefaultWorkspace();
+    if (chosen) {
+      return {
+        client: new SlackApiClient(chosen.auth, {
+          workspaceUrl: chosen.workspace_url
+        }),
+        auth: chosen.auth,
+        workspace_url: chosen.workspace_url
+      };
+    }
+  } catch {}
+  const chrome = extractFromChrome();
+  if (chrome && chrome.teams.length > 0) {
+    const chosen = (workspaceUrl ? chrome.teams.find((t) => normalizeUrl(t.url) === normalizeUrl(workspaceUrl)) : null) ?? chrome.teams[0];
+    const auth = {
+      auth_type: "browser",
+      xoxc_token: chosen.token,
+      xoxd_cookie: chrome.cookie_d
+    };
+    await upsertWorkspace({
+      workspace_url: normalizeUrl(chosen.url),
+      workspace_name: chosen.name,
+      auth: {
+        auth_type: "browser",
+        xoxc_token: chosen.token,
+        xoxd_cookie: chrome.cookie_d
+      }
+    });
+    return {
+      client: new SlackApiClient(auth, {
+        workspaceUrl: normalizeUrl(chosen.url)
+      }),
+      auth,
+      workspace_url: normalizeUrl(chosen.url)
+    };
+  }
+  throw new Error('No Slack credentials available. Try "agent-slack auth import-desktop" or set SLACK_TOKEN / SLACK_COOKIE_D.');
+}
+function createCliContext() {
+  return {
+    effectiveWorkspaceUrl,
+    assertWorkspaceSpecifiedForChannelNames,
+    withAutoRefresh,
+    getClientForWorkspace,
+    normalizeUrl,
+    errorMessage,
+    parseContentType,
+    parseCurl: parseSlackCurlCommand,
+    importDesktop: extractFromSlackDesktop,
+    importChrome: extractFromChrome
+  };
+}
+
+// src/lib/compact-json.ts
+function pruneEmpty(value) {
+  const pruned = pruneEmptyInternal(value);
+  return pruned === undefined ? {} : pruned;
+}
+function pruneEmptyInternal(value) {
+  if (value === null || value === undefined) {
+    return;
+  }
+  if (typeof value === "string") {
+    return value.trim() === "" ? undefined : value;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    const next = value.map((v) => pruneEmptyInternal(v)).filter((v) => v !== undefined);
+    return next.length === 0 ? undefined : next;
+  }
+  if (typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      const next = pruneEmptyInternal(v);
+      if (next !== undefined) {
+        out[k] = next;
+      }
+    }
+    return Object.keys(out).length === 0 ? undefined : out;
+  }
+  return value;
+}
+
+// src/lib/redact.ts
+function redactSecret(value, options) {
+  const keepStart = options?.keepStart ?? 6;
+  const keepEnd = options?.keepEnd ?? 4;
+  if (!value) {
+    return value;
+  }
+  if (value.length <= keepStart + keepEnd + 3) {
+    return "[redacted]";
+  }
+  return `${value.slice(0, keepStart)}…${value.slice(-keepEnd)}`;
+}
+
+// src/cli/auth-command.ts
+async function runAuthTest(input) {
+  return input.ctx.withAutoRefresh({
+    workspaceUrl: input.workspaceUrl,
+    work: async () => {
+      const { client } = await input.ctx.getClientForWorkspace(input.workspaceUrl);
+      return await client.api("auth.test", {});
+    }
+  });
+}
+function registerAuthCommand(input) {
+  const auth = input.program.command("auth").description("Manage Slack authentication");
+  auth.command("whoami").description("Show configured workspaces and token sources").action(async () => {
+    try {
+      const creds = await loadCredentials();
+      const sanitized = {
+        ...creds,
+        workspaces: creds.workspaces.map((w) => ({
+          workspace_url: w.workspace_url,
+          workspace_name: w.workspace_name,
+          auth_type: w.auth.auth_type,
+          token: w.auth.auth_type === "standard" ? redactSecret(w.auth.token) : redactSecret(w.auth.xoxc_token),
+          cookie_d: w.auth.auth_type === "browser" ? redactSecret(w.auth.xoxd_cookie) : undefined
+        }))
+      };
+      console.log(JSON.stringify(pruneEmpty(sanitized), null, 2));
+    } catch (err) {
+      console.error(input.ctx.errorMessage(err));
+      process.exitCode = 1;
+    }
+  });
+  auth.command("test").description("Verify credentials (calls Slack auth.test)").option("--workspace <url>", "Workspace URL (needed when you have multiple workspaces)").action(async (...args) => {
+    const [options] = args;
+    try {
+      const resp = await runAuthTest({
+        ctx: input.ctx,
+        workspaceUrl: input.ctx.effectiveWorkspaceUrl(options.workspace)
+      });
+      console.log(JSON.stringify(pruneEmpty(resp), null, 2));
+    } catch (err) {
+      console.error(input.ctx.errorMessage(err));
+      process.exitCode = 1;
+    }
+  });
+  auth.command("import-chrome").description("Import xoxc/xoxd from a logged-in Slack tab in Google Chrome (macOS)").action(async () => {
+    try {
+      const extracted = input.ctx.importChrome();
+      if (!extracted) {
+        throw new Error("Could not extract tokens from Chrome. Open Slack in Chrome and ensure you're logged in.");
+      }
+      for (const team of extracted.teams) {
+        await upsertWorkspace({
+          workspace_url: input.ctx.normalizeUrl(team.url),
+          workspace_name: team.name,
+          auth: {
+            auth_type: "browser",
+            xoxc_token: team.token,
+            xoxd_cookie: extracted.cookie_d
+          }
+        });
+      }
+      console.log(`Imported ${extracted.teams.length} workspace token(s) from Chrome.`);
+    } catch (err) {
+      console.error(input.ctx.errorMessage(err));
+      process.exitCode = 1;
+    }
+  });
+  auth.command("parse-curl").description("Paste a Slack API request copied as cURL (extracts xoxc/xoxd and saves locally)").action(async () => {
+    try {
+      const curlInput = await new Response(process.stdin).text();
+      if (!curlInput.trim()) {
+        throw new Error("Expected cURL command on stdin");
+      }
+      const parsed = input.ctx.parseCurl(curlInput);
+      await upsertWorkspace({
+        workspace_url: input.ctx.normalizeUrl(parsed.workspace_url),
+        auth: {
+          auth_type: "browser",
+          xoxc_token: parsed.xoxc_token,
+          xoxd_cookie: parsed.xoxd_cookie
+        }
+      });
+      console.log(`Imported tokens for ${input.ctx.normalizeUrl(parsed.workspace_url)}.`);
+    } catch (err) {
+      console.error(input.ctx.errorMessage(err));
+      process.exitCode = 1;
+    }
+  });
+  auth.command("import-desktop").description("Import xoxc token(s) + d cookie from Slack Desktop data (TypeScript; no need to quit Slack)").action(async () => {
+    try {
+      const extracted = await input.ctx.importDesktop();
+      await upsertWorkspaces(extracted.teams.map((team) => ({
+        workspace_url: input.ctx.normalizeUrl(team.url),
+        workspace_name: team.name,
+        auth: {
+          auth_type: "browser",
+          xoxc_token: team.token,
+          xoxd_cookie: extracted.cookie_d
+        }
+      })));
+      const payload = {
+        imported: extracted.teams.length,
+        source: extracted.source,
+        workspaces: extracted.teams.map((t) => ({
+          workspace_url: input.ctx.normalizeUrl(t.url),
+          workspace_name: t.name
+        }))
+      };
+      console.log(JSON.stringify(pruneEmpty(payload), null, 2));
+    } catch (err) {
+      console.error(input.ctx.errorMessage(err));
+      process.exitCode = 1;
+    }
+  });
+  auth.command("add").description("Add credentials (standard token or browser xoxc/xoxd)").requiredOption("--workspace-url <url>", "Workspace URL like https://myteam.slack.com").option("--token <token>", "Standard Slack token (xoxb/xoxp)").option("--xoxc <token>", "Browser token (xoxc-...)").option("--xoxd <cookie>", "Browser cookie d (xoxd-...)").action(async (...args) => {
+    const [options] = args;
+    try {
+      const workspaceUrl = input.ctx.normalizeUrl(options.workspaceUrl);
+      if (options.token) {
+        await upsertWorkspace({
+          workspace_url: workspaceUrl,
+          auth: { auth_type: "standard", token: options.token }
+        });
+        console.log("Saved standard token.");
+        return;
+      }
+      if (options.xoxc && options.xoxd) {
+        await upsertWorkspace({
+          workspace_url: workspaceUrl,
+          auth: {
+            auth_type: "browser",
+            xoxc_token: options.xoxc,
+            xoxd_cookie: options.xoxd
+          }
+        });
+        console.log("Saved browser tokens.");
+        return;
+      }
+      throw new Error("Provide either --token or both --xoxc and --xoxd");
+    } catch (err) {
+      console.error(input.ctx.errorMessage(err));
+      process.exitCode = 1;
+    }
+  });
+  auth.command("set-default").description("Set the default workspace URL").argument("<workspace-url>", "Workspace URL like https://myteam.slack.com").action(async (...args) => {
+    const [workspaceUrl] = args;
+    try {
+      await setDefaultWorkspace(workspaceUrl);
+      console.log("Default workspace updated.");
+    } catch (err) {
+      console.error(input.ctx.errorMessage(err));
+      process.exitCode = 1;
+    }
+  });
+  auth.command("remove").description("Remove a workspace from local config").argument("<workspace-url>", "Workspace URL like https://myteam.slack.com").action(async (...args) => {
+    const [workspaceUrl] = args;
+    try {
+      await removeWorkspace(workspaceUrl);
+      console.log("Removed workspace.");
+    } catch (err) {
+      console.error(input.ctx.errorMessage(err));
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/slack/files.ts
+import { mkdir as mkdir3, writeFile as writeFile2 } from "node:fs/promises";
+import { basename, join as join5, resolve } from "node:path";
+import { existsSync as existsSync3 } from "node:fs";
+async function downloadSlackFile(input) {
+  const { auth, url, destDir, preferredName, options } = input;
+  const absDir = resolve(destDir);
+  await mkdir3(absDir, { recursive: true });
+  const name = sanitizeFilename(preferredName || basename(new URL(url).pathname) || "file");
+  const path = join5(absDir, name);
+  if (existsSync3(path)) {
+    return path;
+  }
+  const headers = {};
+  if (auth.auth_type === "standard") {
+    headers.Authorization = `Bearer ${auth.token}`;
+  } else {
+    headers.Authorization = `Bearer ${auth.xoxc_token}`;
+    headers.Cookie = `d=${encodeURIComponent(auth.xoxd_cookie)}`;
+    headers.Referer = "https://app.slack.com/";
+    headers["User-Agent"] = getUserAgent();
+  }
+  const resp = await fetch(url, { headers });
+  if (!resp.ok) {
+    throw new Error(`Failed to download file (${resp.status})`);
+  }
+  const contentType = resp.headers.get("content-type") || "";
+  if (!options?.allowHtml && contentType.includes("text/html")) {
+    const text = await resp.text();
+    throw new Error(`Downloaded HTML instead of file (auth likely failed). First bytes: ${JSON.stringify(text.slice(0, 120))}`);
+  }
+  const buf = Buffer.from(await resp.arrayBuffer());
+  await writeFile2(path, buf);
+  return path;
+}
+function sanitizeFilename(name) {
+  return name.replace(/[\\/<>:"|?*]/g, "_");
+}
+
+// src/slack/html-to-md.ts
+import TurndownService from "turndown";
+import { gfm } from "turndown-plugin-gfm";
+function htmlToMarkdown(html) {
+  const service = new TurndownService({
+    headingStyle: "atx",
+    codeBlockStyle: "fenced",
+    bulletListMarker: "-",
+    emDelimiter: "_"
+  });
+  service.use(gfm);
+  service.addRule("br", {
+    filter: "br",
+    replacement: () => `
+`
+  });
+  const extracted = extractTag(html, "main") ?? extractTag(html, "article") ?? extractTag(html, "body") ?? html;
+  return service.turndown(extracted);
+}
+function extractTag(html, tag) {
+  const re = new RegExp(`<${tag}\\b[^>]*>([\\s\\S]*?)<\\/${tag}>`, "i");
+  const m = html.match(re);
+  return m ? m[1] : null;
+}
+
+// src/lib/tmp-paths.ts
+import { join as join7, resolve as resolve2 } from "node:path";
+import { mkdir as mkdir4 } from "node:fs/promises";
+
+// src/lib/app-dir.ts
+import { homedir as homedir3, tmpdir } from "node:os";
+import { join as join6 } from "node:path";
+function getAppDir() {
+  const xdg = process.env.XDG_RUNTIME_DIR?.trim();
+  if (xdg) {
+    return join6(xdg, "agent-slack");
+  }
+  const home = homedir3();
+  if (home) {
+    return join6(home, ".agent-slack");
+  }
+  return join6(tmpdir(), "agent-slack");
+}
+
+// src/lib/tmp-paths.ts
+function getDownloadsDir() {
+  return resolve2(join7(getAppDir(), "tmp", "downloads"));
+}
+async function ensureDownloadsDir() {
+  const dir = getDownloadsDir();
+  await mkdir4(dir, { recursive: true });
+  return dir;
+}
+
+// src/slack/canvas.ts
+import { readFile as readFile3 } from "node:fs/promises";
+function parseSlackCanvasUrl(input) {
+  let url;
+  try {
+    url = new URL(input);
+  } catch {
+    throw new Error(`Invalid URL: ${input}`);
+  }
+  if (!/\.slack\.com$/i.test(url.hostname)) {
+    throw new Error(`Not a Slack workspace URL: ${url.hostname}`);
+  }
+  const parts = url.pathname.split("/").filter(Boolean);
+  if (parts[0] !== "docs") {
+    throw new Error(`Unsupported Slack canvas URL path: ${url.pathname}`);
+  }
+  const canvas_id = parts.find((p) => /^F[A-Z0-9]{8,}$/.test(p));
+  if (!canvas_id) {
+    throw new Error(`Could not find canvas id in: ${url.pathname}`);
+  }
+  const workspace_url = `${url.protocol}//${url.host}`;
+  return { workspace_url, canvas_id, raw: input };
+}
+async function fetchCanvasMarkdown(client, input) {
+  const info = await client.api("files.info", { file: input.canvasId });
+  const file = isRecord6(info.file) ? info.file : null;
+  if (!file) {
+    throw new Error("Canvas not found (files.info returned no file)");
+  }
+  const title = (getString2(file.title) || getString2(file.name) || "").trim() || undefined;
+  const downloadUrl = getString2(file.url_private_download) ?? getString2(file.url_private);
+  if (!downloadUrl) {
+    throw new Error("Canvas has no download URL");
+  }
+  let html = "";
+  if (input.options?.downloadHtml ?? true) {
+    const htmlPath = await downloadSlackFile({
+      auth: input.auth,
+      url: downloadUrl,
+      destDir: await ensureDownloadsDir(),
+      preferredName: `${input.canvasId}.html`,
+      options: { allowHtml: true }
+    });
+    html = await readFile3(htmlPath, "utf8");
+  } else {
+    const headers = {};
+    if (input.auth.auth_type === "standard") {
+      headers.Authorization = `Bearer ${input.auth.token}`;
+    } else {
+      headers.Authorization = `Bearer ${input.auth.xoxc_token}`;
+      headers.Cookie = `d=${encodeURIComponent(input.auth.xoxd_cookie)}`;
+      headers.Referer = "https://app.slack.com/";
+      headers["User-Agent"] = getUserAgent();
+    }
+    const resp = await fetch(downloadUrl, { headers });
+    if (!resp.ok) {
+      throw new Error(`Failed to download canvas HTML (${resp.status})`);
+    }
+    html = await resp.text();
+  }
+  const markdownRaw = htmlToMarkdown(html).trim();
+  const maxChars = input.options?.maxChars ?? 20000;
+  const markdown = maxChars >= 0 && markdownRaw.length > maxChars ? `${markdownRaw.slice(0, maxChars)}
+…` : markdownRaw;
+  return {
+    canvas: {
+      id: input.canvasId,
+      title,
+      markdown
+    }
+  };
+}
+function isRecord6(value) {
+  return typeof value === "object" && value !== null;
+}
+function getString2(value) {
+  return typeof value === "string" ? value : undefined;
+}
+
+// src/cli/canvas-command.ts
+function registerCanvasCommand(input) {
+  const canvasCmd = input.program.command("canvas").description("Work with Slack canvases");
+  canvasCmd.command("get").description("Fetch a Slack canvas and convert it to Markdown").argument("<canvas>", "Slack canvas URL (…/docs/…/F…) or canvas id (F…)").option("--workspace <url>", "Workspace URL (required if passing a canvas id and you have multiple workspaces)").option("--max-chars <n>", "Max markdown characters to include (default 20000, -1 for unlimited)", "20000").action(async (...args) => {
+    const [value, options] = args;
+    try {
+      let workspaceUrl;
+      let canvasId;
+      try {
+        const ref = parseSlackCanvasUrl(value);
+        workspaceUrl = ref.workspace_url;
+        canvasId = ref.canvas_id;
+      } catch {
+        const trimmed = String(value).trim();
+        if (!/^F[A-Z0-9]{8,}$/.test(trimmed)) {
+          throw new Error(`Unsupported canvas input: ${value} (expected Slack canvas URL or id like F...)`);
+        }
+        canvasId = trimmed;
+        workspaceUrl = options.workspace?.trim() || undefined;
+      }
+      const payload = await input.ctx.withAutoRefresh({
+        workspaceUrl,
+        work: async () => {
+          const { client, auth, workspace_url } = await input.ctx.getClientForWorkspace(workspaceUrl);
+          const maxChars = Number.parseInt(options.maxChars, 10);
+          return await fetchCanvasMarkdown(client, {
+            auth,
+            workspaceUrl: workspace_url ?? workspaceUrl ?? "",
+            canvasId,
+            options: { maxChars }
+          });
+        }
+      });
+      console.log(JSON.stringify(pruneEmpty(payload), null, 2));
+    } catch (err) {
+      console.error(input.ctx.errorMessage(err));
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/slack/emoji.ts
+import * as emoji from "node-emoji";
+function slackEmojiShortcodesToUnicode(text) {
+  if (!text) {
+    return "";
+  }
+  return emoji.emojify(text);
+}
+function normalizeSlackReactionName(input) {
+  const trimmed = String(input ?? "").trim();
+  if (!trimmed) {
+    throw new Error("Emoji is empty");
+  }
+  const shortcodeMatch = trimmed.match(/^:([^:\s]+):$/);
+  if (shortcodeMatch) {
+    return shortcodeMatch[1];
+  }
+  if (/^[A-Za-z0-9_+-]+$/.test(trimmed)) {
+    return trimmed;
+  }
+  const viaNodeEmoji = emoji.which(trimmed);
+  if (viaNodeEmoji) {
+    return viaNodeEmoji;
+  }
+  throw new Error(`Unsupported emoji format: ${JSON.stringify(input)} (use :emoji: or unicode emoji)`);
+}
+
+// src/slack/mrkdwn.ts
+function slackMrkdwnToMarkdown(text) {
+  if (!text) {
+    return "";
+  }
+  let out = text.replace(/<((https?:\/\/)[^>|]+)\|([^>]+)>/g, "[$3]($1)");
+  out = out.replace(/<((https?:\/\/)[^>]+)>/g, "$1");
+  out = out.replace(/<#[A-Z0-9]+\|([^>]+)>/g, "#$1");
+  out = out.replace(/<@([A-Z0-9]+)\|([^>]+)>/g, "@$2");
+  out = out.replace(/<@([A-Z0-9]+)>/g, "@$1");
+  out = out.replace(/<!([a-zA-Z]+)>/g, "@$1");
+  out = out.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&");
+  out = slackEmojiShortcodesToUnicode(out);
+  return out;
+}
+
+// src/slack/render.ts
+function renderSlackMessageContent(msg) {
+  const msgObj = isRecord7(msg) ? msg : {};
+  const blockMrkdwn = extractMrkdwnFromBlocks(msgObj.blocks);
+  if (blockMrkdwn.trim()) {
+    return slackMrkdwnToMarkdown(blockMrkdwn).trim();
+  }
+  const attachmentMrkdwn = extractMrkdwnFromAttachments(msgObj.attachments);
+  if (attachmentMrkdwn.trim()) {
+    return slackMrkdwnToMarkdown(attachmentMrkdwn).trim();
+  }
+  const text = getString3(msgObj.text).trim();
+  if (text) {
+    return slackMrkdwnToMarkdown(text).trim();
+  }
+  return "";
+}
+function extractMrkdwnFromBlocks(blocks) {
+  if (!Array.isArray(blocks)) {
+    return "";
+  }
+  const out = [];
+  for (const b of blocks) {
+    if (!isRecord7(b)) {
+      continue;
+    }
+    const type = getString3(b.type);
+    if (type === "section") {
+      const text = isRecord7(b.text) ? b.text : null;
+      const textType = text ? getString3(text.type) : "";
+      if (textType === "mrkdwn" || textType === "plain_text") {
+        out.push(getString3(text?.text));
+      }
+      if (Array.isArray(b.fields)) {
+        for (const f of b.fields) {
+          if (!isRecord7(f)) {
+            continue;
+          }
+          const fieldType = getString3(f.type);
+          if (fieldType === "mrkdwn" || fieldType === "plain_text") {
+            out.push(getString3(f.text));
+          }
+        }
+      }
+      const accessory = isRecord7(b.accessory) ? b.accessory : null;
+      if (getString3(accessory?.type) === "button") {
+        const label = getString3(accessory?.text?.text);
+        const url = getString3(accessory?.url);
+        if (url) {
+          out.push(label ? `${label}: ${url}` : url);
+        }
+      }
+      continue;
+    }
+    if (type === "actions" && Array.isArray(b.elements)) {
+      for (const el of b.elements) {
+        if (!isRecord7(el)) {
+          continue;
+        }
+        if (getString3(el.type) === "button") {
+          const label = getString3(el.text?.text);
+          const url = getString3(el.url);
+          if (url) {
+            out.push(label ? `${label}: ${url}` : url);
+          }
+        }
+      }
+      continue;
+    }
+    if (type === "context" && Array.isArray(b.elements)) {
+      for (const el of b.elements) {
+        if (!isRecord7(el)) {
+          continue;
+        }
+        const elType = getString3(el.type);
+        if (elType === "mrkdwn") {
+          out.push(getString3(el.text));
+        }
+        if (elType === "plain_text") {
+          out.push(getString3(el.text));
+        }
+      }
+      continue;
+    }
+    if (type === "image") {
+      const alt = getString3(b.alt_text);
+      const url = getString3(b.image_url);
+      if (url) {
+        out.push(alt ? `${alt}: ${url}` : url);
+      }
+      continue;
+    }
+    if (type === "rich_text") {
+      const rich = extractMrkdwnFromRichTextBlock(b);
+      if (rich.trim()) {
+        out.push(rich);
+      }
+      continue;
+    }
+  }
+  return out.join(`
+
+`);
+}
+function extractMrkdwnFromRichTextBlock(block) {
+  if (!isRecord7(block)) {
+    return "";
+  }
+  const elements = Array.isArray(block.elements) ? block.elements : [];
+  const out = [];
+  for (const el of elements) {
+    const txt = extractMrkdwnFromRichTextElement(el);
+    if (txt.trim()) {
+      out.push(txt);
+    }
+  }
+  return out.join(`
+
+`);
+}
+function extractMrkdwnFromRichTextElement(el) {
+  if (!isRecord7(el)) {
+    return "";
+  }
+  const t = getString3(el.type);
+  if (t === "rich_text_section") {
+    const parts = [];
+    for (const child of Array.isArray(el.elements) ? el.elements : []) {
+      parts.push(extractMrkdwnFromRichTextElement(child));
+    }
+    return parts.join("");
+  }
+  if (t === "rich_text_preformatted") {
+    const parts = [];
+    for (const child of Array.isArray(el.elements) ? el.elements : []) {
+      parts.push(extractMrkdwnFromRichTextElement(child));
+    }
+    const text = parts.join("");
+    return text ? `\`\`\`${text}\`\`\`` : "";
+  }
+  if (t === "rich_text_quote") {
+    const parts = [];
+    for (const child of Array.isArray(el.elements) ? el.elements : []) {
+      parts.push(extractMrkdwnFromRichTextElement(child));
+    }
+    const text = parts.join("").trim();
+    if (!text) {
+      return "";
+    }
+    return text.split(`
+`).map((line) => `> ${line}`).join(`
+`);
+  }
+  if (t === "rich_text_list") {
+    const style = typeof el.style === "string" ? el.style : "bullet";
+    const items = [];
+    const itemEls = Array.isArray(el.elements) ? el.elements : [];
+    for (let idx = 0;idx < itemEls.length; idx++) {
+      const item = itemEls[idx];
+      const txt = extractMrkdwnFromRichTextElement(item).trim();
+      if (!txt) {
+        continue;
+      }
+      const prefix = style === "ordered" ? `${idx + 1}. ` : "- ";
+      items.push(`${prefix}${txt}`);
+    }
+    return items.join(`
+`);
+  }
+  if (t === "text") {
+    const raw = getString3(el.text);
+    const style = isRecord7(el.style) ? el.style : null;
+    if (!style) {
+      return raw;
+    }
+    let text = raw;
+    if (style.code) {
+      text = `\`${text}\``;
+    }
+    if (style.bold) {
+      text = `*${text}*`;
+    }
+    if (style.italic) {
+      text = `_${text}_`;
+    }
+    if (style.strike) {
+      text = `~${text}~`;
+    }
+    return text;
+  }
+  if (t === "link") {
+    const url = getString3(el.url);
+    const text = getString3(el.text);
+    if (!url) {
+      return text;
+    }
+    return text ? `<${url}|${text}>` : url;
+  }
+  if (t === "emoji") {
+    const name = getString3(el.name);
+    return name ? `:${name}:` : "";
+  }
+  if (t === "user") {
+    const userId = getString3(el.user_id);
+    return userId ? `<@${userId}>` : "";
+  }
+  if (t === "channel") {
+    const channelId = getString3(el.channel_id);
+    return channelId ? `<#${channelId}>` : "";
+  }
+  return "";
+}
+function extractMrkdwnFromAttachments(attachments) {
+  if (!Array.isArray(attachments)) {
+    return "";
+  }
+  const parts = [];
+  for (const a of attachments) {
+    if (!isRecord7(a)) {
+      continue;
+    }
+    const chunk = [];
+    const blocks = extractMrkdwnFromBlocks(a.blocks);
+    if (blocks.trim()) {
+      chunk.push(blocks);
+    }
+    const pretext = getString3(a.pretext);
+    if (pretext) {
+      chunk.push(pretext);
+    }
+    const title = getString3(a.title);
+    const titleLink = getString3(a.title_link);
+    if (titleLink && title) {
+      chunk.push(`<${titleLink}|${title}>`);
+    } else if (title) {
+      chunk.push(title);
+    } else if (titleLink) {
+      chunk.push(titleLink);
+    }
+    const text = getString3(a.text);
+    if (text) {
+      chunk.push(text);
+    }
+    if (Array.isArray(a.fields)) {
+      for (const f of a.fields) {
+        if (!isRecord7(f)) {
+          continue;
+        }
+        const fieldTitle = getString3(f.title);
+        const value = getString3(f.value);
+        if (fieldTitle && value) {
+          chunk.push(`${fieldTitle}
+${value}`);
+        } else if (fieldTitle) {
+          chunk.push(fieldTitle);
+        } else if (value) {
+          chunk.push(value);
+        }
+      }
+    }
+    const fallback = getString3(a.fallback);
+    if (chunk.length === 0 && fallback) {
+      chunk.push(fallback);
+    }
+    if (chunk.length > 0) {
+      parts.push(chunk.join(`
+`));
+    }
+  }
+  return parts.join(`
+
+`);
+}
+function isRecord7(value) {
+  return typeof value === "object" && value !== null;
+}
+function getString3(value) {
+  return typeof value === "string" ? value : "";
+}
+
+// src/slack/messages.ts
+function toCompactMessage(msg, input) {
+  const maxBodyChars = input?.maxBodyChars ?? 8000;
+  const includeReactions = input?.includeReactions ?? false;
+  const rendered = renderSlackMessageContent(msg);
+  const content = maxBodyChars >= 0 && rendered.length > maxBodyChars ? `${rendered.slice(0, maxBodyChars)}
+…` : rendered;
+  const files = msg.files?.map((f) => {
+    const path = input?.downloadedPaths?.[f.id];
+    if (!path) {
+      return null;
+    }
+    return {
+      mimetype: f.mimetype,
+      mode: f.mode,
+      path
+    };
+  }).filter((f) => Boolean(f));
+  return {
+    channel_id: msg.channel_id,
+    ts: msg.ts,
+    thread_ts: msg.thread_ts ?? ((msg.reply_count ?? 0) > 0 ? msg.ts : undefined),
+    author: msg.user || msg.bot_id ? { user_id: msg.user, bot_id: msg.bot_id } : undefined,
+    content: content ? content : undefined,
+    files: files && files.length > 0 ? files : undefined,
+    reactions: includeReactions ? compactReactions(msg.reactions) : undefined
+  };
+}
+function compactReactions(reactions) {
+  if (!Array.isArray(reactions) || reactions.length === 0) {
+    return;
+  }
+  const out = [];
+  for (const r of reactions) {
+    if (!isRecord8(r)) {
+      continue;
+    }
+    const name = getString4(r.name)?.trim() ?? "";
+    if (!name) {
+      continue;
+    }
+    const users = Array.isArray(r.users) ? r.users.map((u) => String(u)).filter((u) => /^U[A-Z0-9]{8,}$/.test(u)) : [];
+    const count = typeof r.count === "number" && r.count !== users.length ? r.count : undefined;
+    out.push({ name, users, count });
+  }
+  return out.length ? out : undefined;
+}
+async function fetchMessage(client, input) {
+  const history = await client.api("conversations.history", {
+    channel: input.ref.channel_id,
+    latest: input.ref.message_ts,
+    inclusive: true,
+    limit: 5,
+    include_all_metadata: input.includeReactions ? true : undefined
+  });
+  const historyMessages = asArray2(history.messages);
+  let msg = historyMessages.find((m) => isRecord8(m) && getString4(m.ts) === input.ref.message_ts);
+  if (!msg && input.ref.thread_ts_hint) {
+    msg = await findMessageInThread(client, {
+      channelId: input.ref.channel_id,
+      threadTs: input.ref.thread_ts_hint,
+      targetTs: input.ref.message_ts,
+      includeReactions: input.includeReactions
+    });
+  }
+  if (!msg) {
+    try {
+      const rootResp = await client.api("conversations.replies", {
+        channel: input.ref.channel_id,
+        ts: input.ref.message_ts,
+        limit: 1,
+        include_all_metadata: input.includeReactions ? true : undefined
+      });
+      const [root] = asArray2(rootResp.messages);
+      if (isRecord8(root) && getString4(root.ts) === input.ref.message_ts) {
+        msg = root;
+      }
+    } catch {}
+  }
+  if (!msg) {
+    throw new Error("Message not found (no access or wrong URL)");
+  }
+  const files = asArray2(msg.files).map((f) => toSlackFileSummary(f)).filter((f) => f !== null);
+  const enrichedFiles = files.length > 0 ? await enrichFiles(client, files) : undefined;
+  const text = getString4(msg.text) ?? "";
+  const ts = getString4(msg.ts) ?? input.ref.message_ts;
+  const blocks = Array.isArray(msg.blocks) ? msg.blocks : undefined;
+  const attachments = Array.isArray(msg.attachments) ? msg.attachments : undefined;
+  const reactions = Array.isArray(msg.reactions) ? msg.reactions : undefined;
+  return {
+    channel_id: input.ref.channel_id,
+    ts,
+    thread_ts: getString4(msg.thread_ts),
+    reply_count: getNumber(msg.reply_count),
+    user: getString4(msg.user),
+    bot_id: getString4(msg.bot_id),
+    text,
+    markdown: slackMrkdwnToMarkdown(text),
+    blocks,
+    attachments,
+    files: enrichedFiles,
+    reactions
+  };
+}
+async function findMessageInThread(client, input) {
+  let cursor;
+  for (;; ) {
+    const resp = await client.api("conversations.replies", {
+      channel: input.channelId,
+      ts: input.threadTs,
+      limit: 200,
+      cursor,
+      include_all_metadata: input.includeReactions ? true : undefined
+    });
+    const messages = asArray2(resp.messages);
+    const found = messages.find((m) => isRecord8(m) && getString4(m.ts) === input.targetTs);
+    if (found) {
+      return found;
+    }
+    const meta = isRecord8(resp.response_metadata) ? resp.response_metadata : null;
+    const next = meta ? getString4(meta.next_cursor) : undefined;
+    if (!next) {
+      break;
+    }
+    cursor = next;
+  }
+  return;
+}
+async function fetchThread(client, input) {
+  const out = [];
+  let cursor;
+  for (;; ) {
+    const resp = await client.api("conversations.replies", {
+      channel: input.channelId,
+      ts: input.threadTs,
+      limit: 200,
+      cursor,
+      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
+      });
+    }
+    const meta = isRecord8(resp.response_metadata) ? resp.response_metadata : null;
+    const next = meta ? getString4(meta.next_cursor) : undefined;
+    if (!next) {
+      break;
+    }
+    cursor = next;
+  }
+  out.sort((a, b) => Number.parseFloat(a.ts) - Number.parseFloat(b.ts));
+  return out;
+}
+async function enrichFiles(client, files) {
+  const out = [];
+  for (const f of files) {
+    if (f.mode === "snippet" || !f.url_private_download) {
+      try {
+        const info = await client.api("files.info", { file: f.id });
+        const file = isRecord8(info.file) ? info.file : null;
+        out.push({
+          ...f,
+          name: f.name ?? getString4(file?.name),
+          title: f.title ?? getString4(file?.title),
+          mimetype: f.mimetype ?? getString4(file?.mimetype),
+          filetype: f.filetype ?? getString4(file?.filetype),
+          mode: f.mode ?? getString4(file?.mode),
+          permalink: f.permalink ?? getString4(file?.permalink),
+          url_private: f.url_private ?? getString4(file?.url_private),
+          url_private_download: f.url_private_download ?? getString4(file?.url_private_download),
+          snippet: {
+            content: getString4(file?.content),
+            language: getString4(file?.filetype)
+          }
+        });
+        continue;
+      } catch {}
+    }
+    out.push(f);
+  }
+  return out;
+}
+function isRecord8(value) {
+  return typeof value === "object" && value !== null;
+}
+function getString4(value) {
+  return typeof value === "string" ? value : undefined;
+}
+function getNumber(value) {
+  return typeof value === "number" ? value : undefined;
+}
+function asArray2(value) {
+  return Array.isArray(value) ? value : [];
+}
+function toSlackFileSummary(value) {
+  if (!isRecord8(value)) {
+    return null;
+  }
+  const id = getString4(value.id);
+  if (!id) {
+    return null;
+  }
+  return {
+    id,
+    name: getString4(value.name),
+    title: getString4(value.title),
+    mimetype: getString4(value.mimetype),
+    filetype: getString4(value.filetype),
+    mode: getString4(value.mode),
+    permalink: getString4(value.permalink),
+    url_private: getString4(value.url_private),
+    url_private_download: getString4(value.url_private_download),
+    size: getNumber(value.size)
+  };
+}
+
+// src/slack/url.ts
+function parseSlackMessageUrl(input) {
+  let url;
+  try {
+    url = new URL(input);
+  } catch {
+    throw new Error(`Invalid URL: ${input}`);
+  }
+  if (!/\.slack\.com$/i.test(url.hostname)) {
+    throw new Error(`Not a Slack workspace URL: ${url.hostname}`);
+  }
+  const parts = url.pathname.split("/").filter(Boolean);
+  if (parts.length < 3 || parts[0] !== "archives") {
+    throw new Error(`Unsupported Slack URL path: ${url.pathname}`);
+  }
+  const channel_id = parts[1];
+  const messagePart = parts[2];
+  const match = messagePart.match(/^p(\d{7,})$/);
+  if (!match) {
+    throw new Error(`Unsupported Slack message id: ${messagePart}`);
+  }
+  const digits = match[1];
+  if (digits.length <= 6) {
+    throw new Error(`Invalid Slack message id: ${messagePart}`);
+  }
+  const seconds = digits.slice(0, -6);
+  const micros = digits.slice(-6);
+  const message_ts = `${seconds}.${micros}`;
+  const threadTsParam = url.searchParams.get("thread_ts");
+  const thread_ts_hint = threadTsParam && /^\d{6,}\.\d{6}$/.test(threadTsParam) ? threadTsParam : undefined;
+  const hasCid = url.searchParams.has("cid");
+  const possiblyTruncated = Boolean(threadTsParam && !hasCid);
+  const workspace_url = `${url.protocol}//${url.host}`;
+  return { workspace_url, channel_id, message_ts, thread_ts_hint, raw: input, possiblyTruncated };
+}
+
+// src/cli/targets.ts
+function parseMsgTarget(input) {
+  const trimmed = input.trim();
+  if (!trimmed) {
+    throw new Error("Missing target");
+  }
+  try {
+    const ref = parseSlackMessageUrl(trimmed);
+    return { kind: "url", ref };
+  } catch {}
+  if (trimmed.startsWith("#")) {
+    return { kind: "channel", channel: trimmed };
+  }
+  if (isChannelId(trimmed)) {
+    return { kind: "channel", channel: trimmed };
+  }
+  return { kind: "channel", channel: `#${trimmed}` };
+}
+
+// src/cli/message-actions.ts
+function isRecord9(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asArray3(value) {
+  return Array.isArray(value) ? value : [];
+}
+function getNumber2(value) {
+  return typeof value === "number" ? value : undefined;
+}
+async function getThreadSummary(client, input) {
+  const replyCount = input.msg.reply_count ?? 0;
+  const rootTs = input.msg.thread_ts ?? (replyCount > 0 ? input.msg.ts : null);
+  if (!rootTs) {
+    return null;
+  }
+  if (!input.msg.thread_ts && replyCount > 0) {
+    return { ts: rootTs, length: 1 + replyCount };
+  }
+  const resp = await client.api("conversations.replies", {
+    channel: input.channelId,
+    ts: rootTs,
+    limit: 1
+  });
+  const [root] = asArray3(isRecord9(resp) ? resp.messages : undefined);
+  const rootReplyCount = isRecord9(root) ? getNumber2(root.reply_count) : undefined;
+  if (rootReplyCount === undefined) {
+    return { ts: rootTs, length: 1 };
+  }
+  return { ts: rootTs, length: 1 + rootReplyCount };
+}
+function inferExt(file) {
+  const mt = (file.mimetype || "").toLowerCase();
+  const ft = (file.filetype || "").toLowerCase();
+  if (mt === "image/png" || ft === "png") {
+    return "png";
+  }
+  if (mt === "image/jpeg" || mt === "image/jpg" || ft === "jpg" || ft === "jpeg") {
+    return "jpg";
+  }
+  if (mt === "image/webp" || ft === "webp") {
+    return "webp";
+  }
+  if (mt === "image/gif" || ft === "gif") {
+    return "gif";
+  }
+  if (mt === "text/plain" || ft === "text") {
+    return "txt";
+  }
+  if (mt === "text/markdown" || ft === "markdown" || ft === "md") {
+    return "md";
+  }
+  if (mt === "application/json" || ft === "json") {
+    return "json";
+  }
+  const name = file.name || file.title || "";
+  const m = name.match(/\.([A-Za-z0-9]{1,10})$/);
+  return m ? m[1].toLowerCase() : null;
+}
+async function downloadFilesForMessages(input) {
+  const downloadedPaths = {};
+  const downloadsDir = await ensureDownloadsDir();
+  for (const m of input.messages) {
+    for (const f of m.files ?? []) {
+      if (downloadedPaths[f.id]) {
+        continue;
+      }
+      const url = 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;
+    }
+  }
+  return downloadedPaths;
+}
+function toThreadListMessage(m) {
+  const { channel_id: _channelId, thread_ts: _threadTs, ...rest } = m;
+  return rest;
+}
+function warnIfTruncated(ref) {
+  if (ref.possiblyTruncated) {
+    console.error(`Hint: URL may have been truncated by shell. Quote URLs containing "&":
+` + '  agent-slack message get "https://...?thread_ts=...&cid=..."');
+  }
+}
+async function handleMessageGet(input) {
+  const target = parseMsgTarget(input.targetInput);
+  const workspaceUrl = input.ctx.effectiveWorkspaceUrl(input.options.workspace);
+  return input.ctx.withAutoRefresh({
+    workspaceUrl: target.kind === "url" ? target.ref.workspace_url : workspaceUrl,
+    work: async () => {
+      if (target.kind === "url") {
+        const { ref: ref2 } = target;
+        warnIfTruncated(ref2);
+        const { client: client2, auth: auth2 } = await input.ctx.getClientForWorkspace(ref2.workspace_url);
+        const includeReactions2 = Boolean(input.options.includeReactions);
+        const msg2 = await fetchMessage(client2, { ref: ref2, includeReactions: includeReactions2 });
+        const thread2 = await getThreadSummary(client2, { channelId: ref2.channel_id, msg: msg2 });
+        const downloadedPaths2 = await downloadFilesForMessages({ auth: auth2, messages: [msg2] });
+        const maxBodyChars2 = Number.parseInt(input.options.maxBodyChars, 10);
+        const message2 = toCompactMessage(msg2, { maxBodyChars: maxBodyChars2, includeReactions: includeReactions2, downloadedPaths: downloadedPaths2 });
+        return pruneEmpty({ message: message2, thread: thread2 });
+      }
+      const ts = input.options.ts?.trim();
+      if (!ts) {
+        throw new Error('When targeting a channel, you must pass --ts "<seconds>.<micros>"');
+      }
+      await input.ctx.assertWorkspaceSpecifiedForChannelNames({
+        workspaceUrl,
+        channels: [target.channel]
+      });
+      const includeReactions = Boolean(input.options.includeReactions);
+      const { client, auth, workspace_url } = await input.ctx.getClientForWorkspace(workspaceUrl);
+      const channelId = await resolveChannelId(client, target.channel);
+      const ref = {
+        workspace_url: workspace_url ?? workspaceUrl ?? "",
+        channel_id: channelId,
+        message_ts: ts,
+        thread_ts_hint: input.options.threadTs?.trim() || undefined,
+        raw: input.targetInput
+      };
+      const msg = await fetchMessage(client, { ref, includeReactions });
+      const thread = await getThreadSummary(client, { channelId, msg });
+      const downloadedPaths = await downloadFilesForMessages({ auth, messages: [msg] });
+      const maxBodyChars = Number.parseInt(input.options.maxBodyChars, 10);
+      const message = toCompactMessage(msg, { maxBodyChars, includeReactions, downloadedPaths });
+      return pruneEmpty({ message, thread });
+    }
+  });
+}
+async function handleMessageList(input) {
+  const target = parseMsgTarget(input.targetInput);
+  const workspaceUrl = input.ctx.effectiveWorkspaceUrl(input.options.workspace);
+  return input.ctx.withAutoRefresh({
+    workspaceUrl: target.kind === "url" ? target.ref.workspace_url : workspaceUrl,
+    work: async () => {
+      if (target.kind === "url") {
+        const { ref } = target;
+        warnIfTruncated(ref);
+        const { client: client2, auth: auth2 } = await input.ctx.getClientForWorkspace(ref.workspace_url);
+        const includeReactions2 = Boolean(input.options.includeReactions);
+        const msg = await fetchMessage(client2, { ref, includeReactions: includeReactions2 });
+        const rootTs2 = msg.thread_ts ?? msg.ts;
+        const threadMessages2 = await fetchThread(client2, {
+          channelId: ref.channel_id,
+          threadTs: rootTs2,
+          includeReactions: includeReactions2
+        });
+        const downloadedPaths2 = await downloadFilesForMessages({ auth: auth2, messages: threadMessages2 });
+        const maxBodyChars2 = Number.parseInt(input.options.maxBodyChars, 10);
+        return pruneEmpty({
+          messages: threadMessages2.map((m) => toCompactMessage(m, { maxBodyChars: maxBodyChars2, includeReactions: includeReactions2, downloadedPaths: downloadedPaths2 })).map(toThreadListMessage)
+        });
+      }
+      const { client, auth, workspace_url } = await input.ctx.getClientForWorkspace(workspaceUrl);
+      await input.ctx.assertWorkspaceSpecifiedForChannelNames({
+        workspaceUrl,
+        channels: [target.channel]
+      });
+      const channelId = await resolveChannelId(client, target.channel);
+      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 rootTs = threadTs ?? await (async () => {
+        const ref = {
+          workspace_url: workspace_url ?? workspaceUrl ?? "",
+          channel_id: channelId,
+          message_ts: ts,
+          raw: input.targetInput
+        };
+        const includeReactions2 = Boolean(input.options.includeReactions);
+        const msg = await fetchMessage(client, { ref, includeReactions: includeReactions2 });
+        return msg.thread_ts ?? msg.ts;
+      })();
+      const includeReactions = Boolean(input.options.includeReactions);
+      const threadMessages = await fetchThread(client, {
+        channelId,
+        threadTs: rootTs,
+        includeReactions
+      });
+      const downloadedPaths = await downloadFilesForMessages({ auth, messages: threadMessages });
+      const maxBodyChars = Number.parseInt(input.options.maxBodyChars, 10);
+      return pruneEmpty({
+        messages: threadMessages.map((m) => toCompactMessage(m, { maxBodyChars, includeReactions, downloadedPaths })).map(toThreadListMessage)
+      });
+    }
+  });
+}
+async function sendMessage(input) {
+  const target = parseMsgTarget(String(input.targetInput));
+  if (target.kind === "url") {
+    const { ref } = target;
+    warnIfTruncated(ref);
+    await input.ctx.withAutoRefresh({
+      workspaceUrl: ref.workspace_url,
+      work: async () => {
+        const { client } = await input.ctx.getClientForWorkspace(ref.workspace_url);
+        const msg = await fetchMessage(client, { ref });
+        const threadTs = msg.thread_ts ?? msg.ts;
+        await client.api("chat.postMessage", {
+          channel: ref.channel_id,
+          text: input.text,
+          thread_ts: threadTs
+        });
+      }
+    });
+    return { ok: true };
+  }
+  const workspaceUrl = input.ctx.effectiveWorkspaceUrl(input.options.workspace);
+  await input.ctx.assertWorkspaceSpecifiedForChannelNames({
+    workspaceUrl,
+    channels: [String(target.channel)]
+  });
+  await input.ctx.withAutoRefresh({
+    workspaceUrl,
+    work: async () => {
+      const { client } = await input.ctx.getClientForWorkspace(workspaceUrl);
+      const channelId = await resolveChannelId(client, String(target.channel));
+      await client.api("chat.postMessage", {
+        channel: channelId,
+        text: input.text,
+        thread_ts: input.options.threadTs ? String(input.options.threadTs) : undefined
+      });
+    }
+  });
+  return { ok: true };
+}
+async function reactOnTarget(input) {
+  const target = parseMsgTarget(input.targetInput);
+  const workspaceUrl = input.ctx.effectiveWorkspaceUrl(input.options?.workspace);
+  await input.ctx.withAutoRefresh({
+    workspaceUrl: target.kind === "url" ? target.ref.workspace_url : workspaceUrl,
+    work: async () => {
+      if (target.kind === "url") {
+        const { ref } = target;
+        warnIfTruncated(ref);
+        const { client: client2 } = await input.ctx.getClientForWorkspace(ref.workspace_url);
+        const name2 = normalizeSlackReactionName(input.emoji);
+        await client2.api(`reactions.${input.action}`, {
+          channel: ref.channel_id,
+          timestamp: ref.message_ts,
+          name: name2
+        });
+        return;
+      }
+      const ts = input.options?.ts?.trim();
+      if (!ts) {
+        throw new Error('When targeting a channel, you must pass --ts "<seconds>.<micros>"');
+      }
+      await input.ctx.assertWorkspaceSpecifiedForChannelNames({
+        workspaceUrl,
+        channels: [target.channel]
+      });
+      const { client } = await input.ctx.getClientForWorkspace(workspaceUrl);
+      const channelId = await resolveChannelId(client, target.channel);
+      const name = normalizeSlackReactionName(input.emoji);
+      await client.api(`reactions.${input.action}`, {
+        channel: channelId,
+        timestamp: ts,
+        name
+      });
+    }
+  });
+  return { ok: true };
+}
+
+// src/cli/message-command.ts
+function registerMessageCommand(input) {
+  const messageCmd = input.program.command("message").description("Read/write Slack messages (token-efficient JSON)");
+  messageCmd.command("get", { isDefault: true }).description("Fetch a single Slack message (with thread summary if any)").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("--ts <ts>", "Message ts (required when using #channel/channel id)").option("--thread-ts <ts>", "Thread root ts hint (useful for thread permalinks)").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 handleMessageGet({ ctx: input.ctx, targetInput, options });
+      console.log(JSON.stringify(payload, null, 2));
+    } catch (err) {
+      console.error(input.ctx.errorMessage(err));
+      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) => {
+    const [targetInput, options] = args;
+    try {
+      const payload = await handleMessageList({ ctx: input.ctx, targetInput, options });
+      console.log(JSON.stringify(payload, null, 2));
+    } catch (err) {
+      console.error(input.ctx.errorMessage(err));
+      process.exitCode = 1;
+    }
+  });
+  messageCmd.command("send").description("Send a message (optionally into a thread)").argument("<target>", "Slack message URL, #name/name, or channel id").argument("<text>", "Message text to post").option("--workspace <url>", "Workspace URL (needed when using #channel/channel id and you have multiple workspaces)").option("--thread-ts <ts>", "Thread root ts to post into (optional)").action(async (...args) => {
+    const [targetInput, text, options] = args;
+    try {
+      const payload = await sendMessage({
+        ctx: input.ctx,
+        targetInput,
+        text,
+        options
+      });
+      console.log(JSON.stringify(payload, null, 2));
+    } catch (err) {
+      console.error(input.ctx.errorMessage(err));
+      process.exitCode = 1;
+    }
+  });
+  const reactCmd = messageCmd.command("react").description("Add or remove reactions");
+  reactCmd.command("add").description("Add a reaction to a message").argument("<target>", "Slack message URL, #channel, or channel ID").argument("<emoji>", "Emoji to react with (:rocket:, rocket, or \uD83D\uDE80)").option("--workspace <url>", "Workspace URL (needed when using #channel/channel id and you have multiple workspaces)").option("--ts <ts>", "Message ts (required when using #channel/channel id)").action(async (...args) => {
+    const [targetInput, emoji2, options] = args;
+    try {
+      const payload = await reactOnTarget({
+        ctx: input.ctx,
+        action: "add",
+        targetInput,
+        emoji: emoji2,
+        options
+      });
+      console.log(JSON.stringify(payload, null, 2));
+    } catch (err) {
+      console.error(input.ctx.errorMessage(err));
+      process.exitCode = 1;
+    }
+  });
+  reactCmd.command("remove").description("Remove a reaction from a message").argument("<target>", "Slack message URL, #channel, or channel ID").argument("<emoji>", "Emoji to remove (:rocket:, rocket, or \uD83D\uDE80)").option("--workspace <url>", "Workspace URL (needed when using #channel/channel id and you have multiple workspaces)").option("--ts <ts>", "Message ts (required when using #channel/channel id)").action(async (...args) => {
+    const [targetInput, emoji2, options] = args;
+    try {
+      const payload = await reactOnTarget({
+        ctx: input.ctx,
+        action: "remove",
+        targetInput,
+        emoji: emoji2,
+        options
+      });
+      console.log(JSON.stringify(payload, null, 2));
+    } catch (err) {
+      console.error(input.ctx.errorMessage(err));
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/slack/search-guards.ts
+function isRecord10(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asArray4(value) {
+  return Array.isArray(value) ? value : [];
+}
+function getString5(value) {
+  return typeof value === "string" ? value : undefined;
+}
+function getNumber3(value) {
+  return typeof value === "number" ? value : undefined;
+}
+
+// src/slack/search-query.ts
+async function buildSlackSearchQuery(client, input) {
+  const parts = [];
+  const base = input.query.trim();
+  if (base) {
+    parts.push(base);
+  }
+  if (input.after) {
+    parts.push(`after:${validateDate(input.after)}`);
+  }
+  if (input.before) {
+    parts.push(`before:${validateDate(input.before)}`);
+  }
+  if (input.user) {
+    const token = await userTokenForSearch(client, input.user);
+    if (token) {
+      parts.push(token);
+    }
+  }
+  if (input.channels && input.channels.length > 0) {
+    for (const ch of input.channels) {
+      const inToken = await channelTokenForSearch(client, ch);
+      if (inToken) {
+        parts.push(inToken);
+      }
+    }
+  }
+  return parts.join(" ");
+}
+function validateDate(s) {
+  const v = s.trim();
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(v)) {
+    throw new Error(`Invalid date: ${s} (expected YYYY-MM-DD)`);
+  }
+  return v;
+}
+function dateToUnixSeconds(date, edge) {
+  const d = validateDate(date);
+  const iso = edge === "start" ? `${d}T00:00:00.000Z` : `${d}T23:59:59.999Z`;
+  return Math.floor(Date.parse(iso) / 1000);
+}
+async function userTokenForSearch(client, user) {
+  const trimmed = user.trim();
+  if (!trimmed) {
+    return null;
+  }
+  if (trimmed.startsWith("@")) {
+    return `from:@${trimmed.slice(1)}`;
+  }
+  if (/^U[A-Z0-9]{8,}$/.test(trimmed)) {
+    try {
+      const info = await client.api("users.info", { user: trimmed });
+      const infoUser = isRecord10(info) ? info.user : null;
+      const name = isRecord10(infoUser) ? (getString5(infoUser.name) ?? "").trim() : "";
+      return name ? `from:@${name}` : null;
+    } catch {
+      return null;
+    }
+  }
+  return `from:@${trimmed}`;
+}
+async function channelTokenForSearch(client, channel) {
+  const normalized = normalizeChannelInput(channel);
+  if (normalized.kind === "name") {
+    const name = normalized.value.trim();
+    if (!name) {
+      return null;
+    }
+    return `in:#${name}`;
+  }
+  try {
+    const info = await client.api("conversations.info", {
+      channel: normalized.value
+    });
+    const channelInfo = isRecord10(info) ? info.channel : null;
+    const name = isRecord10(channelInfo) ? (getString5(channelInfo.name) ?? "").trim() : "";
+    if (name) {
+      return `in:#${name}`;
+    }
+  } catch {}
+  return null;
+}
+async function resolveUserId(client, input) {
+  const trimmed = input.trim();
+  if (!trimmed) {
+    return;
+  }
+  if (/^U[A-Z0-9]{8,}$/.test(trimmed)) {
+    return trimmed;
+  }
+  const name = trimmed.startsWith("@") ? trimmed.slice(1) : trimmed;
+  let cursor;
+  for (;; ) {
+    const resp = await client.api("users.list", { limit: 200, cursor });
+    const members = isRecord10(resp) ? asArray4(resp.members).filter(isRecord10) : [];
+    const found = members.find((m) => {
+      const mName = getString5(m.name);
+      const profile = isRecord10(m.profile) ? m.profile : null;
+      const display = profile ? getString5(profile.display_name) : undefined;
+      return mName === name || display === name;
+    });
+    const foundId = found ? getString5(found.id) : undefined;
+    if (foundId) {
+      return foundId;
+    }
+    const meta = isRecord10(resp) ? resp.response_metadata : null;
+    const next = isRecord10(meta) ? getString5(meta.next_cursor) : undefined;
+    if (!next) {
+      break;
+    }
+    cursor = next;
+  }
+  return;
+}
+
+// src/slack/search-raw.ts
+async function searchMessagesRaw(client, input) {
+  const pageSize = Math.min(Math.max(input.limit, 1), 100);
+  const out = [];
+  let page = 1;
+  let pages = 1;
+  for (;; ) {
+    const resp = await client.api("search.messages", {
+      query: input.query,
+      count: pageSize,
+      page,
+      highlight: false,
+      sort: "timestamp",
+      sort_dir: "desc"
+    });
+    const messages = isRecord10(resp) ? resp.messages : null;
+    const matches = isRecord10(messages) ? asArray4(messages.matches).filter(isRecord10) : [];
+    out.push(...matches);
+    const paging = isRecord10(messages) ? messages.paging ?? messages.pagination : null;
+    const totalPages = Number(isRecord10(paging) ? paging.pages ?? 1 : 1);
+    if (Number.isFinite(totalPages) && totalPages > 0) {
+      pages = totalPages;
+    }
+    if (out.length >= input.limit) {
+      break;
+    }
+    if (matches.length === 0) {
+      break;
+    }
+    if (page >= pages) {
+      break;
+    }
+    page++;
+  }
+  return out.slice(0, input.limit);
+}
+async function searchFilesRaw(client, input) {
+  const pageSize = Math.min(Math.max(input.limit, 1), 100);
+  const out = [];
+  let page = 1;
+  let pages = 1;
+  for (;; ) {
+    const resp = await client.api("search.files", {
+      query: input.query,
+      count: pageSize,
+      page,
+      highlight: false,
+      sort: "timestamp",
+      sort_dir: "desc"
+    });
+    const files = isRecord10(resp) ? resp.files : null;
+    const matches = isRecord10(files) ? asArray4(files.matches).filter(isRecord10) : [];
+    out.push(...matches);
+    const paging = isRecord10(files) ? files.paging ?? files.pagination : null;
+    const totalPages = Number(isRecord10(paging) ? paging.pages ?? 1 : 1);
+    if (Number.isFinite(totalPages) && totalPages > 0) {
+      pages = totalPages;
+    }
+    if (out.length >= input.limit) {
+      break;
+    }
+    if (matches.length === 0) {
+      break;
+    }
+    if (page >= pages) {
+      break;
+    }
+    page++;
+  }
+  return out.slice(0, input.limit);
+}
+
+// src/slack/search-file-ext.ts
+function inferExt2(file) {
+  const mt = (file.mimetype || "").toLowerCase();
+  const ft = (file.filetype || "").toLowerCase();
+  if (mt === "image/png" || ft === "png") {
+    return "png";
+  }
+  if (mt === "image/jpeg" || mt === "image/jpg" || ft === "jpg" || ft === "jpeg") {
+    return "jpg";
+  }
+  if (mt === "image/webp" || ft === "webp") {
+    return "webp";
+  }
+  if (mt === "image/gif" || ft === "gif") {
+    return "gif";
+  }
+  if (mt === "text/plain" || ft === "text") {
+    return "txt";
+  }
+  if (mt === "text/markdown" || ft === "markdown" || ft === "md") {
+    return "md";
+  }
+  if (mt === "application/json" || ft === "json") {
+    return "json";
+  }
+  const name = file.name || file.title || "";
+  const m = name.match(/\.([A-Za-z0-9]{1,10})$/);
+  return m ? m[1].toLowerCase() : null;
+}
+
+// src/slack/search-files.ts
+async function searchFilesViaSearchApi(client, input) {
+  const matches = input.rawMatches;
+  if (matches.length === 0) {
+    return [];
+  }
+  const downloadsDir = await ensureDownloadsDir();
+  const out = [];
+  for (const f of matches) {
+    const mode = getString5(f.mode);
+    const mimetype = getString5(f.mimetype);
+    if (!passesFileContentTypeFilter({ mode, mimetype }, input.contentType)) {
+      continue;
+    }
+    const url = getString5(f.url_private_download) ?? getString5(f.url_private);
+    if (!url) {
+      continue;
+    }
+    const ext = inferExt2({
+      mimetype,
+      filetype: getString5(f.filetype),
+      name: getString5(f.name),
+      title: getString5(f.title)
+    });
+    const id = getString5(f.id);
+    if (!id) {
+      continue;
+    }
+    const path = await downloadSlackFile({
+      auth: input.auth,
+      url,
+      destDir: downloadsDir,
+      preferredName: `${id}${ext ? `.${ext}` : ""}`
+    });
+    const title = (getString5(f.title) || getString5(f.name) || "").trim();
+    out.push({
+      title: title || undefined,
+      mimetype,
+      mode,
+      path
+    });
+    if (out.length >= input.limit) {
+      break;
+    }
+  }
+  return out;
+}
+async function searchFilesInChannelsFallback(client, input) {
+  const channelIds = await Promise.all(input.channels.map((c) => resolveChannelId(client, c)));
+  const userId = input.user ? await resolveUserId(client, input.user) : undefined;
+  const queryLower = input.query.trim().toLowerCase();
+  const ts_from = input.after ? dateToUnixSeconds(input.after, "start") : undefined;
+  const ts_to = input.before ? dateToUnixSeconds(input.before, "end") : undefined;
+  const downloadsDir = await ensureDownloadsDir();
+  const out = [];
+  for (const channelId of channelIds) {
+    let page = 1;
+    for (;; ) {
+      const resp = await client.api("files.list", {
+        channel: channelId,
+        user: userId,
+        ts_from,
+        ts_to,
+        count: 100,
+        page
+      });
+      const files = isRecord10(resp) ? asArray4(resp.files).filter(isRecord10) : [];
+      if (files.length === 0) {
+        break;
+      }
+      for (const f of files) {
+        const mode = getString5(f.mode);
+        const mimetype = getString5(f.mimetype);
+        if (!passesFileContentTypeFilter({ mode, mimetype }, input.contentType)) {
+          continue;
+        }
+        const title = (getString5(f.title) || getString5(f.name) || "").trim();
+        if (queryLower && !title.toLowerCase().includes(queryLower)) {
+          continue;
+        }
+        const url = getString5(f.url_private_download) ?? getString5(f.url_private);
+        if (!url) {
+          continue;
+        }
+        const ext = inferExt2({
+          mimetype,
+          filetype: getString5(f.filetype),
+          name: getString5(f.name),
+          title: getString5(f.title)
+        });
+        const id = getString5(f.id);
+        if (!id) {
+          continue;
+        }
+        const path = await downloadSlackFile({
+          auth: input.auth,
+          url,
+          destDir: downloadsDir,
+          preferredName: `${id}${ext ? `.${ext}` : ""}`
+        });
+        out.push({
+          title: title || undefined,
+          mimetype,
+          mode,
+          path
+        });
+        if (out.length >= input.limit) {
+          return out;
+        }
+      }
+      const paging = isRecord10(resp) ? isRecord10(resp.paging) ? resp.paging : resp.pagination : null;
+      const pages = Number(isRecord10(paging) ? paging.pages ?? paging.page_count : undefined);
+      if (Number.isFinite(pages) && page >= pages) {
+        break;
+      }
+      page++;
+    }
+  }
+  return out;
+}
+function passesFileContentTypeFilter(f, contentType) {
+  if (contentType === "any") {
+    return true;
+  }
+  if (contentType === "file") {
+    return true;
+  }
+  if (contentType === "snippet") {
+    return f.mode === "snippet";
+  }
+  if (contentType === "image") {
+    return String(f.mimetype ?? "").toLowerCase().startsWith("image/");
+  }
+  if (contentType === "text") {
+    return String(f.mimetype ?? "") === "text/plain";
+  }
+  return true;
+}
+
+// src/slack/search-messages.ts
+async function searchMessagesViaSearchApi(client, input) {
+  const matches = input.rawMatches;
+  if (matches.length === 0) {
+    return [];
+  }
+  const messageRefs = [];
+  for (const m of matches) {
+    const ts = getString5(m.ts)?.trim() ?? "";
+    if (!ts) {
+      continue;
+    }
+    const channelValue = isRecord10(m.channel) ? m.channel : null;
+    const channelId = channelValue && getString5(channelValue.id) ? getString5(channelValue.id) : channelValue && getString5(channelValue.name) ? await resolveChannelId(client, `#${getString5(channelValue.name)}`) : "";
+    if (!channelId) {
+      continue;
+    }
+    messageRefs.push({
+      channel_id: channelId,
+      message_ts: ts,
+      permalink: getString5(m.permalink)
+    });
+    if (messageRefs.length >= input.limit) {
+      break;
+    }
+  }
+  const downloadedPaths = {};
+  const downloadsDir = input.download ? await ensureDownloadsDir() : null;
+  const out = [];
+  for (const ref of messageRefs) {
+    let full = null;
+    try {
+      const parsed = ref.permalink && typeof ref.permalink === "string" ? (() => {
+        try {
+          return parseSlackMessageUrl(ref.permalink);
+        } catch {
+          return null;
+        }
+      })() : null;
+      full = await fetchMessage(client, {
+        ref: {
+          workspace_url: parsed?.workspace_url ?? input.workspace_url ?? "",
+          channel_id: ref.channel_id,
+          message_ts: ref.message_ts,
+          thread_ts_hint: parsed?.thread_ts_hint,
+          raw: parsed?.raw ?? ref.permalink ?? `${ref.channel_id}:${ref.message_ts}`
+        }
+      });
+    } catch {
+      continue;
+    }
+    if (downloadsDir) {
+      await downloadFilesForMessage({
+        auth: input.auth,
+        downloadsDir,
+        message: full,
+        downloadedPaths
+      });
+    }
+    const compact = toCompactMessage(full, {
+      maxBodyChars: input.maxContentChars,
+      downloadedPaths
+    });
+    if (!passesContentTypeFilter(compact, input.contentType)) {
+      continue;
+    }
+    out.push(stripThreadListFields(compact));
+    if (out.length >= input.limit) {
+      break;
+    }
+  }
+  return out;
+}
+async function searchMessagesInChannelsFallback(client, input) {
+  const channelIds = await Promise.all(input.channels.map((c) => resolveChannelId(client, c)));
+  const queryLower = input.query.trim().toLowerCase();
+  const userId = input.user ? await resolveUserId(client, input.user) : undefined;
+  const afterSec = input.after ? dateToUnixSeconds(input.after, "start") : null;
+  const beforeSec = input.before ? dateToUnixSeconds(input.before, "end") : null;
+  const downloadsDir = input.download ? await ensureDownloadsDir() : null;
+  const downloadedPaths = {};
+  const results = [];
+  for (const channelId of channelIds) {
+    let cursorLatest;
+    for (;; ) {
+      const resp = await client.api("conversations.history", {
+        channel: channelId,
+        limit: 200,
+        latest: cursorLatest
+      });
+      const messages = isRecord10(resp) ? asArray4(resp.messages).filter(isRecord10) : [];
+      if (messages.length === 0) {
+        break;
+      }
+      for (const m of messages) {
+        const summary = messageSummaryFromApiMessage(channelId, m);
+        const tsNum = Number.parseFloat(summary.ts);
+        if (Number.isFinite(tsNum)) {
+          if (beforeSec !== null && tsNum > beforeSec) {
+            continue;
+          }
+          if (afterSec !== null && tsNum < afterSec) {
+            cursorLatest = undefined;
+            break;
+          }
+        }
+        if (userId && summary.user !== userId) {
+          continue;
+        }
+        const content = renderSlackMessageContent(summary);
+        if (queryLower && !content.toLowerCase().includes(queryLower)) {
+          continue;
+        }
+        if (downloadsDir) {
+          await downloadFilesForMessage({
+            auth: input.auth,
+            downloadsDir,
+            message: summary,
+            downloadedPaths
+          });
+        }
+        const compact = toCompactMessage(summary, {
+          maxBodyChars: input.maxContentChars,
+          downloadedPaths
+        });
+        if (!passesContentTypeFilter(compact, input.contentType)) {
+          continue;
+        }
+        results.push(stripThreadListFields(compact));
+        if (results.length >= input.limit) {
+          return results;
+        }
+      }
+      if (!cursorLatest) {
+        break;
+      }
+      const last = messages.at(-1);
+      cursorLatest = last ? getString5(last.ts) : undefined;
+      if (!cursorLatest) {
+        break;
+      }
+    }
+  }
+  return results;
+}
+function passesContentTypeFilter(m, contentType) {
+  if (contentType === "any") {
+    return true;
+  }
+  const hasFiles = Boolean(m.files && m.files.length > 0);
+  if (contentType === "text") {
+    return !hasFiles;
+  }
+  if (!hasFiles) {
+    return false;
+  }
+  if (contentType === "file") {
+    return true;
+  }
+  if (contentType === "snippet") {
+    return (m.files ?? []).some((f) => f.mode === "snippet");
+  }
+  if (contentType === "image") {
+    return (m.files ?? []).some((f) => String(f.mimetype ?? "").startsWith("image/"));
+  }
+  return true;
+}
+function stripThreadListFields(m) {
+  const { channel_id: _channelId, thread_ts: _threadTs, ...rest } = m;
+  return rest;
+}
+async function downloadFilesForMessage(input) {
+  for (const f of input.message.files ?? []) {
+    if (input.downloadedPaths[f.id]) {
+      continue;
+    }
+    const url = f.url_private_download || f.url_private;
+    if (!url) {
+      continue;
+    }
+    const ext = inferExt2(f);
+    const path = await downloadSlackFile({
+      auth: input.auth,
+      url,
+      destDir: input.downloadsDir,
+      preferredName: `${f.id}${ext ? `.${ext}` : ""}`
+    });
+    input.downloadedPaths[f.id] = path;
+  }
+}
+function messageSummaryFromApiMessage(channelId, msg) {
+  const text = getString5(msg.text) ?? "";
+  const files = asArray4(msg.files).map((f) => toSlackFileSummary2(f)).filter((f) => f !== null);
+  return {
+    channel_id: channelId,
+    ts: getString5(msg.ts) ?? "",
+    thread_ts: getString5(msg.thread_ts),
+    reply_count: getNumber3(msg.reply_count),
+    user: getString5(msg.user),
+    bot_id: getString5(msg.bot_id),
+    text,
+    markdown: slackMrkdwnToMarkdown(text),
+    blocks: Array.isArray(msg.blocks) ? msg.blocks : undefined,
+    attachments: Array.isArray(msg.attachments) ? msg.attachments : undefined,
+    files: files.length > 0 ? files : undefined,
+    reactions: Array.isArray(msg.reactions) ? msg.reactions : undefined
+  };
+}
+function toSlackFileSummary2(value) {
+  if (!isRecord10(value)) {
+    return null;
+  }
+  const id = getString5(value.id);
+  if (!id) {
+    return null;
+  }
+  return {
+    id,
+    name: getString5(value.name),
+    title: getString5(value.title),
+    mimetype: getString5(value.mimetype),
+    filetype: getString5(value.filetype),
+    mode: getString5(value.mode),
+    permalink: getString5(value.permalink),
+    url_private: getString5(value.url_private),
+    url_private_download: getString5(value.url_private_download),
+    size: getNumber3(value.size)
+  };
+}
+
+// src/slack/search.ts
+async function searchSlack(input) {
+  const limit = Math.min(Math.max(input.options.limit ?? 20, 1), 200);
+  const maxContentChars = input.options.max_content_chars ?? 4000;
+  const contentType = input.options.content_type ?? "any";
+  const download = input.options.download ?? true;
+  if (!download && (input.options.kind === "files" || input.options.kind === "all")) {
+    throw new Error("File search requires downloads enabled (so agents get local file paths).");
+  }
+  const slackQuery = await buildSlackSearchQuery(input.client, {
+    query: input.options.query,
+    channels: input.options.channels,
+    user: input.options.user,
+    after: input.options.after,
+    before: input.options.before
+  });
+  const out = {};
+  if (input.options.kind === "messages" || input.options.kind === "all") {
+    if (input.options.channels?.length) {
+      out.messages = await searchMessagesInChannelsFallback(input.client, {
+        auth: input.auth,
+        query: input.options.query,
+        channels: input.options.channels,
+        user: input.options.user,
+        after: input.options.after,
+        before: input.options.before,
+        limit,
+        maxContentChars,
+        contentType,
+        download
+      });
+    } else {
+      const rawMatches = await searchMessagesRaw(input.client, { query: slackQuery, limit });
+      out.messages = await searchMessagesViaSearchApi(input.client, {
+        auth: input.auth,
+        workspace_url: input.options.workspace_url,
+        slack_query: slackQuery,
+        limit,
+        maxContentChars,
+        contentType,
+        download,
+        rawMatches
+      });
+    }
+  }
+  if (input.options.kind === "files" || input.options.kind === "all") {
+    if (input.options.channels?.length) {
+      out.files = await searchFilesInChannelsFallback(input.client, {
+        auth: input.auth,
+        query: input.options.query,
+        channels: input.options.channels,
+        user: input.options.user,
+        after: input.options.after,
+        before: input.options.before,
+        limit,
+        contentType
+      });
+    } else {
+      const rawMatches = await searchFilesRaw(input.client, { query: slackQuery, limit });
+      out.files = await searchFilesViaSearchApi(input.client, {
+        auth: input.auth,
+        slack_query: slackQuery,
+        limit,
+        contentType,
+        rawMatches
+      });
+    }
+  }
+  return out;
+}
+
+// src/cli/search-command.ts
+function addSearchOptions(cmd) {
+  return cmd.option("--workspace <url>", "Workspace URL (needed when searching across multiple workspaces)").option("--channel <channel...>", "Channel filter (#name, name, or id). Repeatable.").option("--user <user>", "User filter (@name, name, or user id U...)").option("--after <date>", "Only results after YYYY-MM-DD").option("--before <date>", "Only results before YYYY-MM-DD").option("--content-type <type>", "Filter content type: any|text|image|snippet|file (default any)").option("--limit <n>", "Max results (default 20)", "20").option("--max-content-chars <n>", "Max message content characters (default 4000, -1 for unlimited)", "4000");
+}
+async function runSearch(input) {
+  const workspaceUrl = input.ctx.effectiveWorkspaceUrl(input.options.workspace);
+  const channels = Array.isArray(input.options.channel) ? input.options.channel : input.options.channel ? [input.options.channel] : [];
+  await input.ctx.assertWorkspaceSpecifiedForChannelNames({ workspaceUrl, channels });
+  const payload = await input.ctx.withAutoRefresh({
+    workspaceUrl,
+    work: async () => {
+      const { client, auth, workspace_url } = await input.ctx.getClientForWorkspace(workspaceUrl);
+      const limit = Number.parseInt(input.options.limit || "20", 10);
+      const maxContentChars = Number.parseInt(input.options.maxContentChars || "4000", 10);
+      const contentType = input.ctx.parseContentType(input.options.contentType);
+      return await searchSlack({
+        client,
+        auth,
+        options: {
+          workspace_url: workspace_url ?? workspaceUrl ?? "",
+          query: input.query,
+          kind: input.kind,
+          channels,
+          user: input.options.user,
+          after: input.options.after,
+          before: input.options.before,
+          content_type: contentType,
+          limit,
+          max_content_chars: maxContentChars,
+          download: true
+        }
+      });
+    }
+  });
+  console.log(JSON.stringify(pruneEmpty(payload), null, 2));
+}
+function registerSearchCommand(input) {
+  const searchCmd = input.program.command("search").description("Search Slack messages and files (token-efficient JSON)");
+  const create = (spec) => addSearchOptions(searchCmd.command(spec.name).description(spec.desc)).argument("<query>", "Search query").action(async (...args) => {
+    const [query, options] = args;
+    try {
+      await runSearch({ ctx: input.ctx, kind: spec.kind, query, options });
+    } catch (err) {
+      console.error(input.ctx.errorMessage(err));
+      process.exitCode = 1;
+    }
+  });
+  create({ kind: "all", name: "all", desc: "Search messages and files" });
+  create({ kind: "messages", name: "messages", desc: "Search messages" });
+  create({ kind: "files", name: "files", desc: "Search files" });
+}
+
+// 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 { tmpdir as tmpdir2 } from "node:os";
+import { join as join8 } from "node:path";
+var REPO = "stablyai/agent-slack";
+var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
+function getCachePath() {
+  return join8(getAppDir(), "update-check.json");
+}
+function compareSemver(a, b) {
+  const pa = a.replace(/^v/, "").split(".").map(Number);
+  const pb = b.replace(/^v/, "").split(".").map(Number);
+  for (let i = 0;i < 3; i++) {
+    const diff = (pa[i] ?? 0) - (pb[i] ?? 0);
+    if (diff !== 0) {
+      return diff;
+    }
+  }
+  return 0;
+}
+async function fetchLatestVersion() {
+  try {
+    const resp = await fetch(`https://api.github.com/repos/${REPO}/releases/latest`, {
+      headers: { Accept: "application/vnd.github+json", "User-Agent": "agent-slack-updater" },
+      signal: AbortSignal.timeout(5000)
+    });
+    if (!resp.ok) {
+      return null;
+    }
+    const data = await resp.json();
+    return data.tag_name?.replace(/^v/, "") ?? null;
+  } catch {
+    return null;
+  }
+}
+async function checkForUpdate(force = false) {
+  const current = getPackageVersion();
+  if (!force) {
+    const cached = await readJsonFile(getCachePath());
+    if (cached && Date.now() - cached.checked_at < CHECK_INTERVAL_MS) {
+      return {
+        current,
+        latest: cached.latest_version,
+        update_available: compareSemver(cached.latest_version, current) > 0
+      };
+    }
+  }
+  const latest = await fetchLatestVersion();
+  if (!latest) {
+    return null;
+  }
+  try {
+    await writeJsonFile(getCachePath(), {
+      latest_version: latest,
+      checked_at: Date.now()
+    });
+  } catch {}
+  return {
+    current,
+    latest,
+    update_available: compareSemver(latest, current) > 0
+  };
+}
+function detectPlatformAsset() {
+  const platform4 = 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}`;
+}
+async function sha256(filePath) {
+  const data = await readFile4(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()}`);
+  await mkdir5(tmp, { recursive: true });
+  const binTmp = join8(tmp, asset);
+  const sumsTmp = join8(tmp, "checksums-sha256.txt");
+  try {
+    const [binResp, sumsResp] = await Promise.all([
+      fetch(`${baseUrl}/${asset}`, { signal: AbortSignal.timeout(120000) }),
+      fetch(`${baseUrl}/checksums-sha256.txt`, { signal: AbortSignal.timeout(30000) })
+    ]);
+    if (!binResp.ok) {
+      return { success: false, message: `Failed to download ${asset}: HTTP ${binResp.status}` };
+    }
+    if (!sumsResp.ok) {
+      return { success: false, message: `Failed to download checksums: HTTP ${sumsResp.status}` };
+    }
+    await writeFile3(binTmp, Buffer.from(await binResp.arrayBuffer()));
+    const sumsText = await sumsResp.text();
+    await writeFile3(sumsTmp, sumsText);
+    const expected = sumsText.split(`
+`).map((line) => line.trim().split(/\s+/)).find((parts) => parts[1] === asset)?.[0];
+    if (!expected) {
+      return { success: false, message: `Checksum not found for ${asset} in release checksums` };
+    }
+    const actual = await sha256(binTmp);
+    if (actual !== expected) {
+      return { success: false, message: `Checksum mismatch: expected ${expected}, got ${actual}` };
+    }
+    const currentBin = process.execPath;
+    const backupPath = `${currentBin}.bak`;
+    await rename(currentBin, backupPath);
+    try {
+      await copyFile(binTmp, currentBin);
+      await chmod(currentBin, 493);
+      await rm2(backupPath, { force: true });
+    } catch (err) {
+      try {
+        await rename(backupPath, currentBin);
+      } catch {}
+      throw err;
+    }
+    return { success: true, message: `Updated agent-slack to ${latest}` };
+  } finally {
+    await rm2(tmp, { recursive: true, force: true }).catch(() => {});
+  }
+}
+async function backgroundUpdateCheck() {
+  if (process.env.AGENT_SLACK_NO_UPDATE_CHECK === "1") {
+    return;
+  }
+  try {
+    const result = await checkForUpdate();
+    if (result?.update_available) {
+      process.stderr.write(`
+Update available: ${result.current} → ${result.latest}. Run "agent-slack update" to upgrade.
+`);
+    }
+  } catch {}
+}
+
+// src/cli/update-command.ts
+function registerUpdateCommand(input) {
+  input.program.command("update").description("Update agent-slack to the latest version").option("--check", "Only check for updates (don't install)").action(async (...args) => {
+    const [options] = args;
+    try {
+      const result = await checkForUpdate(true);
+      if (!result) {
+        console.error("Could not check for updates. Check your network connection.");
+        process.exitCode = 1;
+        return;
+      }
+      if (!result.update_available) {
+        console.log(JSON.stringify(pruneEmpty({ ...result, status: "up_to_date" }), null, 2));
+        return;
+      }
+      if (options.check) {
+        console.log(JSON.stringify(pruneEmpty({ ...result, status: "update_available" }), null, 2));
+        return;
+      }
+      process.stderr.write(`Updating agent-slack ${result.current} → ${result.latest}...
+`);
+      const outcome = await performUpdate(result.latest);
+      if (!outcome.success) {
+        console.error(outcome.message);
+        process.exitCode = 1;
+        return;
+      }
+      console.log(JSON.stringify(pruneEmpty({
+        status: "updated",
+        previous_version: result.current,
+        new_version: result.latest,
+        message: outcome.message
+      }), null, 2));
+    } catch (err) {
+      console.error(err instanceof Error ? err.message : String(err));
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/slack/users.ts
+async function listUsers(client, options) {
+  const limit = Math.min(Math.max(options?.limit ?? 200, 1), 1000);
+  const includeBots = options?.includeBots ?? false;
+  const out = [];
+  let cursor = options?.cursor;
+  while (out.length < limit) {
+    const pageSize = Math.min(200, limit - out.length);
+    const resp = await client.api("users.list", {
+      limit: pageSize,
+      cursor
+    });
+    const members = asArray5(resp.members).filter(isRecord11);
+    for (const m of members) {
+      const id = getString6(m.id);
+      if (!id) {
+        continue;
+      }
+      if (!includeBots && m.is_bot) {
+        continue;
+      }
+      out.push(toCompactUser(m));
+      if (out.length >= limit) {
+        break;
+      }
+    }
+    const meta = isRecord11(resp.response_metadata) ? resp.response_metadata : null;
+    const next = meta ? getString6(meta.next_cursor) : undefined;
+    if (!next) {
+      return { users: out };
+    }
+    cursor = next;
+  }
+  return { users: out, next_cursor: cursor };
+}
+async function getUser(client, input) {
+  const trimmed = input.trim();
+  if (!trimmed) {
+    throw new Error("User is empty");
+  }
+  const userId = await resolveUserId2(client, trimmed);
+  if (!userId) {
+    throw new Error(`Could not resolve user: ${input}`);
+  }
+  const resp = await client.api("users.info", { user: userId });
+  const u = isRecord11(resp.user) ? resp.user : null;
+  if (!u || !getString6(u.id)) {
+    throw new Error("users.info returned no user");
+  }
+  return toCompactUser(u);
+}
+async function resolveUserId2(client, input) {
+  const trimmed = input.trim();
+  if (/^U[A-Z0-9]{8,}$/.test(trimmed)) {
+    return trimmed;
+  }
+  const handle = trimmed.startsWith("@") ? trimmed.slice(1) : trimmed;
+  if (!handle) {
+    return null;
+  }
+  let cursor;
+  for (;; ) {
+    const resp = await client.api("users.list", { limit: 200, cursor });
+    const members = asArray5(resp.members).filter(isRecord11);
+    const found = members.find((m) => getString6(m.name) === handle);
+    if (found) {
+      const id = getString6(found.id);
+      if (id) {
+        return id;
+      }
+    }
+    const meta = isRecord11(resp.response_metadata) ? resp.response_metadata : null;
+    const next = meta ? getString6(meta.next_cursor) : undefined;
+    if (!next) {
+      break;
+    }
+    cursor = next;
+  }
+  return null;
+}
+function toCompactUser(u) {
+  const profile = isRecord11(u.profile) ? u.profile : {};
+  return {
+    id: getString6(u.id) ?? "",
+    name: getString6(u.name) ?? undefined,
+    real_name: getString6(u.real_name) ?? undefined,
+    display_name: getString6(profile.display_name) ?? undefined,
+    email: getString6(profile.email) ?? undefined,
+    title: getString6(profile.title) ?? undefined,
+    tz: getString6(u.tz) ?? undefined,
+    is_bot: typeof u.is_bot === "boolean" ? u.is_bot : undefined,
+    deleted: typeof u.deleted === "boolean" ? u.deleted : undefined
+  };
+}
+function isRecord11(value) {
+  return typeof value === "object" && value !== null;
+}
+function asArray5(value) {
+  return Array.isArray(value) ? value : [];
+}
+function getString6(value) {
+  return typeof value === "string" ? value : undefined;
+}
+
+// src/cli/user-command.ts
+function registerUserCommand(input) {
+  const userCmd = input.program.command("user").description("Workspace user directory");
+  userCmd.command("list").description("List users in the workspace").option("--workspace <url>", "Workspace URL (required if you have multiple workspaces)").option("--limit <n>", "Max users (default 200)", "200").option("--cursor <cursor>", "Pagination cursor").option("--include-bots", "Include bot users").action(async (...args) => {
+    const [options] = args;
+    try {
+      const workspaceUrl = input.ctx.effectiveWorkspaceUrl(options.workspace);
+      const payload = await input.ctx.withAutoRefresh({
+        workspaceUrl,
+        work: async () => {
+          const { client } = await input.ctx.getClientForWorkspace(workspaceUrl);
+          const limit = Number.parseInt(options.limit, 10);
+          return await listUsers(client, {
+            limit,
+            cursor: options.cursor,
+            includeBots: Boolean(options.includeBots)
+          });
+        }
+      });
+      console.log(JSON.stringify(pruneEmpty(payload), null, 2));
+    } catch (err) {
+      console.error(input.ctx.errorMessage(err));
+      process.exitCode = 1;
+    }
+  });
+  userCmd.command("get").description("Get a single user by id (U...) or handle (@name)").argument("<user>", "User id (U...) or @handle/handle").option("--workspace <url>", "Workspace URL (required if you have multiple workspaces)").action(async (...args) => {
+    const [user, options] = args;
+    try {
+      const workspaceUrl = input.ctx.effectiveWorkspaceUrl(options.workspace);
+      const payload = await input.ctx.withAutoRefresh({
+        workspaceUrl,
+        work: async () => {
+          const { client } = await input.ctx.getClientForWorkspace(workspaceUrl);
+          return await getUser(client, user);
+        }
+      });
+      console.log(JSON.stringify(pruneEmpty(payload), null, 2));
+    } catch (err) {
+      console.error(input.ctx.errorMessage(err));
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/index.ts
+var program = new Command;
+program.name("agent-slack").description("Slack automation CLI for AI agents").version(getPackageVersion());
+var ctx = createCliContext();
+registerAuthCommand({ program, ctx });
+registerMessageCommand({ program, ctx });
+registerCanvasCommand({ program, ctx });
+registerSearchCommand({ program, ctx });
+registerUpdateCommand({ program });
+registerUserCommand({ program, ctx });
+program.parse(process.argv);
+if (!process.argv.slice(2).length) {
+  program.outputHelp();
+}
+var [subcommand] = process.argv.slice(2);
+if (subcommand && subcommand !== "update") {
+  backgroundUpdateCheck();
+}
+
+//# debugId=09DBB443871FCCB664756E2164756E21
+//# sourceMappingURL=index.js.map