codexbot 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Quan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,145 @@
+# codexbot
+
+Control AI coding agents from your phone. codexbot connects **Telegram** or **Slack** to **OpenAI Codex** and **Anthropic Claude**, so you can ask them to read, write, and refactor code — all from a chat message.
+
+Send a prompt from Telegram while you're on the go. The agent works in your codebase and streams every step back to you in real time: what it's thinking, which files it's reading, the commands it runs, and the changes it makes.
+
+## Why
+
+Sometimes you want to kick off a coding task, review progress, or give follow-up instructions without sitting at your desk. codexbot turns your favorite chat app into a remote terminal for AI agents that can actually write and run code.
+
+## Features
+
+- **Two backends** — Codex (default) or Claude, switchable at any time
+- **Real-time streaming** — see agent thoughts, tool usage, command output, and file changes as they happen
+- **Background service** — runs as a daemon with start/stop/status management
+- **Interactive mode** — test locally in your terminal before connecting a chat platform
+- **Chat commands** — control the agent directly from Telegram or Slack (`/status`, `/stop`, `/restart`, etc.)
+- **Telegram command menu** — commands appear in Telegram's autocomplete for easy access
+- **Multi-turn context** — the agent remembers your conversation across messages
+- **Long message handling** — responses are split intelligently to fit platform limits
+
+## Prerequisites
+
+- **Node.js** 18 or later
+- **Codex CLI** or **Claude CLI** installed and signed in (either via OAuth or API key — however you normally authenticate)
+- A **Telegram bot token** or a **Slack app** with Socket Mode enabled
+
+## Getting Started
+
+### 1. Install
+
+```bash
+npm install -g codexbot
+```
+
+Or install from source:
+
+```bash
+git clone https://github.com/nicklama/codexbot.git
+cd codexbot
+npm install
+npm link
+```
+
+### 2. Configure
+
+Run the setup wizard:
+
+```bash
+codexbot onboard
+```
+
+You'll be asked to choose a platform (Telegram or Slack), enter your bot tokens, and set a working directory — the folder where the agent will operate.
+
+Configuration is stored in `~/.codexbot/config.json`. Run `codexbot onboard` again at any time to update it.
+
+### 3. Start
+
+```bash
+codexbot start
+```
+
+That's it. The bot launches in the background, connects to your chat platform, and is ready to accept prompts.
+
+## Usage
+
+### Managing the service
+
+| Command | What it does |
+|---------|-------------|
+| `codexbot start` | Start the bot as a background service (Codex by default) |
+| `codexbot start --claude` | Start with Claude instead of Codex |
+| `codexbot start --disable-yolo` | Start without auto-accepting agent actions |
+| `codexbot stop` | Stop the background service |
+| `codexbot status` | Check whether the service is running |
+
+### Interactive mode
+
+If you want to test things locally before connecting a chat platform:
+
+```bash
+codexbot start --interactive
+```
+
+You type messages in the terminal and see the same output that would be sent to Telegram or Slack.
+
+### Chat commands
+
+Once the bot is running, send these commands from Telegram or Slack. Both `/` and `$` prefixes work:
+
+| Command | What it does |
+|---------|-------------|
+| `/status` | Show the agent's backend, uptime, and working directory |
+| `/stop` | Stop the agent |
+| `/start` | Start the agent (add `--claude` or `--codex` to switch backends) |
+| `/restart` | Restart the agent |
+| `/dir` | Show the current working directory |
+| `/dir /path/to/project` | Change the working directory (restart to apply) |
+
+Anything else you type is sent directly to the agent as a prompt.
+
+## Setting Up Telegram
+
+1. Open Telegram and message [@BotFather](https://t.me/BotFather)
+2. Create a new bot and copy the token
+3. Run `codexbot onboard` and enter the token
+4. Optionally restrict access by entering your Telegram user ID (find it via [@userinfobot](https://t.me/userinfobot))
+5. Run `codexbot start`
+
+The bot will register its commands with Telegram automatically, so you'll see them in the autocomplete menu when you type `/`.
+
+## Setting Up Slack
+
+1. Create a new app at [api.slack.com/apps](https://api.slack.com/apps)
+2. Enable **Socket Mode** and generate an App-Level Token (`xapp-...`)
+3. Add Bot Token Scopes: `app_mentions:read`, `chat:write`, `im:history`, `im:read`, `im:write`
+4. Subscribe to events: `app_mention`, `message.im`
+5. Install the app to your workspace and copy the Bot User OAuth Token (`xoxb-...`)
+6. Run `codexbot onboard` and enter both tokens
+7. Run `codexbot start`
+
+## How It Works
+
+When you send a message, codexbot forwards it to the AI agent running in your configured working directory. The agent can read files, edit code, run shell commands, search the web, and more — all autonomously.
+
+Every action the agent takes is streamed back to your chat in real time:
+
+- **Text responses** — the agent's reasoning and answers
+- **Tool usage** — which files it's reading, editing, or creating
+- **Command output** — shell commands and their results
+- **File changes** — a summary of files added, updated, or deleted
+
+The agent maintains context across messages, so you can have a natural back-and-forth conversation about your code.
+
+## Logs and Files
+
+| Path | Purpose |
+|------|---------|
+| `~/.codexbot/config.json` | Your bot configuration |
+| `~/.codexbot/codexbot.log` | Service logs (useful for debugging) |
+| `~/.codexbot/codexbot.pid` | Process ID of the running service |
+
+## License
+
+MIT

package/cli.js

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+
+const args = process.argv.slice(2);
+const command = args[0];
+
+function showHelp() {
+  console.log(`
+codexbot - Bridge Slack/Telegram to Claude/Codex via their SDKs
+
+Usage:
+  codexbot start [options]      Start the bot as a background service
+  codexbot stop                 Stop the background service
+  codexbot status               Show service status
+  codexbot onboard              Interactive setup (platform, tokens, config)
+
+Options:
+  --interactive              Run in interactive terminal mode
+  --claude                   Use Claude Agent SDK instead of Codex SDK (default: Codex)
+  --disable-yolo             Disable auto-accept mode
+  --help, -h                 Show this help message
+`);
+}
+
+switch (command) {
+  case 'start': {
+    const rest = args.slice(1);
+    if (rest.includes('--interactive')) {
+      const { start } = await import('./src/main.js');
+      start(rest);
+    } else {
+      const { startService } = await import('./src/service.js');
+      startService(rest);
+    }
+    break;
+  }
+  case 'stop': {
+    const { stopService } = await import('./src/service.js');
+    stopService();
+    break;
+  }
+  case 'status': {
+    const { showStatus } = await import('./src/service.js');
+    showStatus();
+    break;
+  }
+  case '_serve': {
+    // Internal: runs the actual bot (used by background service)
+    const { start } = await import('./src/main.js');
+    start(args.slice(1));
+    break;
+  }
+  case 'onboard':
+    await import('./src/onboard.js');
+    break;
+  case '--help':
+  case '-h':
+  case undefined:
+    showHelp();
+    break;
+  default:
+    console.error(`Unknown command: ${command}`);
+    showHelp();
+    process.exit(1);
+}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "codexbot",
+  "version": "1.0.0",
+  "type": "module",
+  "description": "Control Claude and Codex AI agents from Telegram or Slack",
+  "keywords": [
+    "claude",
+    "codex",
+    "openai",
+    "anthropic",
+    "telegram",
+    "slack",
+    "chatbot",
+    "ai-agent",
+    "cli"
+  ],
+  "author": "Quan <dinhquan191@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dinhquan/codexbot.git"
+  },
+  "homepage": "https://github.com/dinhquan/codexbot#readme",
+  "bugs": {
+    "url": "https://github.com/dinhquan/codexbot/issues"
+  },
+  "main": "cli.js",
+  "bin": {
+    "codexbot": "./cli.js"
+  },
+  "files": [
+    "cli.js",
+    "src/",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "start": "node cli.js start"
+  },
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.2.74",
+    "@openai/codex-sdk": "^0.114.0",
+    "@slack/bolt": "^4.6.0",
+    "@slack/web-api": "^7.13.0",
+    "telegraf": "^4.16.0"
+  }
+}

package/src/agent.js

@@ -0,0 +1,269 @@
+import { EventEmitter } from 'events';
+
+export default class Agent extends EventEmitter {
+  constructor(opts = {}) {
+    super();
+    this.backend = opts.backend || 'codex'; // 'codex' or 'claude'
+    this.workingDir = opts.workingDir || process.cwd();
+    this.disableYolo = opts.disableYolo || false;
+    this.running = false;
+    this.busy = false;
+    this.startTime = null;
+    this._abortController = null;
+
+    // Claude-specific
+    this._claudeSessionId = null;
+
+    // Codex-specific
+    this._codexClient = null;
+    this._codexThread = null;
+  }
+
+  start() {
+    this.running = true;
+    this.startTime = Date.now();
+
+    if (this.backend === 'codex') {
+      this._initCodex();
+    }
+
+    console.log(`[codexbot] Agent started (${this.backend}) in ${this.workingDir}`);
+  }
+
+  async _initCodex() {
+    const { Codex } = await import('@openai/codex-sdk');
+    this._codexClient = new Codex();
+    this._codexThread = this._codexClient.startThread({
+      workingDirectory: this.workingDir,
+      approvalPolicy: this.disableYolo ? 'on-request' : 'never',
+      sandboxMode: this.disableYolo ? 'read-only' : 'danger-full-access',
+    });
+  }
+
+  async sendCommand(text) {
+    if (!this.running) return false;
+    if (this.busy) return true;
+
+    this.busy = true;
+    this._abortController = new AbortController();
+
+    try {
+      if (this.backend === 'claude') {
+        await this._runClaude(text);
+      } else {
+        await this._runCodex(text);
+      }
+    } catch (err) {
+      if (err.name !== 'AbortError') {
+        console.error(`[codexbot] Agent error:`, err.message);
+        this.emit('message', `Error: ${err.message}`);
+      }
+    } finally {
+      this.busy = false;
+      this._abortController = null;
+      this.emit('done');
+    }
+
+    return true;
+  }
+
+  async _runClaude(text) {
+    const { query } = await import('@anthropic-ai/claude-agent-sdk');
+
+    const options = {
+      cwd: this.workingDir,
+      allowedTools: ['Read', 'Edit', 'Write', 'Bash', 'Glob', 'Grep', 'WebSearch', 'WebFetch', 'Agent'],
+      permissionMode: this.disableYolo ? 'default' : 'bypassPermissions',
+      allowDangerouslySkipPermissions: !this.disableYolo,
+      abortController: this._abortController,
+      maxTurns: 50,
+    };
+
+    if (this._claudeSessionId) {
+      options.resume = this._claudeSessionId;
+    }
+
+    const stream = query({ prompt: text, options });
+
+    for await (const message of stream) {
+      console.log(`[codexbot:claude] message: ${message.type}${message.subtype ? `:${message.subtype}` : ''}`);
+
+      if (message.type === 'system' && message.subtype === 'init') {
+        this._claudeSessionId = message.session_id;
+        console.log(`[codexbot:claude] session: ${message.session_id}`);
+      }
+
+      if (message.type === 'assistant') {
+        for (const block of message.message.content) {
+          if (block.type === 'text' && block.text.trim()) {
+            console.log(`[codexbot:claude] text (${block.text.length} chars)`);
+            this.emit('message', block.text);
+          }
+          if (block.type === 'tool_use') {
+            console.log(`[codexbot:claude] tool_use: ${block.name}`);
+            const msg = this._formatClaudeToolUse(block);
+            if (msg) this.emit('message', msg);
+          }
+        }
+      }
+
+      if (message.type === 'user') {
+        // Tool results
+        const content = message.message?.content;
+        if (Array.isArray(content)) {
+          for (const block of content) {
+            if (block.type === 'tool_result') {
+              const msg = this._formatClaudeToolResult(block);
+              if (msg) this.emit('message', msg);
+            }
+          }
+        }
+      }
+
+      if (message.type === 'result') {
+        console.log(`[codexbot:claude] result: ${message.subtype}${message.total_cost_usd ? ` ($${message.total_cost_usd.toFixed(4)})` : ''}`);
+        if (message.subtype !== 'success') {
+          this.emit('message', `Agent finished with: ${message.subtype}`);
+        }
+      }
+    }
+  }
+
+  async _runCodex(text) {
+    if (!this._codexThread) {
+      await this._initCodex();
+    }
+
+    const { events } = await this._codexThread.runStreamed(text, {
+      signal: this._abortController.signal,
+    });
+
+    for await (const event of events) {
+      console.log(`[codexbot:codex] event: ${event.type}`, event.type === 'item.completed' || event.type === 'item.started' ? `item.type=${event.item?.type}` : '');
+
+      if (event.type === 'item.completed') {
+        const item = event.item;
+        console.log(`[codexbot:codex] item.completed:`, JSON.stringify(item, null, 2).slice(0, 500));
+
+        const msg = this._formatCodexItem(item);
+        if (msg) this.emit('message', msg);
+      }
+
+      if (event.type === 'turn.completed') {
+        console.log(`[codexbot:codex] turn.completed`);
+      }
+
+      if (event.type === 'turn.failed') {
+        console.log(`[codexbot:codex] turn.failed:`, event.error);
+        this.emit('message', `Error: ${event.error?.message || 'Unknown error'}`);
+      }
+    }
+  }
+
+  _formatClaudeToolUse(block) {
+    const name = block.name;
+    const input = block.input || {};
+
+    if (name === 'Bash') {
+      return `\`$ ${input.command || ''}\``;
+    }
+    if (name === 'Read') {
+      return `Reading \`${input.file_path || ''}\``;
+    }
+    if (name === 'Edit') {
+      return `Editing \`${input.file_path || ''}\``;
+    }
+    if (name === 'Write') {
+      return `Writing \`${input.file_path || ''}\``;
+    }
+    if (name === 'Glob') {
+      return `Searching files: \`${input.pattern || ''}\``;
+    }
+    if (name === 'Grep') {
+      return `Searching for: \`${input.pattern || ''}\``;
+    }
+    // Other tools — just show the name
+    return `Using tool: ${name}`;
+  }
+
+  _formatClaudeToolResult(block) {
+    const content = block.content;
+    if (!content) return null;
+
+    // Content can be a string or array of blocks
+    if (typeof content === 'string') {
+      if (!content.trim()) return null;
+      const trimmed = content.length > 2000 ? content.slice(0, 2000) + '...' : content;
+      return `\`\`\`\n${trimmed}\n\`\`\``;
+    }
+
+    if (Array.isArray(content)) {
+      const texts = content
+        .filter(b => b.type === 'text' && b.text?.trim())
+        .map(b => b.text);
+      if (!texts.length) return null;
+      const joined = texts.join('\n');
+      const trimmed = joined.length > 2000 ? joined.slice(0, 2000) + '...' : joined;
+      return `\`\`\`\n${trimmed}\n\`\`\``;
+    }
+
+    return null;
+  }
+
+  _formatCodexItem(item) {
+    switch (item.type) {
+      case 'agent_message': {
+        const text = item.text || '';
+        return text.trim() || null;
+      }
+
+      case 'command_execution': {
+        const cmd = item.command || '';
+        const output = item.aggregated_output || '';
+        const failed = item.status === 'failed' || (item.exit_code && item.exit_code !== 0);
+        const statusTag = failed ? ' (failed)' : '';
+        let msg = `\`$ ${cmd}\`${statusTag}`;
+        if (output) {
+          const trimmed = output.length > 2000 ? output.slice(0, 2000) + '...' : output;
+          msg += `\n\`\`\`\n${trimmed}\n\`\`\``;
+        }
+        return msg;
+      }
+
+      case 'file_change': {
+        const changes = item.changes || [];
+        if (!changes.length) return null;
+        const lines = changes.map(c => `  ${c.kind}: ${c.path}`);
+        return `File changes:\n${lines.join('\n')}`;
+      }
+
+      default: {
+        // Forward any other item type with its text if present
+        if (item.text && item.text.trim()) return item.text;
+        return null;
+      }
+    }
+  }
+
+  stop() {
+    if (this._abortController) {
+      this._abortController.abort();
+    }
+    this._codexClient = null;
+    this._codexThread = null;
+    this._claudeSessionId = null;
+    this.running = false;
+    this.busy = false;
+    console.log('[codexbot] Agent stopped');
+  }
+
+  getStatus() {
+    return {
+      running: this.running,
+      busy: this.busy,
+      uptime: this.startTime ? Math.floor((Date.now() - this.startTime) / 1000) : 0,
+      backend: this.backend,
+      cwd: this.workingDir,
+    };
+  }
+}

package/src/chunker.js

@@ -0,0 +1,50 @@
+export function chunkMessage(text, maxLen = 4000) {
+  if (text.length <= maxLen) return [text];
+
+  const chunks = [];
+  let remaining = text;
+
+  while (remaining.length > 0) {
+    if (remaining.length <= maxLen) {
+      chunks.push(remaining);
+      break;
+    }
+
+    let splitAt = -1;
+
+    // Try splitting at double newline (paragraph boundary)
+    const paraIdx = remaining.lastIndexOf('\n\n', maxLen);
+    if (paraIdx > maxLen * 0.3) {
+      splitAt = paraIdx + 2;
+    }
+
+    // Try splitting at single newline
+    if (splitAt === -1) {
+      const lineIdx = remaining.lastIndexOf('\n', maxLen);
+      if (lineIdx > maxLen * 0.3) {
+        splitAt = lineIdx + 1;
+      }
+    }
+
+    // Try splitting at space
+    if (splitAt === -1) {
+      const spaceIdx = remaining.lastIndexOf(' ', maxLen);
+      if (spaceIdx > maxLen * 0.3) {
+        splitAt = spaceIdx + 1;
+      }
+    }
+
+    // Hard split as last resort
+    if (splitAt === -1) {
+      splitAt = maxLen;
+    }
+
+    chunks.push(remaining.slice(0, splitAt));
+    remaining = remaining.slice(splitAt);
+  }
+
+  if (chunks.length > 1) {
+    return chunks.map((chunk, i) => `[${i + 1}/${chunks.length}]\n${chunk}`);
+  }
+  return chunks;
+}

package/src/commands.js

@@ -0,0 +1,74 @@
+import fs from 'fs';
+
+export const COMMANDS = [
+  { command: 'status', description: 'Show agent status' },
+  { command: 'stop', description: 'Stop the agent' },
+  { command: 'start', description: 'Start the agent' },
+  { command: 'restart', description: 'Restart the agent' },
+  { command: 'dir', description: 'Show or change working directory' },
+];
+
+export function handle(text, agent) {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith('$') && !trimmed.startsWith('/')) return { handled: false };
+
+  const parts = trimmed.split(/\s+/);
+  // Normalize: strip leading $ or / to get the command name
+  const cmd = parts[0].slice(1).toLowerCase();
+
+  switch (cmd) {
+    case 'status': {
+      const s = agent.getStatus();
+      const upMin = Math.floor(s.uptime / 60);
+      const upSec = s.uptime % 60;
+      const response = s.running
+        ? `Running: ${s.backend}${s.busy ? ' (busy)' : ''}\nUptime: ${upMin}m ${upSec}s\nCWD: ${s.cwd}`
+        : 'Agent is not running.';
+      return { handled: true, response };
+    }
+
+    case 'stop': {
+      agent.stop();
+      return { handled: true, response: 'Agent stopped.' };
+    }
+
+    case 'start': {
+      if (agent.running) {
+        return { handled: true, response: 'Agent is already running.' };
+      }
+      applyFlags(agent, parts.slice(1));
+      agent.start();
+      return { handled: true, response: 'Agent started.' };
+    }
+
+    case 'restart': {
+      agent.stop();
+      applyFlags(agent, parts.slice(1));
+      agent.start();
+      return { handled: true, response: 'Agent restarted.' };
+    }
+
+    case 'dir': {
+      const dir = parts[1];
+      if (!dir) {
+        return { handled: true, response: `Current directory: ${agent.workingDir}` };
+      }
+      if (!fs.existsSync(dir)) {
+        return { handled: true, response: `Directory not found: ${dir}` };
+      }
+      agent.workingDir = dir;
+      return { handled: true, response: `Working directory set to: ${dir}\nRestart agent for it to take effect.` };
+    }
+
+    default:
+      return { handled: false };
+  }
+}
+
+function applyFlags(agent, flags) {
+  for (const flag of flags) {
+    if (flag === '--codex') agent.backend = 'codex';
+    if (flag === '--claude') agent.backend = 'claude';
+    if (flag === '--disable-yolo') agent.disableYolo = true;
+  }
+}

