aiden-runtime 4.0.2 → 4.1.1

package/dist/core/channels/photo-vision.js

@@ -0,0 +1,157 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_PHOTO_BYTES = void 0;
+exports.analyzePhotoForChannel = analyzePhotoForChannel;
+// core/channels/photo-vision.ts — Phase v4.1-4.
+//
+// Channel-side adapter for inbound photos. Wraps the existing
+// `core/visionAnalyze.ts` chain with Telegram-specific concerns:
+//
+//   1. 25 MB pre-download size cap. Mirrors the voice path's policy
+//      (Telegram Bot API getFile limit is the binding constraint).
+//      Refusing here saves the round-trip when we already know the
+//      payload is too big for the providers.
+//   2. Mode decision — `native` vs `text` — based on whether the
+//      currently active model carries a `supportsVision: true` flag in
+//      `providers/v4/modelCatalog.ts`. When vision is supported, the
+//      channel adapter attaches the file path on the user turn so the
+//      provider sees pixels directly. Otherwise we pre-analyze with
+//      the auxiliary `analyzeImage` chain (Anthropic / OpenAI / Ollama
+//      llava) and prepend a description annotation — same "smuggle
+//      into agent turn" pattern as voice transcripts.
+//   3. Result-shape contract that matches the channel adapter's
+//      expectations so the Telegram adapter's `handlePhotoMessage`
+//      can branch on `mode` and assemble the right outbound payload.
+//
+// Logger comes from the v4.1-1.3a contract; defaults to a noop sink
+// so anything that calls into this module without a wired logger
+// stays REPL-clean.
+const node_fs_1 = require("node:fs");
+const modelCatalog_1 = require("../../providers/v4/modelCatalog");
+const visionAnalyze_1 = require("../visionAnalyze");
+const logger_1 = require("../v4/logger");
+// 25 MiB. Matches the voice cap and the OpenAI / Anthropic vision
+// request-size envelopes; Telegram's getFile cap is 20 MB so a 25 MB
+// payload would already have been rejected upstream — but keeping
+// these caps consistent simplifies the operator mental model.
+exports.MAX_PHOTO_BYTES = 25 * 1024 * 1024;
+/**
+ * Default text-mode prompt. Single source so smokes and the adapter
+ * agree on what gets sent to the auxiliary vision chain. Phrased
+ * for the agent's perspective — the description ends up bracketed
+ * inside an "[The user sent an image. Description: ...]" annotation.
+ */
+const DEFAULT_DESCRIBE_PROMPT = 'Describe everything visible in this image in detail. Include any ' +
+    'text, code, layout, objects, people, colors, and any other notable ' +
+    'visual information.';
+/**
+ * Decide how an inbound photo should be presented to the model and
+ * (in text mode) generate the description the channel adapter will
+ * smuggle into the agent's user turn.
+ *
+ * Never throws — failures land on `success: false` with a
+ * human-readable `error`. Callers downstream decide whether to:
+ *   - hand a `[The user sent an image but description failed: ...]`
+ *     directive to the agent, or
+ *   - render a friendly user-facing reject reply.
+ */
+async function analyzePhotoForChannel(opts) {
+    const log = opts.logger ?? (0, logger_1.noopLogger)();
+    const cap = opts.maxBytesOverride ?? exports.MAX_PHOTO_BYTES;
+    // ── 1. Size precheck ────────────────────────────────────────────
+    let sizeBytes;
+    try {
+        const st = await node_fs_1.promises.stat(opts.filePath);
+        sizeBytes = st.size;
+    }
+    catch (e) {
+        log.warn('photo file not readable', { path: opts.filePath, error: e?.message });
+        return { success: false, mode: 'text', error: `photo file not readable: ${e?.message ?? 'unknown error'}` };
+    }
+    if (sizeBytes > cap) {
+        log.warn('photo file too large', { sizeBytes, cap });
+        return {
+            success: false,
+            mode: 'text',
+            error: `Photo too large: ${(sizeBytes / (1024 * 1024)).toFixed(1)} MB ` +
+                `(cap is ${(cap / (1024 * 1024)).toFixed(0)} MB).`,
+        };
+    }
+    // ── 2. Mode decision ────────────────────────────────────────────
+    const mode = decideMode(opts.providerId, opts.modelId, log);
+    if (mode === 'native') {
+        log.info('photo routed native', {
+            providerId: opts.providerId,
+            modelId: opts.modelId,
+            sizeBytes,
+        });
+        return { success: true, mode: 'native', nativePath: opts.filePath };
+    }
+    // ── 3. Text mode: pre-analyze via the auxiliary vision chain ────
+    const analyze = opts.analyzeFn ?? visionAnalyze_1.analyzeImage;
+    try {
+        const visionResult = await analyze(opts.filePath, opts.prompt ?? DEFAULT_DESCRIBE_PROMPT, log);
+        const description = (visionResult.description ?? '').trim();
+        if (!description) {
+            log.warn('vision chain returned empty description', { provider: visionResult.provider });
+            return {
+                success: false,
+                mode: 'text',
+                error: 'vision chain returned an empty description',
+                provider: visionResult.provider,
+                modelUsed: visionResult.modelUsed,
+                durationMs: visionResult.durationMs,
+            };
+        }
+        return {
+            success: true,
+            mode: 'text',
+            description,
+            provider: visionResult.provider,
+            modelUsed: visionResult.modelUsed,
+            durationMs: visionResult.durationMs,
+        };
+    }
+    catch (e) {
+        log.error('vision chain threw', { error: e?.message ?? String(e) });
+        return {
+            success: false,
+            mode: 'text',
+            error: `vision chain failed: ${e?.message ?? 'unknown error'}`,
+        };
+    }
+}
+/**
+ * Resolve native-vs-text routing for the active model. Returns
+ * `'text'` whenever:
+ *   - either id is missing (caller didn't tell us)
+ *   - the model isn't in `MODEL_CATALOG` (registry drift)
+ *   - the model's `supportsVision` is false
+ *   - the lookup throws for any reason
+ *
+ * `'text'` is the safe fallback — it always works because the
+ * auxiliary `analyzeImage` chain runs against its own provider keys
+ * independent of whatever the user has selected for the agent loop.
+ */
+function decideMode(providerId, modelId, log) {
+    if (!providerId || !modelId) {
+        log.debug('photo mode: missing provider/model id, defaulting to text');
+        return 'text';
+    }
+    try {
+        const entry = (0, modelCatalog_1.findModel)(providerId, modelId);
+        if (!entry) {
+            log.debug('photo mode: model not in catalog, defaulting to text', { providerId, modelId });
+            return 'text';
+        }
+        return entry.supportsVision ? 'native' : 'text';
+    }
+    catch (e) {
+        log.debug('photo mode: lookup threw, defaulting to text', { error: e?.message });
+        return 'text';
+    }
+}

