dominds 1.25.18 → 1.26.0

package/dist/server/network-hosts.js

@@ -0,0 +1,188 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeNetworkHost = normalizeNetworkHost;
+exports.isLanHttpsHost = isLanHttpsHost;
+exports.resolveHttpUrlHostForBindHost = resolveHttpUrlHostForBindHost;
+exports.resolveLanHttpsHostsForBindHost = resolveLanHttpsHostsForBindHost;
+exports.resolveDefaultLanHttpsHosts = resolveDefaultLanHttpsHosts;
+const dgram = __importStar(require("node:dgram"));
+const net = __importStar(require("node:net"));
+const os = __importStar(require("node:os"));
+const OUTBOUND_PROBE_HOST = 'github.com';
+const OUTBOUND_PROBE_PORT = 443;
+const OUTBOUND_PROBE_TIMEOUT_MS = 800;
+function normalizeNetworkHost(host) {
+    const trimmed = host.trim();
+    const unwrapped = trimmed.startsWith('[') && trimmed.endsWith(']') ? trimmed.slice(1, -1) : trimmed;
+    const withoutZone = stripIpv6ZoneId(unwrapped);
+    const mappedIpv4 = parseIpv4MappedIpv6Host(withoutZone.toLowerCase());
+    return mappedIpv4 ?? withoutZone;
+}
+function isLanHttpsHost(host) {
+    const normalizedHost = normalizeNetworkHost(host).toLowerCase();
+    if (normalizedHost === '' || normalizedHost === 'localhost' || normalizedHost === 'loopback') {
+        return false;
+    }
+    const ipVersion = net.isIP(normalizedHost);
+    if (ipVersion === 4) {
+        return normalizedHost !== '0.0.0.0' && !normalizedHost.startsWith('127.');
+    }
+    if (ipVersion === 6) {
+        const mappedIpv4 = parseIpv4MappedIpv6Host(normalizedHost);
+        if (mappedIpv4 !== null) {
+            return isLanHttpsHost(mappedIpv4);
+        }
+        return (normalizedHost !== '::' &&
+            normalizedHost !== '0:0:0:0:0:0:0:0' &&
+            normalizedHost !== '::1' &&
+            normalizedHost !== '0:0:0:0:0:0:0:1');
+    }
+    return true;
+}
+function resolveHttpUrlHostForBindHost(bindHost) {
+    const normalizedHost = normalizeNetworkHost(bindHost);
+    if (normalizedHost === '0.0.0.0' ||
+        normalizedHost === '::' ||
+        normalizedHost === '0:0:0:0:0:0:0:0') {
+        return 'localhost';
+    }
+    return normalizedHost;
+}
+async function resolveLanHttpsHostsForBindHost(bindHost) {
+    const normalizedHost = normalizeNetworkHost(bindHost);
+    if (normalizedHost === '0.0.0.0') {
+        return uniqueHosts([
+            ...(await getUdpOutboundHosts('ipv4')),
+            ...getNetworkInterfaceHosts('ipv4'),
+            os.hostname(),
+        ]).filter(isLanHttpsHost);
+    }
+    if (normalizedHost === '::' || normalizedHost === '0:0:0:0:0:0:0:0') {
+        return uniqueHosts([
+            ...(await getUdpOutboundHosts('ipv6')),
+            ...(await getUdpOutboundHosts('ipv4')),
+            ...getNetworkInterfaceHosts('ipv6'),
+            ...getNetworkInterfaceHosts('ipv4'),
+            os.hostname(),
+        ]).filter(isLanHttpsHost);
+    }
+    return isLanHttpsHost(normalizedHost) ? [normalizedHost] : [];
+}
+async function resolveDefaultLanHttpsHosts() {
+    return await resolveLanHttpsHostsForBindHost('::');
+}
+async function getUdpOutboundHosts(kind) {
+    const host = await getUdpOutboundHost(kind);
+    return host === null ? [] : [host];
+}
+async function getUdpOutboundHost(kind) {
+    return await new Promise((resolve) => {
+        const socket = dgram.createSocket(kind === 'ipv4' ? 'udp4' : 'udp6');
+        let settled = false;
+        const finish = (host) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            socket.removeAllListeners('error');
+            socket.close();
+            resolve(host === null ? null : normalizeNetworkHost(host));
+        };
+        const timeout = setTimeout(() => {
+            finish(null);
+        }, OUTBOUND_PROBE_TIMEOUT_MS);
+        timeout.unref();
+        socket.once('error', () => {
+            finish(null);
+        });
+        socket.connect(OUTBOUND_PROBE_PORT, OUTBOUND_PROBE_HOST, () => {
+            const address = socket.address();
+            if (typeof address === 'string') {
+                finish(null);
+                return;
+            }
+            finish(address.address);
+        });
+    });
+}
+function getNetworkInterfaceHosts(kind) {
+    const hosts = [];
+    const families = os.networkInterfaces();
+    for (const entries of Object.values(families)) {
+        if (entries === undefined)
+            continue;
+        for (const entry of entries) {
+            if (entry.internal)
+                continue;
+            if (kind === 'ipv4' && entry.family === 'IPv4') {
+                hosts.push(entry.address);
+            }
+            if (kind === 'ipv6' && entry.family === 'IPv6') {
+                hosts.push(stripIpv6ZoneId(entry.address));
+            }
+        }
+    }
+    return hosts;
+}
+function uniqueHosts(rawHosts) {
+    const hosts = [];
+    const seen = new Set();
+    for (const rawHost of rawHosts) {
+        const host = normalizeNetworkHost(rawHost);
+        if (host === '')
+            continue;
+        const key = host.toLowerCase();
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        hosts.push(host);
+    }
+    return hosts;
+}
+function stripIpv6ZoneId(address) {
+    const zoneIndex = address.indexOf('%');
+    return zoneIndex === -1 ? address : address.slice(0, zoneIndex);
+}
+function parseIpv4MappedIpv6Host(host) {
+    const dottedQuadIndex = host.lastIndexOf(':');
+    if (dottedQuadIndex === -1)
+        return null;
+    const dottedQuad = host.slice(dottedQuadIndex + 1);
+    if (net.isIP(dottedQuad) !== 4)
+        return null;
+    const prefix = host.slice(0, dottedQuadIndex).toLowerCase();
+    return prefix === '::ffff' || prefix === '0:0:0:0:0:ffff' ? dottedQuad : null;
+}

