@otto-assistant/bridge 0.4.97 → 0.4.101

package/src/cli-send-thread.e2e.test.ts

@@ -339,14 +339,13 @@ describe('kimaki send --channel thread creation', () => {
         })
 
         const allContent = botReplies.map((m) => {
-          return m.content.slice(0, 200)
+          return m.content
         })
-        expect(allContent).toMatchInlineSnapshot(`
-          [
-            "✗ opencode session error: Command not found: "hello-test". Available commands: init, review, goke, security-review, jitter, proxyman, gitchamber, event-sourcing-state, usecomputer, spiceflow, batch, x",
-            "✗ OpenCode API error: Command not found: "hello-test". Available commands: init, review, goke, security-review, jitter, proxyman, gitchamber, event-sourcing-state, usecomputer, spiceflow, batch, x-art",
-          ]
-        `)
+        expect(
+          allContent.some((content) => {
+            return content.includes('Command not found: "hello-test"')
+          }),
+        ).toBe(true)
       } finally {
         store.setState({ registeredUserCommands: prevCommands })
       }

package/src/cli.ts

@@ -141,7 +141,7 @@ const cliLogger = createLogger(LogPrefix.CLI)
 // These are hardcoded because they're deploy-time constants for the gateway infrastructure.
 const KIMAKI_GATEWAY_PROXY_URL =
   process.env.KIMAKI_GATEWAY_PROXY_URL ||