package/dist/core/channels/signal.js

@@ -25,9 +25,12 @@ exports.SignalAdapter = void 0;
 //   SIGNAL_ALLOWED_NUMBERS  — optional comma-separated allowlist
 const axios_1 = __importDefault(require("axios"));
 const gateway_1 = require("../gateway");
+const logger_1 = require("../v4/logger");
 class SignalAdapter {
     constructor() {
         this.name = 'signal';
+        // Phase v4.1-1.3a — diagnostics route through scope logger.
+        this.log = (0, logger_1.noopLogger)();
         this.healthy = false;
         this.pollTimer = null;
         this.lastReceived = 0;
@@ -36,21 +39,22 @@ class SignalAdapter {
         const raw = process.env.SIGNAL_ALLOWED_NUMBERS ?? '';
         this.allowedNumbers = raw ? new Set(raw.split(',').map(s => s.trim()).filter(Boolean)) : new Set();
     }
+    attachLogger(logger) { this.log = logger; }
     // ── Lifecycle ──────────────────────────────────────────────
     async start() {
         if (!this.myNumber) {
-            console.log('[Signal] Disabled — set SIGNAL_PHONE_NUMBER to enable');
+            this.log.info('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}`);
+            this.log.info('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}`);
+        this.log.info('Connected — polling ${this.baseUrl}');
         // Register outbound delivery
         gateway_1.gateway.registerChannel('signal', async (msg) => {
             await this.send(msg.channelId, msg.text);
@@ -66,7 +70,7 @@ class SignalAdapter {
             this.pollTimer = null;
         }
         gateway_1.gateway.unregisterChannel('signal');
-        console.log('[Signal] Disconnected');
+        this.log.info('Disconnected');
     }
     async send(target, message) {
         if (!this.healthy)
@@ -75,7 +79,7 @@ class SignalAdapter {
             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);
+            this.log.error(`send error:${e.message}`);
         }
     }
     isHealthy() { return this.healthy; }
@@ -112,7 +116,7 @@ class SignalAdapter {
         catch (e) {
             // Don't spam logs on transient poll errors
             if (this.healthy) {
-                console.error('[Signal] poll error:', e.message);
+                this.log.error(`poll error:${e.message}`);
             }
         }
     }
@@ -132,7 +136,7 @@ class SignalAdapter {
             });
         }
         catch (e) {
-            console.error('[Signal] routeMessage error:', e.message);
+            this.log.error(`routeMessage error:${e.message}`);
             return '❌ Something went wrong. Try again.';
         }
     }

package/dist/core/channels/slack.js

@@ -27,11 +27,13 @@ exports.SlackAdapter = void 0;
 //   - Graceful degradation: missing creds → disabled, no crash
 const bolt_1 = require("@slack/bolt");
 const gateway_1 = require("../gateway");
+const logger_1 = require("../v4/logger");
 class SlackAdapter {
     constructor() {
         this.name = 'slack';
         this.app = null;
         this.healthy = false;
+        this.log = (0, logger_1.noopLogger)(); // Phase v4.1-1.3a — wired by ChannelManager.register
         this.botToken = process.env.SLACK_BOT_TOKEN ?? '';
         this.signingSecret = process.env.SLACK_SIGNING_SECRET ?? '';
         this.appToken = process.env.SLACK_APP_TOKEN ?? '';
@@ -40,10 +42,11 @@ class SlackAdapter {
             ? new Set(rawChannels.split(',').map(s => s.trim()).filter(Boolean))
             : new Set();
     }
+    attachLogger(logger) { this.log = logger; }
     // ── Lifecycle ──────────────────────────────────────────────
     async start() {
         if (!this.botToken || !this.signingSecret) {
-            console.log('[Slack] Disabled — set SLACK_BOT_TOKEN and SLACK_SIGNING_SECRET to enable');
+            this.log.info('Disabled — set SLACK_BOT_TOKEN and SLACK_SIGNING_SECRET to enable');
             return;
         }
         const useSocketMode = !!this.appToken;
@@ -63,7 +66,7 @@ class SlackAdapter {
             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));
+            await say({ text: response, thread_ts: msg.ts }).catch((e) => this.log.error(`say error: ${e.message}`));
         });
         // ── App mentions (@Aiden) ────────────────────────────────
         this.app.event('app_mention', async ({ event, say }) => {
@@ -72,7 +75,7 @@ class SlackAdapter {
             // 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));
+            await say({ text: response, thread_ts: event.ts }).catch((e) => this.log.error(`mention reply error: ${e.message}`));
         });
         // ── Slash command /aiden ─────────────────────────────────
         this.app.command('/aiden', async ({ command, ack, say }) => {
@@ -82,7 +85,7 @@ class SlackAdapter {
                 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));
+            await say(response).catch((e) => this.log.error(`slash reply error: ${e.message}`));
         });
         // Register outbound delivery so gateway.deliver() and broadcast() work
         gateway_1.gateway.registerChannel('slack', async (msg) => {
@@ -91,7 +94,7 @@ class SlackAdapter {
                 return true;
             }
             catch (e) {
-                console.error('[Slack] Delivery error:', e.message);
+                this.log.error(`Delivery error: ${e.message}`);
                 return false;
             }
         });
@@ -99,10 +102,10 @@ class SlackAdapter {
         try {
             await this.app.start(port);
             this.healthy = true;
-            console.log(`[Slack] Connected (${useSocketMode ? 'socket mode' : `HTTP mode port ${port}`})`);
+            this.log.info(`Connected (${useSocketMode ? 'socket mode' : `HTTP mode port ${port}`})`);
         }
         catch (e) {
-            console.error('[Slack] Start failed:', e.message);
+            this.log.error(`Start failed: ${e.message}`);
             this.healthy = false;
         }
     }
@@ -113,10 +116,10 @@ class SlackAdapter {
             await this.app.stop().catch(() => { });
             this.app = null;
         }
-        console.log('[Slack] Disconnected');
+        this.log.info('Disconnected');
     }
     async send(channelId, message) {
-        await this.app?.client.chat.postMessage({ channel: channelId, text: message }).catch((e) => console.error('[Slack] send error:', e.message));
+        await this.app?.client.chat.postMessage({ channel: channelId, text: message }).catch((e) => this.log.error(`send error: ${e.message}`));
     }
     isHealthy() { return this.healthy; }
     // ── Helpers ────────────────────────────────────────────────
@@ -131,7 +134,7 @@ class SlackAdapter {
             });
         }
         catch (e) {
-            console.error('[Slack] routeMessage error:', e.message);
+            this.log.error(`routeMessage error: ${e.message}`);
             return '❌ Something went wrong. Try again.';
         }
     }