package/src/config.js

@@ -0,0 +1,24 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+export const CONFIG_DIR = path.join(os.homedir(), '.codexbot');
+export const CONFIG_PATH = path.join(CONFIG_DIR, 'config.json');
+
+export function loadConfig() {
+  try {
+    return JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8'));
+  } catch {
+    return {};
+  }
+}
+
+export function saveConfig(obj) {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+  const clean = Object.fromEntries(
+    Object.entries(obj).filter(([, v]) => v !== undefined && v !== '')
+  );
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(clean, null, 2) + '\n');
+}

package/src/main.js

@@ -0,0 +1,177 @@
+import readline from 'readline';
+import { loadConfig } from './config.js';
+import Agent from './agent.js';
+import { handle as handleCommand, COMMANDS } from './commands.js';
+import { chunkMessage } from './chunker.js';
+
+export async function start(args = []) {
+  const interactive = args.includes('--interactive');
+  const config = loadConfig();
+  const useClaude = args.includes('--claude');
+  const disableYolo = args.includes('--disable-yolo');
+
+  // Create agent
+  const agent = new Agent({
+    backend: useClaude ? 'claude' : 'codex',
+    disableYolo,
+    workingDir: config.WORKING_DIR || process.cwd(),
+  });
+
+  // Platform adapter (only for non-interactive mode)
+  let platform = null;
+
+  if (!interactive) {
+    if (!config.PLATFORM) {
+      console.error('No platform configured. Run "codexbot onboard" first.');
+      process.exit(1);
+    }
+
+    if (config.PLATFORM === 'slack') {
+      if (!config.SLACK_BOT_TOKEN || !config.SLACK_APP_TOKEN) {
+        console.error('Missing Slack tokens. Run "codexbot onboard" to configure.');
+        process.exit(1);
+      }
+      const { default: SlackAdapter } = await import('./platforms/slack.js');
+      platform = new SlackAdapter(config);
+    } else if (config.PLATFORM === 'telegram') {
+      if (!config.TELEGRAM_BOT_TOKEN) {
+        console.error('Missing Telegram bot token. Run "codexbot onboard" to configure.');
+        process.exit(1);
+      }
+      const { default: TelegramAdapter } = await import('./platforms/telegram.js');
+      platform = new TelegramAdapter(config);
+    } else {
+      console.error(`Unknown platform: ${config.PLATFORM}`);
+      process.exit(1);
+    }
+  }
+
+  if (interactive) {
+    startInteractive(agent);
+  } else {
+    startService(agent, platform, config);
+  }
+}
+
+function startInteractive(agent) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: '\nyou> ',
+  });
+
+  agent.on('message', (text) => {
+    console.log(`\nbot> ${text}`);
+    rl.prompt();
+  });
+
+  agent.on('done', () => {
+    rl.prompt();
+  });
+
+  agent.start();
+  console.log(`[codexbot] Interactive mode (${agent.backend}). Type your message or Ctrl+C to quit.\n`);
+  rl.prompt();
+
+  rl.on('line', async (line) => {
+    const text = line.trim();
+    if (!text) { rl.prompt(); return; }
+
+    const result = handleCommand(text, agent);
+    if (result.handled) {
+      if (result.response) console.log(result.response);
+      rl.prompt();
+      return;
+    }
+
+    const sent = await agent.sendCommand(text);
+    if (!sent) {
+      console.log('Agent is not running. Use $start to start it.');
+      rl.prompt();
+    }
+  });
+
+  rl.on('close', () => {
+    agent.stop();
+    process.exit(0);
+  });
+}
+
+function startService(agent, platform, config) {
+  let currentCtx = null;
+
+  agent.on('message', async (text) => {
+    if (!currentCtx) return;
+    if (platform.stopTyping) platform.stopTyping();
+    await sendResponse(platform, currentCtx, text);
+  });
+
+  agent.on('done', () => {
+    if (platform.stopTyping) platform.stopTyping();
+  });
+
+  platform.onMessage(async (msg) => {
+    currentCtx = {
+      chatId: msg.chatId,
+      threadId: msg.threadId,
+      replyToMessageId: msg.replyToMessageId,
+      platform: config.PLATFORM,
+    };
+
+    if (platform.startTyping) {
+      platform.startTyping(msg.chatId);
+    }
+
+    const result = handleCommand(msg.text, agent);
+    if (result.handled) {
+      if (result.response) {
+        if (platform.stopTyping) platform.stopTyping();
+        await sendResponse(platform, currentCtx, result.response);
+      }
+      return;
+    }
+
+    const sent = await agent.sendCommand(msg.text);
+    if (!sent) {
+      if (platform.stopTyping) platform.stopTyping();
+      await sendResponse(platform, currentCtx, 'Agent is not running. Use $start to start it.');
+    }
+  });
+
+  agent.start();
+
+  // Register bot commands if platform supports it
+  if (platform.setCommands) {
+    platform.setCommands(COMMANDS);
+  }
+
+  platform.start().then(() => {
+    console.log('[codexbot] Bot is running. Press Ctrl+C to stop.');
+  });
+
+  const shutdown = async () => {
+    console.log('\n[codexbot] Shutting down...');
+    agent.stop();
+    await platform.stop().catch(() => { });
+    process.exit(0);
+  };
+
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+}
+
+async function sendResponse(platform, ctx, text) {
+  const maxLen = platform.maxMessageLen || 4000;
+  const chunks = chunkMessage(text, maxLen);
+
+  for (const chunk of chunks) {
+    try {
+      await platform.sendMessage(ctx.chatId, chunk, {
+        threadId: ctx.threadId,
+        replyToMessageId: ctx.replyToMessageId,
+      });
+    } catch (err) {
+      console.error('[codexbot] Failed to send message:', err.message);
+    }
+  }
+}

