kimaki 0.4.18 → 0.4.20

package/dist/xai-realtime.js

@@ -0,0 +1,95 @@
+import WebSocket from 'ws';
+import { createLogger } from './logger.js';
+const xaiLogger = createLogger('XAI');
+export class XaiRealtimeClient {
+    ws = null;
+    apiKey;
+    baseUrl = 'wss://api.x.ai/v1/realtime';
+    callbacks;
+    isConnected = false;
+    constructor(options) {
+        this.apiKey = options.apiKey;
+        this.callbacks = options.callbacks || {};
+    }
+    async connect() {
+        return new Promise((resolve, reject) => {
+            this.ws = new WebSocket(this.baseUrl, {
+                headers: {
+                    Authorization: `Bearer ${this.apiKey}`,
+                },
+            });
+            this.ws.on('open', () => {
+                xaiLogger.log('WebSocket connected');
+                this.isConnected = true;
+                this.callbacks.onOpen?.();
+                resolve();
+            });
+            this.ws.on('message', (data) => {
+                try {
+                    const event = JSON.parse(data.toString());
+                    this.callbacks.onMessage?.(event);
+                }
+                catch (error) {
+                    xaiLogger.error('Failed to parse message:', error);
+                }
+            });
+            this.ws.on('error', (error) => {
+                xaiLogger.error('WebSocket error:', error);
+                this.callbacks.onError?.(error);
+                if (!this.isConnected) {
+                    reject(error);
+                }
+            });
+            this.ws.on('close', (code, reason) => {
+                xaiLogger.log('WebSocket closed:', code, reason.toString());
+                this.isConnected = false;
+                this.callbacks.onClose?.({ code, reason: reason.toString() });
+            });
+        });
+    }
+    send(event) {
+        if (!this.ws || !this.isConnected) {
+            throw new Error('WebSocket is not connected');
+        }
+        this.ws.send(JSON.stringify(event));
+    }
+    updateSession(session) {
+        this.send({ type: 'session.update', session });
+    }
+    appendInputAudio(base64Audio) {
+        this.send({ type: 'input_audio_buffer.append', audio: base64Audio });
+    }
+    commitInputAudio() {
+        this.send({ type: 'input_audio_buffer.commit' });
+    }
+    clearInputAudio() {
+        this.send({ type: 'input_audio_buffer.clear' });
+    }
+    createConversationItem(item, previousItemId) {
+        this.send({
+            type: 'conversation.item.create',
+            previous_item_id: previousItemId,
+            item,
+        });
+    }
+    sendFunctionCallOutput(callId, output) {
+        this.createConversationItem({
+            type: 'function_call_output',
+            call_id: callId,
+            output,
+        });
+    }
+    createResponse(modalities) {
+        this.send({ type: 'response.create', response: modalities ? { modalities } : undefined });
+    }
+    close() {
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+            this.isConnected = false;
+        }
+    }
+    get connected() {
+        return this.isConnected;
+    }
+}

package/package.json

@@ -2,7 +2,7 @@
   "name": "kimaki",
   "module": "index.ts",
   "type": "module",
-  "version": "0.4.18",
+  "version": "0.4.20",
   "scripts": {
     "dev": "tsx --env-file .env src/cli.ts",
     "prepublishOnly": "pnpm tsc",
@@ -21,7 +21,7 @@
     "bin.js"
   ],
   "devDependencies": {
-    "@opencode-ai/plugin": "^1.0.119",
+    "@opencode-ai/plugin": "^1.0.193",
     "@types/better-sqlite3": "^7.6.13",
     "@types/bun": "latest",
     "@types/js-yaml": "^4.0.9",
@@ -30,15 +30,15 @@
     "tsx": "^4.20.5"
   },
   "dependencies": {
-    "@ai-sdk/google": "^2.0.16",
+    "@ai-sdk/google": "^2.0.47",
     "@clack/prompts": "^0.11.0",
     "@discordjs/opus": "^0.10.0",
     "@discordjs/voice": "^0.19.0",
-    "@google/genai": "^1.16.0",
-    "@opencode-ai/sdk": "^1.0.115",
+    "@google/genai": "^1.34.0",
+    "@opencode-ai/sdk": "^1.0.193",
     "@purinton/resampler": "^1.0.4",
     "@snazzah/davey": "^0.1.6",
-    "ai": "^5.0.29",
+    "ai": "^5.0.114",
     "better-sqlite3": "^12.3.0",
     "cac": "^6.7.14",
     "date-fns": "^4.1.0",
@@ -53,6 +53,6 @@
     "prism-media": "^1.3.5",
     "string-dedent": "^3.0.2",
     "undici": "^7.16.0",
-    "zod": "^4.0.17"
+    "zod": "^4.2.1"
   }
 }

package/src/cli.ts

@@ -37,29 +37,48 @@ import {
 } from 'discord.js'
 import path from 'node:path'
 import fs from 'node:fs'
