@otto-assistant/otto 0.1.2 → 0.7.15

package/dist/ipc-polling.js

@@ -0,0 +1,327 @@
+// IPC polling bridge between the opencode plugin and the Discord bot.
+// The plugin inserts rows into ipc_requests (via Prisma). This module polls
+// that table, claims pending rows atomically, and dispatches them by type.
+// Replaces the old HTTP lock-server approach with DB-based IPC.
+import * as errore from "errore";
+import { createTaggedError } from "errore";
+import { claimPendingIpcRequests, completeIpcRequest, cancelAllPendingIpcRequests, cancelStaleProcessingRequests, } from "./database.js";
+import { showFileUploadButton } from "./commands/file-upload.js";
+import { queueActionButtonsRequest } from "./commands/action-buttons.js";
+import { getOrCreateRuntime } from "./session-handler/thread-session-runtime.js";
+import * as threadState from "./session-handler/thread-runtime-state.js";
+import { createLogger, LogPrefix } from "./logger.js";
+import { notifyError } from "./sentry.js";
+const ipcLogger = createLogger(LogPrefix.IPC);
+// ── Tagged errors ────────────────────────────────────────────────────────
+class IpcDispatchError extends createTaggedError({
+    name: "IpcDispatchError",
+    message: "IPC dispatch failed for request $requestId: $reason",
+}) {
+}
+// ── Button parsing ───────────────────────────────────────────────────────
+const VALID_COLORS = new Set([
+    "white",
+    "blue",
+    "green",
+    "red",
+]);
+function parseButtons(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    const results = [];
+    for (const value of raw) {
+        if (!value || typeof value !== "object")
+            continue;
+        const label = (typeof value.label === "string" ? value.label : "")
+            .trim()
+            .slice(0, 80);
+        if (!label)
+            continue;
+        const color = typeof value.color === "string" &&
+            VALID_COLORS.has(value.color)
+            ? value.color
+            : undefined;
+        results.push({ label, color });
+        if (results.length >= 3)
+            break;
+    }
+    return results;
+}
+async function dispatchRequest({ req, discordClient, }) {
+    switch (req.type) {
+        case "file_upload": {
+            const parsed = errore.try({
+                try: () => JSON.parse(req.payload),
+                catch: (e) => new IpcDispatchError({
+                    requestId: req.id,
+                    reason: "Invalid payload JSON",
+                    cause: e,
+                }),
+            });
+            if (parsed instanceof Error) {
+                await completeIpcRequest({
+                    id: req.id,
+                    response: JSON.stringify({ error: parsed.message }),
+                });
+                return parsed;
+            }
+            const thread = await discordClient.channels.fetch(req.thread_id).catch((e) => new IpcDispatchError({
+                requestId: req.id,
+                reason: "Thread fetch failed",
+                cause: e,
+            }));
+            if (thread instanceof Error) {
+                await completeIpcRequest({
+                    id: req.id,
+                    response: JSON.stringify({ error: "Thread not found" }),
+                });
+                return thread;
+            }
+            if (!thread?.isThread()) {
+                await completeIpcRequest({
+                    id: req.id,
+                    response: JSON.stringify({ error: "Thread not found" }),
+                });
+                return new IpcDispatchError({
+                    requestId: req.id,
+                    reason: "Channel is not a thread",
+                });
+            }
+            // Fire-and-forget: showFileUploadButton waits for user interaction
+            // (button click + modal + file download) which can take minutes.
+            // Don't block the dispatch loop — complete the IPC request asynchronously.
+            showFileUploadButton({
+                thread,
+                sessionId: req.session_id,
+                directory: parsed.directory || "",
+                prompt: parsed.prompt || "Please upload files",
+                maxFiles: Math.min(10, Math.max(1, parsed.maxFiles || 5)),
+            })
+                .then((filePaths) => {
+                return completeIpcRequest({
+                    id: req.id,
+                    response: JSON.stringify({ filePaths }),
+                });
+            })
+                .catch((e) => {
+                ipcLogger.error("[IPC] File upload error:", e instanceof Error ? e.message : String(e));
+                return completeIpcRequest({
+                    id: req.id,
+                    response: JSON.stringify({
+                        error: e instanceof Error ? e.message : "File upload failed",
+                    }),
+                });
+            })
+                .catch((e) => {
+                void notifyError(e, "IPC file upload completion update failed");
+            });
+            return;
+        }
+        case "action_buttons": {
+            const parsed = errore.try({
+                try: () => JSON.parse(req.payload),
+                catch: (e) => new IpcDispatchError({
+                    requestId: req.id,
+                    reason: "Invalid payload JSON",
+                    cause: e,
+                }),
+            });
+            if (parsed instanceof Error) {
+                await completeIpcRequest({
+                    id: req.id,
+                    response: JSON.stringify({ error: parsed.message }),
+                });
+                return parsed;
+            }
+            const buttons = parseButtons(parsed.buttons);
+            if (buttons.length === 0) {
+                await completeIpcRequest({
+                    id: req.id,
+                    response: JSON.stringify({ error: "No valid buttons" }),
+                });
+                return;
+            }
+            const thread = await discordClient.channels.fetch(req.thread_id).catch((e) => new IpcDispatchError({
+                requestId: req.id,
+                reason: "Thread fetch failed",
+                cause: e,
+            }));
+            if (thread instanceof Error) {
+                await completeIpcRequest({
+                    id: req.id,
+                    response: JSON.stringify({ error: "Thread not found" }),
+                });
+                return thread;
+            }
+            if (!thread?.isThread()) {
+                await completeIpcRequest({
+                    id: req.id,
+                    response: JSON.stringify({ error: "Thread not found" }),
+                });
+                return new IpcDispatchError({
+                    requestId: req.id,
+                    reason: "Channel is not a thread",
+                });
+            }
+            queueActionButtonsRequest({
+                sessionId: req.session_id,
+                threadId: req.thread_id,
+                directory: parsed.directory || "",
+                buttons,
+            });
+            await completeIpcRequest({
+                id: req.id,
+                response: JSON.stringify({ ok: true }),
+            });
+            return;
+        }
+        case "start_thread_listener": {
+            const parsed = errore.try({
+                try: () => JSON.parse(req.payload),
+                catch: (e) => new IpcDispatchError({
+                    requestId: req.id,
+                    reason: "Invalid payload JSON",
+                    cause: e,
+                }),
+            });
+            if (parsed instanceof Error) {
+                await completeIpcRequest({
+                    id: req.id,
+                    response: JSON.stringify({ error: parsed.message }),
+                });
+                return parsed;
+            }
+            const thread = await discordClient.channels.fetch(req.thread_id).catch((e) => new IpcDispatchError({
+                requestId: req.id,
+                reason: "Thread fetch failed",
+                cause: e,
+            }));
+            if (thread instanceof Error) {
+                await completeIpcRequest({
+                    id: req.id,
+                    response: JSON.stringify({ error: "Thread fetch failed" }),
+                });
+                return thread;
+            }
+            if (!thread?.isThread()) {
+                await completeIpcRequest({
+                    id: req.id,
+                    response: JSON.stringify({ error: "Channel is not a thread" }),
+                });
+                return new IpcDispatchError({
+                    requestId: req.id,
+                    reason: "Channel is not a thread",
+                });
+            }
+            const runtime = getOrCreateRuntime({
+                threadId: req.thread_id,
+                thread,
+                projectDirectory: parsed.projectDirectory,
+                sdkDirectory: parsed.projectDirectory,
+                channelId: parsed.channelId,
+                appId: parsed.appId,
+            });
+            // Ensure runtime has a session ID before subscribing, otherwise
+            // session-scoped events get dropped by the event demux guard.
+            threadState.setSessionId(req.thread_id, req.session_id);
+            void runtime.startEventListener();
+            if (parsed.initialPrompt && parsed.initialPrompt.trim().length > 0) {
+                const enqueueResult = await runtime.enqueueIncoming({
+                    prompt: parsed.initialPrompt,
+                    userId: parsed.userId || "otto-cli",
+                    username: parsed.username || "otto-cli",
+                    sourceMessageId: parsed.sourceMessageId,
+                    sourceThreadId: parsed.sourceThreadId,
+                    appId: parsed.appId,
+                    agent: parsed.agent,
+                    model: parsed.model,
+                    permissions: parsed.permissions,
+                    injectionGuardPatterns: parsed.injectionGuardPatterns,
+                });
+                if (enqueueResult instanceof Error) {
+                    await completeIpcRequest({
+                        id: req.id,
+                        response: JSON.stringify({ error: enqueueResult.message }),
+                    });
+                    return enqueueResult;
+                }
+            }
+            await completeIpcRequest({
+                id: req.id,
+                response: JSON.stringify({ ok: true }),
+            });
+            return;
+        }
+        default: {
+            await completeIpcRequest({
+                id: req.id,
+                response: JSON.stringify({ error: `Unknown IPC type: ${req.type}` }),
+            });
+            return;
+        }
+    }
+}
+// ── Polling lifecycle ────────────────────────────────────────────────────
+let pollingInterval = null;
+// Cancel requests stuck in 'processing' longer than 24 hours. Users often
+// come back the next day to click permission/question/file-upload buttons,
+// so we keep IPC rows alive for a full day. Checked every 30 seconds.
+const STALE_TTL_MS = 24 * 60 * 60 * 1000;
+const STALE_CHECK_INTERVAL_MS = 30 * 1000;
+let lastStaleCheck = 0;
+/**
+ * Start polling the ipc_requests table for pending requests from the plugin.
+ * Claims rows atomically (pending -> processing) to prevent duplicate dispatch.
+ * Uses an in-flight guard to prevent overlapping poll ticks.
+ */
+export async function startIpcPolling({ discordClient, }) {
+    // Clean up stale requests from previous runs before first poll tick
+    await cancelAllPendingIpcRequests().catch((e) => {
+        ipcLogger.warn("Failed to cancel stale IPC requests:", e.message);
+        void notifyError(e, "Failed to cancel stale IPC requests");
+    });
+    let polling = false;
+    pollingInterval = setInterval(async () => {
+        if (polling)
+            return;
+        polling = true;
+        // Periodically sweep requests stuck in 'processing' past the TTL
+        const now = Date.now();
+        if (now - lastStaleCheck > STALE_CHECK_INTERVAL_MS) {
+            lastStaleCheck = now;
+            await cancelStaleProcessingRequests({ ttlMs: STALE_TTL_MS }).catch((e) => {
+                ipcLogger.warn("Stale sweep failed:", e.message);
+                void notifyError(e, "IPC stale sweep failed");
+            });
+        }
+        const claimed = await claimPendingIpcRequests().catch((e) => new IpcDispatchError({
+            requestId: "poll",
+            reason: "Claim failed",
+            cause: e,
+        }));
+        if (claimed instanceof Error) {
+            ipcLogger.error("IPC claim failed:", claimed.message);
+            void notifyError(claimed, "IPC claim failed");
+            polling = false;
+            return;
+        }
+        for (const req of claimed) {
+            const result = await dispatchRequest({ req, discordClient }).catch((e) => new IpcDispatchError({
+                requestId: req.id,
+                reason: "Dispatch threw",
+                cause: e,
+            }));
+            if (result instanceof Error) {
+                ipcLogger.error(`IPC dispatch error for ${req.type}:`, result.message);
+                void notifyError(result, `IPC dispatch error for ${req.type}`);
+            }
+        }
+        polling = false;
+    }, 200);
+}
+export function stopIpcPolling() {
+    if (!pollingInterval)
+        return;
+    clearInterval(pollingInterval);
+    pollingInterval = null;
+}

