kimaki 0.4.76 → 0.4.78

package/dist/diff-patch-plugin.js

@@ -0,0 +1,314 @@
+// Tracks tool-driven file changes and writes per-message/session .patch files
+// to $KIMAKI_DATA_DIR/diffs/ (default ~/.kimaki/diffs/).
+//
+// The bot process reads these patch files in emitFooter() to upload them via
+// critique and append [ses diff] / [msg diff] links to the footer message.
+//
+// Lifecycle:
+//   tool.execute.before → snapshot file contents before edit
+//   tool.execute.after  → snapshot again, record the delta
+//   message.updated (completed) → write {sessionId}-{messageId}.patch
+//   session.idle         → write {sessionId}.patch (cumulative, overwrites)
+//   session.deleted      → cleanup in-memory state
+//
+// Pruning: caps the diffs folder at MAX_PATCH_FILES, deleting oldest by mtime.
+import { createTwoFilesPatch } from 'diff';
+import fs from 'node:fs';
+import path from 'node:path';
+import { extractPatchFilePaths } from './patch-text-parser.js';
+const TOOLS = new Set(['edit', 'write', 'apply_patch', 'multiedit']);
+// Skip files larger than 512KB to avoid memory spikes
+const MAX_FILE_BYTES = 512 * 1024;
+// Max patch files before pruning oldest
+const MAX_PATCH_FILES = 200;
+// Pending tool calls older than 10 min are garbage collected
+const PENDING_TTL_MS = 10 * 60 * 1000;
+function extractPaths(tool, args) {
+    if (tool === 'edit' || tool === 'write' || tool === 'multiedit') {
+        return typeof args.filePath === 'string' ? [args.filePath] : [];
+    }
+    if (tool === 'apply_patch') {
+        const text = (args.patchText ?? args.patch ?? '');
+        return extractPatchFilePaths(text);
+    }
+    return [];
+}
+function buildPatch(files) {
+    const parts = [];
+    for (const [file, { first, last }] of files) {
+        if (first === last) {
+            continue;
+        }
+        parts.push(createTwoFilesPatch(file, file, first, last));
+    }
+    return parts.join('\n');
+}
+async function readSafe(file) {
+    const stat = await fs.promises.stat(file).catch(() => {
+        return undefined;
+    });
+    if (!stat) {
+        return '';
+    }
+    if (!stat.isFile() || stat.size > MAX_FILE_BYTES) {
+        return undefined;
+    }
+    return fs.promises.readFile(file, 'utf8').catch(() => {
+        return '';
+    });
+}
+async function prunePatchDir(dir) {
+    const entries = await fs.promises.readdir(dir).catch(() => {
+        return [];
+    });
+    if (entries.length <= MAX_PATCH_FILES) {
+        return;
+    }
+    const files = (await Promise.all(entries.map(async (name) => {
+        const full = path.join(dir, name);
+        const stat = await fs.promises.stat(full).catch(() => {
+            return undefined;
+        });
+        return stat?.isFile() ? { full, mtime: stat.mtimeMs } : undefined;
+    }))).filter((f) => {
+        return f !== undefined;
+    });
+    files.sort((a, b) => {
+        return b.mtime - a.mtime;
+    });
+    await Promise.all(files.slice(MAX_PATCH_FILES).map((f) => {
+        return fs.promises.unlink(f.full).catch(() => { });
+    }));
+}
+// Atomic write: write to a temp file then rename to avoid torn reads
+// from the bot process reading a partially-written patch.
+// If content is empty, deletes any existing file so stale patches from
+// previous turns aren't re-uploaded by the bot.
+async function writePatch({ dir, name, content, }) {
+    const target = path.join(dir, name);
+    if (!content) {
+        await fs.promises.unlink(target).catch(() => { });
+        return;
+    }
+    await fs.promises.mkdir(dir, { recursive: true });
+    const tmp = `${target}.tmp.${process.pid}`;
+    await fs.promises.writeFile(tmp, content);
+    await fs.promises.rename(tmp, target);
+    await prunePatchDir(dir);
+}
+const diffPatchPlugin = async (input) => {
+    const dataDir = process.env.KIMAKI_DATA_DIR || path.join(process.env.HOME || '~', '.kimaki');
+    const dir = path.join(dataDir, 'diffs');
+    // session → file → { first snapshot, last snapshot }
+    const sessions = new Map();
+    // session → messageId → file → { first, last }
+    const messages = new Map();
+    // callID → pending tool info (for matching before/after)
+    const pending = new Map();
+    // session → current active assistant messageId
+    const activeMessage = new Map();
+    // dedup guard: "sessionID:messageID:completedTimestamp"
+    const completed = new Set();
+    // child session → root (top-level) parent session.
+    // When a task tool spawns a subtask, tools inside that subtask fire with
+    // the child sessionID. We resolve up to the root parent so file snapshots
+    // always roll up into the top-level session's cumulative patch.
+    const childToRoot = new Map();
+    /** Resolve up the parent chain to find the root (top-level) session. */
+    function resolveRoot(sessionID) {
+        return childToRoot.get(sessionID) ?? sessionID;
+    }
+    function ensureSession(sessionID) {
+        if (!sessions.has(sessionID)) {
+            sessions.set(sessionID, new Map());
+        }
+        if (!messages.has(sessionID)) {
+            messages.set(sessionID, new Map());
+        }
+    }
+    function ensureMessage(sessionID, messageID) {
+        const msgs = messages.get(sessionID);
+        if (!msgs.has(messageID)) {
+            msgs.set(messageID, new Map());
+        }
+    }
+    function setFirst(map, file, content) {
+        if (!map.has(file)) {
+            map.set(file, { first: content, last: content });
+        }
+    }
+    function prunePending() {
+        const now = Date.now();
+        for (const [id, item] of pending) {
+            if (now - item.createdAt > PENDING_TTL_MS) {
+                pending.delete(id);
+            }
+        }
+    }
+    function cleanupSession(sessionID) {
+        sessions.delete(sessionID);
+        messages.delete(sessionID);
+        activeMessage.delete(sessionID);
+        for (const [id, p] of pending) {
+            if (p.sessionID === sessionID) {
+                pending.delete(id);
+            }
+        }
+        for (const key of completed) {
+            if (key.startsWith(sessionID + ':')) {
+                completed.delete(key);
+            }
+        }
+        // Clean up child→root mappings pointing to or from this session
+        for (const [child, root] of childToRoot) {
+            if (child === sessionID || root === sessionID) {
+                childToRoot.delete(child);
+            }
+        }
+    }
+    return {
+        'tool.execute.before': async ({ tool, sessionID, callID }, { args }) => {
+            if (!TOOLS.has(tool)) {
+                return;
+            }
+            const raw = extractPaths(tool, args);
+            if (!raw.length) {
+                return;
+            }
+            prunePending();
+            // Resolve root session so child edits roll up into the parent's patch.
+            const rootID = resolveRoot(sessionID);
+            ensureSession(rootID);
+            const rootFiles = sessions.get(rootID);
+            const msgID = activeMessage.get(rootID);
+            const captured = [];
+            for (const r of raw) {
+                const p = path.isAbsolute(r)
+                    ? r
+                    : path.resolve(input.directory, r);
+                const content = await readSafe(p);
+                if (content === undefined) {
+                    continue;
+                }
+                setFirst(rootFiles, p, content);
+                if (msgID) {
+                    ensureMessage(rootID, msgID);
+                    setFirst(messages.get(rootID).get(msgID), p, content);
+                }
+                captured.push(p);
+            }
+            if (captured.length) {
+                pending.set(callID, {
+                    // Store rootID so tool.execute.after updates the correct maps
+                    sessionID: rootID,
+                    messageID: msgID,
+                    paths: captured,
+                    createdAt: Date.now(),
+                });
+            }
+        },
+        'tool.execute.after': async ({ callID }) => {
+            prunePending();
+            const call = pending.get(callID);
+            if (!call) {
+                return;
+            }
+            pending.delete(callID);
+            const sessionFiles = sessions.get(call.sessionID);
+            // Use messageID captured at before-time, not current activeMessage
+            const msgFiles = call.messageID
+                ? messages.get(call.sessionID)?.get(call.messageID)
+                : undefined;
+            for (const p of call.paths) {
+                const content = await readSafe(p);
+                if (content === undefined) {
+                    continue;
+                }
+                const s = sessionFiles.get(p);
+                if (s) {
+                    s.last = content;
+                }
+                if (msgFiles) {
+                    const m = msgFiles.get(p);
+                    if (m) {
+                        m.last = content;
+                    }
+                }
+            }
+        },
+        event: async ({ event }) => {
+            // Track child→root session mapping from session.updated events.
+            // OpenCode emits session.updated with parentID set when a task tool
+            // creates a child session. This fires BEFORE the child starts executing
+            // tools, so the mapping is ready when child tool.execute.before fires.
+            if (event.type === 'session.updated') {
+                const info = event.properties.info;
+                if (info.id && info.parentID) {
+                    const rootID = resolveRoot(info.parentID);
+                    childToRoot.set(info.id, rootID);
+                }
+            }
+            if (event.type === 'message.updated' &&
+                event.properties.info.role === 'assistant') {
+                const msg = event.properties.info;
+                activeMessage.set(msg.sessionID, msg.id);
+                if (msg.time.completed) {
+                    const key = `${msg.sessionID}:${msg.id}:${msg.time.completed}`;
+                    if (completed.has(key)) {
+                        return;
+                    }
+                    completed.add(key);
+                    const msgFiles = messages.get(msg.sessionID)?.get(msg.id);
+                    if (msgFiles?.size) {
+                        const patch = buildPatch(msgFiles);
+                        await writePatch({
+                            dir,
+                            name: `${msg.sessionID}-${msg.id}.patch`,
+                            content: patch,
+                        });
+                    }
+                    messages.get(msg.sessionID)?.delete(msg.id);
+                }
+                return;
+            }
+            if (event.type === 'session.idle') {
+                const sessionID = event.properties.sessionID;
+                // Child sessions: edits already rolled up into root, skip patch write.
+                if (childToRoot.has(sessionID)) {
+                    return;
+                }
+                const sessionFiles = sessions.get(sessionID);
+                if (sessionFiles?.size) {
+                    const patch = buildPatch(sessionFiles);
+                    await writePatch({
+                        dir,
+                        name: `${sessionID}.patch`,
+                        content: patch,
+                    });
+                    // Reset first snapshots to current state so next turn is incremental
+                    for (const state of sessionFiles.values()) {
+                        state.first = state.last;
+                    }
+                }
+                messages.get(sessionID)?.clear();
+                activeMessage.delete(sessionID);
+                for (const [id, p] of pending) {
+                    if (p.sessionID === sessionID) {
+                        pending.delete(id);
+                    }
+                }
+                // Clear completed dedup keys for this session to bound memory growth
+                for (const key of completed) {
+                    if (key.startsWith(sessionID + ':')) {
+                        completed.delete(key);
+                    }
+                }
+                return;
+            }
+            if (event.type === 'session.deleted') {
+                cleanupSession(event.properties.info.id);
+            }
+        },
+    };
+};
+export default diffPatchPlugin;

