create-ironclaws 1.0.0

package/template/src/channels/slack.ts

@@ -0,0 +1,373 @@
+import { App, LogLevel } from '@slack/bolt';
+import type { GenericMessageEvent, BotMessageEvent } from '@slack/types';
+
+import { ASSISTANT_NAME, TRIGGER_PATTERN } from '../config.js';
+import { updateChatName } from '../db.js';
+import { readEnvFile } from '../env.js';
+import { logger } from '../logger.js';
+import { registerChannel, ChannelOpts } from './registry.js';
+import {
+  Channel,
+  OnInboundMessage,
+  OnChatMetadata,
+  RegisteredGroup,
+} from '../types.js';
+
+// Slack's chat.postMessage API limits text to ~4000 characters per call.
+// Messages exceeding this are split into sequential chunks.
+const MAX_MESSAGE_LENGTH = 4000;
+
+// The message subtypes we process. Bolt delivers all subtypes via app.event('message');
+// we filter to regular messages (GenericMessageEvent, subtype undefined) and bot messages
+// (BotMessageEvent, subtype 'bot_message') so we can track our own output.
+type HandledMessageEvent = GenericMessageEvent | BotMessageEvent;
+
+export interface SlackChannelOpts {
+  onMessage: OnInboundMessage;
+  onChatMetadata: OnChatMetadata;
+  registeredGroups: () => Record<string, RegisteredGroup>;
+}
+
+export class SlackChannel implements Channel {
+  name = 'slack';
+
+  private app: App;
+  private botUserId: string | undefined;
+  private connected = false;
+  private outgoingQueue: Array<{ jid: string; text: string; threadTs?: string }> = [];
+  private flushing = false;
+  private userNameCache = new Map<string, string>();
+  private userEmailCache = new Map<string, string>();
+
+  private opts: SlackChannelOpts;
+  // Tracks the active thread_ts per jid so replies go into the correct thread.
+  // Set when a message arrives: use msg.thread_ts if already threaded, else msg.ts.
+  private activeThreadTs = new Map<string, string>();
+
+  constructor(opts: SlackChannelOpts) {
+    this.opts = opts;
+
+    // Read tokens from .env (not process.env — keeps secrets off the environment
+    // so they don't leak to child processes, matching NanoClaw's security pattern)
+    const env = readEnvFile(['SLACK_BOT_TOKEN', 'SLACK_APP_TOKEN']);
+    const botToken = env.SLACK_BOT_TOKEN;
+    const appToken = env.SLACK_APP_TOKEN;
+
+    if (!botToken || !appToken) {
+      throw new Error(
+        'SLACK_BOT_TOKEN and SLACK_APP_TOKEN must be set in .env',
+      );
+    }
+
+    this.app = new App({
+      token: botToken,
+      appToken,
+      socketMode: true,
+      logLevel: LogLevel.ERROR,
+    });
+
+    this.setupEventHandlers();
+  }
+
+  private setupEventHandlers(): void {
+    // Use app.event('message') instead of app.message() to capture all
+    // message subtypes including bot_message (needed to track our own output)
+    this.app.event('message', async ({ event }) => {
+      // Bolt's event type is the full MessageEvent union (17+ subtypes).
+      // We filter on subtype first, then narrow to the two types we handle.
+      const subtype = (event as { subtype?: string }).subtype;
+      if (subtype && subtype !== 'bot_message') return;
+
+      // After filtering, event is either GenericMessageEvent or BotMessageEvent
+      const msg = event as HandledMessageEvent;
+
+      if (!msg.text) return;
+
+      const jid = `slack:${msg.channel}`;
+      const timestamp = new Date(parseFloat(msg.ts) * 1000).toISOString();
+      const isGroup = msg.channel_type !== 'im';
+
+      // Always report metadata for group discovery
+      this.opts.onChatMetadata(jid, timestamp, undefined, 'slack', isGroup);
+
+      // Only deliver full messages for registered groups
+      const groups = this.opts.registeredGroups();
+      if (!groups[jid]) return;
+
+      const isBotMessage = !!msg.bot_id || msg.user === this.botUserId;
+
+      let senderName: string;
+      let senderEmail: string | undefined;
+      if (isBotMessage) {
+        senderName = ASSISTANT_NAME;
+      } else {
+        senderName =
+          (msg.user ? await this.resolveUserName(msg.user) : undefined) ||
+          msg.user ||
+          'unknown';
+        senderEmail = msg.user ? await this.resolveUserEmail(msg.user) : undefined;
+      }
+
+      // Translate Slack <@UBOTID> mentions into TRIGGER_PATTERN format.
+      // Slack encodes @mentions as <@U12345>, which won't match TRIGGER_PATTERN
+      // (e.g., ^@<ASSISTANT_NAME>\b), so we prepend the trigger when the bot is @mentioned.
+      let content = msg.text;
+      if (this.botUserId && !isBotMessage) {
+        const mentionPattern = `<@${this.botUserId}>`;
+        if (
+          content.includes(mentionPattern) &&
+          !TRIGGER_PATTERN.test(content)
+        ) {
+          content = `@${ASSISTANT_NAME} ${content}`;
+        }
+      }
+
+      // Track thread context: if already in a thread use thread_ts, else start
+      // one from this message so replies stay in-thread.
+      // Groups with noThreading=true always respond in the channel, never in threads.
+      // We skip tracking only for our own bot's replies — external bots (e.g. Alertmanager
+      // webhooks) arrive as bot_messages but must still anchor the thread.
+      const isOurBot = this.botUserId && msg.user === this.botUserId;
+      if (!isOurBot) {
+        const noThreading = groups[jid]?.containerConfig?.noThreading;
+        if (!noThreading) {
+          const threadTs = (msg as { thread_ts?: string }).thread_ts || msg.ts;
+          this.activeThreadTs.set(jid, threadTs);
+        } else {
+          this.activeThreadTs.delete(jid);
+        }
+      }
+
+      this.opts.onMessage(jid, {
+        id: msg.ts,
+        chat_jid: jid,
+        sender: msg.user || msg.bot_id || '',
+        sender_name: senderName,
+        sender_email: senderEmail,
+        content,
+        timestamp,
+        is_from_me: msg.user === this.botUserId,
+        is_bot_message: isBotMessage,
+      });
+    });
+  }
+
+  async connect(): Promise<void> {
+    await this.app.start();
+
+    // Get bot's own user ID for self-message detection.
+    // Resolve this BEFORE setting connected=true so that messages arriving
+    // during startup can correctly detect bot-sent messages.
+    try {
+      const auth = await this.app.client.auth.test();
+      this.botUserId = auth.user_id as string;
+      logger.info({ botUserId: this.botUserId }, 'Connected to Slack');
+    } catch (err) {
+      logger.warn({ err }, 'Connected to Slack but failed to get bot user ID');
+    }
+
+    this.connected = true;
+
+    // Flush any messages queued before connection
+    await this.flushOutgoingQueue();
+
+    // Sync channel names on startup
+    await this.syncChannelMetadata();
+  }
+
+  async sendMessage(jid: string, text: string): Promise<void> {
+    const channelId = jid.replace(/^slack:/, '');
+
+    if (!this.connected) {
+      this.outgoingQueue.push({ jid, text, threadTs: this.activeThreadTs.get(jid) });
+      logger.info(
+        { jid, queueSize: this.outgoingQueue.length },
+        'Slack disconnected, message queued',
+      );
+      return;
+    }
+
+    try {
+      const groups = this.opts.registeredGroups();
+      const noThreading = groups[jid]?.containerConfig?.noThreading;
+      const threadTs = noThreading ? undefined : this.activeThreadTs.get(jid);
+      // Slack limits messages to ~4000 characters; split if needed
+      if (text.length <= MAX_MESSAGE_LENGTH) {
+        await this.app.client.chat.postMessage({ channel: channelId, text, thread_ts: threadTs });
+      } else {
+        for (let i = 0; i < text.length; i += MAX_MESSAGE_LENGTH) {
+          await this.app.client.chat.postMessage({
+            channel: channelId,
+            text: text.slice(i, i + MAX_MESSAGE_LENGTH),
+            thread_ts: threadTs,
+          });
+        }
+      }
+      logger.info({ jid, length: text.length }, 'Slack message sent');
+    } catch (err) {
+      this.outgoingQueue.push({ jid, text });
+      logger.warn(
+        { jid, err, queueSize: this.outgoingQueue.length },
+        'Failed to send Slack message, queued',
+      );
+    }
+  }
+
+  isConnected(): boolean {
+    return this.connected;
+  }
+
+  ownsJid(jid: string): boolean {
+    return jid.startsWith('slack:');
+  }
+
+  async disconnect(): Promise<void> {
+    this.connected = false;
+    await this.app.stop();
+  }
+
+  // Slack does not expose a typing indicator API for bots.
+  // This no-op satisfies the Channel interface so the orchestrator
+  // doesn't need channel-specific branching.
+  async setTyping(_jid: string, _isTyping: boolean): Promise<void> {
+    // no-op: Slack Bot API has no typing indicator endpoint
+  }
+
+  /**
+   * Sync channel metadata from Slack.
+   * Fetches channels the bot is a member of and stores their names in the DB.
+   */
+  async syncChannelMetadata(): Promise<void> {
+    try {
+      logger.info('Syncing channel metadata from Slack...');
+      let cursor: string | undefined;
+      let count = 0;
+
+      do {
+        const result = await this.app.client.conversations.list({
+          types: 'public_channel,private_channel',
+          exclude_archived: true,
+          limit: 200,
+          cursor,
+        });
+
+        for (const ch of result.channels || []) {
+          if (ch.id && ch.name && ch.is_member) {
+            updateChatName(`slack:${ch.id}`, ch.name);
+            count++;
+          }
+        }
+
+        cursor = result.response_metadata?.next_cursor || undefined;
+      } while (cursor);
+
+      logger.info({ count }, 'Slack channel metadata synced');
+    } catch (err) {
+      logger.error({ err }, 'Failed to sync Slack channel metadata');
+    }
+  }
+
+  async getChannelMembers(jid: string): Promise<Array<{ id: string; name: string }>> {
+    const channelId = jid.replace(/^slack:/, '');
+    const members: Array<{ id: string; name: string }> = [];
+    let cursor: string | undefined;
+
+    try {
+      do {
+        const result = await this.app.client.conversations.members({
+          channel: channelId,
+          limit: 200,
+          cursor,
+        });
+
+        for (const userId of result.members || []) {
+          // Skip our own bot user
+          if (userId === this.botUserId) continue;
+          // Skip all bot users — only real people should be mentionable
+          const userInfo = await this.resolveUserInfo(userId);
+          if (!userInfo || userInfo.isBot) continue;
+          if (userInfo.name) {
+            members.push({ id: userId, name: userInfo.name });
+          }
+        }
+
+        cursor = result.response_metadata?.next_cursor || undefined;
+      } while (cursor);
+    } catch (err) {
+      logger.warn({ jid, err }, 'Failed to fetch channel members');
+    }
+
+    return members;
+  }
+
+  private async resolveUserInfo(
+    userId: string,
+  ): Promise<{ name?: string; isBot: boolean } | undefined> {
+    if (!userId) return undefined;
+    try {
+      const result = await this.app.client.users.info({ user: userId });
+      const user = result.user;
+      if (!user) return undefined;
+      const name = user.real_name || user.name;
+      if (name) this.userNameCache.set(userId, name);
+      const email = user.profile?.email;
+      if (email) this.userEmailCache.set(userId, email);
+      return { name, isBot: !!(user.is_bot || user.id === 'USLACKBOT') };
+    } catch (err) {
+      logger.debug({ userId, err }, 'Failed to resolve Slack user info');
+      return undefined;
+    }
+  }
+
+  private async resolveUserName(userId: string): Promise<string | undefined> {
+    if (!userId) return undefined;
+    const cached = this.userNameCache.get(userId);
+    if (cached) return cached;
+    const info = await this.resolveUserInfo(userId);
+    return info?.name;
+  }
+
+  private async resolveUserEmail(userId: string): Promise<string | undefined> {
+    if (!userId) return undefined;
+    const cached = this.userEmailCache.get(userId);
+    if (cached) return cached;
+    const info = await this.resolveUserInfo(userId);
+    // resolveUserInfo populates the email cache, so check it
+    return this.userEmailCache.get(userId);
+  }
+
+  private async flushOutgoingQueue(): Promise<void> {
+    if (this.flushing || this.outgoingQueue.length === 0) return;
+    this.flushing = true;
+    try {
+      logger.info(
+        { count: this.outgoingQueue.length },
+        'Flushing Slack outgoing queue',
+      );
+      while (this.outgoingQueue.length > 0) {
+        const item = this.outgoingQueue.shift()!;
+        const channelId = item.jid.replace(/^slack:/, '');
+        await this.app.client.chat.postMessage({
+          channel: channelId,
+          text: item.text,
+          thread_ts: item.threadTs,
+        });
+        logger.info(
+          { jid: item.jid, length: item.text.length },
+          'Queued Slack message sent',
+        );
+      }
+    } finally {
+      this.flushing = false;
+    }
+  }
+}
+
+registerChannel('slack', (opts: ChannelOpts) => {
+  const envVars = readEnvFile(['SLACK_BOT_TOKEN', 'SLACK_APP_TOKEN']);
+  if (!envVars.SLACK_BOT_TOKEN || !envVars.SLACK_APP_TOKEN) {
+    logger.warn('Slack: SLACK_BOT_TOKEN or SLACK_APP_TOKEN not set');
+    return null;
+  }
+  return new SlackChannel(opts);
+});

