@otto-assistant/otto 0.1.2 → 0.7.16

package/dist/upgrade.js

@@ -0,0 +1,156 @@
+// Otto self-upgrade utilities.
+// Detects the package manager used to install otto, checks npm for newer versions,
+// and runs the global upgrade command. Used by both CLI `otto upgrade` and
+// the Discord `/upgrade-and-restart` command, plus background auto-upgrade on startup.
+import fs from 'node:fs';
+import { createRequire } from 'node:module';
+import { createLogger, LogPrefix } from './logger.js';
+import { execAsync } from './worktrees.js';
+const logger = createLogger(LogPrefix.CLI);
+// Detects which package manager globally installed otto, used to run the
+// correct `<pm> i -g @otto-assistant/otto@latest` upgrade command.
+//
+// Detection order:
+// 1. npm_config_user_agent — set by npx/bunx/pnpm dlx, reliable for those cases
+// 2. Realpath of the running script — resolve symlinks and check if the path
+//    lives under a known PM global directory (e.g. ~/.bun, ~/Library/pnpm,
+//    /usr/local/lib/node_modules). Inspired by sindresorhus/global-directory.
+// 3. process.versions.bun — if the runtime itself is Bun, likely bun ecosystem
+// 4. Default to npm — safest fallback since npm is the most common global installer
+export function detectPm() {
+    const ua = process.env.npm_config_user_agent;
+    if (ua?.startsWith('bun/')) {
+        return 'bun';
+    }
+    if (ua?.startsWith('pnpm/')) {
+        return 'pnpm';
+    }
+    if (ua?.startsWith('npm/')) {
+        return 'npm';
+    }
+    const scriptPath = resolveScriptRealpath();
+    if (scriptPath) {
+        const p = scriptPath.toLowerCase();
+        // bun global installs live under ~/.bun or $BUN_INSTALL
+        if (p.includes('.bun/') || p.includes('/bun/install/')) {
+            return 'bun';
+        }
+        // pnpm global installs live under ~/Library/pnpm, ~/.local/share/pnpm, or $PNPM_HOME
+        if (p.includes('/pnpm/')) {
+            return 'pnpm';
+        }
+        // npm global installs typically live under lib/node_modules/@otto-assistant without
+        // any pnpm or bun path segments, so if we reach here it's likely npm
+    }
+    if (process.versions.bun) {
+        return 'bun';
+    }
+    return 'npm';
+}
+function resolveScriptRealpath() {
+    try {
+        const script = process.argv[1];
+        if (!script) {
+            return null;
+        }
+        return fs.realpathSync(script);
+    }
+    catch {
+        return null;
+    }
+}
+function getCliPackageJson() {
+    const require = createRequire(import.meta.url);
+    return require('../package.json');
+}
+export function getCurrentVersion() {
+    return getCliPackageJson().version;
+}
+function getPackageName() {
+    return getCliPackageJson().name;
+}
+export async function getLatestNpmVersion() {
+    try {
+        const packageName = encodeURIComponent(getPackageName());
+        const res = await fetch(`https://registry.npmjs.org/${packageName}/latest`, {
+            signal: AbortSignal.timeout(15_000),
+        });
+        if (!res.ok) {
+            return null;
+        }
+        const data = (await res.json());
+        return data.version;
+    }
+    catch {
+        return null;
+    }
+}
+const LEGACY_PACKAGE_NAME = '@otto-assistant/bridge';
+const CURRENT_PACKAGE_NAME = '@otto-assistant/otto';
+// Returns true if running under the old @otto-assistant/bridge package name.
+// When true, `upgrade()` will migrate to @otto-assistant/otto automatically.
+export function isLegacyPackageName() {
+    return getPackageName() === LEGACY_PACKAGE_NAME;
+}
+// Returns the new version string if upgraded (or migrated), null if already up to date.
+// If running as the legacy @otto-assistant/bridge package, migrates to
+// @otto-assistant/otto by installing the new package name globally.
+export async function upgrade() {
+    const current = getCurrentVersion();
+    // Migrate legacy package name: install @otto-assistant/otto and remove @otto-assistant/bridge
+    if (isLegacyPackageName()) {
+        const latest = await fetch(`https://registry.npmjs.org/${encodeURIComponent(CURRENT_PACKAGE_NAME)}/latest`, { signal: AbortSignal.timeout(15_000) })
+            .then((r) => (r.ok ? r.json() : null))
+            .then((d) => d?.version ?? null)
+            .catch(() => null);
+        const pm = detectPm();
+        logger.log(`Migrating from ${LEGACY_PACKAGE_NAME} to ${CURRENT_PACKAGE_NAME}${latest ? ` v${latest}` : ''} using ${pm}...`);
+        await execAsync(`${pm} i -g ${CURRENT_PACKAGE_NAME}@latest`, {
+            timeout: 120_000,
+        });
+        // Best-effort removal of the old package — non-fatal if it fails
+        await execAsync(`${pm} remove -g ${LEGACY_PACKAGE_NAME}`, {
+            timeout: 60_000,
+        }).catch(() => { });
+        return latest ?? current;
+    }
+    const latest = await getLatestNpmVersion();
+    if (!latest) {
+        throw new Error('Failed to check latest version from npm');
+    }
+    if (current === latest) {
+        return null;
+    }
+    const pm = detectPm();
+    const packageName = getPackageName();
+    logger.log(`Upgrading ${packageName} from v${current} to v${latest} using ${pm}...`);
+    await execAsync(`${pm} i -g ${packageName}@latest`, { timeout: 120_000 });
+    return latest;
+}
+// Fire-and-forget background upgrade check on bot startup.
+// Only upgrades if a newer version is available. Errors are silently ignored.
+export async function backgroundUpgradeOtto() {
+    try {
+        // Silently migrate legacy package name in the background
+        if (isLegacyPackageName()) {
+            const pm = detectPm();
+            logger.debug(`Background migration from ${LEGACY_PACKAGE_NAME} to ${CURRENT_PACKAGE_NAME}`);
+            await execAsync(`${pm} i -g ${CURRENT_PACKAGE_NAME}@latest`, { timeout: 120_000 });
+            await execAsync(`${pm} remove -g ${LEGACY_PACKAGE_NAME}`, { timeout: 60_000 }).catch(() => { });
+            return;
+        }
+        const current = getCurrentVersion();
+        const latest = await getLatestNpmVersion();
+        if (!latest || current === latest) {
+            return;
+        }
+        const pm = detectPm();
+        const packageName = getPackageName();
+        logger.debug(`Background ${packageName} upgrade started: v${current} -> v${latest}`);
+        await execAsync(`${pm} i -g ${packageName}@latest`, { timeout: 120_000 });
+        logger.debug(`Background ${packageName} upgrade completed: v${latest}`);
+    }
+    catch {
+        // silently ignored, non-critical
+    }
+}

