@otto-assistant/bridge 0.4.92

package/dist/generated/internal/prismaNamespaceBrowser.js

@@ -0,0 +1,223 @@
+/* !!! This is code generated by Prisma. Do not edit directly. !!! */
+/* eslint-disable */
+// biome-ignore-all lint: generated file
+// @ts-nocheck 
+/*
+ * WARNING: This is an internal file that is subject to change!
+ *
+ * 🛑 Under no circumstances should you import this file directly! 🛑
+ *
+ * All exports from this file are wrapped under a `Prisma` namespace object in the browser.ts file.
+ * While this enables partial backward compatibility, it is not part of the stable public API.
+ *
+ * If you are looking for your Models, Enums, and Input Types, please import them from the respective
+ * model files in the `model` directory!
+ */
+import * as runtime from "@prisma/client/runtime/index-browser";
+export const Decimal = runtime.Decimal;
+export const NullTypes = {
+    DbNull: runtime.NullTypes.DbNull,
+    JsonNull: runtime.NullTypes.JsonNull,
+    AnyNull: runtime.NullTypes.AnyNull,
+};
+/**
+ * Helper for filtering JSON entries that have `null` on the database (empty on the db)
+ *
+ * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
+ */
+export const DbNull = runtime.DbNull;
+/**
+ * Helper for filtering JSON entries that have JSON `null` values (not empty on the db)
+ *
+ * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
+ */
+export const JsonNull = runtime.JsonNull;
+/**
+ * Helper for filtering JSON entries that are `Prisma.DbNull` or `Prisma.JsonNull`
+ *
+ * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
+ */
+export const AnyNull = runtime.AnyNull;
+export const ModelName = {
+    thread_sessions: 'thread_sessions',
+    session_events: 'session_events',
+    part_messages: 'part_messages',
+    bot_tokens: 'bot_tokens',
+    channel_directories: 'channel_directories',
+    bot_api_keys: 'bot_api_keys',
+    thread_worktrees: 'thread_worktrees',
+    channel_models: 'channel_models',
+    session_models: 'session_models',
+    channel_agents: 'channel_agents',
+    session_agents: 'session_agents',
+    channel_worktrees: 'channel_worktrees',
+    channel_verbosity: 'channel_verbosity',
+    channel_mention_mode: 'channel_mention_mode',
+    global_models: 'global_models',
+    scheduled_tasks: 'scheduled_tasks',
+    session_start_sources: 'session_start_sources',
+    forum_sync_configs: 'forum_sync_configs',
+    ipc_requests: 'ipc_requests'
+};
+/*
+ * Enums
+ */
+export const TransactionIsolationLevel = runtime.makeStrictEnum({
+    Serializable: 'Serializable'
+});
+export const Thread_sessionsScalarFieldEnum = {
+    thread_id: 'thread_id',
+    session_id: 'session_id',
+    source: 'source',
+    created_at: 'created_at'
+};
+export const Session_eventsScalarFieldEnum = {
+    id: 'id',
+    session_id: 'session_id',
+    thread_id: 'thread_id',
+    timestamp: 'timestamp',
+    event_index: 'event_index',
+    event_json: 'event_json'
+};
+export const Part_messagesScalarFieldEnum = {
+    part_id: 'part_id',
+    message_id: 'message_id',
+    thread_id: 'thread_id',
+    created_at: 'created_at'
+};
+export const Bot_tokensScalarFieldEnum = {
+    app_id: 'app_id',
+    token: 'token',
+    bot_mode: 'bot_mode',
+    client_id: 'client_id',
+    client_secret: 'client_secret',
+    proxy_url: 'proxy_url',
+    created_at: 'created_at',
+    last_used_at: 'last_used_at'
+};
+export const Channel_directoriesScalarFieldEnum = {
+    channel_id: 'channel_id',
+    directory: 'directory',
+    channel_type: 'channel_type',
+    created_at: 'created_at'
+};
+export const Bot_api_keysScalarFieldEnum = {
+    app_id: 'app_id',
+    gemini_api_key: 'gemini_api_key',
+    openai_api_key: 'openai_api_key',
+    xai_api_key: 'xai_api_key',
+    created_at: 'created_at'
+};
+export const Thread_worktreesScalarFieldEnum = {
+    thread_id: 'thread_id',
+    worktree_name: 'worktree_name',
+    worktree_directory: 'worktree_directory',
+    project_directory: 'project_directory',
+    status: 'status',
+    error_message: 'error_message',
+    created_at: 'created_at'
+};
+export const Channel_modelsScalarFieldEnum = {
+    channel_id: 'channel_id',
+    model_id: 'model_id',
+    variant: 'variant',
+    created_at: 'created_at',
+    updated_at: 'updated_at'
+};
+export const Session_modelsScalarFieldEnum = {
+    session_id: 'session_id',
+    model_id: 'model_id',
+    variant: 'variant',
+    created_at: 'created_at'
+};
+export const Channel_agentsScalarFieldEnum = {
+    channel_id: 'channel_id',
+    agent_name: 'agent_name',
+    created_at: 'created_at',
+    updated_at: 'updated_at'
+};
+export const Session_agentsScalarFieldEnum = {
+    session_id: 'session_id',
+    agent_name: 'agent_name',
+    created_at: 'created_at'
+};
+export const Channel_worktreesScalarFieldEnum = {
+    channel_id: 'channel_id',
+    enabled: 'enabled',
+    created_at: 'created_at',
+    updated_at: 'updated_at'
+};
+export const Channel_verbosityScalarFieldEnum = {
+    channel_id: 'channel_id',
+    verbosity: 'verbosity',
+    updated_at: 'updated_at'
+};
+export const Channel_mention_modeScalarFieldEnum = {
+    channel_id: 'channel_id',
+    enabled: 'enabled',
+    created_at: 'created_at',
+    updated_at: 'updated_at'
+};
+export const Global_modelsScalarFieldEnum = {
+    app_id: 'app_id',
+    model_id: 'model_id',
+    variant: 'variant',
+    created_at: 'created_at',
+    updated_at: 'updated_at'
+};
+export const Scheduled_tasksScalarFieldEnum = {
+    id: 'id',
+    status: 'status',
+    schedule_kind: 'schedule_kind',
+    run_at: 'run_at',
+    cron_expr: 'cron_expr',
+    timezone: 'timezone',
+    next_run_at: 'next_run_at',
+    running_started_at: 'running_started_at',
+    last_run_at: 'last_run_at',
+    last_error: 'last_error',
+    attempts: 'attempts',
+    payload_json: 'payload_json',
+    prompt_preview: 'prompt_preview',
+    channel_id: 'channel_id',
+    thread_id: 'thread_id',
+    session_id: 'session_id',
+    project_directory: 'project_directory',
+    created_at: 'created_at',
+    updated_at: 'updated_at'
+};
+export const Session_start_sourcesScalarFieldEnum = {
+    session_id: 'session_id',
+    schedule_kind: 'schedule_kind',
+    scheduled_task_id: 'scheduled_task_id',
+    created_at: 'created_at',
+    updated_at: 'updated_at'
+};
+export const Forum_sync_configsScalarFieldEnum = {
+    id: 'id',
+    app_id: 'app_id',
+    forum_channel_id: 'forum_channel_id',
+    output_dir: 'output_dir',
+    direction: 'direction',
+    created_at: 'created_at',
+    updated_at: 'updated_at'
+};
+export const Ipc_requestsScalarFieldEnum = {
+    id: 'id',
+    type: 'type',
+    session_id: 'session_id',
+    thread_id: 'thread_id',
+    payload: 'payload',
+    response: 'response',
+    status: 'status',
+    created_at: 'created_at',
+    updated_at: 'updated_at'
+};
+export const SortOrder = {
+    asc: 'asc',
+    desc: 'desc'
+};
+export const NullsOrder = {
+    first: 'first',
+    last: 'last'
+};

