kimaki 0.27.0 → 0.29.0

package/dist/bash-tool-schema-plugin.test.js

@@ -0,0 +1,68 @@
+import { describe, expect, test } from 'vitest';
+import { extendBashToolDefinition, injectKimakiSessionEnv, KIMAKI_SESSION_ID_ENV, resolveUploadToDiscordSessionId, } from './bash-tool-schema-plugin.js';
+describe('extendBashToolDefinition', () => {
+    test('keeps parameters and assigns jsonSchema from bashParameters', () => {
+        const parameters = { keep: true };
+        const output = {
+            description: 'Execute a shell command',
+            parameters,
+        };
+        extendBashToolDefinition(output);
+        expect(output.parameters).toBe(parameters);
+        expect(output.jsonSchema).toMatchInlineSnapshot(`
+      {
+        "$schema": "https://json-schema.org/draft/2020-12/schema",
+        "additionalProperties": false,
+        "properties": {
+          "command": {
+            "description": "The command to execute",
+            "type": "string",
+          },
+          "description": {
+            "description": "Short 5-10 word summary shown in Discord when the command is longer than 50 characters",
+            "type": "string",
+          },
+          "hasSideEffect": {
+            "description": "True if the command writes files, modifies state, installs packages, or triggers external effects",
+            "type": "boolean",
+          },
+          "timeout": {
+            "description": "Optional timeout in milliseconds",
+            "maximum": 9007199254740991,
+            "minimum": -9007199254740991,
+            "type": "integer",
+          },
+          "workdir": {
+            "description": "Working directory. Defaults to the current directory.",
+            "type": "string",
+          },
+        },
+        "required": [
+          "command",
+          "description",
+          "hasSideEffect",
+        ],
+        "type": "object",
+      }
+    `);
+    });
+});
+describe('upload-to-discord session targeting', () => {
+    test('bash env uses the live OpenCode session, not a copied --session flag', () => {
+        const env = {};
+        injectKimakiSessionEnv({ sessionID: 'ses_child', env });
+        expect(env).toEqual({ [KIMAKI_SESSION_ID_ENV]: 'ses_child' });
+        expect(resolveUploadToDiscordSessionId({
+            flagSessionId: 'ses_parent',
+            envSessionId: env[KIMAKI_SESSION_ID_ENV],
+        })).toBe('ses_child');
+    });
+    test('falls back to --session when bash is not inside an OpenCode session', () => {
+        expect(resolveUploadToDiscordSessionId({
+            flagSessionId: 'ses_parent',
+        })).toBe('ses_parent');
+    });
+    test('returns undefined when neither live session nor flag is set', () => {
+        expect(resolveUploadToDiscordSessionId({})).toBeUndefined();
+    });
+});

package/dist/channel-management.js

@@ -4,7 +4,7 @@
 import { ChannelType, } from 'discord.js';
 import fs from 'node:fs';
 import path from 'node:path';
-import { getChannelDirectory, setChannelDirectory, findChannelsByDirectory, listTrackedTextChannels, } from './database.js';
+import { getChannelDirectory, setChannelDirectory, findChannelsByDirectory, listTrackedTextChannels, getGuildCategories, setGuildCategoryId, } from './database.js';
 import { getProjectsDir } from './config.js';
 import { execAsync } from './worktrees.js';
 import { createLogger, LogPrefix } from './logger.js';
@@ -39,41 +39,117 @@ async function trackProjectRegistered({ projectKind, source, }) {
     trackEvent('project_registered', props);
 }
 const logger = createLogger(LogPrefix.CHANNEL);