package/dist/utils.js

@@ -0,0 +1,172 @@
+// General utility functions for the bot.
+// Includes Discord OAuth URL generation, array deduplication,
+// abort error detection, and date/time formatting helpers.
+import os from 'node:os';
+// Use namespace import for CJS interop — discord.js is CJS and its named
+// exports aren't detectable by all ESM loaders (e.g. tsx/esbuild) because
+// discord.js uses tslib's __exportStar which is opaque to static analysis.
+import * as discord from 'discord.js';
+const { PermissionsBitField } = discord;
+import * as errore from 'errore';
+export function generateBotInstallUrl({ clientId, permissions = [
+    PermissionsBitField.Flags.ViewChannel,
+    PermissionsBitField.Flags.ManageChannels,
+    PermissionsBitField.Flags.SendMessages,
+    PermissionsBitField.Flags.SendMessagesInThreads,
+    PermissionsBitField.Flags.CreatePublicThreads,
+    PermissionsBitField.Flags.ManageThreads,
+    PermissionsBitField.Flags.ReadMessageHistory,
+    PermissionsBitField.Flags.AddReactions,
+    PermissionsBitField.Flags.ManageMessages,
+    PermissionsBitField.Flags.UseExternalEmojis,
+    PermissionsBitField.Flags.AttachFiles,
+    PermissionsBitField.Flags.Connect,
+    PermissionsBitField.Flags.Speak,
+    PermissionsBitField.Flags.ManageRoles,
+    PermissionsBitField.Flags.ManageEvents,
+    PermissionsBitField.Flags.CreateEvents,
+], scopes = ['bot', 'applications.commands', 'identify', 'email'], guildId, disableGuildSelect = false, state, redirectUri, responseType, }) {
+    const permissionsBitField = new PermissionsBitField(permissions);
+    const permissionsValue = permissionsBitField.bitfield.toString();
+    const url = new URL('https://discord.com/api/oauth2/authorize');
+    url.searchParams.set('client_id', clientId);
+    url.searchParams.set('permissions', permissionsValue);
+    url.searchParams.set('scope', scopes.join(' '));
+    if (guildId) {
+        url.searchParams.set('guild_id', guildId);
+    }
+    if (disableGuildSelect) {
+        url.searchParams.set('disable_guild_select', 'true');
+    }
+    if (state) {
+        url.searchParams.set('state', state);
+    }
+    if (redirectUri) {
+        url.searchParams.set('redirect_uri', redirectUri);
+    }
+    if (responseType) {
+        url.searchParams.set('response_type', responseType);
+    }
+    return url.toString();
+}
+export const OTTO_GATEWAY_APP_ID = process.env.OTTO_GATEWAY_APP_ID || '1477605701202481173';
+export const OTTO_WEBSITE_URL = process.env.OTTO_WEBSITE_URL || 'https://otto.dev';
+export function getGatewayPlatformDisplayName({ gatewayPlatform, }) {
+    if (gatewayPlatform === 'telegram') {
+        return 'Telegram';
+    }
+    return 'Discord';
+}
+export function getGatewayInstallTargetName({ gatewayPlatform, }) {
+    if (gatewayPlatform === 'telegram') {
+        return 'chat';
+    }
+    return 'server';
+}
+export function shouldRegisterSlashCommands({ gatewayPlatform, }) {
+    return gatewayPlatform !== 'telegram';
+}
+export function generateDiscordInstallUrlForBot({ appId, mode, clientId, clientSecret, gatewayPlatform = 'discord', gatewayCallbackUrl, reachableUrl, }) {
+    if (mode !== 'gateway') {
+        return generateBotInstallUrl({ clientId: appId });
+    }
+    if (!clientId || !clientSecret) {
+        return new Error('Gateway credentials are missing from local database');
+    }
+    // In gateway mode, redirect to the website install route for the selected
+    // platform. Discord uses better-auth OAuth; Telegram uses manual token/chat
+    // submission in the install form.
+    // Use an otto-specific callback field name to avoid ambiguity with
+    // better-auth's own callbackURL state field.
+    const installPath = gatewayPlatform === 'telegram' ? '/telegram-install' : '/discord-install';
+    const url = new URL(`${OTTO_WEBSITE_URL}${installPath}`);
+    url.searchParams.set('clientId', clientId);
+    url.searchParams.set('clientSecret', clientSecret);
+    if (gatewayCallbackUrl) {
+        url.searchParams.set('ottoCallbackUrl', gatewayCallbackUrl);
+    }
+    if (reachableUrl) {
+        url.searchParams.set('reachableUrl', reachableUrl);
+    }
+    return url.toString();
+}
+export function buildOpenUrlCommand({ platform, url, }) {
+    if (platform === 'win32') {
+        return { command: 'cmd', args: ['/c', 'start', '', url] };
+    }
+    if (platform === 'darwin') {
+        return { command: 'open', args: [url] };
+    }
+    return { command: 'xdg-open', args: [url] };
+}
+export function deduplicateByKey(arr, keyFn) {
+    const seen = new Set();
+    return arr.filter((item) => {
+        const key = keyFn(item);
+        if (seen.has(key)) {
+            return false;
+        }
+        seen.add(key);
+        return true;
+    });
+}
+// Delegates to errore.isAbortError (walks cause chain for AbortError instances),
+// then falls back to opencode server-specific abort patterns that aren't
+// errore.AbortError but still represent aborted operations.
+export function isAbortError(error) {
+    if (errore.isAbortError(error))
+        return true;
+    if (!(error instanceof Error))
+        return false;
+    return (error.name === 'MessageAbortedError' ||
+        error.message?.includes('aborted') === true);
+}
+const rtf = new Intl.RelativeTimeFormat('en', { numeric: 'auto' });
+const TIME_DIVISIONS = [
+    { amount: 60, name: 'seconds' },
+    { amount: 60, name: 'minutes' },
+    { amount: 24, name: 'hours' },
+    { amount: 7, name: 'days' },
+    { amount: 4.34524, name: 'weeks' },
+    { amount: 12, name: 'months' },
+    { amount: Number.POSITIVE_INFINITY, name: 'years' },
+];
+export function formatDistanceToNow(date) {
+    let duration = (date.getTime() - Date.now()) / 1000;
+    for (const division of TIME_DIVISIONS) {
+        if (Math.abs(duration) < division.amount) {
+            return rtf.format(Math.round(duration), division.name);
+        }
+        duration /= division.amount;
+    }
+    return rtf.format(Math.round(duration), 'years');
+}
+const dtf = new Intl.DateTimeFormat('en-US', {
+    month: 'short',
+    day: 'numeric',
+    year: 'numeric',
+    hour: 'numeric',
+    minute: '2-digit',
+    hour12: true,
+});
+export function formatDateTime(date) {
+    return dtf.format(date);
+}
+// Comprehensive ANSI escape sequence regex covering CSI, OSC, and related sequences.
+// Valid string terminator sequences are BEL, ESC\, and 0x9c.
+const ANSI_REGEX = (() => {
+    const ST = '(?:\\u0007|\\u001B\\u005C|\\u009C)';
+    const osc = `(?:\\u001B\\][\\s\\S]*?${ST})`;
+    const csi = '[\\u001B\\u009B][[\\]()#;?]*(?:\\d{1,4}(?:[;:]\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]';
+    return new RegExp(`${osc}|${csi}`, 'g');
+})();
+export function stripAnsi(str) {
+    return str.replace(ANSI_REGEX, '');
+}
+export function abbreviatePath(fullPath) {
+    const home = os.homedir();
+    if (fullPath.startsWith(home)) {
+        return '~' + fullPath.slice(home.length);
+    }
+    return fullPath;
+}