package/dist/core/channels/telegram-commands.js

@@ -0,0 +1,154 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TelegramCommandRouter = void 0;
+const logger_1 = require("../v4/logger");
+class TelegramCommandRouter {
+    constructor(opts) {
+        this.store = opts.store;
+        this.log = opts.logger ?? (0, logger_1.noopLogger)();
+        this.botUsername = opts.botUsername ?? (() => null);
+        this.fetchGroupAdmins = opts.fetchGroupAdmins;
+    }
+    /**
+     * Inspect a Telegram message and decide whether to consume it as a
+     * command or pass it through to the agent. Pure dispatch — never
+     * sends messages itself; the caller renders the reply text and
+     * applies state changes.
+     */
+    async route(msg) {
+        const text = (msg.text ?? '').trim();
+        if (!text.startsWith('/'))
+            return { kind: 'agent' };
+        const { cmd, args } = this.parseCommand(text);
+        if (!cmd)
+            return { kind: 'agent' };
+        const chatId = String(msg.chat.id);
+        const chatType = msg.chat.type;
+        const senderId = msg.from?.id ? String(msg.from.id) : '';
+        switch (cmd) {
+            case '/help':
+            case '/start':
+                return { kind: 'reply', text: this.helpText(chatType) };
+            case '/status':
+                return { kind: 'reply', text: '✓ Online' };
+            case '/clear': {
+                // DMs: anyone may /clear their own chat. Groups: admin only.
+                if (chatType !== 'private' && !(await this.isAdmin(senderId, chatId))) {
+                    this.log.info(`/clear ignored — non-admin in group`, { chatId, senderId });
+                    return { kind: 'handled' };
+                }
+                if (chatType !== 'private')
+                    this.store.recordAdminAction(chatId, 'clear', senderId);
+                return { kind: 'cleared' };
+            }
+            case '/pause': {
+                if (!this.requireGroup(chatType) || !(await this.isAdmin(senderId, chatId))) {
+                    this.log.info(`/pause ignored`, { chatId, senderId, chatType });
+                    return { kind: 'handled' };
+                }
+                this.store.setPaused(chatId, true, senderId);
+                return { kind: 'paused', groupId: chatId };
+            }
+            case '/resume': {
+                if (!this.requireGroup(chatType) || !(await this.isAdmin(senderId, chatId))) {
+                    this.log.info(`/resume ignored`, { chatId, senderId, chatType });
+                    return { kind: 'handled' };
+                }
+                this.store.setPaused(chatId, false, senderId);
+                return { kind: 'resumed', groupId: chatId };
+            }
+            case '/allowusers': {
+                if (!this.requireGroup(chatType) || !(await this.isAdmin(senderId, chatId))) {
+                    this.log.info(`/allowusers ignored`, { chatId, senderId, chatType });
+                    return { kind: 'handled' };
+                }
+                // Comma- or space-separated. `/allowusers reset` clears the list.
+                const raw = args.join(' ').trim();
+                if (raw === '' || raw === 'reset' || raw === 'clear') {
+                    this.store.setAllowedUsers(chatId, [], senderId);
+                    return { kind: 'reply', text: '✓ Cleared user allowlist for this group.' };
+                }
+                const ids = raw.split(/[,\s]+/).map((s) => s.trim()).filter(Boolean);
+                this.store.setAllowedUsers(chatId, ids, senderId);
+                return {
+                    kind: 'reply',
+                    text: `✓ User allowlist updated: ${ids.length} id(s) — only these users may chat with the bot here.`,
+                };
+            }
+            default:
+                // Unknown slash command — fall through to the agent. The
+                // model can decide whether to interpret it as natural input.
+                return { kind: 'agent' };
+        }
+    }
+    // ── Admin checks ────────────────────────────────────────────────
+    /**
+     * True when `senderId` is allowed to issue admin-only commands here.
+     * Owner takes priority; TELEGRAM_ADMIN_USERS escalates additional
+     * ids; TELEGRAM_TRUST_GROUP_ADMINS=true (off by default) accepts
+     * Telegram-side group admins.
+     */
+    async isAdmin(senderId, chatId) {
+        if (!senderId)
+            return false;
+        const ownerId = (process.env.TELEGRAM_OWNER_ID ?? '').trim();
+        if (ownerId && senderId === ownerId)
+            return true;
+        const adminCsv = (process.env.TELEGRAM_ADMIN_USERS ?? '').trim();
+        if (adminCsv) {
+            const admins = adminCsv.split(',').map((s) => s.trim()).filter(Boolean);
+            if (admins.includes(senderId))
+                return true;
+        }
+        const trustGroupAdmins = (process.env.TELEGRAM_TRUST_GROUP_ADMINS ?? '').toLowerCase() === 'true';
+        if (trustGroupAdmins && this.fetchGroupAdmins) {
+            try {
+                const admins = await this.fetchGroupAdmins(chatId);
+                if (admins.includes(senderId))
+                    return true;
+            }
+            catch (err) {
+                this.log.warn(`getChatAdministrators failed: ${err?.message ?? err}`, { chatId });
+            }
+        }
+        return false;
+    }
+    // ── Internals ───────────────────────────────────────────────────
+    /**
+     * Extract `/cmd` and the args list from raw text.
+     * Strips `@bot_username` suffixes Telegram appends in groups so
+     * `/clear@aiden_test_bot` resolves to `/clear`.
+     */
+    parseCommand(raw) {
+        const parts = raw.split(/\s+/);
+        if (!parts[0] || !parts[0].startsWith('/'))
+            return { cmd: null, args: [] };
+        const username = (this.botUsername() ?? '').toLowerCase();
+        let head = parts[0].toLowerCase();
+        if (username && head.endsWith(`@${username}`)) {
+            head = head.slice(0, head.length - username.length - 1);
+        }
+        return { cmd: head, args: parts.slice(1) };
+    }
+    requireGroup(chatType) {
+        return chatType === 'group' || chatType === 'supergroup';
+    }
+    helpText(chatType) {
+        const groupExtras = chatType !== 'private'
+            ? '`/pause`       admin: stop bot in this group\n' +
+                '`/resume`      admin: resume bot\n' +
+                '`/allowusers`  admin: restrict who may chat\n'
+            : '';
+        return ('*Aiden* — your local AI assistant.\n\n' +
+            'Send any message (or @mention me in a group) to start. Built-in commands:\n' +
+            '`/help`        show this message\n' +
+            '`/status`      bot health check\n' +
+            '`/clear`       wipe this chat\'s memory\n' +
+            groupExtras);
+    }
+}
+exports.TelegramCommandRouter = TelegramCommandRouter;