-  'wss://discord-gateway.kimaki.xyz'
+  'wss://discord-gateway.kimaki.dev'
 
 const KIMAKI_GATEWAY_PROXY_REST_BASE_URL = getGatewayProxyRestBaseUrl({
   gatewayUrl: KIMAKI_GATEWAY_PROXY_URL,
@@ -3792,7 +3792,7 @@ cli
         port,
         tunnelId: options.tunnelId,
         localHost: options.host,
-        baseDomain: 'kimaki.xyz',
+        baseDomain: 'kimaki.dev',
         serverUrl: options.server,
         command: command.length > 0 ? command : undefined,
         kill: options.kill,

package/src/commands/login.ts

@@ -129,6 +129,8 @@ const PROVIDER_POPULARITY_ORDER: string[] = [
   'xai',
   'groq',
   'deepseek',
+  'opencode',
+  'opencode-go',
   'mistral',
   'openrouter',
   'fireworks-ai',
@@ -137,12 +139,12 @@ const PROVIDER_POPULARITY_ORDER: string[] = [
   'azure',
   'google-vertex',
   'google-vertex-anthropic',
-  'cohere',
+  // 'cohere',
   'cerebras',
-  'perplexity',
+  // 'perplexity',
   'cloudflare-workers-ai',
-  'novita-ai',
-  'huggingface',
+  // 'novita-ai',
+  // 'huggingface',
   'deepinfra',
   'github-models',
   'lmstudio',

package/src/commands/screenshare.test.ts

@@ -17,12 +17,12 @@ describe('screenshare security defaults', () => {
 
   test('builds a secure noVNC URL', () => {
     const url = new URL(
-      buildNoVncUrl({ tunnelHost: '0123456789abcdef-tunnel.kimaki.xyz' }),
+      buildNoVncUrl({ tunnelHost: '0123456789abcdef-tunnel.kimaki.dev' }),
     )
 
     expect(url.origin).toBe('https://novnc.com')
     expect(url.searchParams.get('host')).toBe(
-      '0123456789abcdef-tunnel.kimaki.xyz',
+      '0123456789abcdef-tunnel.kimaki.dev',
     )
     expect(url.searchParams.get('port')).toBe('443')
     expect(url.searchParams.get('encrypt')).toBe('1')

package/src/commands/screenshare.ts

@@ -40,7 +40,7 @@ const activeSessions = new Map<string, ScreenshareSession>()
 const VNC_PORT = 5900
 const MAX_SESSION_MINUTES = 30
 const MAX_SESSION_MS = MAX_SESSION_MINUTES * 60 * 1000
-const TUNNEL_BASE_DOMAIN = 'kimaki.xyz'
+const TUNNEL_BASE_DOMAIN = 'kimaki.dev'
 const SCREENSHARE_TUNNEL_ID_BYTES = 16
 
 // Public noVNC client — we point it at our tunnel URL

package/src/commands/vscode.ts

@@ -0,0 +1,342 @@
+import crypto from 'node:crypto'
+import { spawn, type ChildProcess } from 'node:child_process'
+import net from 'node:net'
+import {
+  ChannelType,
+  MessageFlags,
+  type TextChannel,
+  type ThreadChannel,
+} from 'discord.js'
+import { TunnelClient } from 'traforo/client'
+import type { CommandContext } from './types.js'
+import {
+  resolveWorkingDirectory,
+  SILENT_MESSAGE_FLAGS,
+} from '../discord-utils.js'
+import { createLogger } from '../logger.js'
+
+const logger = createLogger('VSCODE')
+const SECURE_REPLY_FLAGS = MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS
+const MAX_SESSION_MINUTES = 30
+const MAX_SESSION_MS = MAX_SESSION_MINUTES * 60 * 1000
+const TUNNEL_BASE_DOMAIN = 'kimaki.dev'
+const TUNNEL_ID_BYTES = 16
+const READY_TIMEOUT_MS = 60_000
+const LOCAL_HOST = '127.0.0.1'
+
+export type VscodeSession = {
+  coderaftProcess: ChildProcess
+  tunnelClient: TunnelClient
+  url: string
+  workingDirectory: string
+  startedBy: string
+  startedAt: number
+  timeoutTimer: ReturnType<typeof setTimeout>
+}
+
+const activeSessions = new Map<string, VscodeSession>()
+
+export function createVscodeTunnelId(): string {
+  return crypto.randomBytes(TUNNEL_ID_BYTES).toString('hex')
+}
+
+export function buildCoderaftArgs({
+  port,
+  workingDirectory,
+}: {
+  port: number
+  workingDirectory: string
+}): string[] {
+  return [
+    'coderaft',
+    '--port',
+    String(port),
+    '--host',
+    LOCAL_HOST,
+    '--without-connection-token',
+    '--disable-workspace-trust',
+    '--default-folder',
+    workingDirectory,
+  ]
+}
+
+function createPortWaiter({
+  port,
+  process: proc,
+  timeoutMs,
+}: {
+  port: number
+  process: ChildProcess
+  timeoutMs: number
+}): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const maxAttempts = Math.ceil(timeoutMs / 100)
+    let attempts = 0
+
+    const check = (): void => {
+      if (proc.exitCode !== null) {
+        reject(new Error(`coderaft exited with code ${proc.exitCode} before becoming ready`))
+        return
+      }
+
+      const socket = net.createConnection(port, LOCAL_HOST)
+      socket.on('connect', () => {
+        socket.destroy()
+        resolve()
+      })
+      socket.on('error', () => {
+        socket.destroy()
+        attempts += 1
+        if (attempts >= maxAttempts) {
+          reject(new Error(`Port ${port} not reachable after ${timeoutMs}ms`))
+          return
+        }
+        setTimeout(check, 100)
+      })
+    }
+
+    check()
+  })
+}
+
+function getAvailablePort(): Promise<number> {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer()
+    server.on('error', reject)
+    server.listen(0, LOCAL_HOST, () => {
+      const address = server.address()
+      if (!address || typeof address === 'string') {
+        server.close(() => {
+          reject(new Error('Failed to resolve an available port'))
+        })
+        return
+      }
+      const port = address.port
+      server.close((error) => {
+        if (error) {
+          reject(error)
+          return
+        }
+        resolve(port)
+      })
+    })
+  })
+}
+
+function cleanupSession(session: VscodeSession): void {
+  clearTimeout(session.timeoutTimer)
+  try {
+    session.tunnelClient.close()
+  } catch {}
+  if (session.coderaftProcess.exitCode === null) {
+    try {
+      session.coderaftProcess.kill('SIGTERM')
+    } catch {}
+  }
+}
+
+export function getActiveVscodeSession({ sessionKey }: { sessionKey: string }): VscodeSession | undefined {
+  return activeSessions.get(sessionKey)
+}
+
+export function stopVscode({ sessionKey }: { sessionKey: string }): boolean {
+  const session = activeSessions.get(sessionKey)
+  if (!session) {
+    return false
+  }
+
+  activeSessions.delete(sessionKey)
+  cleanupSession(session)
+  logger.log(`VS Code stopped (key: ${sessionKey})`)
+  return true
+}
+
+export async function startVscode({
+  sessionKey,
+  startedBy,
+  workingDirectory,
+}: {
+  sessionKey: string
+  startedBy: string
+  workingDirectory: string
+}): Promise<VscodeSession> {
+  const existing = activeSessions.get(sessionKey)
+  if (existing) {
+    return existing
+  }
+
+  const port = await getAvailablePort()
+  const tunnelId = createVscodeTunnelId()
+  const args = buildCoderaftArgs({
+    port,
+    workingDirectory,
+  })
+  const coderaftProcess = spawn('bunx', args, {
+    cwd: workingDirectory,
+    stdio: ['ignore', 'pipe', 'pipe'],
+    env: {
+      ...process.env,
+      PORT: String(port),
+    },
+  })
+
+  coderaftProcess.stdout?.on('data', (data: Buffer) => {
+    logger.log(data.toString().trim())
+  })
+  coderaftProcess.stderr?.on('data', (data: Buffer) => {
+    logger.error(data.toString().trim())
+  })
+
+  try {
+    await createPortWaiter({
+      port,
+      process: coderaftProcess,
+      timeoutMs: READY_TIMEOUT_MS,
+    })
+  } catch (error) {
+    if (coderaftProcess.exitCode === null) {
+      coderaftProcess.kill('SIGTERM')
+    }
+    throw error
+  }
+
+  const tunnelClient = new TunnelClient({
+    localPort: port,
+    localHost: LOCAL_HOST,
+    tunnelId,
+    baseDomain: TUNNEL_BASE_DOMAIN,
+  })
+
+  try {
+    await Promise.race([
+      tunnelClient.connect(),
+      new Promise<never>((_, reject) => {
+        setTimeout(() => {
+          reject(new Error('Tunnel connection timed out after 15s'))
+        }, 15_000)
+      }),
+    ])
+  } catch (error) {
+    tunnelClient.close()
+    if (coderaftProcess.exitCode === null) {
+      coderaftProcess.kill('SIGTERM')
+    }
+    throw error
+  }
+
+  const url = tunnelClient.url
+
+  const timeoutTimer = setTimeout(() => {
+    logger.log(`VS Code auto-stopped after ${MAX_SESSION_MINUTES} minutes (key: ${sessionKey})`)
+    stopVscode({ sessionKey })
+  }, MAX_SESSION_MS)
+  timeoutTimer.unref()
+
+  const session: VscodeSession = {
+    coderaftProcess,
+    tunnelClient,
+    url,
+    workingDirectory,
+    startedBy,
+    startedAt: Date.now(),
+    timeoutTimer,
+  }
+
+  coderaftProcess.once('exit', (code, signal) => {
+    const current = activeSessions.get(sessionKey)
+    if (current !== session) {
+      return
+    }
+    logger.log(`VS Code process exited (key: ${sessionKey}, code: ${code}, signal: ${signal ?? 'none'})`)
+    stopVscode({ sessionKey })
+  })
+
+  activeSessions.set(sessionKey, session)
+  logger.log(`VS Code started by ${startedBy}: ${url}`)
+  return session
+}
+
+export async function handleVscodeCommand({
+  command,
+}: CommandContext): Promise<void> {
+  const channel = command.channel
+  if (!channel) {
+    await command.reply({
+      content: 'This command can only be used in a channel.',
+      flags: SECURE_REPLY_FLAGS,
+    })
+    return
+  }
+
+  const isThread = [
+    ChannelType.PublicThread,
+    ChannelType.PrivateThread,
+    ChannelType.AnnouncementThread,
+  ].includes(channel.type)
+  const isTextChannel = channel.type === ChannelType.GuildText
+  if (!isThread && !isTextChannel) {
+    await command.reply({
+      content: 'This command can only be used in a text channel or thread.',
+      flags: SECURE_REPLY_FLAGS,
+    })
+    return
+  }
+
+  const resolved = await resolveWorkingDirectory({
+    channel: channel as TextChannel | ThreadChannel,
+  })
+  if (!resolved) {
+    await command.reply({
+      content: 'Could not determine project directory for this channel.',
+      flags: SECURE_REPLY_FLAGS,
+    })
+    return
+  }
+
+  await command.deferReply({ flags: SECURE_REPLY_FLAGS })
+
+  const sessionKey = channel.id
+  const existing = getActiveVscodeSession({ sessionKey })
+  if (existing) {
+    await command.editReply({
+      content:
+        `VS Code is already running for this thread. ` +
+        `This unique tunnel auto-stops after ${MAX_SESSION_MINUTES} minutes from startup.\n` +
+        `${existing.url}`,
+    })
+    return
+  }
+
+  try {
+    const session = await startVscode({
+      sessionKey,
+      startedBy: command.user.tag,
+      workingDirectory: resolved.workingDirectory,
+    })
+    await command.editReply({
+      content:
+        `VS Code started for \`${session.workingDirectory}\`. ` +
+        `This unique tunnel auto-stops after ${MAX_SESSION_MINUTES} minutes, so open it before it expires.\n` +
+        `${session.url}`,
+    })
+  } catch (error) {
+    logger.error('Failed to start VS Code:', error)
+    await command.editReply({
+      content: `Failed to start VS Code: ${error instanceof Error ? error.message : String(error)}`,
+    })
+  }
+}
+
+export function cleanupAllVscodeSessions(): void {
+  for (const sessionKey of activeSessions.keys()) {
+    stopVscode({ sessionKey })
+  }
+}
+
+function onProcessExit(): void {
+  cleanupAllVscodeSessions()
+}
+
+process.on('SIGINT', onProcessExit)
+process.on('SIGTERM', onProcessExit)
+process.on('exit', onProcessExit)

package/src/context-awareness-plugin.ts

@@ -1,7 +1,6 @@
 // OpenCode plugin that injects synthetic message parts for context awareness:
 // - Git branch / detached HEAD changes
 // - Working directory (pwd) changes (e.g. after /new-worktree mid-session)
-// - MEMORY.md table of contents on first message
 // - MEMORY.md reminder after a large assistant reply
 // - Onboarding tutorial instructions (when TUTORIAL_WELCOME_TEXT detected)
 //
@@ -18,8 +17,6 @@
 
 import type { Plugin } from '@opencode-ai/plugin'
 import crypto from 'node:crypto'
-import fs from 'node:fs'
-import path from 'node:path'
 import * as errore from 'errore'
 import {
   createPluginLogger,
@@ -29,7 +26,6 @@ import {
 import { setDataDir } from './config.js'
 import { initSentry, notifyError } from './sentry.js'
 import { execAsync } from './exec-async.js'
-import { condenseMemoryMd } from './condense-memory.js'
 import {
   ONBOARDING_TUTORIAL_INSTRUCTIONS,
   TUTORIAL_WELCOME_TEXT,
@@ -49,7 +45,6 @@ type GitState = {
 // All per-session mutable state in one place. One Map entry, one delete.
 type SessionState = {
   gitState: GitState | undefined
-  memoryInjected: boolean
   lastMemoryReminderAssistantMessageId: string | undefined
   tutorialInjected: boolean
   // Last directory observed via session.get(). Refreshed on each real user
@@ -60,17 +55,6 @@ type SessionState = {
   announcedDirectory: string | undefined
 }
 
-function createSessionState(): SessionState {
-  return {
-    gitState: undefined,
-    memoryInjected: false,
-    lastMemoryReminderAssistantMessageId: undefined,
-    tutorialInjected: false,
-    resolvedDirectory: undefined,
-    announcedDirectory: undefined,
-  }
-}
-
 // Minimal type for the opencode plugin client (v1 SDK style with path objects).
 type PluginClient = {
   session: {
@@ -147,10 +131,6 @@ type AssistantMessageInfo = {
   tokens?: AssistantTokenUsage
 }
 
-function getOutputTokenTotal(tokens: AssistantTokenUsage): number {
-  return Math.max(0, tokens.output + tokens.reasoning)
-}
-
 export function shouldInjectMemoryReminderFromLatestAssistant({
   lastMemoryReminderAssistantMessageId,
   latestAssistantMessage,
@@ -175,7 +155,10 @@ export function shouldInjectMemoryReminderFromLatestAssistant({
   if (lastMemoryReminderAssistantMessageId === latestAssistantMessage.id) {
     return { inject: false }
   }
-  const outputTokens = getOutputTokenTotal(latestAssistantMessage.tokens)
+  const outputTokens = Math.max(
+    0,
+    latestAssistantMessage.tokens.output + latestAssistantMessage.tokens.reasoning,
+  )
   if (outputTokens < threshold) {
     return { inject: false }
   }
@@ -311,7 +294,13 @@ const contextAwarenessPlugin: Plugin = async ({ directory, client }) => {
     if (existing) {
       return existing
     }
-    const state = createSessionState()
+    const state: SessionState = {
+      gitState: undefined,
+      lastMemoryReminderAssistantMessageId: undefined,
+      tutorialInjected: false,
+      resolvedDirectory: undefined,
+      announcedDirectory: undefined,
+    }
     sessions.set(sessionID, state)
     return state
   }
@@ -412,26 +401,6 @@ const contextAwarenessPlugin: Plugin = async ({ directory, client }) => {
             })
           }
 
-          // -- MEMORY.md injection --
-          if (!state.memoryInjected) {
-            state.memoryInjected = true
-            const memoryPath = path.join(effectiveDirectory, 'MEMORY.md')
-            const memoryContent = await fs.promises
-              .readFile(memoryPath, 'utf-8')
-              .catch(() => null)
-            if (memoryContent) {
-              const condensed = condenseMemoryMd(memoryContent)
-              output.parts.push({
-                id: `prt_${crypto.randomUUID()}`,
-                sessionID,
-                messageID,
-                type: 'text' as const,
-                text: `<system-reminder>Project memory from MEMORY.md (condensed table of contents, line numbers shown):\n${condensed}\nOnly headings are shown above — section bodies are hidden. Use Grep to search MEMORY.md for specific topics, or Read with offset and limit to read a section's content. When writing to MEMORY.md, keep titles concise (under 10 words) and content brief (2-3 sentences max). Only track non-obvious learnings that prevent future mistakes and are not already documented in code comments or AGENTS.md. Do not duplicate information that is self-evident from the code.</system-reminder>`,
-                synthetic: true,
-              })
-            }
-          }
-
           const memoryReminder = shouldInjectMemoryReminderFromLatestAssistant({
             lastMemoryReminderAssistantMessageId:
               state.lastMemoryReminderAssistantMessageId,

package/src/db.ts

@@ -235,6 +235,7 @@ async function migrateSchema(prisma: PrismaClient): Promise<void> {
   // Also fix NULL worktree status rows that predate the required enum.
   const defensiveMigrations = [
     "UPDATE bot_tokens SET bot_mode = 'self_hosted' WHERE bot_mode = 'self-hosted'",
+    "UPDATE bot_tokens SET proxy_url = REPLACE(proxy_url, 'discord-gateway.kimaki.xyz', 'discord-gateway.kimaki.dev') WHERE bot_mode = 'gateway' AND proxy_url LIKE '%discord-gateway.kimaki.xyz%'",
     "UPDATE thread_worktrees SET status = 'pending' WHERE status IS NULL",
   ]
   for (const stmt of defensiveMigrations) {

package/src/discord-command-registration.ts

@@ -488,6 +488,13 @@ export async function registerCommands({
       .setDescription(truncateCommandDescription('Stop screen sharing'))
       .setDMPermission(false)
       .toJSON(),
+    new SlashCommandBuilder()
+      .setName('vscode')
+      .setDescription(
+        truncateCommandDescription('Open VS Code in the browser for this project or worktree (auto-stops after 30 minutes)'),
+      )
+      .setDMPermission(false)
+      .toJSON(),
   ]
 
   // Dynamic commands are registered in priority order: agents → user commands → skills → MCP prompts.

package/src/gateway-proxy-reconnect.e2e.test.ts

@@ -6,7 +6,7 @@
 //   Starts a digital-twin + local gateway-proxy binary, kills and restarts the proxy.
 //
 // Production mode (env vars):
-//   GATEWAY_TEST_URL        - production gateway WS+REST URL (e.g. wss://discord-gateway.kimaki.xyz)
+//   GATEWAY_TEST_URL        - production gateway WS+REST URL (e.g. wss://discord-gateway.kimaki.dev)
 //   GATEWAY_TEST_TOKEN      - client token (clientId:secret)
 //   GATEWAY_TEST_REDEPLOY   - if "1", runs `fly deploy` between kill/restart instead of local binary
 //
@@ -15,7 +15,7 @@
 //   pnpm test --run src/gateway-proxy-reconnect.e2e.test.ts
 //
 //   # Against production (just connect + kill WS + wait for reconnect):
-//   GATEWAY_TEST_URL=wss://discord-gateway.kimaki.xyz \
+//   GATEWAY_TEST_URL=wss://discord-gateway.kimaki.dev \
 //   GATEWAY_TEST_TOKEN=myclientid:mysecret \
 //   KIMAKI_TEST_LOGS=1 \
 //   pnpm test --run src/gateway-proxy-reconnect.e2e.test.ts -t "production"

package/src/interaction-handler.ts

@@ -101,6 +101,7 @@ import {
   handleScreenshareCommand,
   handleScreenshareStopCommand,
 } from './commands/screenshare.js'
+import { handleVscodeCommand } from './commands/vscode.js'
 import { handleModelVariantSelectMenu } from './commands/model.js'
 import {
   handleModelVariantCommand,
@@ -356,6 +357,10 @@ export function registerInteractionHandler({
                 appId,
               })
               return
+
+            case 'vscode':
+              await handleVscodeCommand({ command: interaction, appId })
+              return
           }
 
           // Handle quick agent commands (ending with -agent suffix, but not the base /agent command)

package/src/kimaki-opencode-plugin.ts

@@ -5,12 +5,14 @@
 //
 // Plugins are split into focused modules:
 // - ipc-tools-plugin: file upload + action buttons (IPC-based Discord tools)
-// - context-awareness-plugin: branch, pwd, memory, time gap, onboarding tutorial
+// - context-awareness-plugin: branch, pwd, memory reminder, onboarding tutorial
+// - memory-overview-plugin: frozen MEMORY.md heading overview per session
 // - opencode-interrupt-plugin: interrupt queued messages at step boundaries
 // - kitty-graphics-plugin: extract Kitty Graphics Protocol images from bash output
 
 export { ipcToolsPlugin } from './ipc-tools-plugin.js'
 export { contextAwarenessPlugin } from './context-awareness-plugin.js'
+export { memoryOverviewPlugin } from './memory-overview-plugin.js'
 export { interruptOpencodeSessionOnUserMessage } from './opencode-interrupt-plugin.js'
 export { systemPromptDriftPlugin } from './system-prompt-drift-plugin.js'
 export { anthropicAuthPlugin } from './anthropic-auth-plugin.js'