kimaki 0.4.58 → 0.4.60

package/bin.js

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-import './dist/cli.js'
+import './dist/bin.js'

package/dist/bin.js

@@ -0,0 +1,68 @@
+// 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.
+import { spawn } from 'node:child_process';
+// 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 hasAutoRestart = process.argv.includes('--auto-restart');
+if (process.env.__KIMAKI_CHILD || isSubcommand || !hasAutoRestart) {
+    await import('./cli.js');
+}
+else {
+    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() {
+        child = spawn(process.argv[0], [...process.execArgv, ...process.argv.slice(1)], {
+            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/cli-parsing.test.js

@@ -0,0 +1,50 @@
+// Regression tests for CLI argument parsing around Discord ID string preservation.
+import { describe, expect, test } from 'vitest';
+import { goke } from 'goke';
+function createCliForIdParsing() {
+    const cli = goke('kimaki');
+    cli
+        .command('send', 'Send a message')
+        .option('-c, --channel <channelId>', 'Discord channel ID')
+        .option('--thread <threadId>', 'Thread ID')
+        .option('--session <sessionId>', 'Session ID');
+    cli
+        .command('session archive <threadId>', 'Archive a thread');
+    cli
+        .command('add-project', 'Add a project')
+        .option('-g, --guild <guildId>', 'Discord guild/server ID');
+    return cli;
+}
+describe('goke CLI ID parsing', () => {
+    test('keeps large Discord IDs as strings', () => {
+        const cli = createCliForIdParsing();
+        const channelId = '1234567890123456789';
+        const threadId = '9876543210987654321';
+        const sessionId = '1111222233334444555';
+        const channelResult = cli.parse(['node', 'kimaki', 'send', '--channel', channelId], { run: false });
+        expect(channelResult.options.channel).toBe(channelId);
+        expect(typeof channelResult.options.channel).toBe('string');
+        const threadResult = cli.parse(['node', 'kimaki', 'send', '--thread', threadId], { run: false });
+        expect(threadResult.options.thread).toBe(threadId);
+        expect(typeof threadResult.options.thread).toBe('string');
+        const sessionResult = cli.parse(['node', 'kimaki', 'send', '--session', sessionId], { run: false });
+        expect(sessionResult.options.session).toBe(sessionId);
+        expect(typeof sessionResult.options.session).toBe('string');
+    });
+    test('preserves leading zeros in Discord IDs', () => {
+        const cli = createCliForIdParsing();
+        const guildId = '001230045600789';
+        const result = cli.parse(['node', 'kimaki', 'add-project', '--guild', guildId], { run: false });
+        expect(result.options.guild).toBe(guildId);
+        expect(typeof result.options.guild).toBe('string');
+    });
+    test('keeps session archive thread ID as string', () => {
+        const cli = createCliForIdParsing();
+        const threadId = '0098765432109876543';
+        const result = cli.parse(['node', 'kimaki', 'session', 'archive', threadId], {
+            run: false,
+        });
+        expect(result.args[0]).toBe(threadId);
+        expect(typeof result.args[0]).toBe('string');
+    });
+});