package/src/onboard.js

@@ -0,0 +1,81 @@
+import fs from 'fs';
+import readline from 'readline';
+import { loadConfig, saveConfig, CONFIG_PATH } from './config.js';
+
+const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+function ask(question, defaultVal) {
+  return new Promise(resolve => {
+    const suffix = defaultVal ? ` [${defaultVal}]` : '';
+    rl.question(`${question}${suffix}: `, answer => {
+      resolve(answer.trim() || defaultVal || '');
+    });
+  });
+}
+
+async function onboard() {
+  console.log('\n=== codexbot Setup ===\n');
+
+  const existing = loadConfig();
+
+  // If config exists, offer to keep it
+  if (existing.PLATFORM) {
+    console.log('Current config:');
+    console.log(`  Platform: ${existing.PLATFORM}`);
+    if (existing.WORKING_DIR) console.log(`  Working dir: ${existing.WORKING_DIR}`);
+    console.log();
+    const keep = await ask('Keep current config? (y/n)', 'y');
+    if (keep.toLowerCase() === 'y') {
+      console.log('Config unchanged.');
+      rl.close();
+      return;
+    }
+    console.log();
+  }
+
+  const config = { ...existing };
+
+  console.log('Choose platform:');
+  console.log('  1) Slack');
+  console.log('  2) Telegram');
+  const platformChoice = await ask('Platform (1 or 2)', config.PLATFORM === 'telegram' ? '2' : '1');
+  config.PLATFORM = platformChoice === '2' ? 'telegram' : 'slack';
+
+  if (config.PLATFORM === 'slack') {
+    console.log('\n--- Slack Configuration ---');
+    config.SLACK_BOT_TOKEN = await ask('Bot Token (xoxb-...)', config.SLACK_BOT_TOKEN);
+    config.SLACK_APP_TOKEN = await ask('App-Level Token (xapp-...)', config.SLACK_APP_TOKEN);
+    config.SLACK_USER_ID = await ask('Your Slack User ID (optional, for auth)', config.SLACK_USER_ID);
+    // Clear telegram keys
+    delete config.TELEGRAM_BOT_TOKEN;
+    delete config.TELEGRAM_ALLOWED_USER_IDS;
+  } else {
+    console.log('\n--- Telegram Configuration ---');
+    config.TELEGRAM_BOT_TOKEN = await ask('Bot Token', config.TELEGRAM_BOT_TOKEN);
+    config.TELEGRAM_ALLOWED_USER_IDS = await ask('Allowed User IDs (comma-separated, optional)', config.TELEGRAM_ALLOWED_USER_IDS);
+    // Clear slack keys
+    delete config.SLACK_BOT_TOKEN;
+    delete config.SLACK_APP_TOKEN;
+    delete config.SLACK_USER_ID;
+  }
+
+  let workingDir = config.WORKING_DIR || process.cwd();
+  while (true) {
+    workingDir = await ask('\nWorking directory (optional)', workingDir);
+    if (!workingDir || fs.existsSync(workingDir)) break;
+    console.log(`Directory does not exist: ${workingDir}`);
+  }
+  config.WORKING_DIR = workingDir;
+
+  saveConfig(config);
+  console.log(`\nConfig saved to ${CONFIG_PATH}`);
+  console.log('Run "codexbot start" to launch the bot.\n');
+
+  rl.close();
+}
+
+onboard().catch(err => {
+  console.error('Setup failed:', err.message);
+  rl.close();
+  process.exit(1);
+});

