relaybot 1.0.5 → 1.0.7

package/README.md

@@ -1,6 +1,6 @@
 # RelayBot
 
-An AI assistant that lives in your Slack DMs — powered by Claude or Codex.
+An AI assistant that lives in your Slack channels and DMs — powered by Claude or Codex.
 
 <img src="demo/demo.jpg" width="30%">
 
@@ -8,11 +8,11 @@ An AI assistant that lives in your Slack DMs — powered by Claude or Codex.
 
 ## What is RelayBot?
 
-RelayBot acts as a bridge between Slack and AI coding agents, allowing you to interact with Claude or Codex through simple Slack DMs. Instead of switching between tools, you can request code changes, ask questions, and manage development tasks without leaving Slack.
+RelayBot acts as a bridge between Slack and AI coding agents, allowing you to interact with Claude or Codex by mentioning the bot in channels or sending a DM. Instead of switching between tools, you can request code changes, ask questions, and manage development tasks without leaving Slack.
 
 ### Key Features
 
-- **Conversational AI Access** — Chat with Claude or Codex directly from Slack DMs
+- **Conversational AI Access** — Chat with Claude or Codex from Slack channels via mentions or via DM
 - **Code Execution** — AI can read, write, and modify code in your projects
 - **Task Automation** — Request file changes, refactoring, bug fixes, or new features
 - **Context-Aware Responses** — Maintains project directory context across conversations
@@ -37,7 +37,7 @@ RelayBot acts as a bridge between Slack and AI coding agents, allowing you to in
 │                           SLACK                                     │
 │  ┌──────────┐                                    ┌──────────────┐   │
 │  │   User   │ ───── sends message ─────────────► │   Channel/   │   │
-│  │          │ ◄──── receives reply ───────────── │      DM      │   │
+│  │          │ ◄──── receives reply ───────────── │   Channel   │   │
 │  └──────────┘                                    └──────────────┘   │
 └─────────────────────────────────────────────────────────────────────┘
                               │ ▲
@@ -84,12 +84,34 @@ RelayBot acts as a bridge between Slack and AI coding agents, allowing you to in
 
 ## How It Works
 
-1. **Slack Connection** — RelayBot connects to Slack via WebSocket (Socket Mode) and listens for DMs
+1. **Slack Connection** — RelayBot connects to Slack via WebSocket (Socket Mode) and listens for mentions and DMs
 2. **Message Reception** — When you send a message, Slack forwards it to RelayBot
 3. **AI Bridge** — RelayBot spawns a persistent Claude or Codex CLI session and forwards your message
 4. **AI Processing** — The AI processes your request with full access to your codebase
 5. **Response Summarization** — Long outputs are summarized into concise, actionable messages
-6. **Slack Reply** — The summarized response is sent back to you via Slack DM
+6. **Slack Reply** — The summarized response is sent back to the same channel or DM
+
+---
+
+## Slack Commands
+
+Send these as a DM to the bot (or in a channel mention) to control the agent session:
+
+- `$status` — Show whether the agent is running, plus PID, start time, uptime, cwd, WORKING_DIR, and last exit
+- `$stop` — Stop the agent session (equivalent to Ctrl-C)
+- `$start [--codex] [--noyolo]` — Start the agent with optional flags
+- `$restart [--codex] [--noyolo]` — Restart the agent with optional flags
+- `$dir /path/to/working/dir` — Update the configured working directory (must exist).
+
+Examples:
+
+```
+$status
+$stop
+$start --codex
+$restart --noyolo
+$dir /Users/you/work/project
+```
 
 ---
 
@@ -215,6 +237,7 @@ Socket Mode allows the bot to receive events via WebSocket instead of HTTP endpo
 2. Scroll to **Scopes** → **Bot Token Scopes**
 3. Add these scopes:
    - `chat:write` — Send messages
+   - `app_mentions:read` — Read mentions of your app
    - `im:history` — Read DM history
    - `im:read` — View DM metadata
    - `im:write` — Start DMs with users