package/dist/discord-bot.js

@@ -14,6 +14,7 @@ import { preprocessExistingThreadMessage, preprocessNewThreadMessage, } from './
 import { cancelPendingActionButtons } from './commands/action-buttons.js';
 import { cancelPendingQuestion } from './commands/ask-question.js';
 import { cancelPendingFileUpload } from './commands/file-upload.js';
+import { cancelPendingPermission } from './commands/permissions.js';
 import { cancelHtmlActionsForThread } from './html-actions.js';
 import { ensureKimakiCategory, ensureKimakiAudioCategory, createProjectChannels, getChannelsWithDescriptions, } from './channel-management.js';
 import { voiceConnections, cleanupVoiceConnection, registerVoiceStateHandler, } from './voice-handler.js';
@@ -330,19 +331,6 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
             if (isThread) {
                 const thread = channel;
                 discordLogger.log(`Message in thread ${thread.name} (${thread.id})`);
-                // Cancel interactive UI when a real user sends a message.
-                // If a question was pending and answered with the user's text,
-                // early-return: the message was consumed as the question answer
-                // and must NOT also be sent as a new prompt (causes abort loops).
-                if (!message.author.bot && !isCliInjectedPrompt) {
-                    cancelPendingActionButtons(thread.id);
-                    cancelHtmlActionsForThread(thread.id);
-                    const questionResult = await cancelPendingQuestion(thread.id, message.content);
-                    void cancelPendingFileUpload(thread.id);
-                    if (questionResult === 'replied') {
-                        return;
-                    }
-                }
                 const parent = thread.parent;
                 let projectDirectory;
                 if (parent) {
@@ -424,6 +412,23 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                     channelId: parent?.id || undefined,
                     appId: currentAppId,
                 });