-import { createRequire } from 'node:module'
-import os from 'node:os'
+
+
 import { createLogger } from './logger.js'
 import { spawn, spawnSync, execSync, type ExecSyncOptions } from 'node:child_process'
+import http from 'node:http'
 
 const cliLogger = createLogger('CLI')
 const cli = cac('kimaki')
 
 process.title = 'kimaki'
 
-process.on('SIGUSR2', () => {
-  cliLogger.info('Received SIGUSR2, restarting process in 1000ms...')
-  setTimeout(() => {
-    cliLogger.info('Restarting...')
-    spawn(process.argv[0]!, [...process.execArgv, ...process.argv.slice(1)], {
-      stdio: 'inherit',
-      detached: true,
-      cwd: process.cwd(),
-      env: process.env,
-    }).unref()
-    process.exit(0)
-  }, 1000)
-})
+const LOCK_PORT = 29988
+
+async function checkSingleInstance(): Promise<void> {
+  try {
+    const response = await fetch(`http://127.0.0.1:${LOCK_PORT}`, {
+      signal: AbortSignal.timeout(1000),
+    })
+    if (response.ok) {
+      cliLogger.error('Another kimaki instance is already running')
+      process.exit(1)
+    }
+  } catch {
+    // Connection refused means no instance running, continue
+  }
+}
+
+function startLockServer(): void {
+  const server = http.createServer((req, res) => {
+    res.writeHead(200)
+    res.end('kimaki')
+  })
+  server.listen(LOCK_PORT, '127.0.0.1')
+  server.on('error', (err: NodeJS.ErrnoException) => {
+    if (err.code === 'EADDRINUSE') {
+      cliLogger.error('Another kimaki instance is already running')
+      process.exit(1)
+    }
+  })
+}
+
+
 
 const EXIT_NO_RESTART = 64
 
@@ -129,6 +148,18 @@ async function registerCommands(token: string, appId: string) {
         return option
       })
       .toJSON(),
+    new SlashCommandBuilder()
+      .setName('add-new-project')
+      .setDescription('Create a new project folder, initialize git, and start a session')
+      .addStringOption((option) => {
+        option
+          .setName('name')
+          .setDescription('Name for the new project folder')
+          .setRequired(true)
+
+        return option
+      })
+      .toJSON(),
     new SlashCommandBuilder()
       .setName('accept')
       .setDescription('Accept a pending permission request (this request only)')
@@ -145,6 +176,10 @@ async function registerCommands(token: string, appId: string) {
       .setName('abort')
       .setDescription('Abort the current OpenCode request in this thread')
       .toJSON(),
+    new SlashCommandBuilder()
+      .setName('share')
+      .setDescription('Share the current session as a public URL')
+      .toJSON(),
   ]
 
   const rest = new REST().setToken(token)