package/dist/ipc-tools-plugin.js

@@ -0,0 +1,193 @@
+// OpenCode plugin that provides IPC-based tools for Discord interaction:
+// - otto_file_upload: prompts the Discord user to upload files via native picker
+// - otto_action_buttons: shows clickable action buttons in the Discord thread
+//
+// Tools communicate with the bot process via IPC rows in SQLite (the plugin
+// runs inside the OpenCode server process, not the bot process).
+//
+// Exported from otto-opencode-plugin.ts — each export is treated as a separate
+// plugin by OpenCode's plugin loader.
+import dedent from 'string-dedent';
+import { z } from 'zod';
+import { setDataDir } from './config.js';
+import { createPluginLogger, setPluginLogFilePath } from './plugin-logger.js';
+import { initSentry } from './sentry.js';
+// Inlined from '@opencode-ai/plugin/tool' because the subpath value import
+// fails at runtime in global npm installs (#35). Opencode loads this plugin
+// file in its own process and resolves modules from otto's install dir,
+// but the '/tool' subpath export isn't found by opencode's module resolver.
+// The type-only imports above are fine (erased at compile time).
+//
+// NOTE: @opencode-ai/plugin bundles its own zod 4.1.x as a hard dependency
+// while goke (used by cli.ts) requires zod 4.3.x. This version skew makes
+// the Plugin return type structurally incompatible with our local tool()
+// even though runtime behavior is identical. ipcToolsPlugin is cast to
+// Plugin via unknown to bypass this purely type-level incompatibility.
+function tool(input) {
+    return input;
+}
+const logger = createPluginLogger('OPENCODE');
+const FILE_UPLOAD_TIMEOUT_MS = 6 * 60 * 1000;
+const DEFAULT_FILE_UPLOAD_MAX_FILES = 5;
+const ACTION_BUTTON_TIMEOUT_MS = 30 * 1000;
+async function loadDatabaseModule() {
+    // The plugin-loading e2e test boots OpenCode directly without the bot-side
+    // Hrana env vars. Lazy-loading avoids pulling Prisma + libsql sqlite mode
+    // during plugin startup when no IPC tool is being executed yet.
+    return import('./database.js');
+}
+// @opencode-ai/plugin bundles zod 4.1.x as a hard dep; our code uses 4.3.x
+// (required by goke for ~standard.jsonSchema). The Plugin return type is
+// structurally incompatible due to _zod.version.minor skew even though
+// runtime behavior is identical. `any` bypasses the type-level mismatch —
+// opencode's plugin loader doesn't care about the zod version at runtime.
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const ipcToolsPlugin = async () => {
+    initSentry();
+    const dataDir = process.env.OTTO_DATA_DIR;
+    if (dataDir) {
+        setDataDir(dataDir);
+        setPluginLogFilePath(dataDir);
+    }
+    return {
+        tool: {
+            otto_file_upload: tool({
+                description: 'Prompt the Discord user to upload files using a native file picker modal. ' +
+                    'The user sees a button, clicks it, and gets a file upload dialog. ' +
+                    'Returns the local file paths of downloaded files in the project directory. ' +
+                    'Use this when you need the user to provide files (images, documents, configs, etc.). ' +
+                    'IMPORTANT: Always call this tool last in your message, after all text parts.',
+                args: {
+                    prompt: z
+                        .string()
+                        .describe('Message shown to the user explaining what files to upload'),
+                    maxFiles: z
+                        .number()
+                        .min(1)
+                        .max(10)
+                        .optional()
+                        .describe('Maximum number of files the user can upload (1-10, default 5)'),
+                },
+                async execute({ prompt, maxFiles }, context) {
+                    const { getPrisma, createIpcRequest, getIpcRequestById } = await loadDatabaseModule();
+                    const prisma = await getPrisma();
+                    const row = await prisma.thread_sessions.findFirst({
+                        where: { session_id: context.sessionID },
+                        select: { thread_id: true },
+                    });
+                    if (!row?.thread_id) {
+                        return 'Could not find thread for current session';
+                    }
+                    const ipcRow = await createIpcRequest({
+                        type: 'file_upload',
+                        sessionId: context.sessionID,
+                        threadId: row.thread_id,
+                        payload: JSON.stringify({
+                            prompt,
+                            maxFiles: maxFiles || DEFAULT_FILE_UPLOAD_MAX_FILES,
+                            directory: context.directory,
+                        }),
+                    });
+                    const deadline = Date.now() + FILE_UPLOAD_TIMEOUT_MS;
+                    const POLL_INTERVAL_MS = 300;
+                    while (Date.now() < deadline) {
+                        await new Promise((resolve) => {
+                            setTimeout(resolve, POLL_INTERVAL_MS);
+                        });
+                        const updated = await getIpcRequestById({ id: ipcRow.id });
+                        if (!updated || updated.status === 'cancelled') {
+                            return 'File upload was cancelled';
+                        }
+                        if (updated.response) {
+                            const parsed = JSON.parse(updated.response);
+                            if (parsed.error) {
+                                return `File upload failed: ${parsed.error}`;
+                            }
+                            const filePaths = parsed.filePaths || [];
+                            if (filePaths.length === 0) {
+                                return 'No files were uploaded (user may have cancelled or sent a new message)';
+                            }
+                            return `Files uploaded successfully:\n${filePaths.join('\n')}`;
+                        }
+                    }
+                    return 'File upload timed out - user did not upload files within the time limit';
+                },
+            }),
+            otto_action_buttons: tool({
+                description: dedent `
+          Show action buttons in the current Discord thread for quick confirmations.
+          Use this when the user can respond by clicking one of up to 3 buttons.
+          Prefer a single button whenever possible.
+          Default color is white (same visual style as permission deny button).
+          If you need more than 3 options, use the question tool instead.
+          IMPORTANT: Always call this tool last in your message, after all text parts.
+
+          Examples:
+          - buttons: [{"label":"Yes, proceed"}]
+          - buttons: [{"label":"Approve","color":"green"}]
+          - buttons: [
+              {"label":"Confirm","color":"blue"},
+              {"label":"Cancel","color":"white"}
+            ]
+        `,
+                args: {
+                    buttons: z
+                        .array(z.object({
+                        label: z
+                            .string()
+                            .min(1)
+                            .max(80)
+                            .describe('Button label shown to the user (1-80 chars)'),
+                        color: z
+                            .enum(['white', 'blue', 'green', 'red'])
+                            .optional()
+                            .describe('Optional button color. white is default and preferred for most confirmations.'),
+                    }))
+                        .min(1)
+                        .max(3)
+                        .describe('Array of 1-3 action buttons. Prefer one button whenever possible.'),
+                },
+                async execute({ buttons }, context) {
+                    const { getPrisma, createIpcRequest, getIpcRequestById } = await loadDatabaseModule();
+                    const prisma = await getPrisma();
+                    const row = await prisma.thread_sessions.findFirst({
+                        where: { session_id: context.sessionID },
+                        select: { thread_id: true },
+                    });
+                    if (!row?.thread_id) {
+                        return 'Could not find thread for current session';
+                    }
+                    const ipcRow = await createIpcRequest({
+                        type: 'action_buttons',
+                        sessionId: context.sessionID,
+                        threadId: row.thread_id,
+                        payload: JSON.stringify({
+                            buttons,
+                            directory: context.directory,
+                        }),
+                    });
+                    const deadline = Date.now() + ACTION_BUTTON_TIMEOUT_MS;
+                    const POLL_INTERVAL_MS = 200;
+                    while (Date.now() < deadline) {
+                        await new Promise((resolve) => {
+                            setTimeout(resolve, POLL_INTERVAL_MS);
+                        });
+                        const updated = await getIpcRequestById({ id: ipcRow.id });
+                        if (!updated || updated.status === 'cancelled') {
+                            return 'Action button request was cancelled';
+                        }
+                        if (updated.response) {
+                            const parsed = JSON.parse(updated.response);
+                            if (parsed.error) {
+                                return `Action button request failed: ${parsed.error}`;
+                            }
+                            return `Action button(s) shown: ${buttons.map((button) => button.label).join(', ')}`;
+                        }
+                    }
+                    return 'Action button request timed out';
+                },
+            }),
+        },
+    };
+};
+export { ipcToolsPlugin };