+                // Cancel interactive UI when a real user sends a message.
+                // If a question was pending and answered with the user's text,
+                // early-return: the message was consumed as the question answer
+                // and must NOT also be sent as a new prompt (causes abort loops).
+                if (!message.author.bot && !isCliInjectedPrompt) {
+                    cancelPendingActionButtons(thread.id);
+                    cancelHtmlActionsForThread(thread.id);
+                    const dismissedPermission = await cancelPendingPermission(thread.id);
+                    if (dismissedPermission) {
+                        runtime.abortActiveRun('user sent a new message while permission was pending');
+                    }
+                    const questionResult = await cancelPendingQuestion(thread.id, message.content);
+                    void cancelPendingFileUpload(thread.id);
+                    if (questionResult === 'replied') {
+                        return;
+                    }
+                }
                 // Expensive pre-processing (voice transcription, context fetch,
                 // attachment download) runs inside the runtime's serialized
                 // preprocess chain, preserving Discord arrival order without
@@ -594,7 +599,7 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                 });
             }
             else {
-                discordLogger.log(`Channel type ${channel.type} is not supported`);
+                // discordLogger.log(`Channel type ${channel.type} is not supported`)
             }
         }
         catch (error) {

package/dist/discord-js-import-boundary.test.js

@@ -0,0 +1,62 @@
+// Guardrail test for adapter boundary imports.
+// Runtime modules must not import discord.js directly outside the Discord adapter,
+// forum-sync bridge, and voice handler.
+import fs from 'node:fs';
+import path from 'node:path';
+import { describe, expect, test } from 'vitest';
+const SRC_DIR = path.resolve(import.meta.dirname);
+function collectTsFiles(dir) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    return entries.flatMap((entry) => {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            return collectTsFiles(fullPath);
+        }
+        if (!entry.name.endsWith('.ts')) {
+            return [];
+        }
+        if (entry.name.endsWith('.test.ts')) {
+            return [];
+        }
+        if (entry.name.includes('e2e')) {
+            return [];
+        }
+        return [fullPath];
+    });
+}
+function toWorkspaceRelative(filePath) {
+    return path.relative(path.resolve(import.meta.dirname, '..'), filePath);
+}
+function isAllowedBoundaryFile(relativePath) {
+    if (relativePath === 'src/platform/discord-adapter.ts') {
+        return true;
+    }
+    if (relativePath === 'src/voice-handler.ts') {
+        return true;
+    }
+    if (relativePath.startsWith('src/forum-sync/')) {
+        return true;
+    }
+    return false;
+}
+describe('discord.js import boundary', () => {
+    test('does not import discord.js outside allowed modules', () => {
+        const violations = collectTsFiles(SRC_DIR)
+            .map((filePath) => {
+            return {
+                relativePath: toWorkspaceRelative(filePath),
+                content: fs.readFileSync(filePath, 'utf8'),
+            };
+        })
+            .filter(({ relativePath }) => {
+            return !isAllowedBoundaryFile(relativePath);
+        })
+            .filter(({ content }) => {
+            return /from\s+['"]discord\.js['"]/.test(content);
+        })
+            .map(({ relativePath }) => {
+            return relativePath;
+        });
+        expect(violations).toMatchInlineSnapshot(`[]`);
+    });
+});

package/dist/discord-utils.js

@@ -480,6 +480,50 @@ export async function getKimakiMetadata(textChannel) {
         projectDirectory: channelConfig.directory,
     };
 }