package/dist/generated/models/bot_api_keys.js

@@ -0,0 +1 @@
+export {};

package/dist/generated/models/bot_tokens.js

@@ -0,0 +1 @@
+export {};

package/dist/generated/models/channel_agents.js

@@ -0,0 +1 @@
+export {};

package/dist/generated/models/channel_directories.js

@@ -0,0 +1 @@
+export {};

package/dist/generated/models/channel_mention_mode.js

@@ -0,0 +1 @@
+export {};

package/dist/generated/models/channel_models.js

@@ -0,0 +1 @@
+export {};

package/dist/generated/models/channel_verbosity.js

@@ -0,0 +1 @@
+export {};

package/dist/generated/models/channel_worktrees.js

@@ -0,0 +1 @@
+export {};

package/dist/generated/models/forum_sync_configs.js

@@ -0,0 +1 @@
+export {};

package/dist/generated/models/global_models.js

@@ -0,0 +1 @@
+export {};

package/dist/generated/models/ipc_requests.js

@@ -0,0 +1 @@
+export {};

package/dist/generated/models/part_messages.js

@@ -0,0 +1 @@
+export {};

package/dist/generated/models/scheduled_tasks.js

@@ -0,0 +1 @@
+export {};

package/dist/generated/models/session_agents.js

@@ -0,0 +1 @@
+export {};