-export async function ensureKimakiCategory(guild, botName) {
-    // Skip appending bot name if it's already "kimaki" to avoid "Kimaki kimaki"
+function defaultCategoryName(kind, botName) {
     const isKimakiBot = botName?.toLowerCase() === 'kimaki';
-    const categoryName = botName && !isKimakiBot ? `Kimaki ${botName}` : 'Kimaki';
-    const existingCategory = guild.channels.cache.find((channel) => {
-        if (channel.type !== ChannelType.GuildCategory) {
-            return false;
+    if (kind === 'audio') {
+        return botName && !isKimakiBot ? `Kimaki Audio ${botName}` : 'Kimaki Audio';
+    }
+    return botName && !isKimakiBot ? `Kimaki ${botName}` : 'Kimaki';
+}
+function defaultKimakiChannelName({ botName, isGatewayMode, }) {
+    if (isGatewayMode || !botName)
+        return 'kimaki';
+    const sanitized = botName
+        .toLowerCase()
+        .replace(/[^a-z0-9-]/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '');
+    if (!sanitized || sanitized === 'kimaki')
+        return 'kimaki';
+    return `kimaki-${sanitized}`.slice(0, 100);
+}
+const categoryEnsures = new Map();
+function ensureCategorySerialized({ key, run, }) {
+    const existing = categoryEnsures.get(key);
+    if (existing)
+        return existing;
+    const promise = run().finally(() => {
+        if (categoryEnsures.get(key) === promise) {
+            categoryEnsures.delete(key);
         }
-        return channel.name.toLowerCase() === categoryName.toLowerCase();
     });
-    if (existingCategory) {
-        return existingCategory;
+    categoryEnsures.set(key, promise);
+    return promise;
+}
+function isUnknownDiscordChannel(error) {
+    const code = error instanceof Error ? Reflect.get(error, 'code') : undefined;
+    const status = error instanceof Error ? Reflect.get(error, 'status') : undefined;
+    return code === 10003 || status === 404;
+}
+function isCategoryChannel(channel) {
+    return channel?.type === ChannelType.GuildCategory;
+}
+async function fetchCategoryById(guild, categoryId) {
+    const cached = guild.channels.cache.get(categoryId);
+    if (isCategoryChannel(cached))
+        return cached;
+    try {
+        const fetched = await guild.channels.fetch(categoryId);
+        return isCategoryChannel(fetched) ? fetched : null;
+    }
+    catch (error) {
+        if (isUnknownDiscordChannel(error))
+            return null;
+        throw error;
     }
-    return guild.channels.create({
-        name: categoryName,
-        type: ChannelType.GuildCategory,
-    });
 }
-export async function ensureKimakiAudioCategory(guild, botName) {
-    // Skip appending bot name if it's already "kimaki" to avoid "Kimaki Audio kimaki"
-    const isKimakiBot = botName?.toLowerCase() === 'kimaki';
-    const categoryName = botName && !isKimakiBot ? `Kimaki Audio ${botName}` : 'Kimaki Audio';
-    const existingCategory = guild.channels.cache.find((channel) => {
-        if (channel.type !== ChannelType.GuildCategory) {
-            return false;
-        }
-        return channel.name.toLowerCase() === categoryName.toLowerCase();
+async function adoptParentFromTrackedChannels({ guild, channelType, }) {
+    const mappings = await findChannelsByDirectory({ channelType });
+    const channels = await guild.channels.fetch();
+    for (const row of mappings) {
+        if (row.guild_id && row.guild_id !== guild.id)
+            continue;
+        const channel = channels.get(row.channel_id);
+        if (!channel?.parentId)
+            continue;
+        const parent = await fetchCategoryById(guild, channel.parentId);
+        if (parent)
+            return parent;
+    }
+    return null;
+}
+async function resolveKimakiCategory({ guild, kind, botName, }) {
+    const stored = await getGuildCategories(guild.id);
+    const storedId = kind === 'audio' ? stored?.audio_category_id : stored?.category_id;
+    if (storedId) {
+        const existing = await fetchCategoryById(guild, storedId);
+        if (existing)
+            return existing;
+    }
+    const adopted = await adoptParentFromTrackedChannels({
+        guild,
+        channelType: kind === 'audio' ? 'voice' : 'text',
     });
-    if (existingCategory) {
-        return existingCategory;
+    if (adopted) {
+        await setGuildCategoryId({
+            guildId: guild.id,
+            kind,
+            categoryId: adopted.id,
+        });
+        return adopted;
     }
-    return guild.channels.create({
-        name: categoryName,
+    const created = await guild.channels.create({
+        name: defaultCategoryName(kind, botName),
         type: ChannelType.GuildCategory,
     });
+    await setGuildCategoryId({
+        guildId: guild.id,
+        kind,
+        categoryId: created.id,
+    });
+    return created;
+}
+export function ensureKimakiCategory(guild, botName) {
+    return ensureCategorySerialized({
+        key: `${guild.id}:text`,
+        run: () => resolveKimakiCategory({ guild, kind: 'text', botName }),
+    });
+}
+export function ensureKimakiAudioCategory(guild, botName) {
+    return ensureCategorySerialized({
+        key: `${guild.id}:audio`,
+        run: () => resolveKimakiCategory({ guild, kind: 'audio', botName }),
+    });
 }
 export async function createProjectChannels({ guild, projectDirectory, botName, enableVoiceChannels = false, analyticsSource = 'cli', }) {
     const baseName = path.basename(projectDirectory);
@@ -92,6 +168,7 @@ export async function createProjectChannels({ guild, projectDirectory, botName,
         channelId: textChannel.id,
         directory: projectDirectory,
         channelType: 'text',
+        guildId: guild.id,
     });
     await trackProjectRegistered({
         projectKind: 'user',
@@ -109,6 +186,7 @@ export async function createProjectChannels({ guild, projectDirectory, botName,
             channelId: voiceChannel.id,
             directory: projectDirectory,
             channelType: 'voice',
+            guildId: guild.id,
         });
         voiceChannelId = voiceChannel.id;
     }
@@ -158,8 +236,9 @@ const DEFAULT_CHANNEL_TOPIC = 'General channel for misc tasks with Kimaki. Not c
  * Directory is ~/.kimaki/projects/kimaki, git-initialized with a .gitignore.
  *
  * Idempotency: checks the database for an existing channel mapped to the
- * kimaki projects directory. Also scans guild channels by name+category
- * as a fallback for channels created before DB mapping existed.
+ * kimaki projects directory. Also scans this machine's category for the
+ * exact default channel name as a fallback for channels created before
+ * DB mapping existed.
  */
 export async function createDefaultKimakiChannel({ guild, botName, appId, isGatewayMode, }) {
     const projectDirectory = getDefaultKimakiDirectory();
@@ -209,11 +288,9 @@ export async function createDefaultKimakiChannel({ guild, botName, appId, isGate
         logger.log(`Default kimaki channel was previously provisioned for guild ${guild.name} (${guild.id}) as ${staleForThisGuild.channel_id}, but no longer exists. Skipping recreation.`);
         return null;
     }
-    // 2. Fallback: detect existing channel by name+category.
-    // If a "kimaki" channel already exists in the guild but is NOT in our local
-    // DB, it was likely created by another kimaki instance (different machine).
-    // Do NOT adopt it — just skip channel creation entirely to avoid both
-    // instances fighting over the same channel.
+    // 2. Fallback: detect an existing default channel in THIS machine's group.
+    // A #kimaki channel in another machine's group is ignored.
+    const channelName = defaultKimakiChannelName({ botName, isGatewayMode });
     const kimakiCategory = await ensureKimakiCategory(guild, botName);
     const existingByName = guild.channels.cache.find((ch) => {
         if (ch.type !== ChannelType.GuildText) {
@@ -222,10 +299,10 @@ export async function createDefaultKimakiChannel({ guild, botName, appId, isGate
         if (ch.parentId !== kimakiCategory.id) {
             return false;
         }
-        return ch.name === 'kimaki' || ch.name.startsWith('kimaki-');
+        return ch.name === channelName;
     });
     if (existingByName) {
-        logger.log(`Found existing default kimaki channel by name: ${existingByName.id}, but it is not in our DB — skipping (likely owned by another kimaki instance)`);
+        logger.log(`Found existing default kimaki channel by name: ${existingByName.id}. Skipping recreation.`);
         return null;
     }
     // Git init — gracefully skip if git is not installed
@@ -244,21 +321,6 @@ export async function createDefaultKimakiChannel({ guild, botName, appId, isGate
     if (!fs.existsSync(gitignorePath)) {
         fs.writeFileSync(gitignorePath, DEFAULT_GITIGNORE);
     }
-    // Channel name: "kimaki-{botName}" for self-hosted, "kimaki" for gateway
-    const channelName = (() => {
-        if (isGatewayMode || !botName) {
-            return 'kimaki';
-        }
-        const sanitized = botName
-            .toLowerCase()
-            .replace(/[^a-z0-9-]/g, '-')
-            .replace(/-+/g, '-')
-            .replace(/^-|-$/g, '');
-        if (!sanitized || sanitized === 'kimaki') {
-            return 'kimaki';
-        }
-        return `kimaki-${sanitized}`.slice(0, 100);
-    })();
     const textChannel = await guild.channels.create({
         name: channelName,
         type: ChannelType.GuildText,

package/dist/cli-commands/misc.js

@@ -24,6 +24,7 @@ import { execAsync, validateWorktreeDirectory } from '../worktrees.js';
 import { upgrade, getCurrentVersion } from '../upgrade.js';
 import { getPromptPreview, parseSendAtValue, parseScheduledTaskPayload, serializeScheduledTaskPayload } from '../task-schedule.js';
 import { EXIT_NO_RESTART, formatMemberLookupUnavailableMessage, formatRelativeTime, formatTaskScheduleLine, isDiscordMemberLookupUnavailable, isGuildMemberSearchResult, isThreadChannelType, printDiscordInstallUrlAndExit, resolveBotCredentials, resolveDiscordUserOption, sendDiscordMessageWithOptionalAttachment, } from '../cli-runner.js';
+import { resolveUploadToDiscordSessionId } from '../bash-tool-schema-plugin.js';
 const cliLogger = createLogger(LogPrefix.CLI);
 const cli = goke();
 cli
@@ -31,7 +32,9 @@ cli
     .option('-s, --session <sessionId>', 'OpenCode session ID')
     .action(async (files, options) => {
     try {
-        const { session: sessionId } = options;
+        const sessionId = resolveUploadToDiscordSessionId({
+            flagSessionId: options.session,
+        });
         if (!sessionId) {
             cliLogger.error('Session ID is required. Use --session <sessionId>');
             process.exit(EXIT_NO_RESTART);

package/dist/cli-commands/project.js

@@ -12,7 +12,7 @@ import { spawn, execSync } from 'node:child_process';
 import { createLogger, LogPrefix, initLogFile } from '../logger.js';
 import { createDiscordClient, initDatabase, getChannelDirectory, initializeOpencodeForDirectory, createProjectChannels } from '../discord-bot.js';
 import { getDefaultKimakiDirectory } from '../channel-management.js';
-import { getBotTokenWithMode, getThreadSession, getThreadIdBySessionId, getSessionEventSnapshot, getDb, createScheduledTask, listScheduledTasks, cancelScheduledTask, getScheduledTask, updateScheduledTask, getSessionStartSourcesBySessionIds, deleteChannelDirectoryById, findChannelsByDirectory } from '../database.js';
+import { getBotTokenWithMode, getThreadSession, getThreadIdBySessionId, getSessionEventSnapshot, getDb, createScheduledTask, listScheduledTasks, cancelScheduledTask, getScheduledTask, updateScheduledTask, getSessionStartSourcesBySessionIds, deleteChannelDirectoryById, findChannelsByDirectory, findRegisteredTextChannelForDirectory, formatProjectAlreadyRegisteredError, listGuildCategoryIds } from '../database.js';
 import { ShareMarkdown } from '../markdown.js';
 import { parseSessionSearchPattern, findFirstSessionSearchHit, buildSessionSearchSnippet, getPartSearchTexts } from '../session-search.js';
 import { formatWorktreeName, formatAutoWorktreeName } from '../commands/new-worktree.js';
@@ -39,8 +39,15 @@ cli
         cliLogger.error(`Directory does not exist: ${absolutePath}`);
         process.exit(EXIT_NO_RESTART);
     }
-    // Initialize database
     await initDatabase();
+    const existingChannel = await findRegisteredTextChannelForDirectory(absolutePath);
+    if (existingChannel) {
+        cliLogger.error(formatProjectAlreadyRegisteredError({
+            channelId: existingChannel.channel_id,
+            directory: absolutePath,
+        }));
+        process.exit(EXIT_NO_RESTART);
+    }
     const { token: botToken, appId } = await resolveBotCredentials({
         appIdOverride: options.appId,
     });
@@ -62,30 +69,6 @@ cli
     });
     cliLogger.log('Finding guild...');
     const guild = await resolveGuildForProjectCommand({ client, guildIdOverride: options.guild });
-    // Check if channel already exists in this guild
-    cliLogger.log('Checking for existing channel...');
-    try {
-        const existingChannels = await findChannelsByDirectory({
-            directory: absolutePath,
-            channelType: 'text',
-        });
-        for (const existingChannel of existingChannels) {
-            try {
-                const ch = await client.channels.fetch(existingChannel.channel_id);
-                if (ch && !ch.isDMBased() && ch.guild.id === guild.id) {
-                    void client.destroy();
-                    cliLogger.error(`Channel already exists for this directory in ${guild.name}. Channel ID: ${existingChannel.channel_id}`);
-                    process.exit(EXIT_NO_RESTART);
-                }
-            }
-            catch (error) {
-                cliLogger.debug(`Failed to fetch channel ${existingChannel.channel_id} while checking existing channels:`, error instanceof Error ? error.stack : String(error));
-            }
-        }
-    }
-    catch (error) {
-        cliLogger.debug('Database lookup failed while checking existing channels:', error instanceof Error ? error.stack : String(error));
-    }
     const { textChannelId, voiceChannelId, channelName } = await createProjectChannels({
         guild,
         projectDirectory: absolutePath,
@@ -105,7 +88,7 @@ cli
 cli
     .command('project list', 'List all registered projects with their Discord channels')
     .option('--json', 'Output as JSON')
-    .option('--all', 'Include remote projects from other machines (scans Kimaki category in Discord)')
+    .option('--all', 'Include remote projects from other machines (scans Kimaki groups in Discord)')
     .option('-g, --guild <guildId>', 'Discord guild/server ID to scan (used with --all when no local projects exist)')
     .option('--prune', 'Remove stale entries whose Discord channel no longer exists')
     .action(async (options) => {
@@ -131,7 +114,8 @@ cli
             }
             catch (error) {
                 // Only mark as deleted for Unknown Channel (10003) or 404,
-                // not transient errors like rate limits or 5xx
+                // not transient errors like rate limits or 5xx.
+                // Gateway-proxy must return Discord 404 for unknown channels, not 403.
                 const code = error instanceof Error ? Reflect.get(error, 'code') : undefined;
                 const status = error instanceof Error ? Reflect.get(error, 'status') : undefined;
                 const isUnknownChannel = code === 10003 || status === 404;
@@ -174,12 +158,15 @@ cli
             process.exit(EXIT_NO_RESTART);
         }
         let guildScanFailures = 0;
+        const storedCategoryIds = new Set(await listGuildCategoryIds());
         for (const guildId of uniqueGuildIds) {
             try {
                 const guildChannels = (await rest.get(Routes.guildChannels(guildId)));
-                // Find Kimaki category channels (type 4 = GuildCategory)
+                // Kimaki groups: name still starts with Kimaki, or this machine stored the id
+                // after a rename. Other machines' renamed groups cannot be found by name.
                 const kimakiCategoryIds = new Set(guildChannels
-                    .filter((ch) => ch.type === 4 && /^kimaki(\s|$)/i.test(ch.name))
+                    .filter((ch) => ch.type === 4 &&
+                    (/^kimaki(\s|$)/i.test(ch.name) || storedCategoryIds.has(ch.id)))
                     .map((ch) => ch.id));
                 // Find text channels (type 0) in Kimaki categories that are not in our local DB
                 for (const ch of guildChannels) {

package/dist/cli-commands/send.js

@@ -21,6 +21,7 @@ import { ShareMarkdown } from '../markdown.js';
 import { parseSessionSearchPattern, findFirstSessionSearchHit, buildSessionSearchSnippet, getPartSearchTexts } from '../session-search.js';
 import { formatWorktreeName, formatAutoWorktreeName } from '../commands/new-worktree.js';
 import { WORKTREE_PREFIX } from '../commands/merge-worktree.js';
+import { QUEUE_PREFIX } from '../message-formatting.js';
 import { buildOpencodeEventLogLine } from '../session-handler/opencode-session-event-log.js';
 import { createDiscordRest } from '../discord-urls.js';
 import { archiveThread, ensureThreadMember, uploadFilesToDiscord, stripMentions } from '../discord-utils.js';
@@ -394,6 +395,10 @@ cli
             }
             const threadPromptMarker = {
                 start: true,
+                ...(threadTargetUser && {
+                    userId: threadTargetUser.id,
+                    ...(threadTargetUser.username && { username: threadTargetUser.username }),
+                }),
                 ...(options.agent && { agent: options.agent }),
                 ...(options.model && { model: options.model }),
                 ...(options.permission?.length ? { permissions: options.permission } : {}),
@@ -409,7 +414,7 @@ cli
             // Prefix the prompt so it's clear who sent it (matches /queue format).
             // Use a newline between prefix and prompt so leading /command
             // detection can find the command on its own line.
-            const prefixedPrompt = `» **kimaki-cli:**\n${prompt}`;
+            const prefixedPrompt = `${QUEUE_PREFIX}**kimaki-cli:**\n${prompt}`;
             if (threadTargetUser) {
                 cliLogger.log(`Adding user ${threadTargetUser.username || threadTargetUser.id} to thread...`);
                 const addMemberResult = await ensureThreadMember({