+/**
+ * Resolve project directory from an autocomplete interaction.
+ * Uses interaction.channelId (always available from raw payload) instead of
+ * interaction.channel (cache-based getter, often null with gateway-proxy).
+ * Checks the channel ID directly in DB, then tries thread worktree lookup,
+ * then falls back to fetching the channel to resolve thread parent.
+ */
+export async function resolveProjectDirectoryFromAutocomplete(interaction) {
+    const channelId = interaction.channelId;
+    // Direct channel lookup — works when the command is run from a project text channel
+    const channelConfig = await getChannelDirectory(channelId);
+    if (channelConfig) {
+        return channelConfig.directory;
+    }
+    // If we're in a thread, try worktree info first (has project_directory)
+    const worktreeInfo = await getThreadWorktree(channelId);
+    if (worktreeInfo?.project_directory) {
+        return worktreeInfo.project_directory;
+    }
+    // Thread fallback: resolve parent channel ID and look up its directory.
+    // Try cached channel first, then fetch if cache misses (gateway-proxy scenario).
+    const cachedParentId = interaction.channel?.isThread() ? interaction.channel.parentId : null;
+    if (cachedParentId) {
+        const parentConfig = await getChannelDirectory(cachedParentId);
+        if (parentConfig) {
+            return parentConfig.directory;
+        }
+    }
+    // Last resort: fetch the channel from Discord API to get parentId for threads
+    // when the channel isn't cached at all (common with gateway-proxy).
+    if (!cachedParentId) {
+        const fetched = await errore.tryAsync({
+            try: () => { return interaction.client.channels.fetch(channelId); },
+            catch: (e) => { return e; },
+        });
+        if (!(fetched instanceof Error) && fetched?.isThread() && fetched.parentId) {
+            const parentConfig = await getChannelDirectory(fetched.parentId);
+            if (parentConfig) {
+                return parentConfig.directory;
+            }
+        }
+    }
+    return undefined;
+}
 /**
  * Resolve the working directory for a channel or thread.
  * Returns both the base project directory (for server init) and the working directory

package/dist/event-stream-real-capture.e2e.test.js

@@ -2,7 +2,6 @@
 // Uses opencode-cached-provider + Gemini to record real tool/lifecycle streams
 // (task, interruption, permission, action buttons, and question flows).
 import fs from 'node:fs';
-import net from 'node:net';
 import path from 'node:path';
 import { afterAll, afterEach, beforeAll, describe, expect, test } from 'vitest';
 import { ChannelType, Client, GatewayIntentBits, Partials } from 'discord.js';
@@ -13,7 +12,7 @@ import { store } from './store.js';
 import { startDiscordBot } from './discord-bot.js';
 import { closeDatabase, getChannelVerbosity, initDatabase, setBotToken, setChannelDirectory, setChannelVerbosity, } from './database.js';
 import { startHranaServer, stopHranaServer } from './hrana-server.js';
-import { cleanupTestSessions } from './test-utils.js';
+import { chooseLockPort, cleanupTestSessions } from './test-utils.js';
 import { waitForBotMessageContaining, waitForBotReplyAfterUserMessage } from './test-utils.js';
 import { stopOpencodeServer } from './opencode.js';
 import { disposeRuntime, pendingPermissions } from './session-handler/thread-session-runtime.js';
@@ -46,23 +45,6 @@ function createRunDirectories() {
         fixtureOutputDir,
     };
 }
-function chooseLockPort() {
-    return new Promise((resolve, reject) => {
-        const server = net.createServer();
-        server.listen(0, () => {
-            const address = server.address();
-            if (!address || typeof address === 'string') {
-                server.close();
-                reject(new Error('Failed to resolve lock port'));
-                return;
-            }
-            const port = address.port;
-            server.close(() => {
-                resolve(port);
-            });
-        });
-    });
-}
 function createDiscordJsClient({ restUrl }) {
     return new Client({
         intents: [
@@ -248,7 +230,7 @@ describe('real event stream capture fixtures (cached provider)', () => {
     }
     beforeAll(async () => {
         testStartTime = Date.now();
-        lockPort = await chooseLockPort();
+        lockPort = chooseLockPort({ key: TEXT_CHANNEL_ID });
         listJsonlFiles(directories.sessionEventsDir).forEach((fileName) => {
             fs.rmSync(path.join(directories.sessionEventsDir, fileName), {
                 force: true,

package/dist/gateway-proxy.e2e.test.js

@@ -19,7 +19,7 @@ import { startHranaServer, stopHranaServer } from './hrana-server.js';
 import { setBotToken, initDatabase, closeDatabase, setChannelDirectory, } from './database.js';
 import { setDataDir } from './config.js';
 import { startDiscordBot } from './discord-bot.js';
-import { cleanupTestSessions, waitForFooterMessage, } from './test-utils.js';
+import { chooseLockPort, cleanupTestSessions, waitForFooterMessage, } from './test-utils.js';
 import { stopOpencodeServer } from './opencode.js';
 import { createDiscordRest } from './discord-urls.js';
 import { store } from './store.js';
@@ -57,9 +57,6 @@ function createRunDirectories() {
     fs.mkdirSync(projectDirectory, { recursive: true });
     return { root, dataDir, projectDirectory };
 }
-function chooseLockPort() {
-    return getAvailablePort();
-}
 function createDiscordJsClient({ restUrl }) {
     return new Client({
         intents: [
@@ -189,7 +186,7 @@ describeIf('gateway-proxy e2e', () => {
     let testStartTime = Date.now();
     beforeAll(async () => {
         testStartTime = Date.now();
-        const lockPort = await chooseLockPort();
+        const lockPort = chooseLockPort({ key: CHANNEL_1_ID });
         directories = createRunDirectories();
         process.env['KIMAKI_LOCK_PORT'] = String(lockPort);
         process.env['KIMAKI_VITEST'] = '1';

package/dist/generated/cloudflare/browser.js

@@ -0,0 +1,17 @@
+/* !!! This is code generated by Prisma. Do not edit directly. !!! */
+/* eslint-disable */
+// biome-ignore-all lint: generated file
+// @ts-nocheck 
+/*
+ * This file should be your main import to use Prisma-related types and utilities in a browser.
+ * Use it to get access to models, enums, and input types.
+ *
+ * This file does not contain a `PrismaClient` class, nor several other helpers that are intended as server-side only.
+ * See `client.ts` for the standard, server-side entry point.
+ *
+ * 🟢 You can import this file directly.
+ */
+import * as Prisma from './internal/prismaNamespaceBrowser.js';
+export { Prisma };
+export * as $Enums from './enums.js';
+export * from './enums.js';