package/dist/generated/models/session_events.js

@@ -0,0 +1 @@
+export {};

package/dist/generated/models/session_models.js

@@ -0,0 +1 @@
+export {};

package/dist/generated/models/session_start_sources.js

@@ -0,0 +1 @@
+export {};

package/dist/generated/models/thread_sessions.js

@@ -0,0 +1 @@
+export {};

package/dist/generated/models/thread_worktrees.js

@@ -0,0 +1 @@
+export {};

package/dist/generated/models.js

@@ -0,0 +1 @@
+export {};

package/dist/heap-monitor.js

@@ -0,0 +1,122 @@
+// Heap memory monitor and snapshot writer.
+// Periodically checks V8 heap usage and writes gzip-compressed .heapsnapshot.gz
+// files to ~/.kimaki/heap-snapshots/ when memory usage is high.
+// Also exposes writeHeapSnapshot() for on-demand snapshots via SIGUSR1.
+//
+// Snapshots use v8.getHeapSnapshot() streaming API piped through gzip for ~5-10x
+// size reduction (heap snapshots are JSON, so they compress very well).
+//
+// Only active in development (detected by import.meta.filename ending in .ts).
+// In production (compiled .js from npm), the monitor is a no-op to avoid filling
+// user disks with multi-GB snapshot files.
+//
+// Threshold: 85% heap used -> write snapshot for debugging
+import v8 from 'node:v8';
+import fs from 'node:fs';
+import path from 'node:path';
+import zlib from 'node:zlib';
+import { pipeline } from 'node:stream/promises';
+import { fileURLToPath } from 'node:url';
+import { getDataDir } from './config.js';
+import { createLogger, LogPrefix } from './logger.js';
+const logger = createLogger(LogPrefix.HEAP);
+const SNAPSHOT_THRESHOLD = 0.85;
+const CHECK_INTERVAL_MS = 30_000;
+// After writing a snapshot, wait at least 5 minutes before writing another
+const SNAPSHOT_COOLDOWN_MS = 5 * 60 * 1000;
+// Development detection: if this file is .ts we're running from source (tsx/ts-node).
+// Compiled npm package runs from .js files.
+const isDevelopment = fileURLToPath(import.meta.url).endsWith('.ts');
+let lastSnapshotTime = 0;
+let monitorInterval = null;
+function getHeapSnapshotDir() {
+    return path.join(getDataDir(), 'heap-snapshots');
+}
+function ensureSnapshotDir() {
+    const dir = getHeapSnapshotDir();
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    return dir;
+}
+function getHeapStats() {
+    const stats = v8.getHeapStatistics();
+    const usedMB = stats.used_heap_size / 1024 / 1024;
+    const limitMB = stats.heap_size_limit / 1024 / 1024;
+    const ratio = stats.used_heap_size / stats.heap_size_limit;
+    return { usedMB, limitMB, ratio };
+}
+/**
+ * Write a gzip-compressed V8 heap snapshot to ~/.kimaki/heap-snapshots/.
+ * Uses v8.getHeapSnapshot() streaming API piped through gzip for ~5-10x
+ * size reduction compared to v8.writeHeapSnapshot().
+ * Filename includes ISO date and current heap size for easy identification.
+ * Returns the snapshot file path.
+ */
+export async function writeHeapSnapshot() {
+    const dir = ensureSnapshotDir();
+    const { usedMB, limitMB, ratio } = getHeapStats();
+    const pct = (ratio * 100).toFixed(1);
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const filename = `heap-${timestamp}-${Math.round(usedMB)}MB.heapsnapshot.gz`;
+    const filepath = path.join(dir, filename);
+    logger.log(`Writing compressed heap snapshot (${Math.round(usedMB)}MB / ${Math.round(limitMB)}MB, ${pct}%)`);
+    const snapshotStream = v8.getHeapSnapshot();
+    const gzipStream = zlib.createGzip({ level: zlib.constants.Z_BEST_SPEED });
+    const fileStream = fs.createWriteStream(filepath);
+    await pipeline(snapshotStream, gzipStream, fileStream);
+    const fileSizeMB = (fs.statSync(filepath).size / 1024 / 1024).toFixed(1);
+    logger.log(`Snapshot saved: ${filepath} (${fileSizeMB}MB compressed)`);
+    return filepath;
+}
+async function checkHeapUsage() {
+    const { usedMB, limitMB, ratio } = getHeapStats();
+    const pct = (ratio * 100).toFixed(1);
+    if (ratio >= SNAPSHOT_THRESHOLD) {
+        logger.warn(`Heap at ${pct}% (${Math.round(usedMB)}MB / ${Math.round(limitMB)}MB) - exceeds snapshot threshold (${SNAPSHOT_THRESHOLD * 100}%)`);
+        const now = Date.now();
+        if (now - lastSnapshotTime >= SNAPSHOT_COOLDOWN_MS) {
+            lastSnapshotTime = now;
+            try {
+                await writeHeapSnapshot();
+            }
+            catch (e) {
+                logger.error('Failed to write heap snapshot:', e instanceof Error ? e.message : String(e));
+            }
+        }
+        else {
+            logger.log('Snapshot cooldown active, skipping');
+        }
+    }
+}
+/**
+ * Start the periodic heap usage monitor.
+ * Checks every 30s and writes snapshots when threshold is exceeded.
+ * Only active in development (running from .ts source). In production
+ * (compiled .js from npm), this is a no-op to avoid filling user disks.
+ */
+export function startHeapMonitor() {
+    if (!isDevelopment) {
+        return;
+    }
+    if (monitorInterval) {
+        return;
+    }
+    // Ensure the snapshot directory exists so V8's --diagnostic-dir has a valid target.
+    // Also needed for our own writeHeapSnapshot() calls.
+    ensureSnapshotDir();
+    const { usedMB, limitMB, ratio } = getHeapStats();
+    logger.log(`Heap monitor started (${Math.round(usedMB)}MB / ${Math.round(limitMB)}MB, ${(ratio * 100).toFixed(1)}%) - ` +
+        `snapshot at ${SNAPSHOT_THRESHOLD * 100}%`);
+    monitorInterval = setInterval(() => {
+        void checkHeapUsage();
+    }, CHECK_INTERVAL_MS);
+    // Don't prevent process exit
+    monitorInterval.unref();
+}
+export function stopHeapMonitor() {
+    if (monitorInterval) {
+        clearInterval(monitorInterval);
+        monitorInterval = null;
+    }
+}

