@otto-assistant/otto 0.1.2 → 0.7.15

package/dist/session-handler.js

@@ -0,0 +1,9 @@
+// Thin re-export shim for backward compatibility.
+// Logic lives in:
+//   - session-handler/thread-session-runtime.ts (runtime class + registry)
+//   - session-handler/thread-runtime-state.ts (state transitions)
+//   - session-handler/model-utils.ts (getDefaultModel, types)
+//   - session-handler/agent-utils.ts (resolveValidatedAgentPreference)
+// New code should import from the specific module directly.
+export { getDefaultModel, } from './session-handler/model-utils.js';
+export { resolveValidatedAgentPreference } from './session-handler/agent-utils.js';

package/dist/session-search.js

@@ -0,0 +1,100 @@
+// Session search helpers for otto CLI commands.
+// Parses string/regex queries and builds readable snippets from matched content.
+export function parseSessionSearchPattern(query) {
+    const trimmedQuery = query.trim();
+    if (!trimmedQuery) {
+        return new Error('Search query cannot be empty');
+    }
+    const regexMatch = trimmedQuery.match(/^\/([\s\S]+)\/([a-z]*)$/);
+    if (!regexMatch) {
+        return {
+            mode: 'literal',
+            raw: trimmedQuery,
+            normalizedNeedle: trimmedQuery.toLowerCase(),
+        };
+    }
+    const pattern = regexMatch[1] || '';
+    const flags = regexMatch[2] || '';
+    try {
+        return {
+            mode: 'regex',
+            raw: trimmedQuery,
+            regex: new RegExp(pattern, flags),
+        };
+    }
+    catch (error) {
+        return new Error(`Invalid regex query "${trimmedQuery}": ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+export function findFirstSessionSearchHit({ text, searchPattern, }) {
+    if (searchPattern.mode === 'literal') {
+        const index = text.toLowerCase().indexOf(searchPattern.normalizedNeedle);
+        if (index < 0) {
+            return undefined;
+        }
+        return {
+            index,
+            length: searchPattern.raw.length,
+        };
+    }
+    searchPattern.regex.lastIndex = 0;
+    const match = searchPattern.regex.exec(text);
+    if (!match || match.index < 0) {
+        return undefined;
+    }
+    return {
+        index: match.index,
+        length: Math.max(match[0]?.length || 0, 1),
+    };
+}
+export function buildSessionSearchSnippet({ text, hit, contextLength = 90, }) {
+    const start = Math.max(0, hit.index - contextLength);
+    const end = Math.min(text.length, hit.index + hit.length + contextLength);
+    const prefix = start > 0 ? '...' : '';
+    const suffix = end < text.length ? '...' : '';
+    const body = text
+        .slice(start, end)
+        .replace(/[\r\n\t]+/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+    return `${prefix}${body}${suffix}`;
+}
+function stringifyUnknown(value) {
+    if (value === undefined || value === null) {
+        return '';
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+export function getPartSearchTexts(part) {
+    switch (part.type) {
+        case 'text':
+            return part.text ? [part.text] : [];
+        case 'reasoning':
+            return part.text ? [part.text] : [];
+        case 'tool': {
+            const inputText = stringifyUnknown(part.state.input);
+            const outputText = part.state.status === 'completed'
+                ? stringifyUnknown(part.state.output)
+                : part.state.status === 'error'
+                    ? part.state.error || ''
+                    : '';
+            return [`tool:${part.tool}`, inputText, outputText].filter((entry) => {
+                return entry.trim().length > 0;
+            });
+        }
+        case 'file':
+            return [part.filename || '', part.url || ''].filter((entry) => {
+                return entry.trim().length > 0;
+            });
+        default:
+            return [];
+    }
+}

package/dist/session-search.test.js

@@ -0,0 +1,40 @@
+// Tests for session search query parsing and snippet matching helpers.
+import { describe, expect, test } from 'vitest';
+import { buildSessionSearchSnippet, findFirstSessionSearchHit, parseSessionSearchPattern, } from './session-search.js';
+describe('session search helpers', () => {
+    test('returns error for invalid regex query', () => {
+        const parsed = parseSessionSearchPattern('/(unclosed/');
+        expect(parsed).toBeInstanceOf(Error);
+    });
+    test('returns snippets that include the matched substring', () => {
+        const cases = [
+            {
+                query: 'panic',
+                text: 'There was a PANIC in production',
+                expectedSubstring: 'PANIC',
+            },
+            {
+                query: '/error\\s+42/i',
+                text: 'Request failed with ERROR 42 in worker',
+                expectedSubstring: 'ERROR 42',
+            },
+        ];
+        cases.forEach(({ query, text, expectedSubstring }) => {
+            const parsed = parseSessionSearchPattern(query);
+            if (parsed instanceof Error) {
+                throw parsed;
+            }
+            const hit = findFirstSessionSearchHit({ text, searchPattern: parsed });
+            expect(hit).toBeDefined();
+            if (!hit) {
+                return;
+            }
+            const snippet = buildSessionSearchSnippet({
+                text,
+                hit,
+                contextLength: 8,
+            });
+            expect(snippet.toUpperCase()).toContain(expectedSubstring.toUpperCase());
+        });
+    });
+});

package/dist/session-title-rename.test.js

@@ -0,0 +1,92 @@
+// Unit tests for deriveThreadNameFromSessionTitle — the pure helper that
+// decides whether (and how) to rename a Discord thread based on an
+// OpenCode session title. Kept focused and deterministic; no Discord mocks.
+import { describe, test, expect } from 'vitest';
+import { deriveThreadNameFromSessionTitle } from './session-handler/thread-session-runtime.js';
+describe('deriveThreadNameFromSessionTitle', () => {
+    test('returns trimmed title for plain thread', () => {
+        expect(deriveThreadNameFromSessionTitle({
+            sessionTitle: '  Fix auth bug  ',
+            currentName: 'fix the auth',
+        })).toMatchInlineSnapshot(`"Fix auth bug"`);
+    });
+    test('preserves worktree prefix from current name', () => {
+        expect(deriveThreadNameFromSessionTitle({
+            sessionTitle: 'Refactor queue',
+            currentName: '⬦ refactor queue old',
+        })).toMatchInlineSnapshot(`"⬦ Refactor queue"`);
+    });
+    test('ignores placeholder "New Session -" titles', () => {
+        expect(deriveThreadNameFromSessionTitle({
+            sessionTitle: 'New Session - 2025-01-02',
+            currentName: 'whatever',
+        })).toMatchInlineSnapshot(`undefined`);
+    });
+    test('ignores case-insensitive placeholder titles', () => {
+        expect(deriveThreadNameFromSessionTitle({
+            sessionTitle: 'new session -abc',
+            currentName: 'whatever',
+        })).toMatchInlineSnapshot(`undefined`);
+    });
+    test('returns undefined when candidate already matches current name', () => {
+        expect(deriveThreadNameFromSessionTitle({
+            sessionTitle: 'Fix auth bug',
+            currentName: 'Fix auth bug',
+        })).toMatchInlineSnapshot(`undefined`);
+    });
+    test('returns undefined when candidate (with worktree prefix) already matches', () => {
+        expect(deriveThreadNameFromSessionTitle({
+            sessionTitle: 'Refactor queue',
+            currentName: '⬦ Refactor queue',
+        })).toMatchInlineSnapshot(`undefined`);
+    });
+    test('truncates to 100 chars including worktree prefix', () => {
+        const result = deriveThreadNameFromSessionTitle({
+            sessionTitle: 'x'.repeat(200),
+            currentName: '⬦ seed',
+        });
+        expect(result?.length).toMatchInlineSnapshot(`100`);
+        expect(result?.startsWith('⬦ ')).toMatchInlineSnapshot(`true`);
+    });
+    test('truncates to 100 chars without prefix', () => {
+        const result = deriveThreadNameFromSessionTitle({
+            sessionTitle: 'y'.repeat(200),
+            currentName: 'seed',
+        });
+        expect(result?.length).toMatchInlineSnapshot(`100`);
+    });
+    test('returns undefined for empty string', () => {
+        expect(deriveThreadNameFromSessionTitle({
+            sessionTitle: '',
+            currentName: 'seed',
+        })).toMatchInlineSnapshot(`undefined`);
+    });
+    test('returns undefined for whitespace-only title', () => {
+        expect(deriveThreadNameFromSessionTitle({
+            sessionTitle: '   ',
+            currentName: 'seed',
+        })).toMatchInlineSnapshot(`undefined`);
+    });
+    test('preserves btw: prefix from current name', () => {
+        expect(deriveThreadNameFromSessionTitle({
+            sessionTitle: 'Side question about auth',
+            currentName: 'btw: why is auth broken',
+        })).toMatchInlineSnapshot(`"btw: Side question about auth"`);
+    });
+    test('preserves Fork: prefix from current name', () => {
+        expect(deriveThreadNameFromSessionTitle({
+            sessionTitle: 'Forked task title',
+            currentName: 'Fork: old session title',
+        })).toMatchInlineSnapshot(`"Fork: Forked task title"`);
+    });
+    test('returns undefined for null/undefined title', () => {
+        expect(deriveThreadNameFromSessionTitle({
+            sessionTitle: null,
+            currentName: 'seed',
+        })).toMatchInlineSnapshot(`undefined`);
+        expect(deriveThreadNameFromSessionTitle({
+            sessionTitle: undefined,
+            currentName: 'seed',
+        })).toMatchInlineSnapshot(`undefined`);
+    });
+});

package/dist/skill-filter.js

@@ -0,0 +1,31 @@
+// Computes opencode permission.skill rules from otto's --enable-skill /
+// --disable-skill CLI flags.
+//
+// OpenCode filters skills available to the model via
+// Permission.evaluate("skill", skill.name, agent.permission). We inject a
+// top-level permission.skill ruleset into the generated opencode-config.json
+// so every agent inherits the same whitelist/blacklist via Permission.merge.
+//
+// Whitelist mode: { '*': 'deny', 'name': 'allow', ... }
+// Blacklist mode: { 'name': 'deny', ... }
+// Neither set:    undefined (skills are unfiltered)
+//
+// cli.ts validates mutual exclusion of the two flags at startup, so this
+// helper assumes at most one of the two arrays is non-empty.
+export function computeSkillPermission({ enabledSkills, disabledSkills, }) {
+    if (enabledSkills.length > 0) {
+        const rules = { '*': 'deny' };
+        for (const name of enabledSkills) {
+            rules[name] = 'allow';
+        }
+        return rules;
+    }
+    if (disabledSkills.length > 0) {
+        const rules = {};
+        for (const name of disabledSkills) {
+            rules[name] = 'deny';
+        }
+        return rules;
+    }
+    return undefined;
+}

package/dist/skill-filter.test.js

@@ -0,0 +1,65 @@
+import { describe, test, expect } from 'vitest';
+import { computeSkillPermission } from './skill-filter.js';
+describe('computeSkillPermission', () => {
+    test('empty inputs returns undefined (no filtering)', () => {
+        expect(computeSkillPermission({ enabledSkills: [], disabledSkills: [] })).toMatchInlineSnapshot(`undefined`);
+    });
+    test('whitelist single skill', () => {
+        expect(computeSkillPermission({
+            enabledSkills: ['npm-package'],
+            disabledSkills: [],
+        })).toMatchInlineSnapshot(`
+      {
+        "*": "deny",
+        "npm-package": "allow",
+      }
+    `);
+    });
+    test('whitelist multiple skills', () => {
+        expect(computeSkillPermission({
+            enabledSkills: ['npm-package', 'playwriter', 'errore'],
+            disabledSkills: [],
+        })).toMatchInlineSnapshot(`
+      {
+        "*": "deny",
+        "errore": "allow",
+        "npm-package": "allow",
+        "playwriter": "allow",
+      }
+    `);
+    });
+    test('blacklist single skill', () => {
+        expect(computeSkillPermission({
+            enabledSkills: [],
+            disabledSkills: ['jitter'],
+        })).toMatchInlineSnapshot(`
+      {
+        "jitter": "deny",
+      }
+    `);
+    });
+    test('blacklist multiple skills', () => {
+        expect(computeSkillPermission({
+            enabledSkills: [],
+            disabledSkills: ['jitter', 'termcast'],
+        })).toMatchInlineSnapshot(`
+      {
+        "jitter": "deny",
+        "termcast": "deny",
+      }
+    `);
+    });
+    test('whitelist takes precedence when both are set (cli.ts is expected to reject this upstream)', () => {
+        // cli.ts validates mutual exclusion before reaching this helper. This
+        // test documents the defensive behavior if both arrays ever leak through.
+        expect(computeSkillPermission({
+            enabledSkills: ['npm-package'],
+            disabledSkills: ['jitter'],
+        })).toMatchInlineSnapshot(`
+      {
+        "*": "deny",
+        "npm-package": "allow",
+      }
+    `);
+    });
+});

package/dist/startup-service.js

@@ -0,0 +1,153 @@
+// Cross-platform startup service registration for otto daemon.
+// Vendored from startup-run (MIT, github.com/vilicvane/startup-run) with
+// significant simplifications: no abstract classes, no fs-extra, no winreg
+// npm dep, no separate daemon process (otto's bin.ts already handles
+// respawn/crash-loop). Just writes/deletes the platform service file.
+//
+// macOS:   ~/Library/LaunchAgents/xyz.otto.plist  (launchd)
+// Linux:   ~/.config/autostart/otto.desktop       (XDG autostart)
+// Windows: HKCU\Software\Microsoft\Windows\CurrentVersion\Run  (registry)
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { execAsync } from './worktrees.js';
+const SERVICE_NAME = 'xyz.otto';
+function getServiceFilePath() {
+    switch (process.platform) {
+        case 'darwin':
+            return path.join(os.homedir(), 'Library', 'LaunchAgents', `${SERVICE_NAME}.plist`);
+        case 'linux':
+            return path.join(os.homedir(), '.config', 'autostart', 'otto.desktop');
+        case 'win32':
+            // No file — registry key, return a descriptive string for status display
+            return 'HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run\\otto';
+        default:
+            throw new Error(`Unsupported platform: ${process.platform}`);
+    }
+}
+function escapeXml(value) {
+    return value
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;');
+}
+// Shell-escape a string for use in a Linux .desktop Exec= line.
+// Wraps in double quotes if it contains spaces or special chars.
+function shellEscape(value) {
+    if (/^[a-zA-Z0-9._/=-]+$/.test(value)) {
+        return value;
+    }
+    return `"${value.replace(/"/g, '\\"')}"`;
+}
+function buildMacOSPlist({ command, args, }) {
+    const segments = [command, ...args];
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${SERVICE_NAME}</string>
+  <key>ProgramArguments</key>
+  <array>
+${segments.map((s) => `    <string>${escapeXml(s)}</string>`).join('\n')}
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <false/>
+</dict>
+</plist>
+`;
+}
+function buildLinuxDesktop({ command, args, }) {
+    const execLine = [command, ...args].map(shellEscape).join(' ');
+    return `[Desktop Entry]
+Type=Application
+Version=1.0
+Name=Otto
+Comment=Otto Discord Bot Daemon
+Exec=${execLine}
+StartupNotify=false
+Terminal=false
+`;
+}
+/**
+ * Register otto to start on user login.
+ * Writes the appropriate service file for the current platform.
+ */
+export async function enableStartupService({ command, args, }) {
+    const platform = process.platform;
+    if (platform === 'darwin') {
+        const filePath = getServiceFilePath();
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        fs.writeFileSync(filePath, buildMacOSPlist({ command, args }));
+    }
+    else if (platform === 'linux') {
+        const filePath = getServiceFilePath();
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        fs.writeFileSync(filePath, buildLinuxDesktop({ command, args }));
+    }
+    else if (platform === 'win32') {
+        const execLine = [command, ...args]
+            .map((s) => {
+            return s.includes(' ') ? `"${s}"` : s;
+        })
+            .join(' ');
+        await execAsync(`reg add "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run" /v otto /t REG_SZ /d "${execLine}" /f`);
+    }
+    else {
+        throw new Error(`Unsupported platform: ${platform}`);
+    }
+}
+/**
+ * Unregister otto from user login startup.
+ */
+export async function disableStartupService() {
+    const platform = process.platform;
+    if (platform === 'darwin' || platform === 'linux') {
+        const filePath = getServiceFilePath();
+        if (fs.existsSync(filePath)) {
+            fs.unlinkSync(filePath);
+        }
+    }
+    else if (platform === 'win32') {
+        await execAsync(`reg delete "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run" /v otto /f`).catch(() => {
+            // Key may not exist, ignore
+        });
+    }
+    else {
+        throw new Error(`Unsupported platform: ${platform}`);
+    }
+}
+/**
+ * Check if otto is registered as a startup service.
+ */
+export async function isStartupServiceEnabled() {
+    const platform = process.platform;
+    if (platform === 'darwin' || platform === 'linux') {
+        return fs.existsSync(getServiceFilePath());
+    }
+    if (platform === 'win32') {
+        const result = await execAsync(`reg query "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run" /v otto`).catch(() => {
+            return null;
+        });
+        return result !== null;
+    }
+    return false;
+}
+/**
+ * Get a human-readable description of the service location for status display.
+ */
+export function getServiceLocationDescription() {
+    const platform = process.platform;
+    if (platform === 'darwin') {
+        return `launchd: ${getServiceFilePath()}`;
+    }
+    if (platform === 'linux') {
+        return `XDG autostart: ${getServiceFilePath()}`;
+    }
+    if (platform === 'win32') {
+        return `registry: ${getServiceFilePath()}`;
+    }
+    return `unsupported platform: ${platform}`;
+}