@otto-assistant/bridge 0.4.92

package/dist/anthropic-auth-plugin.test.js

@@ -0,0 +1,125 @@
+// Tests for Anthropic OAuth multi-account persistence and rotation.
+import { mkdtemp, readFile, rm, mkdir, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, test } from 'vitest';
+import { authFilePath, loadAccountStore, rememberAnthropicOAuth, removeAccount, rotateAnthropicAccount, saveAccountStore, shouldRotateAuth, } from './anthropic-auth-state.js';
+const firstAccount = {
+    type: 'oauth',
+    refresh: 'refresh-first',
+    access: 'access-first',
+    expires: 1,
+};
+const secondAccount = {
+    type: 'oauth',
+    refresh: 'refresh-second',
+    access: 'access-second',
+    expires: 2,
+};
+let originalXdgDataHome;
+let tempDir = '';
+beforeEach(async () => {
+    originalXdgDataHome = process.env.XDG_DATA_HOME;
+    tempDir = await mkdtemp(path.join(tmpdir(), 'anthropic-auth-plugin-'));
+    process.env.XDG_DATA_HOME = tempDir;
+});
+afterEach(async () => {
+    if (originalXdgDataHome === undefined) {
+        delete process.env.XDG_DATA_HOME;
+    }
+    else {
+        process.env.XDG_DATA_HOME = originalXdgDataHome;
+    }
+    await rm(tempDir, { force: true, recursive: true });
+});
+describe('rememberAnthropicOAuth', () => {
+    test('stores accounts and updates existing entries by refresh token', async () => {
+        await rememberAnthropicOAuth(firstAccount);
+        await rememberAnthropicOAuth({ ...firstAccount, access: 'access-first-new', expires: 3 });
+        const store = await loadAccountStore();
+        expect(store.activeIndex).toBe(0);
+        expect(store.accounts).toHaveLength(1);
+        expect(store.accounts[0]).toMatchObject({
+            refresh: 'refresh-first',
+            access: 'access-first-new',
+            expires: 3,
+        });
+    });
+});
+describe('rotateAnthropicAccount', () => {
+    test('rotates to the next stored account and syncs auth state', async () => {
+        await saveAccountStore({
+            version: 1,
+            activeIndex: 0,
+            accounts: [
+                { ...firstAccount, addedAt: 1, lastUsed: 1 },
+                { ...secondAccount, addedAt: 2, lastUsed: 2 },
+            ],
+        });
+        const authSetCalls = [];
+        const client = {
+            auth: {
+                set: async (input) => {
+                    authSetCalls.push(input);
+                },
+            },
+        };
+        const rotated = await rotateAnthropicAccount(firstAccount, client);
+        const store = await loadAccountStore();
+        const authJson = JSON.parse(await readFile(authFilePath(), 'utf8'));
+        expect(rotated).toMatchObject({ refresh: 'refresh-second' });
+        expect(store.activeIndex).toBe(1);
+        expect(authJson.anthropic?.refresh).toBe('refresh-second');
+        expect(authSetCalls).toEqual([
+            {
+                path: { id: 'anthropic' },
+                body: {
+                    type: 'oauth',
+                    refresh: 'refresh-second',
+                    access: 'access-second',
+                    expires: 2,
+                },
+            },
+        ]);
+    });
+});
+describe('removeAccount', () => {
+    test('removing the active account promotes the next stored account', async () => {
+        await saveAccountStore({
+            version: 1,
+            activeIndex: 1,
+            accounts: [
+                { ...firstAccount, addedAt: 1, lastUsed: 1 },
+                { ...secondAccount, addedAt: 2, lastUsed: 2 },
+            ],
+        });
+        await removeAccount(1);
+        const store = await loadAccountStore();
+        const authJson = JSON.parse(await readFile(authFilePath(), 'utf8'));
+        expect(store.activeIndex).toBe(0);
+        expect(store.accounts).toHaveLength(1);
+        expect(store.accounts[0]?.refresh).toBe('refresh-first');
+        expect(authJson.anthropic?.refresh).toBe('refresh-first');
+    });
+    test('removing the last account clears active Anthropic auth', async () => {
+        await saveAccountStore({
+            version: 1,
+            activeIndex: 0,
+            accounts: [{ ...firstAccount, addedAt: 1, lastUsed: 1 }],
+        });
+        await mkdir(path.dirname(authFilePath()), { recursive: true });
+        await writeFile(authFilePath(), JSON.stringify({ anthropic: firstAccount }, null, 2));
+        await removeAccount(0);
+        const store = await loadAccountStore();
+        const authJson = JSON.parse(await readFile(authFilePath(), 'utf8'));
+        expect(store.accounts).toHaveLength(0);
+        expect(authJson.anthropic).toBeUndefined();
+    });
+});
+describe('shouldRotateAuth', () => {
+    test('only rotates on rate limit or auth failures', () => {
+        expect(shouldRotateAuth(429, '')).toBe(true);
+        expect(shouldRotateAuth(401, 'permission_error')).toBe(true);
+        expect(shouldRotateAuth(400, 'bad request')).toBe(false);
+    });
+});