package/dist/hrana-server.js

@@ -0,0 +1,263 @@
+// In-process HTTP server speaking the Hrana v2 protocol.
+// Backed by the `libsql` npm package (better-sqlite3 API).
+// Binds to the fixed lock port for single-instance enforcement.
+//
+// Protocol logic is implemented in the `libsqlproxy` package.
+// This file handles: server lifecycle, single-instance enforcement,
+// auth, and kimaki-specific endpoints (/kimaki/wake, /health).
+//
+// Hrana v2 protocol spec ("Hrana over HTTP"):
+//   https://github.com/tursodatabase/libsql/blob/main/docs/HTTP_V2_SPEC.md
+import fs from 'node:fs';
+import http from 'node:http';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import Database from 'libsql';
+import * as errore from 'errore';
+import { createLibsqlHandler, createLibsqlNodeHandler, libsqlExecutor, } from 'libsqlproxy';
+import { createLogger, LogPrefix } from './logger.js';
+import { ServerStartError, FetchError } from './errors.js';
+import { getLockPort } from './config.js';
+import { store } from './store.js';
+const hranaLogger = createLogger(LogPrefix.DB);
+let db = null;
+let server = null;
+let hranaUrl = null;
+let discordGatewayReady = false;
+let readyWaiters = [];
+export function markDiscordGatewayReady() {
+    if (discordGatewayReady) {
+        return;
+    }
+    discordGatewayReady = true;
+    for (const resolve of readyWaiters) {
+        resolve();
+    }
+    readyWaiters = [];
+}
+async function waitForDiscordGatewayReady({ timeoutMs }) {
+    if (discordGatewayReady) {
+        return true;
+    }
+    const readyPromise = new Promise((resolve) => {
+        readyWaiters.push(() => {
+            resolve(true);
+        });
+    });
+    const timeoutPromise = new Promise((resolve) => {
+        setTimeout(() => {
+            resolve(false);
+        }, timeoutMs);
+    });
+    return Promise.race([readyPromise, timeoutPromise]);
+}
+function getRequestAuthToken(req) {
+    const authorizationHeader = req.headers.authorization;
+    if (typeof authorizationHeader === 'string' && authorizationHeader.startsWith('Bearer ')) {
+        return authorizationHeader.slice('Bearer '.length);
+    }
+    return null;
+}
+// Timing-safe comparison to prevent timing attacks when the hrana server
+// is internet-facing (bindAll=true / KIMAKI_INTERNET_REACHABLE_URL set).
+function isAuthorizedRequest(req) {
+    const expectedToken = store.getState().gatewayToken;
+    if (!expectedToken) {
+        return false;
+    }
+    const providedToken = getRequestAuthToken(req);
+    if (!providedToken) {
+        return false;
+    }
+    const expectedBuf = Buffer.from(expectedToken, 'utf8');
+    const providedBuf = Buffer.from(providedToken, 'utf8');
+    if (expectedBuf.length !== providedBuf.length) {
+        return false;
+    }
+    return crypto.timingSafeEqual(expectedBuf, providedBuf);
+}
+function ensureServiceAuthTokenInStore() {
+    const existingToken = store.getState().gatewayToken;
+    if (existingToken) {
+        return existingToken;
+    }
+    const generatedToken = `${crypto.randomUUID()}:${crypto.randomBytes(32).toString('hex')}`;
+    store.setState({ gatewayToken: generatedToken });
+    return generatedToken;
+}
+/**
+ * Get the Hrana HTTP URL for injecting into plugin child processes.
+ * Returns null if the server hasn't been started yet.
+ * Only used for KIMAKI_DB_URL env var in opencode.ts — the bot process
+ * itself always uses direct file: access via Prisma.
+ */
+export function getHranaUrl() {
+    return hranaUrl;
+}
+/**
+ * Start the in-process Hrana v2 server on the fixed lock port.
+ * Handles single-instance enforcement: if the port is occupied, kills the
+ * existing process first.
+ */
+export async function startHranaServer({ dbPath, bindAll = false, }) {
+    if (server && db && hranaUrl)
+        return hranaUrl;
+    const port = getLockPort();
+    const bindHost = bindAll ? '0.0.0.0' : '127.0.0.1';
+    const serviceAuthToken = ensureServiceAuthTokenInStore();
+    process.env.KIMAKI_DB_AUTH_TOKEN = serviceAuthToken;
+    fs.mkdirSync(path.dirname(dbPath), { recursive: true });
+    await evictExistingInstance({ port });
+    hranaLogger.log(`Starting hrana server on ${bindHost}:${port} with db: ${dbPath}`);
+    const database = new Database(dbPath);
+    database.exec('PRAGMA journal_mode = WAL');
+    database.exec('PRAGMA busy_timeout = 5000');
+    db = database;
+    // Create the Hrana handler using libsqlproxy
+    const hranaFetchHandler = createLibsqlHandler(libsqlExecutor(database));
+    const hranaNodeHandler = createLibsqlNodeHandler(hranaFetchHandler);
+    // Combined handler: kimaki-specific endpoints + hrana protocol
+    const handler = async (req, res) => {
+        const pathname = new URL(req.url || '/', 'http://localhost').pathname;
+        if (pathname === '/kimaki/wake') {
+            if (req.method !== 'POST') {
+                res.writeHead(405, { 'content-type': 'application/json' });
+                res.end(JSON.stringify({ error: 'method_not_allowed' }));
+                return;
+            }
+            if (!isAuthorizedRequest(req)) {
+                res.writeHead(401, { 'content-type': 'application/json' });
+                res.end(JSON.stringify({ error: 'unauthorized' }));
+                return;
+            }
+            const isReady = await waitForDiscordGatewayReady({ timeoutMs: 30_000 });
+            if (!isReady) {
+                res.writeHead(504, { 'content-type': 'application/json' });
+                res.end(JSON.stringify({ ready: false, error: 'timeout_waiting_for_discord_ready' }));
+                return;
+            }
+            res.writeHead(200, { 'content-type': 'application/json' });
+            res.end(JSON.stringify({ ready: true }));
+            return;
+        }
+        // Health check — no auth required
+        if (pathname === '/health') {
+            res.writeHead(200, { 'content-type': 'application/json' });
+            res.end(JSON.stringify({ status: 'ok', pid: process.pid }));
+            return;
+        }
+        // Hrana routes: /v2, /v2/pipeline — require auth
+        if (pathname === '/v2' || pathname === '/v2/pipeline') {
+            if (!isAuthorizedRequest(req)) {
+                res.writeHead(401, { 'content-type': 'application/json' });
+                res.end(JSON.stringify({ error: 'unauthorized' }));
+                return;
+            }
+            hranaNodeHandler(req, res);
+            return;
+        }
+        res.writeHead(404);
+        res.end();
+    };
+    const started = await new Promise((resolve) => {
+        const srv = http.createServer(handler);
+        srv.on('error', (err) => {
+            resolve(new ServerStartError({
+                port,
+                reason: err.code === 'EADDRINUSE'
+                    ? `Port ${port} still in use after eviction`
+                    : err.message,
+            }));
+        });
+        srv.listen(port, bindHost, () => {
+            server = srv;
+            resolve(true);
+        });
+    });
+    if (started instanceof Error) {
+        database.close();
+        db = null;
+        return started;
+    }
+    hranaUrl = `http://127.0.0.1:${port}`;
+    hranaLogger.log(`Hrana server ready at ${hranaUrl}`);
+    return hranaUrl;
+}
+/**
+ * Stop the Hrana server and close the database.
+ */
+export async function stopHranaServer() {
+    if (server) {
+        hranaLogger.log('Stopping hrana server...');
+        await new Promise((resolve) => {
+            server.close(() => {
+                resolve();
+            });
+        });
+        server = null;
+    }
+    if (db) {
+        db.close();
+        db = null;
+    }
+    hranaUrl = null;
+    discordGatewayReady = false;
+    readyWaiters = [];
+    hranaLogger.log('Hrana server stopped');
+}
+// ── Single-instance enforcement ──────────────────────────────────────
+/**
+ * Evict a previous kimaki instance on the lock port.
+ * Fetches /health to get the running process PID, then kills it directly.
+ * No lsof/netstat/spawnSync needed — the PID comes from the health response.
+ */
+export async function evictExistingInstance({ port }) {
+    const url = `http://127.0.0.1:${port}/health`;
+    const probe = await fetch(url, { signal: AbortSignal.timeout(1000) }).catch((e) => new FetchError({ url, cause: e }));
+    if (probe instanceof Error)
+        return;
+    const body = await probe.json().catch((e) => new FetchError({ url, cause: e }));
+    if (body instanceof Error)
+        return;
+    const targetPid = body.pid;
+    if (!targetPid || targetPid === process.pid)
+        return;
+    hranaLogger.log(`Evicting existing kimaki process (PID: ${targetPid}) on port ${port}`);
+    const killResult = errore.try({
+        try: () => {
+            process.kill(targetPid, 'SIGTERM');
+        },
+        catch: (e) => new Error('Failed to send SIGTERM to existing kimaki process', {
+            cause: e,
+        }),
+    });
+    if (killResult instanceof Error) {
+        hranaLogger.log(`Failed to kill PID ${targetPid}: ${killResult.message}`);
+        return;
+    }
+    await new Promise((resolve) => {
+        setTimeout(resolve, 1000);
+    });
+    // Verify it's gone — if still alive, escalate to SIGKILL
+    const secondProbe = await fetch(url, {
+        signal: AbortSignal.timeout(500),
+    }).catch((e) => new FetchError({ url, cause: e }));
+    if (secondProbe instanceof Error)
+        return;
+    hranaLogger.log(`PID ${targetPid} still alive after SIGTERM, sending SIGKILL`);
+    const forceKillResult = errore.try({
+        try: () => {
+            process.kill(targetPid, 'SIGKILL');
+        },
+        catch: (e) => new Error('Failed to send SIGKILL to existing kimaki process', {
+            cause: e,
+        }),
+    });
+    if (forceKillResult instanceof Error) {
+        hranaLogger.log(`Failed to force-kill PID ${targetPid}: ${forceKillResult.message}`);
+        return;
+    }
+    await new Promise((resolve) => {
+        setTimeout(resolve, 1000);
+    });
+}