@@ -226,6 +249,7 @@ Socket Mode allows the bot to receive events via WebSocket instead of HTTP endpo
 2. Toggle **Enable Events** to ON
 3. Expand **Subscribe to bot events**
 4. Add these events:
+   - `app_mention` — Receive mentions in channels
    - `message.im` — Receive DM messages
 
 #### 5. Install the App

package/guide.md

@@ -0,0 +1,18 @@
+Send a Slack DM after tasks or answers using `send-slack-message.js`, replying naturally as a bot (avoid meta summaries).
+Choose the best default and proceed automatically; do not ask for clarification.
+
+## Output rules
+
+- Keep messages concise and actionable
+- Include relevant links (PR URLs, documentation, etc.)
+- For long answers, distill key points in a natural voice (no meta summary framing)
+- Use clean line breaks; do not include literal `\n` sequences
+- Use emojis sparingly when they improve clarity or tone
+
+## Quick commands
+
+Send a Slack DM:
+
+```bash
+node ./src/send-slack-message.js "Your message here"
+```

package/main.js

@@ -20,6 +20,14 @@ const app = new App({
   socketMode: true
 });
 
+if (config.WORKING_DIR) {
+  try {
+    process.chdir(config.WORKING_DIR);
+  } catch (error) {
+    console.error(`Failed to change WORKING_DIR to ${config.WORKING_DIR}:`, error.message);
+  }
+}
+
 slackHandlers.registerHandlers(app);
 
 (async () => {

package/manifest.json

@@ -1,7 +1,7 @@
 {
   "display_information": {
     "name": "RelayBot",
-    "description": "An AI assistant that lives in your Slack DMs — powered by Claude or Codex",
+    "description": "An AI assistant that lives in your Slack channels and DMs — powered by Claude or Codex",
     "background_color": "#4A154B"
   },
   "features": {
@@ -14,6 +14,7 @@
     "scopes": {
       "bot": [
         "chat:write",
+        "app_mentions:read",
         "im:history",
         "im:read",
         "im:write",
@@ -24,6 +25,7 @@
   "settings": {
     "event_subscriptions": {
       "bot_events": [
+        "app_mention",
         "message.im"
       ]
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "relaybot",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "An AI assistant that lives in your Slack DMs — powered by Claude or Codex",
   "main": "main.js",
   "bin": {

package/src/agent.js

@@ -1,9 +1,14 @@
 const pty = require('@lydell/node-pty');
 
 let claudeProcess = null;
-const useCodex = process.argv.includes('--codex');
-const noYolo = process.argv.includes('--noyolo');
-const shell = useCodex ? 'codex' : 'claude';
+let startTime = null;
+let lastExit = null;
+let stdinHandler = null;
+let stdinAttached = false;
+let rawModeBefore = null;
+let useCodex = process.argv.includes('--codex');
+let noYolo = process.argv.includes('--noyolo');
+let shell = useCodex ? 'codex' : 'claude';
 
 function sendCommand(text) {
   if (claudeProcess) {
@@ -21,29 +26,20 @@ function isRunning() {
   return claudeProcess !== null;
 }
 
-function start() {
-  const defaultArgs = useCodex ? ['--yolo'] : ['--dangerously-skip-permissions'];
-  const spawnArgs = noYolo ? [] : defaultArgs;
-  claudeProcess = pty.spawn(shell, spawnArgs, {
-    name: 'xterm-color',
-    cols: 80,
-    rows: 30,
-    cwd: process.cwd(),
-    env: { ...process.env, TERM: process.env.TERM || 'xterm-256color' }
-  });
-
-  console.log(`--- Persistent ${useCodex ? 'Codex' : 'Claude'} Session Started ---`);
+function attachStdin() {
+  if (stdinAttached) return;
 
-  const hadRawMode = Boolean(process.stdin.isTTY && process.stdin.isRaw);
+  rawModeBefore = Boolean(process.stdin.isTTY && process.stdin.isRaw);
   if (process.stdin.isTTY) {
     process.stdin.setRawMode(true);
   }
   process.stdin.resume();
-  process.stdin.on('data', (data) => {
+
+  stdinHandler = (data) => {
     if (data && data.length === 1 && data[0] === 3) {
       // Ctrl+C: restore terminal and exit.
       if (process.stdin.isTTY) {
-        process.stdin.setRawMode(Boolean(hadRawMode));
+        process.stdin.setRawMode(Boolean(rawModeBefore));
       }
       if (claudeProcess) {
         claudeProcess.kill('SIGINT');
@@ -53,8 +49,50 @@ function start() {
     if (claudeProcess) {
       claudeProcess.write(data);
     }
+  };
+
+  process.stdin.on('data', stdinHandler);
+  stdinAttached = true;
+}
+
+function detachStdin() {
+  if (!stdinAttached) return;
+  process.stdin.off('data', stdinHandler);
+  stdinHandler = null;
+  stdinAttached = false;
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(Boolean(rawModeBefore));
+  }
+}
+
+function start(options = {}) {
+  if (claudeProcess) {
+    return claudeProcess;
+  }
+
+  if (typeof options.useCodex === 'boolean') {
+    useCodex = options.useCodex;
+  }
+  if (typeof options.noYolo === 'boolean') {
+    noYolo = options.noYolo;
+  }
+  shell = useCodex ? 'codex' : 'claude';
+
+  const defaultArgs = useCodex ? ['--yolo'] : ['--dangerously-skip-permissions'];
+  const spawnArgs = noYolo ? [] : defaultArgs;
+  claudeProcess = pty.spawn(shell, spawnArgs, {
+    name: 'xterm-color',
+    cols: 80,
+    rows: 30,
+    cwd: process.cwd(),
+    env: { ...process.env, TERM: process.env.TERM || 'xterm-256color' }
   });
 
+  console.log(`--- Persistent ${useCodex ? 'Codex' : 'Claude'} Session Started ---`);
+  startTime = new Date();
+
+  attachStdin();
+
   claudeProcess.onData((data) => {
     const dataStr = data.toString();
     const byPassPrompts = ['Do you want to proceed?'];
@@ -76,11 +114,59 @@ function start() {
     process.stdout.write(data);
   });
 
+  claudeProcess.onExit(({ exitCode, signal }) => {
+    lastExit = {
+      exitCode,
+      signal,
+      at: new Date()
+    };
+    claudeProcess = null;
+    startTime = null;
+    detachStdin();
+  });
+
   return claudeProcess;
 }
 
+function stop() {
+  if (!claudeProcess) {
+    return { stopped: false, reason: 'not_running' };
+  }
+
+  try {
+    claudeProcess.write('\x03');
+    setTimeout(() => {
+      if (claudeProcess) {
+        claudeProcess.kill('SIGINT');
+      }
+    }, 250);
+  } catch (error) {
+    return { stopped: false, reason: 'error', error };
+  }
+
+  return { stopped: true };
+}
+
+function getStatus() {
+  const now = Date.now();
+  const uptimeSeconds = startTime ? Math.floor((now - startTime.getTime()) / 1000) : null;
+  return {
+    running: Boolean(claudeProcess),
+    shell,
+    pid: claudeProcess ? claudeProcess.pid : null,
+    startedAt: startTime ? startTime.toISOString() : null,
+    uptimeSeconds,
+    noYolo,
+    useCodex,
+    cwd: process.cwd(),
+    lastExit
+  };
+}
+
 module.exports = {
   sendCommand,
   isRunning,
-  start
+  start,
+  stop,
+  getStatus
 };

package/src/send-slack-message.js

@@ -27,29 +27,85 @@ function getLastChannel() {
 }
 const channelId = getLastChannel() || config.SLACK_USER_ID;
 
-// Get the message from command line arguments
-// Convert literal \n to actual newlines
-const message = process.argv[2]?.replace(/\\n/g, '\n');
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const useStdin = args.includes('--stdin');
+  const filtered = args.filter((arg) => arg !== '--stdin');
+  const argMessage = filtered.join(' ');
+  return { useStdin, argMessage };
+}
 
-if (!message) {
-    console.error('Please provide a message to send.');
-    process.exit(1);
+function readStdin() {
+  return new Promise((resolve) => {
+    if (process.stdin.isTTY) {
+      resolve('');
+      return;
+    }
+    let data = '';
+    process.stdin.setEncoding('utf-8');
+    process.stdin.on('data', (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on('end', () => resolve(data));
+  });
+}
+
+function chunkMessage(text, maxLen) {
+  const normalized = text.replace(/\r\n/g, '\n').trim();
+  if (!normalized) return [];
+  if (normalized.length <= maxLen) return [normalized];
+
+  const chunks = [];
+  let remaining = normalized;
+  while (remaining.length > maxLen) {
+    const slice = remaining.slice(0, maxLen);
+    let idx = slice.lastIndexOf('\n\n');
+    if (idx < maxLen * 0.5) idx = slice.lastIndexOf('\n');
+    if (idx < maxLen * 0.5) idx = slice.lastIndexOf(' ');
+    if (idx < 1) idx = maxLen;
+    const piece = remaining.slice(0, idx).trimEnd();
+    if (piece) chunks.push(piece);
+    remaining = remaining.slice(idx).trimStart();
+  }
+  if (remaining) chunks.push(remaining);
+  return chunks;
 }
 
 (async () => {
-    try {
-        if (!channelId) {
-            console.error('No recent channel found and SLACK_USER_ID is not set.');
-            console.error('Send a Slack message to the bot first or set SLACK_USER_ID in the config.');
-            process.exit(1);
-        }
-        const result = await web.chat.postMessage({
-            channel: channelId,
-            text: message,
-        });
-        console.log(`Successfully sent message to ${channelId}`);
-    } catch (error) {
-        console.error(`Error sending message: ${error}`);
-        process.exit(1);
+  try {
+    if (!channelId) {
+      console.error('No recent channel found and SLACK_USER_ID is not set.');
+      console.error('Send a Slack message to the bot first or set SLACK_USER_ID in the config.');
+      process.exit(1);
     }
+
+    const { useStdin, argMessage } = parseArgs();
+    let message = argMessage.replace(/\\n/g, '\n');
+    if (useStdin || !message) {
+      const stdinMessage = await readStdin();
+      if (stdinMessage) {
+        message = stdinMessage;
+      }
+    }
+
+    if (!message || !message.trim()) {
+      console.error('Please provide a message to send.');
+      console.error('Usage: node ./src/send-slack-message.js "Your message here"');
+      console.error('Or: cat message.txt | node ./src/send-slack-message.js --stdin');
+      process.exit(1);
+    }
+
+    const chunks = chunkMessage(message, 39000);
+    for (const chunk of chunks) {
+      await web.chat.postMessage({
+        channel: channelId,
+        text: chunk,
+      });
+    }
+    console.log(`Successfully sent ${chunks.length} message(s) to ${channelId}`);
+  } catch (error) {
+    const apiError = error?.data?.error ? ` (${error.data.error})` : '';
+    console.error(`Error sending message: ${error}${apiError}`);
+    process.exit(1);
+  }
 })();

package/src/slack-handlers.js

@@ -5,7 +5,7 @@ const loadConfig = require('./load-config');
 
 const config = loadConfig();
 const isProduction = __dirname.includes('node_modules');
-const skillPath = path.join(__dirname, '..', 'skills', 'relay-bot', 'SKILL.md');
+const skillPath = path.join(__dirname, '..', 'guide.md');
 const lastMessagePath = path.join(loadConfig.CONFIG_DIR, 'last_message.json');
 
 function storeLastMessage(message) {
@@ -23,14 +23,57 @@ function storeLastMessage(message) {
 }
 
 function getPromptSuffix() {
-  if (isProduction) {
-    return `\nIMPORTANT: Read and follow the instructions in ${skillPath}`;
+  return `\nIMPORTANT: Read and follow the instructions in ${skillPath}`;
+}
+
+function stripMentions(text) {
+  if (!text) return text;
+  return text.replace(/<@[^>]+>/g, '').replace(/\s+/g, ' ').trim();
+}
+
+function updateConfigValue(key, value) {
+  fs.mkdirSync(loadConfig.CONFIG_DIR, { recursive: true });
+  let lines = [];
+  if (fs.existsSync(loadConfig.CONFIG_PATH)) {
+    const content = fs.readFileSync(loadConfig.CONFIG_PATH, 'utf-8');
+    lines = content.split('\n');
   }
-  return '\nIMPORTANT: Use the relay-bot skill.';
+
+  let updated = false;
+  lines = lines.map((line) => {
+    if (line.trim().startsWith('#') || !line.includes('=')) {
+      return line;
+    }
+    const [k] = line.split('=');
+    if (k.trim() === key) {
+      updated = true;
+      return `${key}=${value}`;
+    }
+    return line;
+  });
+
+  if (!updated) {
+    lines.push(`${key}=${value}`);
+  }
+
+  fs.writeFileSync(loadConfig.CONFIG_PATH, lines.join('\n'));
+}
+
+function parseCommandOptions(text) {
+  const parts = (text || '').trim().split(/\s+/);
+  const options = {
+    useCodex: parts.includes('--codex'),
+    noYolo: parts.includes('--noyolo')
+  };
+  return options;
+}
+
+function delay(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
 }
 
 function registerHandlers(app) {
-  app.message(async ({ message, say }) => {
+  async function handleMessage({ message, say, text }) {
     // Only respond to messages from the configured user
     if (config.SLACK_USER_ID && message.user !== config.SLACK_USER_ID) {
       return;
@@ -38,12 +81,105 @@ function registerHandlers(app) {
 
     storeLastMessage(message);
 
+    const trimmedText = (text || '').trim();
+    if (trimmedText === '$stop') {
+      const result = agent.stop();
+      if (result.stopped) {
+        await say('Stopped the agent session (SIGINT).');
+      } else if (result.reason === 'not_running') {
+        await say('Agent is not running.');
+      } else {
+        await say('Failed to stop the agent session.');
+      }
+      return;
+    }
+
+    if (trimmedText.startsWith('$start')) {
+      const options = parseCommandOptions(trimmedText);
+      if (agent.isRunning()) {
+        await say('Agent is already running.');
+      } else {
+        agent.start(options);
+        await say(`Started the agent session${options.useCodex ? ' (Codex)' : ' (Claude)'}${options.noYolo ? ' without auto-approve flags' : ''}.`);
+      }
+      return;
+    }
+
+    if (trimmedText.startsWith('$restart')) {
+      const options = parseCommandOptions(trimmedText);
+      if (agent.isRunning()) {
+        agent.stop();
+        await delay(400);
+      }
+      agent.start(options);
+      await say(`Restarted the agent session${options.useCodex ? ' (Codex)' : ' (Claude)'}${options.noYolo ? ' without auto-approve flags' : ''}.`);
+      return;
+    }
+
+    if (trimmedText === '$status') {
+      const status = agent.getStatus();
+      const lines = [
+        `Running: ${status.running}`,
+        `Shell: ${status.shell}`,
+        `PID: ${status.pid || 'n/a'}`,
+        `Started: ${status.startedAt || 'n/a'}`,
+        `Uptime (s): ${status.uptimeSeconds || 'n/a'}`,
+        `CWD: ${status.cwd}`,
+        `Configured WORKING_DIR: ${config.WORKING_DIR || 'n/a'}`,
+        `Use Codex: ${status.useCodex}`,
+        `No YOLO: ${status.noYolo}`
+      ];
+      if (status.lastExit) {
+        lines.push(`Last exit: code=${status.lastExit.exitCode ?? 'n/a'} signal=${status.lastExit.signal || 'n/a'} at=${status.lastExit.at.toISOString()}`);
+      }
+      await say(lines.join('\n'));
+      return;
+    }
+
+    if (trimmedText.startsWith('$dir ')) {
+      const newDir = trimmedText.replace(/^\$dir\s+/, '').trim();
+      if (!newDir) {
+        await say('Usage: $dir /path/to/working/dir');
+        return;
+      }
+      if (!fs.existsSync(newDir)) {
+        await say(`Directory does not exist: ${newDir}`);
+        return;
+      }
+      const stat = fs.statSync(newDir);
+      if (!stat.isDirectory()) {
+        await say(`Not a directory: ${newDir}`);
+        return;
+      }
+      updateConfigValue('WORKING_DIR', newDir);
+      config.WORKING_DIR = newDir;
+      await say(`Working directory set to: ${newDir}`);
+      return;
+    }
+
     if (agent.isRunning()) {
-      const fullPrompt = message.text + getPromptSuffix();
+      const fullPrompt = trimmedText + getPromptSuffix();
       agent.sendCommand(fullPrompt);
     } else {
       await say('Agent process is not running.');
     }
+  }
+
+  app.event('app_mention', async ({ event, say }) => {
+    if (event.channel_type === 'im' || event.channel_type === 'mpim') {
+      return;
+    }
+
+    const cleanedText = stripMentions(event.text);
+    await handleMessage({ message: event, say, text: cleanedText });
+  });
+
+  app.message(async ({ message, say }) => {
+    if (message.channel_type !== 'im') {
+      return;
+    }
+
+    await handleMessage({ message, say, text: message.text });
   });
 }
 

package/.claude/settings.local.json

@@ -1,15 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(*)",
-      "Read(*)",
-      "Edit(*)",
-      "Write(*)"
-    ],
-    "deny": [
-      "Bash(rm *)",
-      "Bash(rm -rf *)",
-      "Bash(rmdir *)"
-    ]
-  }
-}

package/skills/relay-bot/SKILL.md

@@ -1,53 +0,0 @@
----
-name: relay-bot
-description: "Workspace-aware assistant that maintains project directory context and sends a Slack DM reply after completing a task or answering a question."
----
-
-# RelayBot
-
-## Overview
-
-Maintain working-directory context for projects and send a Slack DM after tasks or answers using `send-slack-message.js`.
-
-## Working directory
-
-The working directory where the AI operates is configured in `~/.relaybot/config.conf`:
-
-```
-WORKING_DIR=/path/to/directory
-```
-
-## Workflow
-
-### 1) Resolve project context
-
-- Use the directory configured in `WORKING_DIR` as the working context when set; otherwise use the current process working directory.
-- Run all commands and file operations within this directory.
-- Avoid asking the user for clarification; pick the best default and proceed automatically.
-- If a question is truly required to continue, send it as a Slack DM using the script, then wait for the user's response via the Slack socket before proceeding.
-
-### 2) Execute the task in the active project
-
-- Run commands and edit files in the resolved working directory.
-- Keep the project context for follow-up requests unless the user switches again.
-
-### 3) Send a Slack DM reply after completion
-
-Run from this repo root:
-
-```bash
-node ./src/send-slack-message.js "Your message here"
-```
-
-## Output rules
-
-- Keep messages concise and actionable
-- Include relevant links (PR URLs, documentation, etc.)
-- For long answers, summarize key points
-- Format replies with clean, readable line breaks; do not use literal `\n` sequences
-- Use emojis sparingly when they improve clarity or tone
-
-## Notes
-
-- The script posts to the configured DM user in `~/.relaybot/config.conf`
-- The Slack bot token must be configured in `~/.relaybot/config.conf`