package/src/platforms/slack.js

@@ -0,0 +1,66 @@
+import pkg from '@slack/bolt';
+const { App } = pkg;
+
+export default class SlackAdapter {
+  constructor(config) {
+    this.config = config;
+    this.app = new App({
+      token: config.SLACK_BOT_TOKEN,
+      appToken: config.SLACK_APP_TOKEN,
+      socketMode: true,
+    });
+    this._messageCallback = null;
+    this.maxMessageLen = 4000;
+  }
+
+  async start() {
+    // Listen for app mentions
+    this.app.event('app_mention', async ({ event }) => {
+      if (this._messageCallback) {
+        const text = event.text.replace(/<@[A-Z0-9]+>/g, '').trim();
+        this._messageCallback({
+          text,
+          chatId: event.channel,
+          threadId: event.thread_ts || event.ts,
+          userId: event.user,
+        });
+      }
+    });
+
+    // Listen for DMs
+    this.app.event('message', async ({ event }) => {
+      if (event.channel_type !== 'im') return;
+      if (event.subtype) return;
+      if (this._messageCallback) {
+        this._messageCallback({
+          text: event.text || '',
+          chatId: event.channel,
+          threadId: event.thread_ts || event.ts,
+          userId: event.user,
+        });
+      }
+    });
+
+    await this.app.start();
+    console.log('[codexbot] Slack connected (Socket Mode)');
+  }
+
+  onMessage(callback) {
+    this._messageCallback = callback;
+  }
+
+  async sendMessage(chatId, text, opts = {}) {
+    const params = {
+      channel: chatId,
+      text,
+    };
+    if (opts.threadId) {
+      params.thread_ts = opts.threadId;
+    }
+    await this.app.client.chat.postMessage(params);
+  }
+
+  async stop() {
+    await this.app.stop();
+  }
+}