package/dist/utils.test.js

@@ -0,0 +1,130 @@
+import { describe, expect, test } from 'vitest';
+import { buildOpenUrlCommand, generateDiscordInstallUrlForBot, getGatewayInstallTargetName, getGatewayPlatformDisplayName, shouldRegisterSlashCommands, } from './utils.js';
+describe('generateDiscordInstallUrlForBot', () => {
+    test('uses telegram install path in gateway mode', () => {
+        const result = generateDiscordInstallUrlForBot({
+            appId: 'app-id',
+            mode: 'gateway',
+            clientId: 'client-id',
+            clientSecret: 'client-secret',
+            gatewayPlatform: 'telegram',
+        });
+        expect(result).toBeTypeOf('string');
+        if (typeof result !== 'string') {
+            throw new Error('Expected install URL string');
+        }
+        const url = new URL(result);
+        expect(url.pathname).toBe('/telegram-install');
+        expect(url.searchParams.get('clientId')).toBe('client-id');
+        expect(url.searchParams.get('clientSecret')).toBe('client-secret');
+    });
+    test('uses discord install path by default in gateway mode', () => {
+        const result = generateDiscordInstallUrlForBot({
+            appId: 'app-id',
+            mode: 'gateway',
+            clientId: 'client-id',
+            clientSecret: 'client-secret',
+        });
+        expect(result).toBeTypeOf('string');
+        if (typeof result !== 'string') {
+            throw new Error('Expected install URL string');
+        }
+        const url = new URL(result);
+        expect(url.pathname).toBe('/discord-install');
+        expect(url.searchParams.get('clientId')).toBe('client-id');
+        expect(url.searchParams.get('clientSecret')).toBe('client-secret');
+    });
+    test('includes callback and reachable URL query params when provided', () => {
+        const callbackUrl = 'https://example.com/callback?foo=bar';
+        const reachableUrl = 'https://example-ngrok.test';
+        const result = generateDiscordInstallUrlForBot({
+            appId: 'app-id',
+            mode: 'gateway',
+            clientId: 'client-id',
+            clientSecret: 'client-secret',
+            gatewayPlatform: 'telegram',
+            gatewayCallbackUrl: callbackUrl,
+            reachableUrl,
+        });
+        expect(result).toBeTypeOf('string');
+        if (typeof result !== 'string') {
+            throw new Error('Expected install URL string');
+        }
+        const url = new URL(result);
+        expect(url.searchParams.get('ottoCallbackUrl')).toBe(callbackUrl);
+        expect(url.searchParams.get('reachableUrl')).toBe(reachableUrl);
+    });
+    test('returns error when gateway credentials are missing', () => {
+        const result = generateDiscordInstallUrlForBot({
+            appId: 'app-id',
+            mode: 'gateway',
+            clientId: null,
+            clientSecret: null,
+            gatewayPlatform: 'telegram',
+        });
+        expect(result).toBeInstanceOf(Error);
+        if (!(result instanceof Error)) {
+            throw new Error('Expected Error result');
+        }
+        expect(result.message).toContain('Gateway credentials are missing');
+    });
+});
+describe('gateway platform helpers', () => {
+    test('returns display names and install target names', () => {
+        expect(getGatewayPlatformDisplayName({ gatewayPlatform: 'discord' })).toBe('Discord');
+        expect(getGatewayPlatformDisplayName({ gatewayPlatform: 'telegram' })).toBe('Telegram');
+        expect(getGatewayInstallTargetName({ gatewayPlatform: 'discord' })).toBe('server');
+        expect(getGatewayInstallTargetName({ gatewayPlatform: 'telegram' })).toBe('chat');
+    });
+    test('registers slash commands only for discord gateway', () => {
+        expect(shouldRegisterSlashCommands({ gatewayPlatform: 'discord' })).toBe(true);
+        expect(shouldRegisterSlashCommands({ gatewayPlatform: 'telegram' })).toBe(false);
+    });
+});
+describe('buildOpenUrlCommand', () => {
+    test('uses cmd start on windows', () => {
+        const result = buildOpenUrlCommand({
+            platform: 'win32',
+            url: 'https://example.com/path?x=1',
+        });
+        expect(result).toMatchInlineSnapshot(`
+      {
+        "args": [
+          "/c",
+          "start",
+          "",
+          "https://example.com/path?x=1",
+        ],
+        "command": "cmd",
+      }
+    `);
+    });
+    test('uses open on macOS', () => {
+        const result = buildOpenUrlCommand({
+            platform: 'darwin',
+            url: 'https://example.com/path?x=1',
+        });
+        expect(result).toMatchInlineSnapshot(`
+      {
+        "args": [
+          "https://example.com/path?x=1",
+        ],
+        "command": "open",
+      }
+    `);
+    });
+    test('uses xdg-open on linux', () => {
+        const result = buildOpenUrlCommand({
+            platform: 'linux',
+            url: 'https://example.com/path?x=1',
+        });
+        expect(result).toMatchInlineSnapshot(`
+      {
+        "args": [
+          "https://example.com/path?x=1",
+        ],
+        "command": "xdg-open",
+      }
+    `);
+    });
+});

