relaybot 1.0.6 → 1.0.8

package/README.md

@@ -93,6 +93,28 @@ RelayBot acts as a bridge between Slack and AI coding agents, allowing you to in
 
 ---
 
+## 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
+```
+
+---
+
 ## Installation
 
 ### Option 1: Install via npm (Recommended)

package/guide.md

@@ -0,0 +1,21 @@
+Send a Slack DM after tasks or answers using `send-slack-message.js`, replying naturally as a bot (avoid meta summaries about what was asked/answered).
+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
+- Send the message itself, not a description of the message. Example:
+  - Bad: `User asked how I am; I replied I'm good and ready to help.`
+  - Good: `Doing well—ready when you are. What can I help with?`
+
+## 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "relaybot",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "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,10 +23,7 @@ function storeLastMessage(message) {
 }
 
 function getPromptSuffix() {
-  if (isProduction) {
-    return `\nIMPORTANT: Read and follow the instructions in ${skillPath}`;
-  }
-  return '\nIMPORTANT: Use the relay-bot skill.';
+  return `\nIMPORTANT: Read and follow the instructions in ${skillPath}`;
 }
 
 function stripMentions(text) {
@@ -34,6 +31,47 @@ function stripMentions(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');
+  }
+
+  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) {
   async function handleMessage({ message, say, text }) {
     // Only respond to messages from the configured user
@@ -43,8 +81,84 @@ 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 = text + getPromptSuffix();
+      const fullPrompt = trimmedText + getPromptSuffix();
       agent.sendCommand(fullPrompt);
     } else {
       await say('Agent process is not running.');

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`