package/template/src/claw-skill.test.ts

@@ -0,0 +1,45 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { spawnSync } from 'child_process';
+
+import { describe, expect, it } from 'vitest';
+
+describe('claw skill script', () => {
+  it('exits zero after successful structured output even if the runtime is terminated', () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'claw-skill-test-'));
+    const binDir = path.join(tempDir, 'bin');
+    fs.mkdirSync(binDir, { recursive: true });
+
+    const runtimePath = path.join(binDir, 'container');
+    fs.writeFileSync(
+      runtimePath,
+      `#!/bin/sh
+cat >/dev/null
+printf '%s\n' '---NANOCLAW_OUTPUT_START---' '{"status":"success","result":"4","newSessionId":"sess-1"}' '---NANOCLAW_OUTPUT_END---'
+sleep 30
+`,
+    );
+    fs.chmodSync(runtimePath, 0o755);
+
+    const result = spawnSync(
+      'python3',
+      ['.claude/skills/claw/scripts/claw', '-j', 'tg:123', 'What is 2+2?'],
+      {
+        cwd: process.cwd(),
+        encoding: 'utf8',
+        env: {
+          ...process.env,
+          NANOCLAW_DIR: tempDir,
+          PATH: `${binDir}:${process.env.PATH || ''}`,
+        },
+        timeout: 15000,
+      },
+    );
+
+    expect(result.status).toBe(0);
+    expect(result.signal).toBeNull();
+    expect(result.stdout).toContain('4');
+    expect(result.stderr).toContain('[session: sess-1]');
+  });
+});

