aiden-runtime 3.16.0

package/dist/core/channels/imessage.js

@@ -0,0 +1,164 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IMessageAdapter = void 0;
+// core/channels/imessage.ts — iMessage channel adapter via BlueBubbles.
+//
+// BlueBubbles is a Mac app that exposes iMessage via REST + WebSocket.
+// A Mac running the BlueBubbles server is REQUIRED — iMessage is an
+// Apple-exclusive service.
+//
+// Setup (one-time, on a Mac):
+//   1. Install BlueBubbles from https://bluebubbles.app
+//   2. Open BlueBubbles, set a server password, note the URL/port
+//   3. Set BLUEBUBBLES_URL and BLUEBUBBLES_PASSWORD in Aiden's .env
+//
+// Config (env vars):
+//   BLUEBUBBLES_URL              — e.g. http://192.168.1.5:1234
+//   BLUEBUBBLES_PASSWORD         — set in BlueBubbles server settings
+//   BLUEBUBBLES_ALLOWED_NUMBERS  — optional comma-separated allowlist
+const axios_1 = __importDefault(require("axios"));
+const ws_1 = require("ws");
+const gateway_1 = require("../gateway");
+class IMessageAdapter {
+    constructor() {
+        this.name = 'imessage';
+        this.healthy = false;
+        this.ws = null;
+        this.reconnectTimer = null;
+        this.baseUrl = (process.env.BLUEBUBBLES_URL ?? '').replace(/\/$/, '');
+        this.password = process.env.BLUEBUBBLES_PASSWORD ?? '';
+        const raw = process.env.BLUEBUBBLES_ALLOWED_NUMBERS ?? '';
+        this.allowedNumbers = raw ? new Set(raw.split(',').map(s => s.trim()).filter(Boolean)) : new Set();
+    }
+    // ── Lifecycle ──────────────────────────────────────────────
+    async start() {
+        if (!this.baseUrl || !this.password) {
+            console.log('[iMessage] Disabled — set BLUEBUBBLES_URL and BLUEBUBBLES_PASSWORD to enable');
+            return;
+        }
+        // Verify BlueBubbles is reachable
+        const reachable = await this.checkHealth();
+        if (!reachable) {
+            console.log(`[iMessage] Disabled — BlueBubbles server not reachable at ${this.baseUrl}`);
+            return;
+        }
+        this.healthy = true;
+        console.log(`[iMessage] Connected to BlueBubbles at ${this.baseUrl}`);
+        // Register outbound delivery
+        gateway_1.gateway.registerChannel('imessage', async (msg) => {
+            await this.send(msg.channelId, msg.text);
+            return true;
+        });
+        // Connect WebSocket for real-time inbound messages
+        this.connectWebSocket();
+    }
+    async stop() {
+        this.healthy = false;
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+        gateway_1.gateway.unregisterChannel('imessage');
+        console.log('[iMessage] Disconnected');
+    }
+    async send(target, message) {
+        if (!this.healthy)
+            return;
+        try {
+            await axios_1.default.post(`${this.baseUrl}/api/v1/message/text`, { chatGuid: target, message, tempGuid: `aiden-${Date.now()}` }, {
+                params: { password: this.password },
+                timeout: 10000,
+            });
+        }
+        catch (e) {
+            console.error('[iMessage] send error:', e.message);
+        }
+    }
+    isHealthy() { return this.healthy; }
+    // ── Helpers ────────────────────────────────────────────────
+    async checkHealth() {
+        try {
+            await axios_1.default.get(`${this.baseUrl}/api/v1/ping`, {
+                params: { password: this.password },
+                timeout: 3000,
+            });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    connectWebSocket() {
+        if (!this.healthy)
+            return;
+        const wsUrl = this.baseUrl.replace(/^http/, 'ws');
+        this.ws = new ws_1.WebSocket(`${wsUrl}?password=${encodeURIComponent(this.password)}`);
+        this.ws.on('open', () => {
+            console.log('[iMessage] WebSocket connected');
+        });
+        this.ws.on('message', async (raw) => {
+            try {
+                const event = JSON.parse(raw.toString());
+                if (event.type !== 'new-message')
+                    return;
+                const msg = event.data;
+                // Only handle inbound (not self-sent) chat messages
+                if (!msg || msg.isFromMe)
+                    return;
+                if (msg.attributedBody === null && !msg.text)
+                    return;
+                const text = msg.text ?? '';
+                const chatId = msg.chats?.[0]?.guid ?? '';
+                const sender = msg.handle?.address ?? '';
+                if (!this.isAllowed(sender))
+                    return;
+                const response = await this.processMessage(chatId || sender, sender, text);
+                await this.send(chatId || sender, response);
+            }
+            catch (e) {
+                console.error('[iMessage] message parse error:', e.message);
+            }
+        });
+        this.ws.on('error', (e) => {
+            console.error('[iMessage] WebSocket error:', e.message);
+        });
+        this.ws.on('close', () => {
+            if (this.healthy) {
+                // Reconnect after 5 seconds
+                this.reconnectTimer = setTimeout(() => this.connectWebSocket(), 5000);
+            }
+        });
+    }
+    isAllowed(number) {
+        if (this.allowedNumbers.size === 0)
+            return true;
+        return this.allowedNumbers.has(number);
+    }
+    async processMessage(channelId, userId, text) {
+        try {
+            return await gateway_1.gateway.routeMessage({
+                channel: 'imessage',
+                channelId,
+                userId,
+                text,
+                timestamp: Date.now(),
+            });
+        }
+        catch (e) {
+            console.error('[iMessage] routeMessage error:', e.message);
+            return '❌ Something went wrong. Try again.';
+        }
+    }
+}
+exports.IMessageAdapter = IMessageAdapter;

package/dist/core/channels/manager.js

@@ -0,0 +1,96 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.channelManager = exports.ChannelManager = void 0;
+// ── ChannelManager ─────────────────────────────────────────
+class ChannelManager {
+    constructor() {
+        this.adapters = new Map();
+        this.lastActivity = new Map();
+    }
+    /** Register an adapter — must be called before startAll() */
+    register(adapter) {
+        this.adapters.set(adapter.name, adapter);
+    }
+    /**
+     * Start all registered adapters.
+     * Each adapter self-checks its credentials and reports 'started' or 'disabled'.
+     * Adapters that throw are marked 'failed' — startup continues for others.
+     */
+    async startAll() {
+        const results = [];
+        for (const [name, adapter] of this.adapters) {
+            try {
+                await adapter.start();
+                const status = adapter.isHealthy() ? 'started' : 'disabled';
+                results.push({ name, status });
+            }
+            catch (error) {
+                console.error(`[ChannelManager] ${name} failed to start:`, error.message);
+                results.push({ name, status: 'failed', error: String(error.message) });
+            }
+        }
+        // Summary line
+        const summary = results
+            .map(r => {
+            if (r.status === 'started')
+                return `${r.name} ✓`;
+            if (r.status === 'disabled')
+                return `${r.name} (disabled)`;
+            return `${r.name} ✗ ${r.error ?? ''}`;
+        })
+            .join(' | ');
+        if (results.length > 0)
+            console.log(`[Channels] ${summary}`);
+        return results;
+    }
+    /** Gracefully stop all adapters — called on SIGTERM / shutdown */
+    async stopAll() {
+        for (const [, adapter] of this.adapters) {
+            try {
+                await adapter.stop();
+            }
+            catch (e) {
+                console.error(`[ChannelManager] Error stopping ${adapter.name}:`, e.message);
+            }
+        }
+    }
+    /** Current health status for all registered adapters */
+    getStatus() {
+        return Array.from(this.adapters.values()).map(adapter => ({
+            name: adapter.name,
+            healthy: adapter.isHealthy(),
+            lastActivity: this.lastActivity.get(adapter.name),
+            lastMessageTimestamp: this.lastActivity.get(adapter.name),
+            configValid: adapter.isHealthy(),
+        }));
+    }
+    /** Record an activity timestamp for a channel (called by gateway hooks, etc.) */
+    recordActivity(name) {
+        this.lastActivity.set(name, Date.now());
+    }
+    /** Restart a specific adapter by name */
+    async restart(name) {
+        const adapter = this.adapters.get(name);
+        if (!adapter)
+            return { name, status: 'failed', error: `Unknown channel: ${name}` };
+        try {
+            await adapter.stop();
+            await adapter.start();
+            return { name, status: adapter.isHealthy() ? 'started' : 'disabled' };
+        }
+        catch (error) {
+            return { name, status: 'failed', error: String(error.message) };
+        }
+    }
+    /** Get a single adapter by name */
+    get(name) {
+        return this.adapters.get(name);
+    }
+}
+exports.ChannelManager = ChannelManager;
+/** Singleton instance — import this in server.ts and cli handlers */
+exports.channelManager = new ChannelManager();

package/dist/core/channels/signal.js

@@ -0,0 +1,140 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignalAdapter = void 0;
+// core/channels/signal.ts — Signal channel adapter.
+//
+// Uses signal-cli-rest-api — a standalone REST wrapper around the
+// official signal-cli Java tool. Users run it separately:
+//   https://github.com/bbernhard/signal-cli-rest-api
+//
+// Setup (one-time, outside Aiden):
+//   docker run -p 8080:8080 -v ~/.local/share/signal-cli:/home/.local/share/signal-cli \
+//     bbernhard/signal-cli-rest-api
+//   # then register your number at http://localhost:8080/v1/register/<number>
+//
+// Config (env vars):
+//   SIGNAL_CLI_URL          — REST API base URL (default: http://localhost:8080)
+//   SIGNAL_PHONE_NUMBER     — your registered Signal number (+15551234567)
+//   SIGNAL_ALLOWED_NUMBERS  — optional comma-separated allowlist
+const axios_1 = __importDefault(require("axios"));
+const gateway_1 = require("../gateway");
+class SignalAdapter {
+    constructor() {
+        this.name = 'signal';
+        this.healthy = false;
+        this.pollTimer = null;
+        this.lastReceived = 0;
+        this.baseUrl = (process.env.SIGNAL_CLI_URL ?? 'http://localhost:8080').replace(/\/$/, '');
+        this.myNumber = process.env.SIGNAL_PHONE_NUMBER ?? '';
+        const raw = process.env.SIGNAL_ALLOWED_NUMBERS ?? '';
+        this.allowedNumbers = raw ? new Set(raw.split(',').map(s => s.trim()).filter(Boolean)) : new Set();
+    }
+    // ── Lifecycle ──────────────────────────────────────────────
+    async start() {
+        if (!this.myNumber) {
+            console.log('[Signal] Disabled — set SIGNAL_PHONE_NUMBER to enable');
+            return;
+        }
+        // Verify signal-cli is reachable
+        const reachable = await this.checkHealth();
+        if (!reachable) {
+            console.log(`[Signal] Disabled — signal-cli-rest-api not reachable at ${this.baseUrl}`);
+            return;
+        }
+        this.healthy = true;
+        this.lastReceived = Date.now();
+        console.log(`[Signal] Connected — polling ${this.baseUrl}`);
+        // Register outbound delivery
+        gateway_1.gateway.registerChannel('signal', async (msg) => {
+            await this.send(msg.channelId, msg.text);
+            return true;
+        });
+        // Poll for new messages every 2 seconds
+        this.pollTimer = setInterval(() => this.poll(), 2000);
+    }
+    async stop() {
+        this.healthy = false;
+        if (this.pollTimer) {
+            clearInterval(this.pollTimer);
+            this.pollTimer = null;
+        }
+        gateway_1.gateway.unregisterChannel('signal');
+        console.log('[Signal] Disconnected');
+    }
+    async send(target, message) {
+        if (!this.healthy)
+            return;
+        try {
+            await axios_1.default.post(`${this.baseUrl}/v2/send`, { message, number: this.myNumber, recipients: [target] }, { timeout: 10000 });
+        }
+        catch (e) {
+            console.error('[Signal] send error:', e.message);
+        }
+    }
+    isHealthy() { return this.healthy; }
+    // ── Helpers ────────────────────────────────────────────────
+    async checkHealth() {
+        try {
+            await axios_1.default.get(`${this.baseUrl}/v1/health`, { timeout: 3000 });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async poll() {
+        if (!this.healthy)
+            return;
+        try {
+            const res = await axios_1.default.get(`${this.baseUrl}/v1/receive/${encodeURIComponent(this.myNumber)}`, { timeout: 5000 });
+            const messages = Array.isArray(res.data) ? res.data : [];
+            for (const item of messages) {
+                const envelope = item.envelope;
+                if (!envelope)
+                    continue;
+                const dm = envelope.dataMessage;
+                if (!dm?.message)
+                    continue;
+                const sender = envelope.source ?? envelope.sourceNumber ?? '';
+                if (!this.isAllowed(sender))
+                    continue;
+                const response = await this.processMessage(sender, sender, dm.message);
+                await this.send(sender, response);
+            }
+        }
+        catch (e) {
+            // Don't spam logs on transient poll errors
+            if (this.healthy) {
+                console.error('[Signal] poll error:', e.message);
+            }
+        }
+    }
+    isAllowed(number) {
+        if (this.allowedNumbers.size === 0)
+            return true;
+        return this.allowedNumbers.has(number);
+    }
+    async processMessage(channelId, userId, text) {
+        try {
+            return await gateway_1.gateway.routeMessage({
+                channel: 'signal',
+                channelId,
+                userId,
+                text,
+                timestamp: Date.now(),
+            });
+        }
+        catch (e) {
+            console.error('[Signal] routeMessage error:', e.message);
+            return '❌ Something went wrong. Try again.';
+        }
+    }
+}
+exports.SignalAdapter = SignalAdapter;

package/dist/core/channels/slack.js

@@ -0,0 +1,139 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlackAdapter = void 0;
+// core/channels/slack.ts — Slack channel adapter.
+//
+// Config (env vars):
+//   SLACK_BOT_TOKEN         — required (xoxb-…); adapter stays disabled if absent
+//   SLACK_SIGNING_SECRET    — required; used for request signature verification
+//   SLACK_APP_TOKEN         — optional (xapp-…); enables Socket Mode (preferred for local dev)
+//   SLACK_ALLOWED_CHANNELS  — optional comma-separated channel IDs
+//
+// Modes:
+//   Socket mode  — if SLACK_APP_TOKEN set; no public URL required (ideal for local dev)
+//   HTTP mode    — if no SLACK_APP_TOKEN; listens on port 3001
+//
+// Features:
+//   - Responds to direct messages and app_mention events
+//   - /aiden slash command
+//   - Thread replies (replies in same thread as trigger)
+//   - Allowlist enforcement
+//   - Ignores bot messages
+//   - Signature verification via SLACK_SIGNING_SECRET
+//   - Graceful degradation: missing creds → disabled, no crash
+const bolt_1 = require("@slack/bolt");
+const gateway_1 = require("../gateway");
+class SlackAdapter {
+    constructor() {
+        this.name = 'slack';
+        this.app = null;
+        this.healthy = false;
+        this.botToken = process.env.SLACK_BOT_TOKEN ?? '';
+        this.signingSecret = process.env.SLACK_SIGNING_SECRET ?? '';
+        this.appToken = process.env.SLACK_APP_TOKEN ?? '';
+        const rawChannels = process.env.SLACK_ALLOWED_CHANNELS ?? '';
+        this.allowedChannels = rawChannels
+            ? new Set(rawChannels.split(',').map(s => s.trim()).filter(Boolean))
+            : new Set();
+    }
+    // ── Lifecycle ──────────────────────────────────────────────
+    async start() {
+        if (!this.botToken || !this.signingSecret) {
+            console.log('[Slack] Disabled — set SLACK_BOT_TOKEN and SLACK_SIGNING_SECRET to enable');
+            return;
+        }
+        const useSocketMode = !!this.appToken;
+        this.app = new bolt_1.App({
+            token: this.botToken,
+            signingSecret: this.signingSecret,
+            ...(useSocketMode
+                ? { socketMode: true, appToken: this.appToken }
+                : {}),
+            logLevel: bolt_1.LogLevel.WARN,
+        });
+        // ── Direct messages ─────────────────────────────────────
+        this.app.message(async ({ message, say }) => {
+            const msg = message;
+            if (msg.bot_id || msg.subtype)
+                return; // ignore bots & system messages
+            if (this.allowedChannels.size > 0 && !this.allowedChannels.has(msg.channel))
+                return;
+            const response = await this.processMessage(msg.channel, msg.user ?? 'unknown', msg.text ?? '');
+            await say({ text: response, thread_ts: msg.ts }).catch((e) => console.error('[Slack] say error:', e.message));
+        });
+        // ── App mentions (@Aiden) ────────────────────────────────
+        this.app.event('app_mention', async ({ event, say }) => {
+            if (this.allowedChannels.size > 0 && !this.allowedChannels.has(event.channel))
+                return;
+            // Strip the @mention prefix from the message
+            const text = (event.text ?? '').replace(/<@[^>]+>/g, '').trim();
+            const response = await this.processMessage(event.channel, event.user, text);
+            await say({ text: response, thread_ts: event.ts }).catch((e) => console.error('[Slack] mention reply error:', e.message));
+        });
+        // ── Slash command /aiden ─────────────────────────────────
+        this.app.command('/aiden', async ({ command, ack, say }) => {
+            await ack();
+            if (this.allowedChannels.size > 0 && !this.allowedChannels.has(command.channel_id)) {
+                await say('⚠️ This channel is not authorized for Aiden.');
+                return;
+            }
+            const response = await this.processMessage(command.channel_id, command.user_id, command.text);
+            await say(response).catch((e) => console.error('[Slack] slash reply error:', e.message));
+        });
+        // Register outbound delivery so gateway.deliver() and broadcast() work
+        gateway_1.gateway.registerChannel('slack', async (msg) => {
+            try {
+                await this.app.client.chat.postMessage({ channel: msg.channelId, text: msg.text });
+                return true;
+            }
+            catch (e) {
+                console.error('[Slack] Delivery error:', e.message);
+                return false;
+            }
+        });
+        const port = useSocketMode ? undefined : 3001;
+        try {
+            await this.app.start(port);
+            this.healthy = true;
+            console.log(`[Slack] Connected (${useSocketMode ? 'socket mode' : `HTTP mode port ${port}`})`);
+        }
+        catch (e) {
+            console.error('[Slack] Start failed:', e.message);
+            this.healthy = false;
+        }
+    }
+    async stop() {
+        this.healthy = false;
+        if (this.app) {
+            gateway_1.gateway.unregisterChannel('slack');
+            await this.app.stop().catch(() => { });
+            this.app = null;
+        }
+        console.log('[Slack] Disconnected');
+    }
+    async send(channelId, message) {
+        await this.app?.client.chat.postMessage({ channel: channelId, text: message }).catch((e) => console.error('[Slack] send error:', e.message));
+    }
+    isHealthy() { return this.healthy; }
+    // ── Helpers ────────────────────────────────────────────────
+    async processMessage(channelId, userId, text) {
+        try {
+            return await gateway_1.gateway.routeMessage({
+                channel: 'slack',
+                channelId,
+                userId,
+                text,
+                timestamp: Date.now(),
+            });
+        }
+        catch (e) {
+            console.error('[Slack] routeMessage error:', e.message);
+            return '❌ Something went wrong. Try again.';
+        }
+    }
+}
+exports.SlackAdapter = SlackAdapter;

package/dist/core/channels/twilio.js

@@ -0,0 +1,144 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TwilioAdapter = void 0;
+// core/channels/twilio.ts — SMS channel adapter via Twilio.
+//
+// Inbound SMS requires a publicly reachable webhook URL pointing to
+//   POST /api/channels/sms/inbound
+// Use ngrok or similar for local dev: ngrok http 4200
+// Then set WEBHOOK_URL=https://<your-ngrok-id>.ngrok.io
+//
+// Config (env vars):
+//   TWILIO_ACCOUNT_SID    — required
+//   TWILIO_AUTH_TOKEN     — required
+//   TWILIO_PHONE_NUMBER   — your Twilio-owned number (+15551234567)
+//   TWILIO_ALLOWED_NUMBERS — optional comma-separated inbound allowlist
+//   WEBHOOK_URL           — base URL for inbound webhook registration
+const gateway_1 = require("../gateway");
+// SMS max segment length per GSM spec
+const SMS_CHUNK_SIZE = 160;
+/** Split a message into ≤160-character segments */
+function chunkSms(text) {
+    const chunks = [];
+    let remaining = text;
+    while (remaining.length > 0) {
+        chunks.push(remaining.substring(0, SMS_CHUNK_SIZE));
+        remaining = remaining.substring(SMS_CHUNK_SIZE);
+    }
+    return chunks;
+}
+class TwilioAdapter {
+    constructor(app) {
+        this.name = 'sms';
+        this.twilioClient = null;
+        this.healthy = false;
+        this.app = null;
+        this.accountSid = process.env.TWILIO_ACCOUNT_SID ?? '';
+        this.authToken = process.env.TWILIO_AUTH_TOKEN ?? '';
+        this.fromNumber = process.env.TWILIO_PHONE_NUMBER ?? '';
+        const raw = process.env.TWILIO_ALLOWED_NUMBERS ?? '';
+        this.allowedNumbers = raw ? new Set(raw.split(',').map(s => s.trim()).filter(Boolean)) : new Set();
+        this.webhookUrl = process.env.WEBHOOK_URL ?? '';
+        this.app = app ?? null;
+    }
+    // ── Lifecycle ──────────────────────────────────────────────
+    async start() {
+        if (!this.accountSid || !this.authToken || !this.fromNumber) {
+            console.log('[SMS] Disabled — set TWILIO_ACCOUNT_SID, TWILIO_AUTH_TOKEN, TWILIO_PHONE_NUMBER to enable');
+            return;
+        }
+        let twilio;
+        try {
+            twilio = require('twilio');
+        }
+        catch (e) {
+            console.log('[SMS] Disabled — twilio package not available:', e.message);
+            return;
+        }
+        this.twilioClient = twilio(this.accountSid, this.authToken);
+        // Register outbound delivery
+        gateway_1.gateway.registerChannel('sms', async (msg) => {
+            await this.send(msg.channelId, msg.text);
+            return true;
+        });
+        // Register inbound webhook handler on the express app
+        if (this.app) {
+            this.app.post('/api/channels/sms/inbound', async (req, res) => {
+                res.set('Content-Type', 'text/xml');
+                const from = req.body?.From ?? '';
+                const body = req.body?.Body ?? '';
+                if (!this.isAllowed(from)) {
+                    res.send('<?xml version="1.0" encoding="UTF-8"?><Response></Response>');
+                    return;
+                }
+                const response = await this.processMessage(from, from, body);
+                // Reply via TwiML (Twilio Markup Language) — Twilio sends this as SMS
+                const twiml = [
+                    '<?xml version="1.0" encoding="UTF-8"?>',
+                    '<Response>',
+                    ...chunkSms(response).map(chunk => `  <Message>${chunk.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')}</Message>`),
+                    '</Response>',
+                ].join('\n');
+                res.send(twiml);
+            });
+        }
+        if (!this.webhookUrl) {
+            console.log('[SMS] Outbound ready — inbound SMS requires public webhook URL (set WEBHOOK_URL env or use ngrok)');
+        }
+        else {
+            console.log(`[SMS] Ready — inbound webhook: ${this.webhookUrl}/api/channels/sms/inbound`);
+        }
+        this.healthy = true;
+    }
+    async stop() {
+        this.healthy = false;
+        gateway_1.gateway.unregisterChannel('sms');
+        this.twilioClient = null;
+        console.log('[SMS] Disconnected');
+    }
+    async send(target, message) {
+        if (!this.twilioClient || !this.healthy)
+            return;
+        const chunks = chunkSms(message);
+        for (const chunk of chunks) {
+            try {
+                await this.twilioClient.messages.create({
+                    body: chunk,
+                    from: this.fromNumber,
+                    to: target,
+                });
+            }
+            catch (e) {
+                console.error('[SMS] send error:', e.message);
+                break;
+            }
+        }
+    }
+    isHealthy() { return this.healthy; }
+    // ── Helpers ────────────────────────────────────────────────
+    isAllowed(number) {
+        if (this.allowedNumbers.size === 0)
+            return true;
+        return this.allowedNumbers.has(number);
+    }
+    async processMessage(channelId, userId, text) {
+        try {
+            return await gateway_1.gateway.routeMessage({
+                channel: 'sms',
+                channelId,
+                userId,
+                text,
+                timestamp: Date.now(),
+            });
+        }
+        catch (e) {
+            console.error('[SMS] routeMessage error:', e.message);
+            return 'Something went wrong. Try again.';
+        }
+    }
+}
+exports.TwilioAdapter = TwilioAdapter;