package/dist/generated/cloudflare/client.js

@@ -0,0 +1,34 @@
+/* !!! This is code generated by Prisma. Do not edit directly. !!! */
+/* eslint-disable */
+// biome-ignore-all lint: generated file
+// @ts-nocheck 
+/*
+ * This file should be your main import to use Prisma. Through it you get access to all the models, enums, and input types.
+ * If you're looking for something you can import in the client-side of your application, please refer to the `browser.ts` file instead.
+ *
+ * 🟢 You can import this file directly.
+ */
+globalThis['__dirname'] = '/';
+import * as runtime from "@prisma/client/runtime/wasm-compiler-edge";
+import * as $Enums from "./enums.js";
+import * as $Class from "./internal/class.js";
+import * as Prisma from "./internal/prismaNamespace.js";
+export * as $Enums from './enums.js';
+export * from "./enums.js";
+/**
+ * ## Prisma Client
+ *
+ * Type-safe database client for TypeScript
+ * @example
+ * ```
+ * const prisma = new PrismaClient({
+ *   adapter: new PrismaPg({ connectionString: process.env.DATABASE_URL })
+ * })
+ * // Fetch zero or more Thread_sessions
+ * const thread_sessions = await prisma.thread_sessions.findMany()
+ * ```
+ *
+ * Read more in our [docs](https://pris.ly/d/client).
+ */
+export const PrismaClient = $Class.getPrismaClientClass();
+export { Prisma };