package/src/platforms/telegram.js

@@ -0,0 +1,85 @@
+import { Telegraf } from 'telegraf';
+
+export default class TelegramAdapter {
+  constructor(config) {
+    this.config = config;
+    this.bot = new Telegraf(config.TELEGRAM_BOT_TOKEN);
+    this._messageCallback = null;
+    this.maxMessageLen = 4096;
+
+    // Parse allowed user IDs
+    this.allowedUserIds = [];
+    if (config.TELEGRAM_ALLOWED_USER_IDS) {
+      this.allowedUserIds = config.TELEGRAM_ALLOWED_USER_IDS
+        .split(',')
+        .map(id => id.trim())
+        .filter(Boolean);
+    }
+  }
+
+  async start() {
+    this.bot.on('text', (ctx) => {
+      const userId = String(ctx.from.id);
+
+      // Filter by allowed users if configured
+      if (this.allowedUserIds.length > 0 && !this.allowedUserIds.includes(userId)) {
+        return;
+      }
+
+      if (this._messageCallback) {
+        this._messageCallback({
+          text: ctx.message.text,
+          chatId: ctx.chat.id,
+          replyToMessageId: ctx.message.message_id,
+          userId,
+        });
+      }
+    });
+
+    this.bot.launch();
+
+    // Register bot commands so they appear in Telegram's command menu
+    if (this._commands) {
+      this.bot.telegram.setMyCommands(this._commands).catch(() => { });
+    }
+
+    console.log('[codexbot] Telegram bot started');
+
+    // Graceful stop on signals
+    process.once('SIGINT', () => this.bot.stop('SIGINT'));
+    process.once('SIGTERM', () => this.bot.stop('SIGTERM'));
+  }
+
+  onMessage(callback) {
+    this._messageCallback = callback;
+  }
+
+  setCommands(commands) {
+    this._commands = commands;
+  }
+
+  startTyping(chatId) {
+    this.stopTyping();
+    const send = () => {
+      this.bot.telegram.sendChatAction(chatId, 'typing').catch(() => { });
+    };
+    send();
+    this._typingInterval = setInterval(send, 5000);
+  }
+
+  stopTyping() {
+    if (this._typingInterval) {
+      clearInterval(this._typingInterval);
+      this._typingInterval = null;
+    }
+  }
+
+  async sendMessage(chatId, text) {
+    this.stopTyping();
+    await this.bot.telegram.sendMessage(chatId, text);
+  }
+
+  async stop() {
+    this.bot.stop();
+  }
+}