package/dist/ipc-utils.js

@@ -0,0 +1,18 @@
+import { getIpcRequestById } from './database.js';
+/**
+ * Wait for an IPC request to reach "completed" status.
+ * Used by both the CLI send flow and the task-runner.
+ */
+export async function waitForIpcRequestCompletion({ requestId, timeoutMs = 4_000, pollMs = 100, }) {
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < timeoutMs) {
+        const row = await getIpcRequestById({ id: requestId });
+        if (row?.status === 'completed') {
+            return true;
+        }
+        await new Promise((resolve) => {
+            setTimeout(resolve, pollMs);
+        });
+    }
+    return new Error(`Timed out waiting for IPC request ${requestId} completion`);
+}

package/dist/limit-heading-depth.js

@@ -0,0 +1,25 @@
+// Limit heading depth for Discord.
+// Discord only supports headings up to ### (h3), so this converts
+// ####, #####, etc. to ### to maintain consistent rendering.
+import { Lexer } from 'marked';
+export function limitHeadingDepth(markdown, maxDepth = 3) {
+    const lexer = new Lexer();
+    const tokens = lexer.lex(markdown);
+    let result = '';
+    for (const token of tokens) {
+        if (token.type === 'heading') {
+            const heading = token;
+            if (heading.depth > maxDepth) {
+                const hashes = '#'.repeat(maxDepth);
+                result += hashes + ' ' + heading.text + '\n';
+            }
+            else {
+                result += token.raw;
+            }
+        }
+        else {
+            result += token.raw;
+        }
+    }
+    return result;
+}

