@teamvibe/poller 0.1.65 → 0.1.67

package/dist/claude-spawner.js

@@ -109,7 +109,8 @@ export function buildPrompt(msg, resumeHint) {
         return 'heartbeat';
     }
     const isEmail = msg.source === 'email';
-    let prompt = isEmail ? '## Incoming Email\n\n' : '## Incoming Slack Message\n\n';
+    const isWebhook = msg.source === 'webhook';
+    let prompt = isEmail ? '## Incoming Email\n\n' : isWebhook ? '## Incoming Webhook\n\n' : '## Incoming Slack Message\n\n';
     prompt += `**From:** ${msg.sender.name}`;
     if (msg.sender.id && msg.sender.id !== msg.sender.name) {
         prompt += ` (${msg.sender.id})`;
@@ -151,8 +152,8 @@ export function buildPrompt(msg, resumeHint) {
     if (msg.type === 'view_closed' && msg.modal) {
         prompt += `\n\n**Modal Dismissed:** User closed "${msg.modal.callbackId}" without submitting.`;
     }
-    if (msg.teamvibe.emailChannelPrompt) {
-        prompt += '\n\n**Channel Instructions:**\n' + msg.teamvibe.emailChannelPrompt + '\n';
+    if (msg.teamvibe.emailHookPrompt) {
+        prompt += '\n\n**Channel Instructions:**\n' + msg.teamvibe.emailHookPrompt + '\n';
     }
     if (resumeHint) {
         prompt += `\n\n${resumeHint}`;
@@ -226,7 +227,8 @@ async function runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = t
     const isCronMessage = msg.source === 'cron';
     const isHeartbeat = msg.source === 'heartbeat';
     const isEmailMessage = msg.source === 'email';
-    if (!slackContext && !isCronMessage && !isHeartbeat && !isEmailMessage) {
+    const isWebhookMessage = msg.source === 'webhook';
+    if (!slackContext && !isCronMessage && !isHeartbeat && !isEmailMessage && !isWebhookMessage) {
         throw new Error('No Slack context in message');
     }
     // Build resume hint
@@ -273,7 +275,11 @@ async function runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = t
         }
         // Inbox protocol: instruct Claude to check for mid-task messages (thread-scoped)
         const inboxNewDir = `.inbox/${msg.thread_id}/new`;
+        const now = new Date();
+        const todayLine = `Today: ${now.toISOString().slice(0, 10)} (${now.toLocaleDateString('en-US', { weekday: 'long' })})`;
         args.push('--append-system-prompt', [
+            todayLine,
+            ``,
             `CRITICAL — INBOX PROTOCOL: You MUST check for new user messages after EVERY tool call.`,
             `Run: ls ${inboxNewDir}/ 2>/dev/null`,
             `If files exist: read each file (oldest first), delete it, and act on the message IMMEDIATELY — it takes priority over your current task.`,

package/dist/inbox-manager.d.ts

@@ -12,6 +12,10 @@ export declare function pickNextMessage(brainPath: string, threadId: string): {
     filename: string;
     content: string;
 } | null;
+/**
+ * Move a message from processing/ to failed/ after exhausting retries.
+ */
+export declare function markFailed(brainPath: string, threadId: string, filename: string): void;
 /**
  * Delete a message file from processing/ (marks it as done).
  */

package/dist/inbox-manager.js

@@ -4,6 +4,7 @@ import { logger } from './logger.js';
 const INBOX_DIR = '.inbox';
 const NEW_DIR = 'new';
 const PROCESSING_DIR = 'processing';
+const FAILED_DIR = 'failed';
 function getInboxPath(brainPath, threadId) {
     return join(brainPath, INBOX_DIR, threadId);
 }
@@ -56,6 +57,27 @@ export function pickNextMessage(brainPath, threadId) {
     }
     return null;
 }
+/**
+ * Move a message from processing/ to failed/ after exhausting retries.
+ */
+export function markFailed(brainPath, threadId, filename) {
+    const inbox = getInboxPath(brainPath, threadId);
+    const srcPath = join(inbox, PROCESSING_DIR, filename);
+    const failedDir = join(inbox, FAILED_DIR);
+    mkdirSync(failedDir, { recursive: true });
+    const dstPath = join(failedDir, filename);
+    try {
+        if (existsSync(srcPath)) {
+            renameSync(srcPath, dstPath);
+            logger.info(`[Inbox] Moved exhausted message to failed/: ${filename}`);
+        }
+    }
+    catch (error) {
+        logger.warn(`[Inbox] Failed to move ${filename} to failed/: ${error}`);
+        // Fallback: delete so the loop doesn't get stuck
+        markProcessed(brainPath, threadId, filename);
+    }
+}
 /**
  * Delete a message file from processing/ (marks it as done).
  */

package/dist/poller.js

@@ -9,7 +9,7 @@ import { postMaintenanceReports } from './maintenance-reporter.js';
 import { initAuth, stopRefresh } from './auth-provider.js';
 import { registerBrain, startHeartbeatLoop, stopHeartbeatLoop } from './heartbeat-manager.js';
 import { startEventQueue, stopEventQueue, flush as flushEventQueue, emitEvent } from './event-queue.js';
-import { writeMessage, pickNextMessage, markProcessed, hasUnprocessed } from './inbox-manager.js';
+import { writeMessage, pickNextMessage, markProcessed, markFailed, hasUnprocessed } from './inbox-manager.js';
 // Track active message processing
 const processingMessages = new Set();
 // Track which threads have an active processing loop
@@ -21,6 +21,7 @@ async function runInboxLoop(threadId, kbPath, queueMessage, sessionLog) {
     }
     activeLoops.add(threadId);
     let iteration = 0;
+    const failureCounts = new Map();
     try {
         let lockResult = await acquireSessionLock(threadId, kbPath);
         if (!lockResult.success) {
@@ -28,6 +29,7 @@ async function runInboxLoop(threadId, kbPath, queueMessage, sessionLog) {
             return;
         }
         const { session, lockToken } = lockResult;
+        let currentSessionId = session.session_id || undefined;
         while (true) {
             const message = pickNextMessage(kbPath, threadId);
             if (!message) {
@@ -44,6 +46,7 @@ async function runInboxLoop(threadId, kbPath, queueMessage, sessionLog) {
                 ? startTypingIndicator(queueMessage)
                 : undefined;
             let succeeded = false;
+            let lastExitCode = null;
             try {
                 // Reconstruct queue message from stored inbox data
                 const storedData = JSON.parse(message.content);
@@ -51,10 +54,21 @@ async function runInboxLoop(threadId, kbPath, queueMessage, sessionLog) {
                     ...queueMessage,
                     ...storedData,
                 };
-                const result = await spawnClaudeCode(inboxMsg, sessionLog, kbPath, session.session_id || undefined, isFirstMessage, session.last_message_ts, () => typing?.stop(), typing);
+                const result = await spawnClaudeCode(inboxMsg, sessionLog, kbPath, currentSessionId, isFirstMessage, session.last_message_ts, () => typing?.stop(), typing);
                 typing?.stop();
-                if (result.newSessionId && lockToken) {
-                    await updateSessionId(threadId, lockToken, result.newSessionId);
+                if (result.newSessionId) {
+                    // Update local state first — DynamoDB writes may fail (expired token,
+                    // network), but subsequent iterations MUST use the fresh session ID
+                    // to avoid "session already in use" retry loops.
+                    currentSessionId = result.newSessionId;
+                    if (lockToken) {
+                        try {
+                            await updateSessionId(threadId, lockToken, result.newSessionId);
+                        }
+                        catch (err) {
+                            sessionLog.error(`[Loop] Failed to persist new session ID to DynamoDB: ${err instanceof Error ? err.message : err}`);
+                        }
+                    }
                 }
                 if (result.metrics) {
                     sessionLog.info(`[Loop] Iteration #${iteration} complete — ` +
@@ -84,6 +98,7 @@ async function runInboxLoop(threadId, kbPath, queueMessage, sessionLog) {
                     await postMaintenanceReports(kbPath, queueMessage.teamvibe.channelId);
                 }
                 else {
+                    lastExitCode = result.exitCode;
                     sessionLog.error(`[Loop] Claude failed iteration #${iteration}: ${result.error}`);
                     if (hasSlackContext) {
                         const errorMessage = result.error || `Process exited with code ${result.exitCode}`;
@@ -97,10 +112,27 @@ async function runInboxLoop(threadId, kbPath, queueMessage, sessionLog) {
                 typing?.stop();
                 sessionLog.error(`[Loop] Error in iteration #${iteration}: ${error instanceof Error ? error.message : error}`);
             }
-            // Only delete processing file on success — failed/killed sessions get retried
             if (succeeded) {
                 markProcessed(kbPath, threadId, message.filename);
             }
+            else {
+                // SIGTERM (143) or SIGKILL (137) = intentional kill → retry immediately, no backoff
+                const isKilledSignal = lastExitCode === 143 || lastExitCode === 137;
+                if (!isKilledSignal) {
+                    const failures = (failureCounts.get(message.filename) || 0) + 1;
+                    failureCounts.set(message.filename, failures);
+                    const MAX_RETRIES = 3;
+                    if (failures >= MAX_RETRIES) {
+                        sessionLog.error(`[Loop] Message ${message.filename} failed ${failures} times, giving up`);
+                        markFailed(kbPath, threadId, message.filename);
+                    }
+                    else {
+                        const backoffMs = Math.min(10_000 * Math.pow(2, failures - 1), 60_000);
+                        sessionLog.info(`[Loop] Retry ${failures}/${MAX_RETRIES - 1} for ${message.filename}, backing off ${backoffMs}ms`);
+                        await sleep(backoffMs);
+                    }
+                }
+            }
             if (!hasUnprocessed(kbPath, threadId)) {
                 break;
             }

package/dist/types.d.ts

@@ -1,6 +1,6 @@
 export interface TeamVibeQueueMessage {
     id: string;
-    source: 'slack' | 'email' | 'cron' | 'heartbeat';
+    source: 'slack' | 'email' | 'cron' | 'heartbeat' | 'webhook';
     thread_id: string;
     sender: {
         id: string;
@@ -50,7 +50,7 @@ export interface TeamVibeQueueMessage {
             gitRepoUrl: string;
             branch: string;
         };
-        emailChannelPrompt?: string;
+        emailHookPrompt?: string;
     };
 }
 export interface SessionRecord {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teamvibe/poller",
-  "version": "0.1.65",
+  "version": "0.1.67",
   "type": "module",
   "main": "./dist/index.js",
   "bin": {

package/dist/kb-manager.d.ts

@@ -1,15 +0,0 @@
-interface KBConfig {
-    kbId: string;
-    gitRepoUrl: string;
-    branch: string;
-    claudePath: string;
-}
-/**
- * Get or clone KB for a persona. Returns the working directory path.
- */
-export declare function getKnowledgeBasePath(kb?: KBConfig): Promise<string>;
-/**
- * Ensure base paths exist
- */
-export declare function ensureDirectories(): Promise<void>;
-export {};

package/dist/kb-manager.js

@@ -1,61 +0,0 @@
-import { exec } from 'child_process';
-import { promisify } from 'util';
-import { existsSync } from 'fs';
-import { join } from 'path';
-import { config } from './config.js';
-import { logger } from './logger.js';
-const execAsync = promisify(exec);
-// Cooldown tracker per KB
-const lastUpdateTimes = new Map();
-/**
- * Get or clone KB for a persona. Returns the working directory path.
- */
-export async function getKnowledgeBasePath(kb) {
-    if (!kb?.gitRepoUrl)
-        return config.DEFAULT_KB_PATH;
-    const kbDir = join(config.KB_BASE_PATH, kb.kbId);
-    if (!existsSync(kbDir)) {
-        logger.info(`Cloning KB ${kb.kbId} from ${kb.gitRepoUrl} (branch: ${kb.branch})...`);
-        await execAsync(`git clone --branch ${kb.branch} ${kb.gitRepoUrl} ${kbDir}`);
-        logger.info(`KB ${kb.kbId} cloned successfully`);
-    }
-    else if (config.KB_AUTO_UPDATE) {
-        await updateKB(kbDir, kb.kbId, kb.branch);
-    }
-    return kbDir;
-}
-/**
- * Update a KB repo (respects cooldown)
- */
-async function updateKB(kbDir, kbId, branch) {
-    const now = Date.now();
-    const lastUpdate = lastUpdateTimes.get(kbId) || 0;
-    if (now - lastUpdate < config.KB_UPDATE_COOLDOWN_MS) {
-        logger.debug(`KB ${kbId} update skipped - cooldown active (${Math.round((config.KB_UPDATE_COOLDOWN_MS - (now - lastUpdate)) / 1000)}s remaining)`);
-        return;
-    }
-    try {
-        logger.info(`Updating KB ${kbId} at ${kbDir}...`);
-        await execAsync(`git fetch origin ${branch} && git reset --hard origin/${branch}`, {
-            cwd: kbDir,
-        });
-        lastUpdateTimes.set(kbId, Date.now());
-        logger.info(`KB ${kbId} updated successfully`);
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logger.error(`Failed to update KB ${kbId}: ${errorMessage}`);
-    }
-}
-/**
- * Ensure base paths exist
- */
-export async function ensureDirectories() {
-    const { mkdirSync } = await import('fs');
-    if (!existsSync(config.KB_BASE_PATH)) {
-        mkdirSync(config.KB_BASE_PATH, { recursive: true });
-    }
-    if (!existsSync(config.DEFAULT_KB_PATH)) {
-        mkdirSync(config.DEFAULT_KB_PATH, { recursive: true });
-    }
-}

package/dist/mailbox-manager.d.ts

@@ -1,26 +0,0 @@
-/**
- * Write a new message to the mailbox.
- * Returns the filename of the created message file.
- */
-export declare function writeMessage(brainPath: string, threadId: string, content: string): string;
-/**
- * Pick the oldest message from processing/ (crash recovery) or new/.
- * If found in new/, moves it to processing/.
- * Returns { filename, content } or null if no messages.
- */
-export declare function pickNextMessage(brainPath: string, threadId: string): {
-    filename: string;
-    content: string;
-} | null;
-/**
- * Delete a message file from processing/ (marks it as done).
- */
-export declare function markProcessed(brainPath: string, threadId: string, filename: string): void;
-/**
- * Check if there are unprocessed messages in new/ or processing/.
- */
-export declare function hasUnprocessed(brainPath: string, threadId: string): boolean;
-/**
- * Get the mailbox new/ directory path for use in Claude's system prompt.
- */
-export declare function getMailboxNewPath(brainPath: string, threadId: string): string;

package/dist/mailbox-manager.js

@@ -1,95 +0,0 @@
-import { mkdirSync, writeFileSync, readFileSync, renameSync, unlinkSync, readdirSync, existsSync } from 'fs';
-import { join } from 'path';
-import { logger } from './logger.js';
-const MAILBOX_DIR = '.mailbox';
-const NEW_DIR = 'new';
-const PROCESSING_DIR = 'processing';
-function getMailboxPath(brainPath, threadId) {
-    return join(brainPath, MAILBOX_DIR, threadId);
-}
-function ensureMailboxDirs(brainPath, threadId) {
-    const mailbox = getMailboxPath(brainPath, threadId);
-    mkdirSync(join(mailbox, NEW_DIR), { recursive: true });
-    mkdirSync(join(mailbox, PROCESSING_DIR), { recursive: true });
-}
-/**
- * Write a new message to the mailbox.
- * Returns the filename of the created message file.
- */
-export function writeMessage(brainPath, threadId, content) {
-    ensureMailboxDirs(brainPath, threadId);
-    const timestamp = process.hrtime.bigint().toString();
-    const filename = `${timestamp}.txt`;
-    const filepath = join(getMailboxPath(brainPath, threadId), NEW_DIR, filename);
-    writeFileSync(filepath, content, 'utf-8');
-    logger.info(`[Mailbox] Wrote message: ${filename} to ${getMailboxPath(brainPath, threadId)}/new/ (${content.length} chars, threadId=${threadId})`);
-    return filename;
-}
-/**
- * Pick the oldest message from processing/ (crash recovery) or new/.
- * If found in new/, moves it to processing/.
- * Returns { filename, content } or null if no messages.
- */
-export function pickNextMessage(brainPath, threadId) {
-    ensureMailboxDirs(brainPath, threadId);
-    const mailbox = getMailboxPath(brainPath, threadId);
-    const processingDir = join(mailbox, PROCESSING_DIR);
-    const newDir = join(mailbox, NEW_DIR);
-    // First check processing/ (crash recovery)
-    const processingFiles = readdirSync(processingDir).filter(f => f.endsWith('.txt')).sort();
-    if (processingFiles.length > 0) {
-        const filename = processingFiles[0];
-        const content = readFileSync(join(processingDir, filename), 'utf-8');
-        logger.info(`[Mailbox] Resuming processing message: ${filename}`);
-        return { filename, content };
-    }
-    // Then check new/
-    const newFiles = readdirSync(newDir).filter(f => f.endsWith('.txt')).sort();
-    if (newFiles.length > 0) {
-        const filename = newFiles[0];
-        const srcPath = join(newDir, filename);
-        const dstPath = join(processingDir, filename);
-        const content = readFileSync(srcPath, 'utf-8');
-        renameSync(srcPath, dstPath);
-        logger.info(`[Mailbox] Picked message: ${filename} (moved to processing)`);
-        return { filename, content };
-    }
-    return null;
-}
-/**
- * Delete a message file from processing/ (marks it as done).
- */
-export function markProcessed(brainPath, threadId, filename) {
-    const filepath = join(getMailboxPath(brainPath, threadId), PROCESSING_DIR, filename);
-    try {
-        if (existsSync(filepath)) {
-            unlinkSync(filepath);
-            logger.info(`[Mailbox] Deleted processed message: ${filename}`);
-        }
-    }
-    catch (error) {
-        logger.warn(`[Mailbox] Failed to delete ${filename}: ${error}`);
-    }
-}
-/**
- * Check if there are unprocessed messages in new/ or processing/.
- */
-export function hasUnprocessed(brainPath, threadId) {
-    const mailbox = getMailboxPath(brainPath, threadId);
-    const newDir = join(mailbox, NEW_DIR);
-    const processingDir = join(mailbox, PROCESSING_DIR);
-    try {
-        const newCount = existsSync(newDir) ? readdirSync(newDir).filter(f => f.endsWith('.txt')).length : 0;
-        const procCount = existsSync(processingDir) ? readdirSync(processingDir).filter(f => f.endsWith('.txt')).length : 0;
-        return (newCount + procCount) > 0;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Get the mailbox new/ directory path for use in Claude's system prompt.
- */
-export function getMailboxNewPath(brainPath, threadId) {
-    return join(getMailboxPath(brainPath, threadId), NEW_DIR);
-}

package/dist/scripts/add-reaction.d.ts

@@ -1,9 +0,0 @@
-#!/usr/bin/env node
-/**
- * Add an emoji reaction to the original message.
- *
- * Usage:
- *   node add-reaction.js emoji_name
- *   node add-reaction.js --channel C123 --message_ts 123.456 emoji_name
- */
-export {};

package/dist/scripts/add-reaction.js

@@ -1,22 +0,0 @@
-#!/usr/bin/env node
-/**
- * Add an emoji reaction to the original message.
- *
- * Usage:
- *   node add-reaction.js emoji_name
- *   node add-reaction.js --channel C123 --message_ts 123.456 emoji_name
- */
-import { slack, fail, succeed, parseArgs } from './lib/slack-client.js';
-const { channel, messageTs, positional } = parseArgs();
-const emoji = positional[0];
-if (!emoji)
-    fail('Emoji name required');
-if (!channel)
-    fail('Channel required (--channel or SLACK_CHANNEL env)');
-if (!messageTs)
-    fail('Message TS required (--message_ts or SLACK_MESSAGE_TS env)');
-async function main() {
-    await slack.reactions.add({ channel: channel, timestamp: messageTs, name: emoji });
-    succeed();
-}
-main().catch((err) => fail(err instanceof Error ? err.message : String(err)));

package/dist/scripts/lib/slack-client.d.ts

@@ -1,16 +0,0 @@
-import { WebClient } from '@slack/web-api';
-export declare function fail(error: string): never;
-export declare function succeed(data?: Record<string, unknown>): never;
-export declare const slack: WebClient;
-/**
- * Parse CLI args: extracts known --flags and returns remaining positional args.
- * Supports both --flag value and --flag=value syntax.
- * Falls back to env vars for channel/thread_ts/message_ts.
- */
-export declare function parseArgs(argv?: string[]): {
-    channel: string | undefined;
-    threadTs: string | undefined;
-    messageTs: string | undefined;
-    positional: string[];
-    textFromFlag: string | undefined;
-};

package/dist/scripts/lib/slack-client.js

@@ -1,48 +0,0 @@
-import { WebClient } from '@slack/web-api';
-const BOT_TOKEN = process.env['SLACK_BOT_TOKEN'];
-export function fail(error) {
-    console.log(JSON.stringify({ ok: false, error }));
-    process.exit(1);
-}
-export function succeed(data = {}) {
-    console.log(JSON.stringify({ ok: true, ...data }));
-    process.exit(0);
-}
-if (!BOT_TOKEN)
-    fail('SLACK_BOT_TOKEN not set');
-export const slack = new WebClient(BOT_TOKEN);
-/**
- * Parse CLI args: extracts known --flags and returns remaining positional args.
- * Supports both --flag value and --flag=value syntax.
- * Falls back to env vars for channel/thread_ts/message_ts.
- */
-export function parseArgs(argv = process.argv.slice(2)) {
-    const flags = {};
-    const positional = [];
-    const knownFlags = ['--channel', '--thread_ts', '--thread-ts', '--message_ts', '--message-ts', '--text'];
-    let i = 0;
-    while (i < argv.length) {
-        const arg = argv[i];
-        // --flag=value
-        const eqMatch = arg.match(/^(--[\w-]+)=(.*)$/);
-        if (eqMatch) {
-            flags[eqMatch[1]] = eqMatch[2];
-            i++;
-            continue;
-        }
-        // --flag value
-        if (knownFlags.includes(arg) && i + 1 < argv.length) {
-            flags[arg] = argv[i + 1];
-            i += 2;
-            continue;
-        }
-        positional.push(arg);
-        i++;
-    }
-    // If --text was provided, use it (and any remaining positional after it)
-    const textFromFlag = flags['--text'];
-    const channel = flags['--channel'] || process.env['SLACK_CHANNEL'];
-    const threadTs = flags['--thread_ts'] || flags['--thread-ts'] || process.env['SLACK_THREAD_TS'];
-    const messageTs = flags['--message_ts'] || flags['--message-ts'] || process.env['SLACK_MESSAGE_TS'];
-    return { channel, threadTs, messageTs, positional, textFromFlag };
-}

package/dist/scripts/read-thread.d.ts

@@ -1,9 +0,0 @@
-#!/usr/bin/env node
-/**
- * Read thread history from a Slack thread.
- *
- * Usage:
- *   node read-thread.js [limit]
- *   node read-thread.js --channel C123 --thread_ts 123.456 [limit]
- */
-export {};

package/dist/scripts/read-thread.js

@@ -1,26 +0,0 @@
-#!/usr/bin/env node
-/**
- * Read thread history from a Slack thread.
- *
- * Usage:
- *   node read-thread.js [limit]
- *   node read-thread.js --channel C123 --thread_ts 123.456 [limit]
- */
-import { slack, fail, succeed, parseArgs } from './lib/slack-client.js';
-const { channel, threadTs, positional } = parseArgs();
-const limit = parseInt(positional[0] || '20', 10);
-if (!channel)
-    fail('Channel required (--channel or SLACK_CHANNEL env)');
-if (!threadTs)
-    fail('Thread TS required (--thread_ts or SLACK_THREAD_TS env)');
-async function main() {
-    const result = await slack.conversations.replies({ channel: channel, ts: threadTs, limit });
-    const messages = (result.messages || []).map((m) => ({
-        user: m.user || m.bot_id || 'unknown',
-        text: m.text || '',
-        ts: m.ts,
-        is_bot: Boolean(m.bot_id),
-    }));
-    succeed({ messages });
-}
-main().catch((err) => fail(err instanceof Error ? err.message : String(err)));

package/dist/scripts/remove-reaction.d.ts

@@ -1,9 +0,0 @@
-#!/usr/bin/env node
-/**
- * Remove an emoji reaction from the original message.
- *
- * Usage:
- *   node remove-reaction.js emoji_name
- *   node remove-reaction.js --channel C123 --message_ts 123.456 emoji_name
- */
-export {};

package/dist/scripts/remove-reaction.js

@@ -1,22 +0,0 @@
-#!/usr/bin/env node
-/**
- * Remove an emoji reaction from the original message.
- *
- * Usage:
- *   node remove-reaction.js emoji_name
- *   node remove-reaction.js --channel C123 --message_ts 123.456 emoji_name
- */
-import { slack, fail, succeed, parseArgs } from './lib/slack-client.js';
-const { channel, messageTs, positional } = parseArgs();
-const emoji = positional[0];
-if (!emoji)
-    fail('Emoji name required');
-if (!channel)
-    fail('Channel required (--channel or SLACK_CHANNEL env)');
-if (!messageTs)
-    fail('Message TS required (--message_ts or SLACK_MESSAGE_TS env)');
-async function main() {
-    await slack.reactions.remove({ channel: channel, timestamp: messageTs, name: emoji });
-    succeed();
-}
-main().catch((err) => fail(err instanceof Error ? err.message : String(err)));

package/dist/scripts/send-message.d.ts

@@ -1,10 +0,0 @@
-#!/usr/bin/env node
-/**
- * Send a message to a Slack thread.
- *
- * Usage:
- *   node send-message.js "Your message here"
- *   node send-message.js --text "Your message here"
- *   node send-message.js --channel C123 --thread_ts 123.456 "Your message"
- */
-export {};

package/dist/scripts/send-message.js

@@ -1,31 +0,0 @@
-#!/usr/bin/env node
-/**
- * Send a message to a Slack thread.
- *
- * Usage:
- *   node send-message.js "Your message here"
- *   node send-message.js --text "Your message here"
- *   node send-message.js --channel C123 --thread_ts 123.456 "Your message"
- */
-import { slack, fail, succeed, parseArgs } from './lib/slack-client.js';
-const { channel, threadTs, positional, textFromFlag } = parseArgs();
-const text = textFromFlag || positional.join(' ');
-if (!text)
-    fail('Message text required');
-if (!channel)
-    fail('Channel required (--channel or SLACK_CHANNEL env)');
-if (!threadTs)
-    fail('Thread TS required (--thread_ts or SLACK_THREAD_TS env)');
-async function main() {
-    console.error(`[slack] send_message: channel=${channel}, thread_ts=${threadTs}`);
-    const result = await slack.chat.postMessage({
-        channel: channel,
-        thread_ts: threadTs,
-        text,
-        unfurl_links: false,
-        unfurl_media: false,
-    });
-    console.error(`[slack] posted: ts=${result.ts}`);
-    succeed({ ts: result.ts });
-}
-main().catch((err) => fail(err instanceof Error ? err.message : String(err)));

package/dist/scripts/set-status.d.ts

@@ -1,8 +0,0 @@
-#!/usr/bin/env node
-/**
- * Set the assistant thread status.
- *
- * Usage:
- *   node set-status.js "Status text"
- */
-export {};

package/dist/scripts/set-status.js

@@ -1,19 +0,0 @@
-#!/usr/bin/env node
-/**
- * Set the assistant thread status.
- *
- * Usage:
- *   node set-status.js "Status text"
- */
-import { slack, fail, succeed, parseArgs } from './lib/slack-client.js';
-const { channel, threadTs, positional } = parseArgs();
-const status = positional.join(' ');
-if (!channel)
-    fail('Channel required');
-if (!threadTs)
-    fail('Thread TS required');
-async function main() {
-    await slack.apiCall('assistant.threads.setStatus', { channel_id: channel, thread_ts: threadTs, status });
-    succeed();
-}
-main().catch((err) => fail(err instanceof Error ? err.message : String(err)));

package/dist/scripts/slack-tool.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/scripts/slack-tool.js

@@ -1,155 +0,0 @@
-import { WebClient } from '@slack/web-api';
-const BOT_TOKEN = process.env['SLACK_BOT_TOKEN'];
-const CHANNEL = process.env['SLACK_CHANNEL'];
-const THREAD_TS = process.env['SLACK_THREAD_TS'];
-const MESSAGE_TS = process.env['SLACK_MESSAGE_TS'];
-function fail(error) {
-    console.log(JSON.stringify({ ok: false, error }));
-    process.exit(1);
-}
-function succeed(data = {}) {
-    console.log(JSON.stringify({ ok: true, ...data }));
-    process.exit(0);
-}
-if (!BOT_TOKEN)
-    fail('SLACK_BOT_TOKEN not set');
-const slack = new WebClient(BOT_TOKEN);
-const [, , command, ...args] = process.argv;
-/**
- * Strip --channel, --thread_ts, --text flags that Claude sometimes adds.
- * These values come from env vars, not CLI args.
- */
-function stripFlags(rawArgs) {
-    const flagsToStrip = ['--channel', '--thread_ts', '--thread-ts', '--text'];
-    const cleaned = [];
-    let i = 0;
-    while (i < rawArgs.length) {
-        if (flagsToStrip.includes(rawArgs[i])) {
-            // If this is --text, everything after the next arg is the message
-            if (rawArgs[i] === '--text') {
-                return rawArgs.slice(i + 1).join(' ');
-            }
-            i += 2; // skip flag + value
-        }
-        else {
-            cleaned.push(rawArgs[i]);
-            i++;
-        }
-    }
-    return cleaned.join(' ');
-}
-async function main() {
-    switch (command) {
-        case 'send_message': {
-            const text = stripFlags(args);
-            if (!text)
-                fail('Message text required');
-            if (!CHANNEL)
-                fail('SLACK_CHANNEL not set');
-            if (!THREAD_TS)
-                fail('SLACK_THREAD_TS not set');
-            console.error(`[slack-tool] send_message: channel=${CHANNEL}, thread_ts=${THREAD_TS}`);
-            const result = await slack.chat.postMessage({
-                channel: CHANNEL,
-                thread_ts: THREAD_TS,
-                text,
-                unfurl_links: false,
-                unfurl_media: false,
-            });
-            console.error(`[slack-tool] posted: ts=${result.ts}, thread_ts=${result.message?.thread_ts}`);
-            succeed({ ts: result.ts });
-            break;
-        }
-        case 'add_reaction': {
-            const emoji = args[0];
-            if (!emoji)
-                fail('Emoji name required');
-            if (!CHANNEL)
-                fail('SLACK_CHANNEL not set');
-            if (!MESSAGE_TS)
-                fail('SLACK_MESSAGE_TS not set');
-            await slack.reactions.add({
-                channel: CHANNEL,
-                timestamp: MESSAGE_TS,
-                name: emoji,
-            });
-            succeed();
-            break;
-        }
-        case 'remove_reaction': {
-            const emoji = args[0];
-            if (!emoji)
-                fail('Emoji name required');
-            if (!CHANNEL)
-                fail('SLACK_CHANNEL not set');
-            if (!MESSAGE_TS)
-                fail('SLACK_MESSAGE_TS not set');
-            await slack.reactions.remove({
-                channel: CHANNEL,
-                timestamp: MESSAGE_TS,
-                name: emoji,
-            });
-            succeed();
-            break;
-        }
-        case 'read_thread': {
-            if (!CHANNEL)
-                fail('SLACK_CHANNEL not set');
-            if (!THREAD_TS)
-                fail('SLACK_THREAD_TS not set');
-            const limit = parseInt(args[0] || '20', 10);
-            const result = await slack.conversations.replies({
-                channel: CHANNEL,
-                ts: THREAD_TS,
-                limit,
-            });
-            const messages = (result.messages || []).map((m) => ({
-                user: m.user || m.bot_id || 'unknown',
-                text: m.text || '',
-                ts: m.ts,
-                is_bot: Boolean(m.bot_id),
-            }));
-            succeed({ messages });
-            break;
-        }
-        case 'set_status': {
-            const status = args.join(' ');
-            if (!CHANNEL)
-                fail('SLACK_CHANNEL not set');
-            if (!THREAD_TS)
-                fail('SLACK_THREAD_TS not set');
-            await slack.apiCall('assistant.threads.setStatus', {
-                channel_id: CHANNEL,
-                thread_ts: THREAD_TS,
-                status,
-            });
-            succeed();
-            break;
-        }
-        case 'upload_snippet': {
-            const title = args[0];
-            const content = args[1];
-            const filetype = args[2] || 'text';
-            if (!title || !content)
-                fail('Title and content required');
-            if (!CHANNEL)
-                fail('SLACK_CHANNEL not set');
-            if (!THREAD_TS)
-                fail('SLACK_THREAD_TS not set');
-            await slack.filesUploadV2({
-                channel_id: CHANNEL,
-                thread_ts: THREAD_TS,
-                title,
-                content,
-                filetype,
-            });
-            succeed();
-            break;
-        }
-        default:
-            fail(`Unknown command: ${command}. Available: send_message, add_reaction, remove_reaction, read_thread, set_status, upload_snippet`);
-    }
-}
-main().catch((err) => {
-    fail(err instanceof Error ? err.message : String(err));
-});

package/dist/scripts/upload-snippet.d.ts

@@ -1,8 +0,0 @@
-#!/usr/bin/env node
-/**
- * Upload a code/text snippet to a Slack thread.
- *
- * Usage:
- *   node upload-snippet.js "title" "content" [filetype]
- */
-export {};

package/dist/scripts/upload-snippet.js

@@ -1,21 +0,0 @@
-#!/usr/bin/env node
-/**
- * Upload a code/text snippet to a Slack thread.
- *
- * Usage:
- *   node upload-snippet.js "title" "content" [filetype]
- */
-import { slack, fail, succeed, parseArgs } from './lib/slack-client.js';
-const { channel, threadTs, positional } = parseArgs();
-const [title, content, filetype = 'text'] = positional;
-if (!title || !content)
-    fail('Title and content required');
-if (!channel)
-    fail('Channel required');
-if (!threadTs)
-    fail('Thread TS required');
-async function main() {
-    await slack.filesUploadV2({ channel_id: channel, thread_ts: threadTs, title: title, content: content, filetype });
-    succeed();
-}
-main().catch((err) => fail(err instanceof Error ? err.message : String(err)));