package/dist/anthropic-auth-state.js

@@ -0,0 +1,231 @@
+import * as fs from 'node:fs/promises';
+import { homedir } from 'node:os';
+import path from 'node:path';
+const AUTH_LOCK_STALE_MS = 30_000;
+const AUTH_LOCK_RETRY_MS = 100;
+async function readJson(filePath, fallback) {
+    try {
+        return JSON.parse(await fs.readFile(filePath, 'utf8'));
+    }
+    catch {
+        return fallback;
+    }
+}
+async function writeJson(filePath, value) {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, JSON.stringify(value, null, 2), 'utf8');
+    await fs.chmod(filePath, 0o600);
+}
+function getErrorCode(error) {
+    if (!(error instanceof Error))
+        return undefined;
+    return error.code;
+}
+async function sleep(ms) {
+    await new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+export function authFilePath() {
+    if (process.env.XDG_DATA_HOME) {
+        return path.join(process.env.XDG_DATA_HOME, 'opencode', 'auth.json');
+    }
+    return path.join(homedir(), '.local', 'share', 'opencode', 'auth.json');
+}
+export function accountsFilePath() {
+    if (process.env.XDG_DATA_HOME) {
+        return path.join(process.env.XDG_DATA_HOME, 'opencode', 'anthropic-oauth-accounts.json');
+    }
+    return path.join(homedir(), '.local', 'share', 'opencode', 'anthropic-oauth-accounts.json');
+}
+export async function withAuthStateLock(fn) {
+    const file = authFilePath();
+    const lockDir = `${file}.lock`;
+    const deadline = Date.now() + AUTH_LOCK_STALE_MS;
+    await fs.mkdir(path.dirname(file), { recursive: true });
+    while (true) {
+        try {
+            await fs.mkdir(lockDir);
+            break;
+        }
+        catch (error) {
+            const code = getErrorCode(error);
+            if (code !== 'EEXIST') {
+                throw error;
+            }
+            const stats = await fs.stat(lockDir).catch(() => {
+                return null;
+            });
+            if (stats && Date.now() - stats.mtimeMs > AUTH_LOCK_STALE_MS) {
+                await fs.rm(lockDir, { force: true, recursive: true }).catch(() => { });
+                continue;
+            }
+            if (Date.now() >= deadline) {
+                throw new Error(`Timed out waiting for auth lock: ${lockDir}`);
+            }
+            await sleep(AUTH_LOCK_RETRY_MS);
+        }
+    }
+    try {
+        return await fn();
+    }
+    finally {
+        await fs.rm(lockDir, { force: true, recursive: true }).catch(() => { });
+    }
+}
+export function normalizeAccountStore(input) {
+    const accounts = Array.isArray(input?.accounts)
+        ? input.accounts.filter((account) => !!account &&
+            account.type === 'oauth' &&
+            typeof account.refresh === 'string' &&
+            typeof account.access === 'string' &&
+            typeof account.expires === 'number' &&
+            typeof account.addedAt === 'number' &&
+            typeof account.lastUsed === 'number')
+        : [];
+    const rawIndex = typeof input?.activeIndex === 'number' ? Math.floor(input.activeIndex) : 0;
+    const activeIndex = accounts.length === 0 ? 0 : ((rawIndex % accounts.length) + accounts.length) % accounts.length;
+    return { version: 1, activeIndex, accounts };
+}
+export async function loadAccountStore() {
+    const raw = await readJson(accountsFilePath(), null);
+    return normalizeAccountStore(raw);
+}
+export async function saveAccountStore(store) {
+    await writeJson(accountsFilePath(), normalizeAccountStore(store));
+}
+function findCurrentAccountIndex(store, auth) {
+    if (!store.accounts.length)
+        return 0;
+    const byRefresh = store.accounts.findIndex((account) => {
+        return account.refresh === auth.refresh;
+    });
+    if (byRefresh >= 0)
+        return byRefresh;
+    const byAccess = store.accounts.findIndex((account) => {
+        return account.access === auth.access;
+    });
+    if (byAccess >= 0)
+        return byAccess;
+    return store.activeIndex;
+}
+export function upsertAccount(store, auth, now = Date.now()) {
+    const index = store.accounts.findIndex((account) => {
+        return account.refresh === auth.refresh || account.access === auth.access;
+    });
+    const nextAccount = {
+        type: 'oauth',
+        refresh: auth.refresh,
+        access: auth.access,
+        expires: auth.expires,
+        addedAt: now,
+        lastUsed: now,
+    };
+    if (index < 0) {
+        store.accounts.push(nextAccount);
+        store.activeIndex = store.accounts.length - 1;
+        return store.activeIndex;
+    }
+    const existing = store.accounts[index];
+    if (!existing)
+        return index;
+    store.accounts[index] = {
+        ...existing,
+        ...nextAccount,
+        addedAt: existing.addedAt,
+    };
+    store.activeIndex = index;
+    return index;
+}
+export async function rememberAnthropicOAuth(auth) {
+    await withAuthStateLock(async () => {
+        const store = await loadAccountStore();
+        upsertAccount(store, auth);
+        await saveAccountStore(store);
+    });
+}
+async function writeAnthropicAuthFile(auth) {
+    const file = authFilePath();
+    const data = await readJson(file, {});
+    if (auth) {
+        data.anthropic = auth;
+    }
+    else {
+        delete data.anthropic;
+    }
+    await writeJson(file, data);
+}
+export async function setAnthropicAuth(auth, client) {
+    await writeAnthropicAuthFile(auth);
+    await client.auth.set({ path: { id: 'anthropic' }, body: auth });
+}
+export async function rotateAnthropicAccount(auth, client) {
+    return withAuthStateLock(async () => {
+        const store = await loadAccountStore();
+        if (store.accounts.length < 2)
+            return undefined;
+        const currentIndex = findCurrentAccountIndex(store, auth);
+        const nextIndex = (currentIndex + 1) % store.accounts.length;
+        const nextAccount = store.accounts[nextIndex];
+        if (!nextAccount)
+            return undefined;
+        nextAccount.lastUsed = Date.now();
+        store.activeIndex = nextIndex;
+        await saveAccountStore(store);
+        const nextAuth = {
+            type: 'oauth',
+            refresh: nextAccount.refresh,
+            access: nextAccount.access,
+            expires: nextAccount.expires,
+        };
+        await setAnthropicAuth(nextAuth, client);
+        return nextAuth;
+    });
+}
+export async function removeAccount(index) {
+    return withAuthStateLock(async () => {
+        const store = await loadAccountStore();
+        if (!Number.isInteger(index) || index < 0 || index >= store.accounts.length) {
+            throw new Error(`Account ${index + 1} does not exist`);
+        }
+        store.accounts.splice(index, 1);
+        if (store.accounts.length === 0) {
+            store.activeIndex = 0;
+            await saveAccountStore(store);
+            await writeAnthropicAuthFile(undefined);
+            return { store, active: undefined };
+        }
+        if (store.activeIndex > index) {
+            store.activeIndex -= 1;
+        }
+        else if (store.activeIndex >= store.accounts.length) {
+            store.activeIndex = 0;
+        }
+        const active = store.accounts[store.activeIndex];
+        if (!active)
+            throw new Error('Active Anthropic account disappeared during removal');
+        active.lastUsed = Date.now();
+        await saveAccountStore(store);
+        const nextAuth = {
+            type: 'oauth',
+            refresh: active.refresh,
+            access: active.access,
+            expires: active.expires,
+        };
+        await writeAnthropicAuthFile(nextAuth);
+        return { store, active: nextAuth };
+    });
+}
+export function shouldRotateAuth(status, bodyText) {
+    const haystack = bodyText.toLowerCase();
+    if (status === 429)
+        return true;
+    if (status === 401 || status === 403)
+        return true;
+    return (haystack.includes('rate_limit') ||
+        haystack.includes('rate limit') ||
+        haystack.includes('invalid api key') ||
+        haystack.includes('authentication_error') ||
+        haystack.includes('permission_error') ||
+        haystack.includes('oauth'));
+}

package/dist/bin.js

@@ -0,0 +1,90 @@
+// Respawn wrapper for the kimaki bot process.
+// When running the default command (no subcommand) with --auto-restart,
+// spawns cli.js as a child process and restarts it on non-zero exit codes
+// (crash, OOM kill, etc). Intentional exits (code 0 or EXIT_NO_RESTART=64)
+// are not restarted.
+//
+// Subcommands (send, tunnel, project, etc.) run directly without the wrapper
+// since they are short-lived and don't need crash recovery.
+//
+// When __KIMAKI_CHILD is set, we're the child process -- just run cli.js directly.
+//
+// V8 heap snapshot flags:
+// Injects --heapsnapshot-near-heap-limit=3 and --diagnostic-dir so V8 writes
+// heap snapshots internally as it approaches the heap limit. This catches OOM
+// situations where SIGKILL (exit 137) would kill the process before our
+// heap-monitor.ts polling can react. The polling monitor is kept as an early
+// warning system at 85% usage; the V8 flag is the last-resort safety net.
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+const HEAP_SNAPSHOT_DIR = path.join(os.homedir(), '.kimaki', 'heap-snapshots');
+// First arg after node + script is either a subcommand or a flag.
+// If it doesn't start with '-', it's a subcommand (e.g. "send", "tunnel", "project").
+const firstArg = process.argv[2];
+const isSubcommand = firstArg && !firstArg.startsWith('-');
+const isHelpFlag = process.argv.includes('--help');
+if (process.env.__KIMAKI_CHILD || isSubcommand || isHelpFlag) {
+    await import('./cli.js');
+}
+else {
+    console.error('no subcommand detected. kimaki will automatically restart on crash');
+    console.error();
+    const EXIT_NO_RESTART = 64;
+    const MAX_RAPID_RESTARTS = 5;
+    const RAPID_RESTART_WINDOW_MS = 60_000;
+    const RESTART_DELAY_MS = 2_000;
+    const restartTimestamps = [];
+    let child = null;
+    // Track when we forwarded a termination signal so we don't restart after graceful shutdown
+    let shutdownRequested = false;
+    function start() {
+        if (!fs.existsSync(HEAP_SNAPSHOT_DIR)) {
+            fs.mkdirSync(HEAP_SNAPSHOT_DIR, { recursive: true });
+        }
+        const heapArgs = [
+            `--heapsnapshot-near-heap-limit=3`,
+            `--diagnostic-dir=${HEAP_SNAPSHOT_DIR}`,
+        ];
+        const args = [...heapArgs, ...process.execArgv, ...process.argv.slice(1)];
+        child = spawn(process.argv[0], args, {
+            stdio: 'inherit',
+            env: { ...process.env, __KIMAKI_CHILD: '1' },
+        });
+        child.on('exit', (code, signal) => {
+            if (code === 0 || code === EXIT_NO_RESTART || shutdownRequested) {
+                process.exit(code ?? 0);
+                return;
+            }
+            const now = Date.now();
+            restartTimestamps.push(now);
+            while (restartTimestamps.length > 0 &&
+                restartTimestamps[0] < now - RAPID_RESTART_WINDOW_MS) {
+                restartTimestamps.shift();
+            }
+            if (restartTimestamps.length > MAX_RAPID_RESTARTS) {
+                console.error(`[kimaki] Crash loop detected (${MAX_RAPID_RESTARTS} crashes in ${RAPID_RESTART_WINDOW_MS / 1000}s), exiting`);
+                process.exit(1);
+                return;
+            }
+            const reason = signal ? `signal ${signal}` : `code ${code}`;
+            console.error(`[kimaki] Process exited with ${reason}, restarting in ${RESTART_DELAY_MS / 1000}s...`);
+            setTimeout(start, RESTART_DELAY_MS);
+        });
+    }
+    // Forward signals to child so graceful shutdown and heap snapshots work.
+    // SIGTERM/SIGINT mark shutdownRequested so we don't restart after graceful exit.
+    for (const sig of ['SIGTERM', 'SIGINT']) {
+        process.on(sig, () => {
+            shutdownRequested = true;
+            child?.kill(sig);
+        });
+    }
+    for (const sig of ['SIGUSR1', 'SIGUSR2']) {
+        process.on(sig, () => {
+            child?.kill(sig);
+        });
+    }
+    start();
+}

package/dist/channel-management.js

@@ -0,0 +1,227 @@
+// Discord channel and category management.
+// Creates and manages Kimaki project channels (text + voice pairs),
+// extracts channel metadata from topic tags, and ensures category structure.
+import { ChannelType, } from 'discord.js';
+import fs from 'node:fs';
+import path from 'node:path';
+import { getChannelDirectory, setChannelDirectory, findChannelsByDirectory, } from './database.js';
+import { getProjectsDir } from './config.js';
+import { execAsync } from './worktrees.js';
+import { createLogger, LogPrefix } from './logger.js';
+const logger = createLogger(LogPrefix.CHANNEL);
+export async function ensureKimakiCategory(guild, botName) {
+    // Skip appending bot name if it's already "kimaki" to avoid "Kimaki kimaki"
+    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;
+        }
+        return channel.name.toLowerCase() === categoryName.toLowerCase();
+    });
+    if (existingCategory) {
+        return existingCategory;
+    }
+    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();
+    });
+    if (existingCategory) {
+        return existingCategory;
+    }
+    return guild.channels.create({
+        name: categoryName,
+        type: ChannelType.GuildCategory,
+    });
+}
+export async function createProjectChannels({ guild, projectDirectory, botName, enableVoiceChannels = false, }) {
+    const baseName = path.basename(projectDirectory);
+    const channelName = `${baseName}`
+        .toLowerCase()
+        .replace(/[^a-z0-9-]/g, '-')
+        .slice(0, 100);
+    const kimakiCategory = await ensureKimakiCategory(guild, botName);
+    const textChannel = await guild.channels.create({
+        name: channelName,
+        type: ChannelType.GuildText,
+        parent: kimakiCategory,
+        // Channel configuration is stored in SQLite, not in the topic
+    });
+    await setChannelDirectory({
+        channelId: textChannel.id,
+        directory: projectDirectory,
+        channelType: 'text',
+    });
+    let voiceChannelId = null;
+    if (enableVoiceChannels) {
+        const kimakiAudioCategory = await ensureKimakiAudioCategory(guild, botName);
+        const voiceChannel = await guild.channels.create({
+            name: channelName,
+            type: ChannelType.GuildVoice,
+            parent: kimakiAudioCategory,
+        });
+        await setChannelDirectory({
+            channelId: voiceChannel.id,
+            directory: projectDirectory,
+            channelType: 'voice',
+        });
+        voiceChannelId = voiceChannel.id;
+    }
+    return {
+        textChannelId: textChannel.id,
+        voiceChannelId,
+        channelName,
+    };
+}
+export async function getChannelsWithDescriptions(guild) {
+    const channels = [];
+    const textChannels = guild.channels.cache.filter((channel) => channel.isTextBased());
+    for (const channel of textChannels.values()) {
+        const textChannel = channel;
+        const description = textChannel.topic || null;
+        // Get channel config from database instead of parsing XML from topic
+        const channelConfig = await getChannelDirectory(textChannel.id);
+        channels.push({
+            id: textChannel.id,
+            name: textChannel.name,
+            description,
+            kimakiDirectory: channelConfig?.directory,
+        });
+    }
+    return channels;
+}
+const DEFAULT_GITIGNORE = `node_modules/
+dist/
+.env
+.env.*
+!.env.example
+.DS_Store
+tmp/
+*.log
+__pycache__/
+*.pyc
+.venv/
+*.egg-info/
+`;
+const DEFAULT_CHANNEL_TOPIC = 'General channel for misc tasks with Kimaki. Not connected to a specific OpenCode project or repository.';
+/**
+ * Create (or find) the default "kimaki" channel for general-purpose tasks.
+ * Channel name is "kimaki-{botName}" for self-hosted bots, "kimaki" for gateway.
+ * 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.
+ */
+export async function createDefaultKimakiChannel({ guild, botName, appId, isGatewayMode, }) {
+    const projectDirectory = path.join(getProjectsDir(), 'kimaki');
+    // Ensure the default kimaki project directory exists before any DB mapping
+    // restoration or git setup. Custom data dirs may not have <dataDir>/projects
+    // created yet, and later writes assume the full path is present.
+    if (!fs.existsSync(projectDirectory)) {
+        fs.mkdirSync(projectDirectory, { recursive: true });
+        logger.log(`Created default kimaki directory: ${projectDirectory}`);
+    }
+    // Hydrate guild channels from API so the cache scan is complete
+    try {
+        await guild.channels.fetch();
+    }
+    catch (error) {
+        logger.warn(`Could not fetch guild channels for ${guild.name}: ${error instanceof Error ? error.stack : String(error)}`);
+    }
+    // 1. Check database for existing channel mapped to this directory.
+    // Check ALL mappings (not just the first) since the same directory could
+    // have stale rows from deleted channels or other guilds.
+    const existingMappings = await findChannelsByDirectory({
+        directory: projectDirectory,
+        channelType: 'text',
+    });
+    const mappedChannelInGuild = existingMappings
+        .map((row) => guild.channels.cache.get(row.channel_id))
+        .find((ch) => ch?.type === ChannelType.GuildText);
+    if (mappedChannelInGuild) {
+        logger.log(`Default kimaki channel already exists: ${mappedChannelInGuild.id}`);
+        return null;
+    }
+    // 2. Fallback: detect existing channel by name+category
+    const kimakiCategory = await ensureKimakiCategory(guild, botName);
+    const existingByName = guild.channels.cache.find((ch) => {
+        if (ch.type !== ChannelType.GuildText) {
+            return false;
+        }
+        if (ch.parentId !== kimakiCategory.id) {
+            return false;
+        }
+        return ch.name === 'kimaki' || ch.name.startsWith('kimaki-');
+    });
+    if (existingByName) {
+        logger.log(`Found existing default kimaki channel by name: ${existingByName.id}, restoring DB mapping`);
+        await setChannelDirectory({
+            channelId: existingByName.id,
+            directory: projectDirectory,
+            channelType: 'text',
+            skipIfExists: true,
+        });
+        return null;
+    }
+    // Git init — gracefully skip if git is not installed
+    const gitDir = path.join(projectDirectory, '.git');
+    if (!fs.existsSync(gitDir)) {
+        try {
+            await execAsync('git init', { cwd: projectDirectory, timeout: 10_000 });
+            logger.log(`Initialized git in: ${projectDirectory}`);
+        }
+        catch (error) {
+            logger.warn(`Could not initialize git in ${projectDirectory}: ${error instanceof Error ? error.stack : String(error)}`);
+        }
+    }
+    // Write .gitignore if it doesn't exist
+    const gitignorePath = path.join(projectDirectory, '.gitignore');
+    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,
+        parent: kimakiCategory,
+        topic: DEFAULT_CHANNEL_TOPIC,
+    });
+    await setChannelDirectory({
+        channelId: textChannel.id,
+        directory: projectDirectory,
+        channelType: 'text',
+    });
+    logger.log(`Created default kimaki channel: #${channelName} (${textChannel.id})`);
+    return {
+        textChannel,
+        textChannelId: textChannel.id,
+        channelName,
+        projectDirectory,
+    };
+}