package/dist/voice-attachment.js

@@ -0,0 +1,34 @@
+// Voice attachment detection helpers.
+// Normalizes Discord attachment heuristics for voice-message detection so
+// message routing, transcription, and empty-prompt guards all agree even when
+// Discord omits contentType on uploaded audio attachments.
+import path from 'node:path';
+const VOICE_ATTACHMENT_EXTENSIONS = new Set([
+    '.m4a',
+    '.mp3',
+    '.mp4',
+    '.oga',
+    '.ogg',
+    '.opus',
+    '.wav',
+]);
+export function getVoiceAttachmentMatchReason(attachment) {
+    const contentType = attachment.contentType?.trim().toLowerCase() || '';
+    if (contentType.startsWith('audio/')) {
+        return `contentType:${contentType}`;
+    }
+    if (typeof attachment.duration === 'number' && attachment.duration > 0) {
+        return `duration:${attachment.duration}`;
+    }
+    if (attachment.waveform?.trim()) {
+        return 'waveform';
+    }
+    const extension = path.extname(attachment.name || '').toLowerCase();
+    if (VOICE_ATTACHMENT_EXTENSIONS.has(extension)) {
+        return `extension:${extension}`;
+    }
+    return null;
+}
+export function isVoiceAttachment(attachment) {
+    return getVoiceAttachmentMatchReason(attachment) !== null;
+}