package/src/service.js

@@ -0,0 +1,101 @@
+import fs from 'fs';
+import path from 'path';
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+import { CONFIG_DIR, loadConfig } from './config.js';
+
+const PID_FILE = path.join(CONFIG_DIR, 'codexbot.pid');
+const LOG_FILE = path.join(CONFIG_DIR, 'codexbot.log');
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const CLI_PATH = path.join(__dirname, '..', 'cli.js');
+
+export function startService(args = []) {
+  const config = loadConfig();
+  if (!config.PLATFORM) {
+    console.error('No platform configured. Run "codexbot onboard" first.');
+    process.exit(1);
+  }
+
+  const existing = getServicePid();
+  if (existing) {
+    console.error(`codexbot is already running (PID ${existing}). Use "codexbot stop" first.`);
+    process.exit(1);
+  }
+
+  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+
+  const logFd = fs.openSync(LOG_FILE, 'a');
+
+  const child = spawn(process.execPath, [CLI_PATH, '_serve', ...args], {
+    detached: true,
+    stdio: ['ignore', logFd, logFd],
+    env: process.env,
+  });
+
+  fs.writeFileSync(PID_FILE, String(child.pid));
+  child.unref();
+  fs.closeSync(logFd);
+
+  console.log(`codexbot started (PID ${child.pid})`);
+  console.log(`Logs: ${LOG_FILE}`);
+}
+
+export function stopService() {
+  const pid = getServicePid();
+  if (!pid) {
+    console.log('codexbot is not running.');
+    return;
+  }
+
+  try {
+    process.kill(pid, 'SIGTERM');
+    console.log(`codexbot stopped (PID ${pid})`);
+  } catch (err) {
+    if (err.code === 'ESRCH') {
+      console.log('codexbot process not found (stale PID file). Cleaning up.');
+    } else {
+      console.error(`Failed to stop codexbot: ${err.message}`);
+    }
+  }
+
+  cleanupPid();
+}
+
+export function showStatus() {
+  const pid = getServicePid();
+  if (!pid) {
+    console.log('codexbot is not running.');
+    return;
+  }
+
+  const alive = isProcessAlive(pid);
+  if (alive) {
+    console.log(`codexbot is running (PID ${pid})`);
+    console.log(`Logs: ${LOG_FILE}`);
+  } else {
+    console.log('codexbot is not running (stale PID file). Cleaning up.');
+    cleanupPid();
+  }
+}
+
+function getServicePid() {
+  try {
+    const pid = parseInt(fs.readFileSync(PID_FILE, 'utf-8').trim(), 10);
+    return isNaN(pid) ? null : pid;
+  } catch {
+    return null;
+  }
+}
+
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function cleanupPid() {
+  try { fs.unlinkSync(PID_FILE); } catch { }
+}