package/template/src/config.ts

@@ -0,0 +1,94 @@
+import os from 'os';
+import path from 'path';
+
+import { readEnvFile } from './env.js';
+import { isValidTimezone } from './timezone.js';
+
+// Read config values from .env (falls back to process.env).
+const envConfig = readEnvFile([
+  'ASSISTANT_NAME',
+  'ASSISTANT_HAS_OWN_NUMBER',
+  'ONECLI_URL',
+  'TZ',
+  'CONTAINER_IMAGE',
+]);
+
+export const ASSISTANT_NAME =
+  process.env.ASSISTANT_NAME || envConfig.ASSISTANT_NAME || 'Andy';
+export const ASSISTANT_HAS_OWN_NUMBER =
+  (process.env.ASSISTANT_HAS_OWN_NUMBER ||
+    envConfig.ASSISTANT_HAS_OWN_NUMBER) === 'true';
+export const POLL_INTERVAL = parseInt(process.env.POLL_INTERVAL || '2000', 10);
+export const SCHEDULER_POLL_INTERVAL = parseInt(process.env.SCHEDULER_POLL_INTERVAL || '60000', 10);
+
+// Absolute paths needed for container mounts
+const PROJECT_ROOT = process.cwd();
+const HOME_DIR = process.env.HOME || os.homedir();
+
+// Mount security: allowlist stored OUTSIDE project root, never mounted into containers
+export const MOUNT_ALLOWLIST_PATH = path.join(
+  HOME_DIR,
+  '.config',
+  'nanoclaw',
+  'mount-allowlist.json',
+);
+export const SENDER_ALLOWLIST_PATH = path.join(
+  HOME_DIR,
+  '.config',
+  'nanoclaw',
+  'sender-allowlist.json',
+);
+export const STORE_DIR = path.resolve(PROJECT_ROOT, 'store');
+export const GROUPS_DIR = path.resolve(PROJECT_ROOT, 'groups');
+export const DATA_DIR = path.resolve(PROJECT_ROOT, 'data');
+
+export const CONTAINER_IMAGE =
+  process.env.CONTAINER_IMAGE || envConfig.CONTAINER_IMAGE || 'nanoclaw-agent:latest';
+export const CONTAINER_TIMEOUT = parseInt(
+  process.env.CONTAINER_TIMEOUT || '1800000',
+  10,
+);
+export const CONTAINER_MAX_OUTPUT_SIZE = parseInt(
+  process.env.CONTAINER_MAX_OUTPUT_SIZE || '10485760',
+  10,
+); // 10MB default
+export const ONECLI_URL =
+  process.env.ONECLI_URL || envConfig.ONECLI_URL || 'http://localhost:10254';
+export const IPC_POLL_INTERVAL = parseInt(process.env.IPC_POLL_INTERVAL || '1000', 10);
+export const IDLE_TIMEOUT = parseInt(process.env.IDLE_TIMEOUT || '300000', 10); // 5 min default — how long to keep container alive after last result
+export const MAX_CONCURRENT_CONTAINERS = parseInt(process.env.MAX_CONCURRENT_CONTAINERS || '7', 10);
+export const MAX_RETRIES = parseInt(process.env.MAX_RETRIES || '5', 10);
+export const BASE_RETRY_MS = parseInt(process.env.BASE_RETRY_MS || '5000', 10);
+export const TASK_CLOSE_DELAY_MS = parseInt(process.env.TASK_CLOSE_DELAY_MS || '10000', 10);
+
+function escapeRegex(str: string): string {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+export function buildTriggerPattern(trigger: string): RegExp {
+  return new RegExp(`^${escapeRegex(trigger.trim())}\\b`, 'i');
+}
+
+export const DEFAULT_TRIGGER = `@${ASSISTANT_NAME}`;
+
+export function getTriggerPattern(trigger?: string): RegExp {
+  const normalizedTrigger = trigger?.trim();
+  return buildTriggerPattern(normalizedTrigger || DEFAULT_TRIGGER);
+}
+
+export const TRIGGER_PATTERN = buildTriggerPattern(DEFAULT_TRIGGER);
+
+// Timezone for scheduled tasks, message formatting, etc.
+// Validates each candidate is a real IANA identifier before accepting.
+function resolveConfigTimezone(): string {
+  const candidates = [
+    process.env.TZ,
+    envConfig.TZ,
+    Intl.DateTimeFormat().resolvedOptions().timeZone,
+  ];
+  for (const tz of candidates) {
+    if (tz && isValidTimezone(tz)) return tz;
+  }
+  return 'UTC';
+}
+export const TIMEZONE = resolveConfigTimezone();