@@ -649,6 +684,8 @@ cli
   )
   .action(async (options: { restart?: boolean; addChannels?: boolean }) => {
     try {
+      await checkSingleInstance()
+      startLockServer()
       await run({
         restart: options.restart,
         addChannels: options.addChannels,
@@ -662,179 +699,7 @@ cli
     }
   })
 
-cli
-  .command(
-    'send-to-discord <sessionId>',
-    'Send an OpenCode session to Discord and create a thread for it',
-  )
-  .option('-d, --directory <dir>', 'Project directory (defaults to current working directory)')
-  .action(async (sessionId: string, options: { directory?: string }) => {
-    try {
-      const directory = options.directory || process.cwd()
-      
-      const db = getDatabase()
-      
-      const botRow = db
-        .prepare(
-          'SELECT app_id, token FROM bot_tokens ORDER BY created_at DESC LIMIT 1',
-        )
-        .get() as { app_id: string; token: string } | undefined
-
-      if (!botRow) {
-        cliLogger.error('No bot credentials found. Run `kimaki` first to set up the bot.')
-        process.exit(EXIT_NO_RESTART)
-      }
-
-      const channelRow = db
-        .prepare(
-          'SELECT channel_id FROM channel_directories WHERE directory = ? AND channel_type = ?',
-        )
-        .get(directory, 'text') as { channel_id: string } | undefined
-
-      if (!channelRow) {
-        cliLogger.error(
-          `No Discord channel found for directory: ${directory}\n` +
-            'Run `kimaki --add-channels` to create a channel for this project.',
-        )
-        process.exit(EXIT_NO_RESTART)
-      }
-
-      const s = spinner()
-      s.start('Connecting to Discord...')
-
-      const discordClient = await createDiscordClient()
 
-      await new Promise<void>((resolve, reject) => {
-        discordClient.once(Events.ClientReady, () => {
-          resolve()
-        })
-        discordClient.once(Events.Error, reject)
-        discordClient.login(botRow.token).catch(reject)
-      })
-
-      s.stop('Connected to Discord!')
-
-      const channel = await discordClient.channels.fetch(channelRow.channel_id)
-      if (!channel || channel.type !== ChannelType.GuildText) {
-        cliLogger.error('Could not find the text channel or it is not a text channel')
-        discordClient.destroy()
-        process.exit(EXIT_NO_RESTART)
-      }
-
-      const textChannel = channel as import('discord.js').TextChannel
-
-      s.start('Fetching session from OpenCode...')
-
-      const getClient = await initializeOpencodeForDirectory(directory)
-      const sessionResponse = await getClient().session.get({
-        path: { id: sessionId },
-      })
-
-      if (!sessionResponse.data) {
-        s.stop('Session not found')
-        discordClient.destroy()
-        process.exit(EXIT_NO_RESTART)
-      }
-
-      const session = sessionResponse.data
-      s.stop(`Found session: ${session.title}`)
-
-      s.start('Creating Discord thread...')
-
-      const thread = await textChannel.threads.create({
-        name: `Resume: ${session.title}`.slice(0, 100),
-        autoArchiveDuration: 1440,
-        reason: `Resuming session ${sessionId} from CLI`,
-      })
-
-      db.prepare(
-        'INSERT OR REPLACE INTO thread_sessions (thread_id, session_id) VALUES (?, ?)',
-      ).run(thread.id, sessionId)
-
-      s.stop('Created Discord thread!')
-
-      s.start('Loading session messages...')
-
-      const messagesResponse = await getClient().session.messages({
-        path: { id: sessionId },
-      })
-
-      if (!messagesResponse.data) {
-        s.stop('Failed to fetch session messages')
-        discordClient.destroy()
-        process.exit(EXIT_NO_RESTART)
-      }
-
-      const messages = messagesResponse.data
-
-      await thread.send(
-        `📂 **Resumed session:** ${session.title}\n📅 **Created:** ${new Date(session.time.created).toLocaleString()}\n\n*Loading ${messages.length} messages...*`,
-      )
-
-      let messageCount = 0
-      for (const message of messages) {
-        if (message.info.role === 'user') {
-          const userParts = message.parts.filter(
-            (p) => p.type === 'text' && !p.synthetic,
-          )
-          const userTexts = userParts
-            .map((p) => {
-              if (p.type === 'text') {
-                return p.text
-              }
-              return ''
-            })
-            .filter((t) => t.trim())
-
-          const userText = userTexts.join('\n\n')
-          if (userText) {
-            const truncated = userText.length > 1900 ? userText.slice(0, 1900) + '…' : userText
-            await thread.send(`**User:**\n${truncated}`)
-          }
-        } else if (message.info.role === 'assistant') {
-          const textParts = message.parts.filter((p) => p.type === 'text')
-          const texts = textParts
-            .map((p) => {
-              if (p.type === 'text') {
-                return p.text
-              }
-              return ''
-            })
-            .filter((t) => t?.trim())
-
-          if (texts.length > 0) {
-            const combinedText = texts.join('\n\n')
-            const truncated = combinedText.length > 1900 ? combinedText.slice(0, 1900) + '…' : combinedText
-            await thread.send(truncated)
-          }
-        }
-        messageCount++
-      }
-
-      await thread.send(
-        `✅ **Session resumed!** Loaded ${messageCount} messages.\n\nYou can now continue the conversation by sending messages in this thread.`,
-      )
-
-      s.stop(`Loaded ${messageCount} messages`)
-
-      const guildId = textChannel.guildId
-      const threadUrl = `https://discord.com/channels/${guildId}/${thread.id}`
-
-      note(
-        `Session "${session.title}" has been sent to Discord!\n\nThread: ${threadUrl}`,
-        '✅ Success',
-      )
-
-      discordClient.destroy()
-      process.exit(0)
-    } catch (error) {
-      cliLogger.error(
-        'Error:',
-        error instanceof Error ? error.message : String(error),
-      )
-      process.exit(EXIT_NO_RESTART)
-    }
-  })
 
 cli
   .command('upload-to-discord [...files]', 'Upload files to a Discord thread for a session')
@@ -929,36 +794,7 @@ cli
     }
   })
 
-cli
-  .command('install-plugin', 'Install the OpenCode command for kimaki Discord integration')
-  .action(async () => {
-    try {
-      const require = createRequire(import.meta.url)
-      const sendCommandSrc = require.resolve('./opencode-command-send-to-discord.md')
-
-      const opencodeConfig = path.join(os.homedir(), '.config', 'opencode')
-      const commandDir = path.join(opencodeConfig, 'command')
 
-      fs.mkdirSync(commandDir, { recursive: true })
-
-      const sendCommandDest = path.join(commandDir, 'send-to-kimaki-discord.md')
-
-      fs.copyFileSync(sendCommandSrc, sendCommandDest)
-
-      note(
-        `Command installed:\n- ${sendCommandDest}\n\nUse /send-to-kimaki-discord to send session to Discord.`,
-        '✅ Installed',
-      )
-
-      process.exit(0)
-    } catch (error) {
-      cliLogger.error(
-        'Error:',
-        error instanceof Error ? error.message : String(error),
-      )
-      process.exit(EXIT_NO_RESTART)
-    }
-  })
 
 cli.help()
 cli.parse()