kimaki 0.4.27 → 0.4.29

package/dist/cli.js

@@ -4,7 +4,7 @@
 // project channel creation, and launching the bot with opencode integration.
 import { cac } from 'cac';
 import { intro, outro, text, password, note, cancel, isCancel, confirm, log, multiselect, spinner, } from '@clack/prompts';
-import { deduplicateByKey, generateBotInstallUrl } from './utils.js';
+import { deduplicateByKey, generateBotInstallUrl, abbreviatePath } from './utils.js';
 import { getChannelsWithDescriptions, createDiscordClient, getDatabase, startDiscordBot, initializeOpencodeForDirectory, ensureKimakiCategory, createProjectChannels, } from './discord-bot.js';
 import { Events, ChannelType, REST, Routes, SlashCommandBuilder, AttachmentBuilder, } from 'discord.js';
 import path from 'node:path';
@@ -12,10 +12,10 @@ import fs from 'node:fs';
 import { createLogger } from './logger.js';
 import { spawn, spawnSync, execSync } from 'node:child_process';
 import http from 'node:http';
+import { setDataDir, getDataDir, getLockPort } from './config.js';
 const cliLogger = createLogger('CLI');
 const cli = cac('kimaki');
 process.title = 'kimaki';
-const LOCK_PORT = 29988;
 async function killProcessOnPort(port) {
     const isWindows = process.platform === 'win32';
     const myPid = process.pid;
@@ -58,13 +58,14 @@ async function killProcessOnPort(port) {
     return false;
 }
 async function checkSingleInstance() {
+    const lockPort = getLockPort();
     try {
-        const response = await fetch(`http://127.0.0.1:${LOCK_PORT}`, {
+        const response = await fetch(`http://127.0.0.1:${lockPort}`, {
             signal: AbortSignal.timeout(1000),
         });
         if (response.ok) {
-            cliLogger.log('Another kimaki instance detected');
-            await killProcessOnPort(LOCK_PORT);
+            cliLogger.log(`Another kimaki instance detected for data dir: ${getDataDir()}`);
+            await killProcessOnPort(lockPort);
             // Wait a moment for port to be released
             await new Promise((resolve) => { setTimeout(resolve, 500); });
         }
@@ -74,22 +75,24 @@ async function checkSingleInstance() {
     }
 }
 async function startLockServer() {
+    const lockPort = getLockPort();
     return new Promise((resolve, reject) => {
         const server = http.createServer((req, res) => {
             res.writeHead(200);
             res.end('kimaki');
         });
-        server.listen(LOCK_PORT, '127.0.0.1');
+        server.listen(lockPort, '127.0.0.1');
         server.once('listening', () => {
+            cliLogger.debug(`Lock server started on port ${lockPort}`);
             resolve();
         });
         server.on('error', async (err) => {
             if (err.code === 'EADDRINUSE') {
                 cliLogger.log('Port still in use, retrying...');
-                await killProcessOnPort(LOCK_PORT);
+                await killProcessOnPort(lockPort);
                 await new Promise((r) => { setTimeout(r, 500); });
                 // Retry once
-                server.listen(LOCK_PORT, '127.0.0.1');
+                server.listen(lockPort, '127.0.0.1');
             }
             else {
                 reject(err);
@@ -461,7 +464,15 @@ async function run({ restart, addChannels }) {
         .filter((ch) => ch.kimakiDirectory && ch.kimakiApp === appId)
         .map((ch) => ch.kimakiDirectory)
         .filter(Boolean));
-    const availableProjects = deduplicateByKey(projects.filter((project) => !existingDirs.includes(project.worktree)), (x) => x.worktree);
+    const availableProjects = deduplicateByKey(projects.filter((project) => {
+        if (existingDirs.includes(project.worktree)) {
+            return false;
+        }
+        if (path.basename(project.worktree).startsWith('opencode-test-')) {
+            return false;
+        }
+        return true;
+    }), (x) => x.worktree);
     if (availableProjects.length === 0) {
         note('All OpenCode projects already have Discord channels', 'No New Projects');
     }
@@ -471,7 +482,7 @@ async function run({ restart, addChannels }) {
             message: 'Select projects to create Discord channels for:',
             options: availableProjects.map((project) => ({
                 value: project.id,
-                label: `${path.basename(project.worktree)} (${project.worktree})`,
+                label: `${path.basename(project.worktree)} (${abbreviatePath(project.worktree)})`,
             })),
             required: false,
         });
@@ -585,13 +596,20 @@ cli
     .command('', 'Set up and run the Kimaki Discord bot')
     .option('--restart', 'Prompt for new credentials even if saved')
     .option('--add-channels', 'Select OpenCode projects to create Discord channels before starting')
+    .option('--data-dir <path>', 'Data directory for config and database (default: ~/.kimaki)')
     .action(async (options) => {
     try {
+        // Set data directory early, before any database access
+        if (options.dataDir) {
+            setDataDir(options.dataDir);
+            cliLogger.log(`Using data directory: ${getDataDir()}`);
+        }
         await checkSingleInstance();
         await startLockServer();
         await run({
             restart: options.restart,
             addChannels: options.addChannels,
+            dataDir: options.dataDir,
         });
     }
     catch (error) {

package/dist/commands/add-project.js

@@ -5,6 +5,7 @@ import { getDatabase } from '../database.js';
 import { initializeOpencodeForDirectory } from '../opencode.js';
 import { createProjectChannels } from '../channel-management.js';
 import { createLogger } from '../logger.js';
+import { abbreviatePath } from '../utils.js';
 const logger = createLogger('ADD-PROJECT');
 export async function handleAddProjectCommand({ command, appId, }) {
     await command.deferReply({ ephemeral: false });
@@ -69,7 +70,15 @@ export async function handleAddProjectAutocomplete({ interaction, appId, }) {
             .prepare('SELECT DISTINCT directory FROM channel_directories WHERE channel_type = ?')
             .all('text');
         const existingDirSet = new Set(existingDirs.map((row) => row.directory));
-        const availableProjects = projectsResponse.data.filter((project) => !existingDirSet.has(project.worktree));
+        const availableProjects = projectsResponse.data.filter((project) => {
+            if (existingDirSet.has(project.worktree)) {
+                return false;
+            }
+            if (path.basename(project.worktree).startsWith('opencode-test-')) {
+                return false;
+            }
+            return true;
+        });
         const projects = availableProjects
             .filter((project) => {
             const baseName = path.basename(project.worktree);
@@ -83,7 +92,7 @@ export async function handleAddProjectAutocomplete({ interaction, appId, }) {
         })
             .slice(0, 25)
             .map((project) => {
-            const name = `${path.basename(project.worktree)} (${project.worktree})`;
+            const name = `${path.basename(project.worktree)} (${abbreviatePath(project.worktree)})`;
             return {
                 name: name.length > 100 ? name.slice(0, 99) + '…' : name,
                 value: project.id,

package/dist/commands/create-new-project.js

@@ -1,8 +1,8 @@
 // /create-new-project command - Create a new project folder, initialize git, and start a session.
 import { ChannelType } from 'discord.js';
 import fs from 'node:fs';
-import os from 'node:os';
 import path from 'node:path';
+import { getProjectsDir } from '../config.js';
 import { createProjectChannels } from '../channel-management.js';
 import { handleOpencodeSession } from '../session-handler.js';
 import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
@@ -31,12 +31,12 @@ export async function handleCreateNewProjectCommand({ command, appId, }) {
         await command.editReply('Invalid project name');
         return;
     }
-    const kimakiDir = path.join(os.homedir(), 'kimaki');
-    const projectDirectory = path.join(kimakiDir, sanitizedName);
+    const projectsDir = getProjectsDir();
+    const projectDirectory = path.join(projectsDir, sanitizedName);
     try {
-        if (!fs.existsSync(kimakiDir)) {
-            fs.mkdirSync(kimakiDir, { recursive: true });
-            logger.log(`Created kimaki directory: ${kimakiDir}`);
+        if (!fs.existsSync(projectsDir)) {
+            fs.mkdirSync(projectsDir, { recursive: true });
+            logger.log(`Created projects directory: ${projectsDir}`);
         }
         if (fs.existsSync(projectDirectory)) {
             await command.editReply(`Project directory already exists: ${projectDirectory}`);

package/dist/commands/permissions.js

@@ -3,7 +3,7 @@
 // with Accept, Accept Always, and Deny options.
 import { StringSelectMenuBuilder, StringSelectMenuInteraction, ActionRowBuilder, } from 'discord.js';
 import crypto from 'node:crypto';
-import { initializeOpencodeForDirectory } from '../opencode.js';
+import { getOpencodeClientV2 } from '../opencode.js';
 import { NOTIFY_MESSAGE_FLAGS } from '../discord-utils.js';
 import { createLogger } from '../logger.js';
 const logger = createLogger('PERMISSIONS');
@@ -76,13 +76,13 @@ export async function handlePermissionSelectMenu(interaction) {
     await interaction.deferUpdate();
     const response = interaction.values[0];
     try {
-        const getClient = await initializeOpencodeForDirectory(context.directory);
-        await getClient().postSessionIdPermissionsPermissionId({
-            path: {
-                id: context.permission.sessionID,
-                permissionID: context.permission.id,
-            },
-            body: { response },
+        const clientV2 = getOpencodeClientV2(context.directory);
+        if (!clientV2) {
+            throw new Error('OpenCode server not found for directory');
+        }
+        await clientV2.permission.reply({
+            requestID: context.permission.id,
+            reply: response,
         });
         pendingPermissionContexts.delete(contextHash);
         // Update message: show result and remove dropdown

package/dist/config.js

@@ -0,0 +1,59 @@
+// Runtime configuration for Kimaki bot.
+// Stores data directory path and provides accessors for other modules.
+// Must be initialized before database or other path-dependent modules are used.
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+const DEFAULT_DATA_DIR = path.join(os.homedir(), '.kimaki');
+let dataDir = null;
+/**
+ * Get the data directory path.
+ * Falls back to ~/.kimaki if not explicitly set.
+ */
+export function getDataDir() {
+    if (!dataDir) {
+        dataDir = DEFAULT_DATA_DIR;
+    }
+    return dataDir;
+}
+/**
+ * Set the data directory path.
+ * Creates the directory if it doesn't exist.
+ * Must be called before any database or path-dependent operations.
+ */
+export function setDataDir(dir) {
+    const resolvedDir = path.resolve(dir);
+    if (!fs.existsSync(resolvedDir)) {
+        fs.mkdirSync(resolvedDir, { recursive: true });
+    }
+    dataDir = resolvedDir;
+}
+/**
+ * Get the projects directory path (for /create-new-project command).
+ * Returns <dataDir>/projects
+ */
+export function getProjectsDir() {
+    return path.join(getDataDir(), 'projects');
+}
+const DEFAULT_LOCK_PORT = 29988;
+/**
+ * Derive a lock port from the data directory path.
+ * Returns 29988 for the default ~/.kimaki directory (backwards compatible).
+ * For custom data dirs, uses a hash to generate a port in the range 30000-39999.
+ */
+export function getLockPort() {
+    const dir = getDataDir();
+    // Use original port for default data dir (backwards compatible)
+    if (dir === DEFAULT_DATA_DIR) {
+        return DEFAULT_LOCK_PORT;
+    }
+    // Hash-based port for custom data dirs
+    let hash = 0;
+    for (let i = 0; i < dir.length; i++) {
+        const char = dir.charCodeAt(i);
+        hash = ((hash << 5) - hash) + char;
+        hash = hash & hash; // Convert to 32bit integer
+    }
+    // Map to port range 30000-39999
+    return 30000 + (Math.abs(hash) % 10000);
+}

package/dist/database.js

@@ -1,23 +1,23 @@
 // SQLite database manager for persistent bot state.
 // Stores thread-session mappings, bot tokens, channel directories,
-// API keys, and model preferences in ~/.kimaki/discord-sessions.db.
+// API keys, and model preferences in <dataDir>/discord-sessions.db.
 import Database from 'better-sqlite3';
 import fs from 'node:fs';
-import os from 'node:os';
 import path from 'node:path';
 import { createLogger } from './logger.js';
+import { getDataDir } from './config.js';
 const dbLogger = createLogger('DB');
 let db = null;
 export function getDatabase() {
     if (!db) {
-        const kimakiDir = path.join(os.homedir(), '.kimaki');
+        const dataDir = getDataDir();
         try {
-            fs.mkdirSync(kimakiDir, { recursive: true });
+            fs.mkdirSync(dataDir, { recursive: true });
         }
         catch (error) {
-            dbLogger.error('Failed to create ~/.kimaki directory:', error);
+            dbLogger.error(`Failed to create data directory ${dataDir}:`, error);
         }
-        const dbPath = path.join(kimakiDir, 'discord-sessions.db');
+        const dbPath = path.join(dataDir, 'discord-sessions.db');
         dbLogger.log(`Opening database at: ${dbPath}`);
         db = new Database(dbPath);
         db.exec(`

package/dist/session-handler.js

@@ -136,13 +136,13 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
     if (pendingPerm) {
         try {
             sessionLogger.log(`[PERMISSION] Auto-rejecting pending permission ${pendingPerm.permission.id} due to new message`);
-            await getClient().postSessionIdPermissionsPermissionId({
-                path: {
-                    id: pendingPerm.permission.sessionID,
-                    permissionID: pendingPerm.permission.id,
-                },
-                body: { response: 'reject' },
-            });
+            const clientV2 = getOpencodeClientV2(directory);
+            if (clientV2) {
+                await clientV2.permission.reply({
+                    requestID: pendingPerm.permission.id,
+                    reply: 'reject',
+                });
+            }
             // Clean up both the pending permission and its dropdown context
             cleanupPermissionContext(pendingPerm.contextHash);
             pendingPermissions.delete(thread.id);

package/dist/utils.js

@@ -1,6 +1,7 @@
 // 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';
 import { PermissionsBitField } from 'discord.js';
 export function generateBotInstallUrl({ clientId, permissions = [
     PermissionsBitField.Flags.ViewChannel,
@@ -83,3 +84,10 @@ const dtf = new Intl.DateTimeFormat('en-US', {
 export function formatDateTime(date) {
     return dtf.format(date);
 }
+export function abbreviatePath(fullPath) {
+    const home = os.homedir();
+    if (fullPath.startsWith(home)) {
+        return '~' + fullPath.slice(home.length);
+    }
+    return fullPath;
+}

package/package.json

@@ -2,7 +2,7 @@
   "name": "kimaki",
   "module": "index.ts",
   "type": "module",
-  "version": "0.4.27",
+  "version": "0.4.29",
   "scripts": {
     "dev": "tsx --env-file .env src/cli.ts",
     "prepublishOnly": "pnpm tsc",

package/src/cli.ts

@@ -16,7 +16,7 @@ import {
   multiselect,
   spinner,
 } from '@clack/prompts'
-import { deduplicateByKey, generateBotInstallUrl } from './utils.js'
+import { deduplicateByKey, generateBotInstallUrl, abbreviatePath } from './utils.js'
 import {
   getChannelsWithDescriptions,
   createDiscordClient,
@@ -45,14 +45,13 @@ import fs from 'node:fs'
 import { createLogger } from './logger.js'
 import { spawn, spawnSync, execSync, type ExecSyncOptions } from 'node:child_process'
 import http from 'node:http'
+import { setDataDir, getDataDir, getLockPort } from './config.js'
 
 const cliLogger = createLogger('CLI')
 const cli = cac('kimaki')
 
 process.title = 'kimaki'
 
-const LOCK_PORT = 29988
-
 async function killProcessOnPort(port: number): Promise<boolean> {
   const isWindows = process.platform === 'win32'
   const myPid = process.pid
@@ -95,13 +94,14 @@ async function killProcessOnPort(port: number): Promise<boolean> {
 }
 
 async function checkSingleInstance(): Promise<void> {
+  const lockPort = getLockPort()
   try {
-    const response = await fetch(`http://127.0.0.1:${LOCK_PORT}`, {
+    const response = await fetch(`http://127.0.0.1:${lockPort}`, {
       signal: AbortSignal.timeout(1000),
     })
     if (response.ok) {
-      cliLogger.log('Another kimaki instance detected')
-      await killProcessOnPort(LOCK_PORT)
+      cliLogger.log(`Another kimaki instance detected for data dir: ${getDataDir()}`)
+      await killProcessOnPort(lockPort)
       // Wait a moment for port to be released
       await new Promise((resolve) => { setTimeout(resolve, 500) })
     }
@@ -111,22 +111,24 @@ async function checkSingleInstance(): Promise<void> {
 }
 
 async function startLockServer(): Promise<void> {
+  const lockPort = getLockPort()
   return new Promise((resolve, reject) => {
     const server = http.createServer((req, res) => {
       res.writeHead(200)
       res.end('kimaki')
     })
-    server.listen(LOCK_PORT, '127.0.0.1')
+    server.listen(lockPort, '127.0.0.1')
     server.once('listening', () => {
+      cliLogger.debug(`Lock server started on port ${lockPort}`)
       resolve()
     })
     server.on('error', async (err: NodeJS.ErrnoException) => {
       if (err.code === 'EADDRINUSE') {
         cliLogger.log('Port still in use, retrying...')
-        await killProcessOnPort(LOCK_PORT)
+        await killProcessOnPort(lockPort)
         await new Promise((r) => { setTimeout(r, 500) })
         // Retry once
-        server.listen(LOCK_PORT, '127.0.0.1')
+        server.listen(lockPort, '127.0.0.1')
       } else {
         reject(err)
       }
@@ -151,6 +153,7 @@ type Project = {
 type CliOptions = {
   restart?: boolean
   addChannels?: boolean
+  dataDir?: string
 }
 
 // Commands to skip when registering user commands (reserved names)
@@ -644,7 +647,15 @@ async function run({ restart, addChannels }: CliOptions) {
   )
 
   const availableProjects = deduplicateByKey(
-    projects.filter((project) => !existingDirs.includes(project.worktree)),
+    projects.filter((project) => {
+      if (existingDirs.includes(project.worktree)) {
+        return false
+      }
+      if (path.basename(project.worktree).startsWith('opencode-test-')) {
+        return false
+      }
+      return true
+    }),
     (x) => x.worktree,
   )
 
@@ -663,7 +674,7 @@ async function run({ restart, addChannels }: CliOptions) {
       message: 'Select projects to create Discord channels for:',
       options: availableProjects.map((project) => ({
         value: project.id,
-        label: `${path.basename(project.worktree)} (${project.worktree})`,
+        label: `${path.basename(project.worktree)} (${abbreviatePath(project.worktree)})`,
       })),
       required: false,
     })
@@ -823,13 +834,24 @@ cli
     '--add-channels',
     'Select OpenCode projects to create Discord channels before starting',
   )
-  .action(async (options: { restart?: boolean; addChannels?: boolean }) => {
+  .option(
+    '--data-dir <path>',
+    'Data directory for config and database (default: ~/.kimaki)',
+  )
+  .action(async (options: { restart?: boolean; addChannels?: boolean; dataDir?: string }) => {
     try {
+      // Set data directory early, before any database access
+      if (options.dataDir) {
+        setDataDir(options.dataDir)
+        cliLogger.log(`Using data directory: ${getDataDir()}`)
+      }
+      
       await checkSingleInstance()
       await startLockServer()
       await run({
         restart: options.restart,
         addChannels: options.addChannels,
+        dataDir: options.dataDir,
       })
     } catch (error) {
       cliLogger.error(

package/src/commands/add-project.ts

@@ -7,6 +7,7 @@ import { getDatabase } from '../database.js'
 import { initializeOpencodeForDirectory } from '../opencode.js'
 import { createProjectChannels } from '../channel-management.js'
 import { createLogger } from '../logger.js'
+import { abbreviatePath } from '../utils.js'
 
 const logger = createLogger('ADD-PROJECT')
 
@@ -107,9 +108,15 @@ export async function handleAddProjectAutocomplete({
       .all('text') as { directory: string }[]
     const existingDirSet = new Set(existingDirs.map((row) => row.directory))
 
-    const availableProjects = projectsResponse.data.filter(
-      (project) => !existingDirSet.has(project.worktree),
-    )
+    const availableProjects = projectsResponse.data.filter((project) => {
+      if (existingDirSet.has(project.worktree)) {
+        return false
+      }
+      if (path.basename(project.worktree).startsWith('opencode-test-')) {
+        return false
+      }
+      return true
+    })
 
     const projects = availableProjects
       .filter((project) => {
@@ -124,7 +131,7 @@ export async function handleAddProjectAutocomplete({
       })
       .slice(0, 25)
       .map((project) => {
-        const name = `${path.basename(project.worktree)} (${project.worktree})`
+        const name = `${path.basename(project.worktree)} (${abbreviatePath(project.worktree)})`
         return {
           name: name.length > 100 ? name.slice(0, 99) + '…' : name,
           value: project.id,

package/src/commands/create-new-project.ts

@@ -2,9 +2,9 @@
 
 import { ChannelType, type TextChannel } from 'discord.js'
 import fs from 'node:fs'
-import os from 'node:os'
 import path from 'node:path'
 import type { CommandContext } from './types.js'
+import { getProjectsDir } from '../config.js'
 import { createProjectChannels } from '../channel-management.js'
 import { handleOpencodeSession } from '../session-handler.js'
 import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js'
@@ -44,13 +44,13 @@ export async function handleCreateNewProjectCommand({
     return
   }
 
-  const kimakiDir = path.join(os.homedir(), 'kimaki')
-  const projectDirectory = path.join(kimakiDir, sanitizedName)
+  const projectsDir = getProjectsDir()
+  const projectDirectory = path.join(projectsDir, sanitizedName)
 
   try {
-    if (!fs.existsSync(kimakiDir)) {
-      fs.mkdirSync(kimakiDir, { recursive: true })
-      logger.log(`Created kimaki directory: ${kimakiDir}`)
+    if (!fs.existsSync(projectsDir)) {
+      fs.mkdirSync(projectsDir, { recursive: true })
+      logger.log(`Created projects directory: ${projectsDir}`)
     }
 
     if (fs.existsSync(projectDirectory)) {

package/src/commands/permissions.ts

@@ -10,7 +10,7 @@ import {
 } from 'discord.js'
 import crypto from 'node:crypto'
 import type { PermissionRequest } from '@opencode-ai/sdk/v2'
-import { initializeOpencodeForDirectory } from '../opencode.js'
+import { getOpencodeClientV2 } from '../opencode.js'
 import { NOTIFY_MESSAGE_FLAGS } from '../discord-utils.js'
 import { createLogger } from '../logger.js'
 
@@ -120,13 +120,13 @@ export async function handlePermissionSelectMenu(
   const response = interaction.values[0] as 'once' | 'always' | 'reject'
 
   try {
-    const getClient = await initializeOpencodeForDirectory(context.directory)
-    await getClient().postSessionIdPermissionsPermissionId({
-      path: {
-        id: context.permission.sessionID,
-        permissionID: context.permission.id,
-      },
-      body: { response },
+    const clientV2 = getOpencodeClientV2(context.directory)
+    if (!clientV2) {
+      throw new Error('OpenCode server not found for directory')
+    }
+    await clientV2.permission.reply({
+      requestID: context.permission.id,
+      reply: response,
     })
 
     pendingPermissionContexts.delete(contextHash)

package/src/config.ts

@@ -0,0 +1,71 @@
+// Runtime configuration for Kimaki bot.
+// Stores data directory path and provides accessors for other modules.
+// Must be initialized before database or other path-dependent modules are used.
+
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+
+const DEFAULT_DATA_DIR = path.join(os.homedir(), '.kimaki')
+
+let dataDir: string | null = null
+
+/**
+ * Get the data directory path.
+ * Falls back to ~/.kimaki if not explicitly set.
+ */
+export function getDataDir(): string {
+  if (!dataDir) {
+    dataDir = DEFAULT_DATA_DIR
+  }
+  return dataDir
+}
+
+/**
+ * Set the data directory path.
+ * Creates the directory if it doesn't exist.
+ * Must be called before any database or path-dependent operations.
+ */
+export function setDataDir(dir: string): void {
+  const resolvedDir = path.resolve(dir)
+  
+  if (!fs.existsSync(resolvedDir)) {
+    fs.mkdirSync(resolvedDir, { recursive: true })
+  }
+  
+  dataDir = resolvedDir
+}
+
+/**
+ * Get the projects directory path (for /create-new-project command).
+ * Returns <dataDir>/projects
+ */
+export function getProjectsDir(): string {
+  return path.join(getDataDir(), 'projects')
+}
+
+const DEFAULT_LOCK_PORT = 29988
+
+/**
+ * Derive a lock port from the data directory path.
+ * Returns 29988 for the default ~/.kimaki directory (backwards compatible).
+ * For custom data dirs, uses a hash to generate a port in the range 30000-39999.
+ */
+export function getLockPort(): number {
+  const dir = getDataDir()
+  
+  // Use original port for default data dir (backwards compatible)
+  if (dir === DEFAULT_DATA_DIR) {
+    return DEFAULT_LOCK_PORT
+  }
+  
+  // Hash-based port for custom data dirs
+  let hash = 0
+  for (let i = 0; i < dir.length; i++) {
+    const char = dir.charCodeAt(i)
+    hash = ((hash << 5) - hash) + char
+    hash = hash & hash // Convert to 32bit integer
+  }
+  // Map to port range 30000-39999
+  return 30000 + (Math.abs(hash) % 10000)
+}

package/src/database.ts

@@ -1,12 +1,12 @@
 // SQLite database manager for persistent bot state.
 // Stores thread-session mappings, bot tokens, channel directories,
-// API keys, and model preferences in ~/.kimaki/discord-sessions.db.
+// API keys, and model preferences in <dataDir>/discord-sessions.db.
 
 import Database from 'better-sqlite3'
 import fs from 'node:fs'
-import os from 'node:os'
 import path from 'node:path'
 import { createLogger } from './logger.js'
+import { getDataDir } from './config.js'
 
 const dbLogger = createLogger('DB')
 
@@ -14,15 +14,15 @@ let db: Database.Database | null = null
 
 export function getDatabase(): Database.Database {
   if (!db) {
-    const kimakiDir = path.join(os.homedir(), '.kimaki')
+    const dataDir = getDataDir()
 
     try {
-      fs.mkdirSync(kimakiDir, { recursive: true })
+      fs.mkdirSync(dataDir, { recursive: true })
     } catch (error) {
-      dbLogger.error('Failed to create ~/.kimaki directory:', error)
+      dbLogger.error(`Failed to create data directory ${dataDir}:`, error)
     }
 
-    const dbPath = path.join(kimakiDir, 'discord-sessions.db')
+    const dbPath = path.join(dataDir, 'discord-sessions.db')
 
     dbLogger.log(`Opening database at: ${dbPath}`)
     db = new Database(dbPath)

package/src/session-handler.ts

@@ -221,13 +221,13 @@ export async function handleOpencodeSession({
   if (pendingPerm) {
     try {
       sessionLogger.log(`[PERMISSION] Auto-rejecting pending permission ${pendingPerm.permission.id} due to new message`)
-      await getClient().postSessionIdPermissionsPermissionId({
-        path: {
-          id: pendingPerm.permission.sessionID,
-          permissionID: pendingPerm.permission.id,
-        },
-        body: { response: 'reject' },
-      })
+      const clientV2 = getOpencodeClientV2(directory)
+      if (clientV2) {
+        await clientV2.permission.reply({
+          requestID: pendingPerm.permission.id,
+          reply: 'reject',
+        })
+      }
       // Clean up both the pending permission and its dropdown context
       cleanupPermissionContext(pendingPerm.contextHash)
       pendingPermissions.delete(thread.id)

package/src/utils.ts

@@ -2,6 +2,7 @@
 // Includes Discord OAuth URL generation, array deduplication,
 // abort error detection, and date/time formatting helpers.
 
+import os from 'node:os'
 import { PermissionsBitField } from 'discord.js'
 
 type GenerateInstallUrlOptions = {
@@ -116,3 +117,11 @@ const dtf = new Intl.DateTimeFormat('en-US', {
 export function formatDateTime(date: Date): string {
   return dtf.format(date)
 }
+
+export function abbreviatePath(fullPath: string): string {
+  const home = os.homedir()
+  if (fullPath.startsWith(home)) {
+    return '~' + fullPath.slice(home.length)
+  }
+  return fullPath
+}