package/dist/generated/cloudflare/commonInputTypes.js

@@ -0,0 +1,10 @@
+/* !!! This is code generated by Prisma. Do not edit directly. !!! */
+/* eslint-disable */
+// biome-ignore-all lint: generated file
+// @ts-nocheck 
+/*
+ * This file exports various common sort, input & filter types that are not directly linked to a particular model.
+ *
+ * 🟢 You can import this file directly.
+ */
+import * as $Enums from "./enums.js";

package/dist/generated/cloudflare/enums.js

@@ -0,0 +1,48 @@
+/* !!! This is code generated by Prisma. Do not edit directly. !!! */
+/* eslint-disable */
+// biome-ignore-all lint: generated file
+// @ts-nocheck 
+/*
+* This file exports all enum related types from the schema.
+*
+* 🟢 You can import this file directly.
+*/
+export const BotMode = {
+    self_hosted: 'self_hosted',
+    gateway: 'gateway'
+};
+export const ChannelType = {
+    text: 'text',
+    voice: 'voice'
+};
+export const WorktreeStatus = {
+    pending: 'pending',
+    ready: 'ready',
+    error: 'error'
+};
+export const VerbosityLevel = {
+    tools_and_text: 'tools_and_text',
+    text_and_essential_tools: 'text_and_essential_tools',
+    text_only: 'text_only'
+};
+export const task_status = {
+    planned: 'planned',
+    running: 'running',
+    completed: 'completed',
+    cancelled: 'cancelled',
+    failed: 'failed'
+};
+export const task_schedule_kind = {
+    at: 'at',
+    cron: 'cron'
+};
+export const ipc_request_type = {
+    file_upload: 'file_upload',
+    action_buttons: 'action_buttons'
+};
+export const ipc_request_status = {
+    pending: 'pending',
+    processing: 'processing',
+    completed: 'completed',
+    cancelled: 'cancelled'
+};