package/dist/server/server-core.d.ts

@@ -5,6 +5,7 @@
  */
 import * as http from 'http';
 import { IncomingMessage, ServerResponse } from 'http';
+import type { Server as HttpsServer } from 'node:https';
 import type { ParsedUrlQuery } from 'querystring';
 import type { WebSocket } from 'ws';
 import type { AuthConfig } from './auth';
@@ -12,11 +13,18 @@ export interface ServerConfig {
     port: number;
     host: string;
     mode: 'development' | 'production';
+    tls?: {
+        cert: string;
+        key: string;
+        certPath: string;
+        keyPath: string;
+    };
     clients?: Set<WebSocket>;
     staticRoot?: string;
     enableLiveReload?: boolean;
     auth?: AuthConfig;
 }
+export type HttpServerLike = http.Server | HttpsServer;
 export interface RequestHandler {
     (req: IncomingMessage, res: ServerResponse, pathname: string, query: ParsedUrlQuery): Promise<boolean>;
 }
@@ -27,6 +35,8 @@ export declare class HttpServerCore {
     private server;
     private config;
     private customHandlers;
+    private started;
+    private stopping;
     constructor(config: ServerConfig);
     /**
      * Add custom request handler
@@ -57,7 +67,8 @@ export declare class HttpServerCore {
     /**
      * Get the underlying HTTP server
      */
-    getHttpServer(): http.Server;
+    getHttpServer(): HttpServerLike;
+    getScheme(): 'http' | 'https';
     /**
      * Resolve dominds installation root
      */

package/dist/server/server-core.js

@@ -44,6 +44,7 @@ exports.sendText = sendText;
  * Core HTTP server functionality shared between production and development servers
  */
 const http = __importStar(require("http"));
+const https = __importStar(require("node:https"));
 const path = __importStar(require("path"));
 const log_1 = require("../log");
 const api_routes_1 = require("./api-routes");
@@ -72,8 +73,14 @@ function toParsedUrlQuery(searchParams) {
 class HttpServerCore {
     constructor(config) {
         this.customHandlers = [];
+        this.started = false;
+        this.stopping = null;
         this.config = config;
-        this.server = http.createServer(this.handleRequest.bind(this));
+        const requestHandler = this.handleRequest.bind(this);
+        this.server =
+            config.tls === undefined
+                ? http.createServer(requestHandler)
+                : https.createServer({ cert: config.tls.cert, key: config.tls.key }, requestHandler);
     }
     /**
      * Add custom request handler
@@ -212,7 +219,8 @@ class HttpServerCore {
                     ? address.port
                     : this.config.port;
                 this.config = { ...this.config, port: actualPort };
-                log.debug(`Server listening on http://${this.config.host}:${actualPort}`);
+                this.started = true;
+                log.debug(`Server listening on ${this.getScheme()}://${this.config.host}:${actualPort}`);
                 resolve(actualPort);
             };
             this.server.once('error', onError);
@@ -224,12 +232,23 @@ class HttpServerCore {
      * Stop the server
      */
     stop() {
-        return new Promise((resolve) => {
-            this.server.close(() => {
+        if (this.stopping !== null)
+            return this.stopping;
+        if (!this.started)
+            return Promise.resolve();
+        this.stopping = new Promise((resolve, reject) => {
+            this.server.close((error) => {
+                this.started = false;
+                this.stopping = null;
+                if (error !== undefined) {
+                    reject(error);
+                    return;
+                }
                 log.info('Server stopped');
                 resolve();
             });
         });
+        return this.stopping;
     }
     /**
      * Get the underlying HTTP server
@@ -237,6 +256,9 @@ class HttpServerCore {
     getHttpServer() {
         return this.server;
     }
+    getScheme() {
+        return this.config.tls === undefined ? 'http' : 'https';
+    }
     /**
      * Resolve dominds installation root
      */

package/dist/server/websocket-handler.d.ts

@@ -1,6 +1,7 @@
 import type { DomindsRuntimeMode, WebSocketMessage } from '@longrun-ai/kernel/types';
 import { type LanguageCode } from '@longrun-ai/kernel/types/language';
-import type { Server } from 'http';
+import type { Server as HttpServer } from 'http';
+import type { Server as HttpsServer } from 'https';
 import { WebSocket, WebSocketServer } from 'ws';
 import { Dialog } from '../dialog';
 import type { AuthConfig } from './auth';
@@ -28,7 +29,7 @@ export declare function handleWebSocketMessage(ws: WebSocket, packet: WebSocketM
 /**
  * Setup WebSocket server with dialog handling
  */
-export declare function setupWebSocketServer(httpServer: Server, clients: Set<WebSocket>, auth: AuthConfig, serverWorkLanguage: LanguageCode, mode: DomindsRuntimeMode): WebSocketServer;
+export declare function setupWebSocketServer(httpServers: HttpServer | HttpsServer | readonly (HttpServer | HttpsServer)[], clients: Set<WebSocket>, auth: AuthConfig, serverWorkLanguage: LanguageCode, mode: DomindsRuntimeMode): readonly WebSocketServer[];
 /**
  * Clean up all event channels and subscriptions
  */

package/dist/server/websocket-handler.js

@@ -1855,8 +1855,9 @@ async function handleReceiveHumanReply(ws, packet) {
 /**
  * Setup WebSocket server with dialog handling
  */
-function setupWebSocketServer(httpServer, clients, auth, serverWorkLanguage, mode) {
-    const wss = new ws_1.WebSocketServer({ server: httpServer });
+function setupWebSocketServer(httpServers, clients, auth, serverWorkLanguage, mode) {
+    const servers = Array.isArray(httpServers) ? httpServers : [httpServers];
+    const webSocketServers = servers.map((server) => new ws_1.WebSocketServer({ server }));
     const runtimeStatusPubChan = (0, evt_1.createPubChan)();
     const broadcastToClients = (msg) => {
         const data = JSON.stringify(msg);
@@ -1944,7 +1945,7 @@ function setupWebSocketServer(httpServer, clients, auth, serverWorkLanguage, mod
         });
     });
     (0, team_config_updates_1.startTeamConfigWatcher)();
-    httpServer.once('close', () => {
+    const cleanupRuntime = () => {
         (0, team_config_updates_1.stopTeamConfigWatcher)();
         (0, team_config_updates_1.clearTeamConfigBroadcaster)();
         (0, tool_availability_updates_1.clearToolAvailabilityBroadcaster)();
@@ -1954,9 +1955,12 @@ function setupWebSocketServer(httpServer, clients, auth, serverWorkLanguage, mod
         (0, persistence_1.setDialogsQuarantinedBroadcaster)(null);
         broadcastDialogsIndexMessage = null;
         broadcastDiligencePushUpdatedMessage = null;
-        void wss.close();
-    });
-    wss.on('connection', (ws, req) => {
+        for (const wss of webSocketServers) {
+            void wss.close();
+        }
+    };
+    servers[0]?.once('close', cleanupRuntime);
+    const onConnection = (ws, req) => {
         const authCheck = (0, auth_1.getWebSocketAuthCheck)(req, auth);
         if (authCheck.kind !== 'ok') {
             ws.close(4401, 'unauthorized');
@@ -2036,8 +2040,11 @@ function setupWebSocketServer(httpServer, clients, auth, serverWorkLanguage, mod
             // Clean up client subscriptions on error
             cleanupWsClient(ws);
         });
-    });
-    return wss;
+    };
+    for (const wss of webSocketServers) {
+        wss.on('connection', onConnection);
+    }
+    return webSocketServers;
 }
 function isRecord(value) {
     return typeof value === 'object' && value !== null;

package/dist/server.d.ts

@@ -6,6 +6,7 @@ export type ServerOptions = {
     port?: number;
     host?: string;
     mode?: 'dev' | 'prod';
+    certsDirAbs?: string;
     startBackendDriver?: boolean;
     returnAfterListen?: boolean;
     strictPort?: boolean;
@@ -13,9 +14,13 @@ export type ServerOptions = {
 };
 export type StartedServer = {
     httpServer: HttpServerCore;
+    httpsServer?: HttpServerCore;
     auth: AuthConfig;
     host: string;
+    urlHost: string;
     port: number;
+    httpsPort?: number;
+    httpsUrlHost?: string;
     mode: 'dev' | 'prod';
 };
 export declare function startServer(opts?: ServerOptions): Promise<StartedServer>;

package/dist/server.js

@@ -54,7 +54,9 @@ const open_generation_recovery_1 = require("./recovery/open-generation-recovery"
 const reply_delivery_recovery_1 = require("./recovery/reply-delivery-recovery");
 const work_language_1 = require("./runtime/work-language");
 const auth_1 = require("./server/auth");
+const certificates_1 = require("./server/certificates");
 const dominds_self_update_1 = require("./server/dominds-self-update");
+const network_hosts_1 = require("./server/network-hosts");
 const port_selection_1 = require("./server/port-selection");
 const server_core_1 = require("./server/server-core");
 const websocket_handler_1 = require("./server/websocket-handler");
@@ -128,6 +130,15 @@ function getErrnoCode(error) {
     const withCode = error;
     return typeof withCode.code === 'string' ? withCode.code : undefined;
 }
+function buildAdjacentHttpsPortCandidates(params) {
+    if (params.preferredPort < 1 || params.preferredPort > 65535)
+        return [];
+    return (0, port_selection_1.buildWebuiPortCandidates)({
+        preferredPort: params.preferredPort,
+        strictPort: false,
+        direction: params.direction,
+    });
+}
 async function runPostListenStartup(params) {
     await new Promise((resolve) => {
         setImmediate(resolve);
@@ -177,7 +188,6 @@ async function startServer(opts = {}) {
         strictPort,
         direction: portAutoDirection,
     });
-    log.info(`Starting server in ${mode} mode on ${host}:${preferredPort} (${strictPort ? 'strict port' : `auto port ${portAutoDirection}`}; working language: ${(0, work_language_1.getWorkLanguage)()} from ${source})`);
     // WebSocket clients set
     const clients = new Set();
     const serverMode = mode === 'dev' ? 'development' : 'production';
@@ -185,6 +195,26 @@ async function startServer(opts = {}) {
         mode: serverMode,
         env: process.env,
     });
+    const certificateLookup = await (0, certificates_1.findAutoHttpsCertificateForHost)({
+        host,
+        certsDirAbs: opts.certsDirAbs,
+    });
+    for (const diagnostic of certificateLookup.diagnostics) {
+        log.warn(diagnostic.message);
+    }
+    const tls = certificateLookup.kind === 'found' && !strictPort ? certificateLookup.certificate : undefined;
+    const urlHost = (0, network_hosts_1.resolveHttpUrlHostForBindHost)(host);
+    log.info(`Starting server in ${mode} mode on ${(0, auth_1.formatServerOrigin)({
+        scheme: 'http',
+        host: urlHost,
+        port: preferredPort,
+    })} (bind ${host}; ${strictPort ? 'strict port' : `auto port ${portAutoDirection}`}; working language: ${(0, work_language_1.getWorkLanguage)()} from ${source})`);
+    if (certificateLookup.kind === 'found' && strictPort) {
+        log.info(`HTTPS certificate found but Dominds HTTPS is disabled for strict --port; assuming HTTPS, if needed, is handled by a front proxy (${certificateLookup.certificate.certPath})`);
+    }
+    else if (tls !== undefined) {
+        log.info(`HTTPS certificate available: ${tls.certPath} (matched host ${tls.matchedHost})`);
+    }
     let startedCore = null;
     let boundPort = null;
     for (const candidatePort of portCandidates) {
@@ -199,7 +229,6 @@ async function startServer(opts = {}) {
         const candidateServer = (0, server_core_1.createHttpServer)(config);
         try {
             boundPort = await candidateServer.start();
-            (0, websocket_handler_1.setupWebSocketServer)(candidateServer.getHttpServer(), clients, auth, (0, work_language_1.getWorkLanguage)(), config.mode);
             startedCore = candidateServer;
             break;
         }
@@ -209,9 +238,6 @@ async function startServer(opts = {}) {
                 log.warn(`WebUI port ${candidatePort} is already in use; trying the next ${nextDirection} port`);
                 continue;
             }
-            if (boundPort !== null && startedCore === null) {
-                await candidateServer.stop();
-            }
             throw error;
         }
     }
@@ -225,8 +251,66 @@ async function startServer(opts = {}) {
     if (!strictPort && boundPort !== preferredPort) {
         log.warn(`WebUI preferred port ${preferredPort} was unavailable; listening on ${boundPort}`);
     }
+    let httpsServer;
+    let httpsPort;
+    let httpsUrlHost;
+    if (tls !== undefined) {
+        const preferredHttpsPort = portAutoDirection === 'up' ? boundPort + 1 : boundPort - 1;
+        const httpsPortCandidates = buildAdjacentHttpsPortCandidates({
+            preferredPort: preferredHttpsPort,
+            direction: portAutoDirection,
+        });
+        for (const candidatePort of httpsPortCandidates) {
+            const config = {
+                mode: serverMode,
+                staticRoot: 'webapp/dist',
+                host,
+                port: candidatePort,
+                tls,
+                clients,
+                auth,
+            };
+            const candidateServer = (0, server_core_1.createHttpServer)(config);
+            try {
+                httpsPort = await candidateServer.start();
+                httpsServer = candidateServer;
+                httpsUrlHost = tls.matchedHost;
+                break;
+            }
+            catch (error) {
+                if (getErrnoCode(error) === 'EADDRINUSE') {
+                    const nextDirection = portAutoDirection === 'down' ? 'lower' : 'higher';
+                    log.warn(`WebUI HTTPS port ${candidatePort} is already in use; trying the next ${nextDirection} port`);
+                    continue;
+                }
+                await startedCore.stop();
+                throw error;
+            }
+        }
+        if (httpsServer === undefined || httpsPort === undefined || httpsUrlHost === undefined) {
+            await startedCore.stop();
+            throw new Error(`Failed to start WebUI HTTPS: no available adjacent port found from ${preferredHttpsPort}`);
+        }
+        log.info(`HTTPS WebUI ready: ${(0, auth_1.formatServerOrigin)({
+            scheme: 'https',
+            host: httpsUrlHost,
+            port: httpsPort,
+        })}`);
+    }
+    (0, websocket_handler_1.setupWebSocketServer)(httpsServer === undefined
+        ? startedCore.getHttpServer()
+        : [startedCore.getHttpServer(), httpsServer.getHttpServer()], clients, auth, (0, work_language_1.getWorkLanguage)(), serverMode);
     const postListenStartupToken = { canceled: false };
     const httpServer = attachPostListenStartupCancellation(startedCore, postListenStartupToken);
+    if (httpsServer !== undefined) {
+        const originalStop = httpServer.stop.bind(httpServer);
+        const httpsServerToStop = httpsServer;
+        httpServer.stop = async () => {
+            postListenStartupToken.canceled = true;
+            await httpsServerToStop.stop();
+            await originalStop();
+        };
+    }
     try {
         const rtwsRootAbs = process.cwd();
         (0, dominds_self_update_1.configureDomindsSelfUpdate)({
@@ -259,7 +343,7 @@ async function startServer(opts = {}) {
         }
         const postListenStartup = runPostListenStartup({
             rtwsRootAbs,
-            kernel: { host, port: boundPort },
+            kernel: { scheme: 'http', host: urlHost, port: boundPort },
             startBackendDriver,
             token: postListenStartupToken,
         });
@@ -279,7 +363,17 @@ async function startServer(opts = {}) {
         }
         throw error;
     }
-    return { httpServer, auth, host, port: boundPort, mode };
+    return {
+        httpServer,
+        httpsServer,
+        auth,
+        host,
+        urlHost,
+        port: boundPort,
+        httpsPort,
+        httpsUrlHost,
+        mode,
+    };
 }
 // Main function for CLI execution
 async function main() {
@@ -287,13 +381,14 @@ async function main() {
     // Handle working directory change from -C flag
     const wsDir = cliArgs['C'];
     if (wsDir) {
-        // Resolve to absolute path before changing directory
-        const absoluteWsDir = path.isAbsolute(wsDir) ? wsDir : path.resolve(process.cwd(), wsDir);
+        if (!path.isAbsolute(wsDir)) {
+            throw new Error(`-C requires an absolute directory path: ${wsDir}`);
+        }
         try {
             process.chdir(wsDir);
         }
         catch (err) {
-            log.warn(`Failed to change working directory to ${wsDir}:`, err);
+            throw new Error(`Failed to change working directory to ${wsDir}: ${err instanceof Error ? err.message : String(err)}`);
         }
     }
     // Get port, host, and mode from CLI args

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dominds",
-  "version": "1.25.18",
+  "version": "1.26.0",
   "description": "Dominds CLI and aggregation shell for the LongRun AI kernel/runtime packages.",
   "type": "commonjs",
   "publishConfig": {
@@ -52,9 +52,9 @@
     "ws": "^8.19.0",
     "yaml": "^2.8.2",
     "zod": "^4.3.6",
+    "@longrun-ai/kernel": "1.16.0",
     "@longrun-ai/codex-auth": "0.13.0",
-    "@longrun-ai/kernel": "1.15.12",
-    "@longrun-ai/shell": "1.15.12"
+    "@longrun-ai/shell": "1.16.0"
   },
   "devDependencies": {
     "@types/node": "^25.3.5",