package/dist/limit-heading-depth.test.js

@@ -0,0 +1,105 @@
+import { expect, test } from 'vitest';
+import { limitHeadingDepth } from './limit-heading-depth.js';
+test('converts h4 to h3', () => {
+    const input = '#### Fourth level heading';
+    const result = limitHeadingDepth(input);
+    expect(result).toMatchInlineSnapshot(`
+    "### Fourth level heading
+    "
+  `);
+});
+test('converts h5 to h3', () => {
+    const input = '##### Fifth level heading';
+    const result = limitHeadingDepth(input);
+    expect(result).toMatchInlineSnapshot(`
+    "### Fifth level heading
+    "
+  `);
+});
+test('converts h6 to h3', () => {
+    const input = '###### Sixth level heading';
+    const result = limitHeadingDepth(input);
+    expect(result).toMatchInlineSnapshot(`
+    "### Sixth level heading
+    "
+  `);
+});
+test('preserves h3 unchanged', () => {
+    const input = '### Third level heading';
+    const result = limitHeadingDepth(input);
+    expect(result).toMatchInlineSnapshot(`"### Third level heading"`);
+});
+test('preserves h2 unchanged', () => {
+    const input = '## Second level heading';
+    const result = limitHeadingDepth(input);
+    expect(result).toMatchInlineSnapshot(`"## Second level heading"`);
+});
+test('preserves h1 unchanged', () => {
+    const input = '# First level heading';
+    const result = limitHeadingDepth(input);
+    expect(result).toMatchInlineSnapshot(`"# First level heading"`);
+});
+test('handles multiple headings in document', () => {
+    const input = `# Title
+
+Some text
+
+## Section
+
+### Subsection
+
+#### Too deep
+
+##### Even deeper
+
+Regular paragraph
+
+### Back to normal
+`;
+    const result = limitHeadingDepth(input);
+    expect(result).toMatchInlineSnapshot(`
+    "# Title
+
+    Some text
+
+    ## Section
+
+    ### Subsection
+
+    ### Too deep
+    ### Even deeper
+    Regular paragraph
+
+    ### Back to normal
+    "
+  `);
+});
+test('preserves heading with inline formatting', () => {
+    const input = '#### Heading with **bold** and `code`';
+    const result = limitHeadingDepth(input);
+    expect(result).toMatchInlineSnapshot(`
+    "### Heading with **bold** and \`code\`
+    "
+  `);
+});
+test('handles empty markdown', () => {
+    const result = limitHeadingDepth('');
+    expect(result).toMatchInlineSnapshot(`""`);
+});
+test('handles markdown with no headings', () => {
+    const input = 'Just some text\n\nAnd more text';
+    const result = limitHeadingDepth(input);
+    expect(result).toMatchInlineSnapshot(`
+    "Just some text
+
+    And more text"
+  `);
+});
+test('allows custom maxDepth', () => {
+    const input = '### Third level';
+    const result = limitHeadingDepth(input, 2);
+    expect(result).toMatchInlineSnapshot(`
+    "## Third level
+    "
+  `);
+});