@neuralnomads/codenomad-dev 0.13.3-dev-20260402-19a4c3df → 0.13.3-dev-20260404-7996e514

package/dist/auth/manager.js

@@ -75,12 +75,16 @@ export class AuthManager {
         return isLoopbackAddress(request.socket.remoteAddress);
     }
     getSessionFromRequest(request) {
+        return this.getSessionFromHeaders(request.headers);
+    }
+    getSessionFromHeaders(headers) {
         if (!this.authEnabled) {
             // When auth is disabled, treat all requests as authenticated.
             // We still return a stable username so callers can display it.
             return { username: this.init.username, sessionId: "auth-disabled" };
         }
-        const cookies = parseCookies(request.headers.cookie);
+        const cookieHeader = Array.isArray(headers.cookie) ? headers.cookie.join("; ") : headers.cookie;
+        const cookies = parseCookies(cookieHeader);
         const sessionId = cookies[this.cookieName];
         const session = this.sessionManager.getSession(sessionId);
         if (!session)

package/dist/events/bus.js

@@ -20,6 +20,8 @@ export class EventBus extends EventEmitter {
         this.on("workspace.error", handler);
         this.on("workspace.stopped", handler);
         this.on("workspace.log", handler);
+        this.on("sidecar.updated", handler);
+        this.on("sidecar.removed", handler);
         this.on("storage.configChanged", handler);
         this.on("storage.stateChanged", handler);
         this.on("instance.dataChanged", handler);
@@ -31,6 +33,8 @@ export class EventBus extends EventEmitter {
             this.off("workspace.error", handler);
             this.off("workspace.stopped", handler);
             this.off("workspace.log", handler);
+            this.off("sidecar.updated", handler);
+            this.off("sidecar.removed", handler);
             this.off("storage.configChanged", handler);
             this.off("storage.stateChanged", handler);
             this.off("instance.dataChanged", handler);

package/dist/index.js

@@ -23,6 +23,7 @@ import { resolveHttpsOptions } from "./server/tls";
 import { resolveNetworkAddresses, resolveRemoteAddresses } from "./server/network-addresses";
 import { startDevReleaseMonitor } from "./releases/dev-release-monitor";
 import { SpeechService } from "./speech/service";
+import { SideCarManager } from "./sidecars/manager";
 const require = createRequire(import.meta.url);
 const packageJson = require("../package.json");
 const __filename = fileURLToPath(import.meta.url);
@@ -208,6 +209,11 @@ async function main() {
     const fileSystemBrowser = new FileSystemBrowser({ rootDir: options.rootDir, unrestricted: options.unrestrictedRoot });
     const instanceStore = new InstanceStore(configLocation.instancesDir);
     const speechService = new SpeechService(settings, logger.child({ component: "speech" }));
+    const sidecarManager = new SideCarManager({
+        settings,
+        eventBus,
+        logger: logger.child({ component: "sidecars" }),
+    });
     const instanceEventBridge = new InstanceEventBridge({
         workspaceManager,
         eventBus,
@@ -281,6 +287,7 @@ async function main() {
             serverMeta,
             instanceStore,
             speechService,
+            sidecarManager,
             authManager,
             uiStaticDir: uiResolution.uiStaticDir ?? DEFAULT_UI_STATIC_DIR,
             uiDevServerUrl: uiResolution.uiDevServerUrl,
@@ -301,6 +308,7 @@ async function main() {
             serverMeta,
             instanceStore,
             speechService,
+            sidecarManager,
             authManager,
             uiStaticDir: uiResolution.uiStaticDir ?? DEFAULT_UI_STATIC_DIR,
             uiDevServerUrl: undefined,
@@ -391,6 +399,12 @@ async function main() {
             catch (error) {
                 logger.warn({ err: error }, "Instance event bridge shutdown failed");
             }
+            try {
+                await sidecarManager.shutdown();
+            }
+            catch (error) {
+                logger.error({ err: error }, "SideCar manager shutdown failed");
+            }
             try {
                 await workspaceManager.shutdown();
                 logger.info("Workspace manager shutdown complete");

package/dist/server/http-server.js

@@ -3,7 +3,9 @@ import cors from "@fastify/cors";
 import fastifyStatic from "@fastify/static";
 import replyFrom from "@fastify/reply-from";
 import fs from "fs";
+import { connect as connectTcp } from "net";
 import path from "path";
+import { connect as connectTls } from "tls";
 import { fetch } from "undici";
 import { isValidWorktreeSlug, listWorktrees, resolveRepoRoot } from "../workspaces/git-worktrees";
 import { registerWorkspaceRoutes } from "./routes/workspaces";
@@ -17,6 +19,7 @@ import { registerBackgroundProcessRoutes } from "./routes/background-processes";
 import { registerWorktreeRoutes } from "./routes/worktrees";
 import { registerSpeechRoutes } from "./routes/speech";
 import { registerRemoteServerRoutes } from "./routes/remote-servers";
+import { registerSideCarRoutes } from "./routes/sidecars";
 import { BackgroundProcessManager } from "../background-processes/manager";
 import { registerAuthRoutes } from "./routes/auth";
 import { sendUnauthorized, wantsHtml } from "../auth/http-auth";
@@ -150,7 +153,7 @@ export function createHttpServer(deps) {
             return;
         }
         const session = deps.authManager.getSessionFromRequest(request);
-        const requiresAuthForApi = pathname.startsWith("/api/") || pathname.startsWith("/workspaces/");
+        const requiresAuthForApi = pathname.startsWith("/api/") || pathname.startsWith("/workspaces/") || pathname.startsWith("/sidecars/");
         if (requiresAuthForApi && !session) {
             // Allow OpenCode plugin -> CodeNomad calls with per-instance basic auth.
             const pluginMatch = pathname.match(/^\/workspaces\/([^/]+)\/plugin(?:\/|$)/);
@@ -210,6 +213,13 @@ export function createHttpServer(deps) {
     });
     registerRemoteServerRoutes(app, { logger: apiLogger });
     registerSpeechRoutes(app, { speechService: deps.speechService });
+    registerSideCarRoutes(app, { sidecarManager: deps.sidecarManager });
+    registerSideCarProxyRoutes(app, { sidecarManager: deps.sidecarManager, logger: proxyLogger });
+    setupSideCarWebSocketProxy(app, {
+        sidecarManager: deps.sidecarManager,
+        authManager: deps.authManager,
+        logger: proxyLogger,
+    });
     registerPluginRoutes(app, {
         workspaceManager: deps.workspaceManager,
         eventBus: deps.eventBus,
@@ -279,6 +289,48 @@ export function createHttpServer(deps) {
         },
     };
 }
+function registerSideCarProxyRoutes(app, deps) {
+    const proxyBaseHandler = async (request, reply) => {
+        await proxySideCarRequest({
+            request,
+            reply,
+            sidecarManager: deps.sidecarManager,
+            logger: deps.logger,
+            pathSuffix: "",
+        });
+    };
+    const proxyWildcardHandler = async (request, reply) => {
+        await proxySideCarRequest({
+            request,
+            reply,
+            sidecarManager: deps.sidecarManager,
+            logger: deps.logger,
+            pathSuffix: request.params["*"] ?? "",
+        });
+    };
+    app.all("/sidecars/:id", proxyBaseHandler);
+    app.all("/sidecars/:id/*", proxyWildcardHandler);
+}
+function setupSideCarWebSocketProxy(app, deps) {
+    app.server.on("upgrade", (request, socket, head) => {
+        const rawUrl = request.url ?? "/";
+        const parsed = parseSideCarUpgradePath(rawUrl);
+        if (!parsed) {
+            return;
+        }
+        void proxySideCarWebSocketUpgrade({
+            request,
+            socket: socket,
+            head,
+            sidecarId: parsed.sidecarId,
+            incomingPath: parsed.pathname,
+            search: parsed.search,
+            sidecarManager: deps.sidecarManager,
+            authManager: deps.authManager,
+            logger: deps.logger,
+        });
+    });
+}
 function registerInstanceProxyRoutes(app, deps) {
     app.register(async (instance) => {
         instance.removeAllContentTypeParsers();
@@ -681,3 +733,229 @@ function buildProxyHeaders(headers) {
     }
     return result;
 }
+async function proxySideCarRequest(args) {
+    const sidecarId = args.request.params.id ?? "";
+    const sidecar = await args.sidecarManager.get(sidecarId);
+    if (!sidecar) {
+        args.reply.code(404).send({ error: "SideCar not found" });
+        return;
+    }
+    const pathname = (args.request.raw.url ?? args.request.url ?? "").split("?")[0] ?? "";
+    const queryIndex = (args.request.raw.url ?? args.request.url ?? "").indexOf("?");
+    const search = queryIndex >= 0 ? (args.request.raw.url ?? args.request.url ?? "").slice(queryIndex) : "";
+    const pathSuffix = args.pathSuffix ?? "";
+    const requestPath = pathSuffix ? `${args.sidecarManager.buildProxyBasePath(sidecarId)}/${pathSuffix.replace(/^\/+/, "")}` : args.sidecarManager.buildProxyBasePath(sidecarId);
+    const targetPath = args.sidecarManager.buildTargetPath(sidecarId, requestPath, search);
+    const targetOrigin = args.sidecarManager.buildTargetOrigin(sidecar);
+    const targetUrl = `${targetOrigin}${targetPath}`;
+    args.logger.debug({ sidecarId: sidecar.id, targetUrl, pathname, prefixMode: sidecar.prefixMode }, "Proxying request to SideCar");
+    await args.reply.from(targetUrl, {
+        rewriteRequestHeaders: (_originalRequest, headers) => sanitizeSideCarProxyRequestHeaders(headers, targetOrigin),
+        rewriteHeaders: (headers) => rewriteSideCarResponseHeaders(headers, sidecarId, targetOrigin, sidecar.prefixMode),
+        onError: (reply, { error }) => {
+            args.logger.error({ sidecarId: sidecar.id, err: error, targetUrl }, "Failed to proxy SideCar request");
+            if (!reply.sent) {
+                reply.code(502).send({ error: "SideCar proxy failed" });
+            }
+        },
+    });
+}
+function parseSideCarUpgradePath(rawUrl) {
+    let parsed;
+    try {
+        parsed = new URL(rawUrl, "http://localhost");
+    }
+    catch {
+        return null;
+    }
+    const match = parsed.pathname.match(/^\/sidecars\/([^/]+)(?:\/.*)?$/);
+    if (!match) {
+        return null;
+    }
+    try {
+        return {
+            sidecarId: decodeURIComponent(match[1] ?? ""),
+            pathname: parsed.pathname,
+            search: parsed.search,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function proxySideCarWebSocketUpgrade(args) {
+    const { request, socket, head, sidecarId, incomingPath, search, sidecarManager, authManager, logger } = args;
+    if (!isWebSocketUpgradeRequest(request)) {
+        rejectUpgrade(socket, 400, "Bad Request");
+        return;
+    }
+    const session = authManager.getSessionFromHeaders(request.headers);
+    if (!session) {
+        rejectUpgrade(socket, 401, "Unauthorized");
+        return;
+    }
+    const sidecar = await sidecarManager.get(sidecarId);
+    if (!sidecar) {
+        rejectUpgrade(socket, 404, "Not Found");
+        return;
+    }
+    const targetOrigin = sidecarManager.buildTargetOrigin(sidecar);
+    const targetPath = sidecarManager.buildTargetPath(sidecarId, incomingPath, search);
+    const targetUrl = new URL(`${targetOrigin}${targetPath}`);
+    logger.debug({ sidecarId, targetUrl: targetUrl.toString(), prefixMode: sidecar.prefixMode }, "Proxying websocket to SideCar");
+    const { socket: upstream, readyEvent } = createSideCarUpstreamSocket(targetUrl);
+    const closeBoth = () => {
+        if (!socket.destroyed) {
+            socket.destroy();
+        }
+        if (!upstream.destroyed) {
+            upstream.destroy();
+        }
+    };
+    upstream.once("error", (error) => {
+        logger.error({ sidecarId, err: error, targetUrl: targetUrl.toString() }, "Failed to proxy SideCar websocket");
+        rejectUpgrade(socket, 502, "Bad Gateway");
+        if (!upstream.destroyed) {
+            upstream.destroy();
+        }
+    });
+    socket.once("error", (error) => {
+        logger.debug({ sidecarId, err: error }, "SideCar websocket client socket errored");
+        if (!upstream.destroyed) {
+            upstream.destroy();
+        }
+    });
+    upstream.once(readyEvent, () => {
+        try {
+            upstream.write(buildSideCarWebSocketRequest(request, targetUrl));
+            if (head.length > 0) {
+                upstream.write(head);
+            }
+            upstream.pipe(socket);
+            socket.pipe(upstream);
+        }
+        catch (error) {
+            logger.error({ sidecarId, err: error, targetUrl: targetUrl.toString() }, "Failed to forward SideCar websocket upgrade");
+            closeBoth();
+        }
+    });
+    upstream.once("close", () => {
+        if (!socket.destroyed) {
+            socket.end();
+        }
+    });
+    socket.once("close", () => {
+        if (!upstream.destroyed) {
+            upstream.end();
+        }
+    });
+}
+function createSideCarUpstreamSocket(targetUrl) {
+    const port = Number(targetUrl.port || (targetUrl.protocol === "https:" ? 443 : 80));
+    if (targetUrl.protocol === "https:") {
+        return {
+            socket: connectTls({
+                host: targetUrl.hostname,
+                port,
+                servername: targetUrl.hostname,
+            }),
+            readyEvent: "secureConnect",
+        };
+    }
+    return {
+        socket: connectTcp(port, targetUrl.hostname),
+        readyEvent: "connect",
+    };
+}
+function buildSideCarWebSocketRequest(request, targetUrl) {
+    const pathWithQuery = `${targetUrl.pathname}${targetUrl.search}`;
+    const requestLine = `${request.method ?? "GET"} ${pathWithQuery} HTTP/${request.httpVersion}\r\n`;
+    const headerLines = [];
+    const rawHeaders = request.rawHeaders ?? [];
+    const blockedHeaders = getBlockedSideCarRequestHeaders();
+    for (let index = 0; index < rawHeaders.length; index += 2) {
+        const key = rawHeaders[index];
+        const value = rawHeaders[index + 1];
+        if (!key || value === undefined)
+            continue;
+        const lower = key.toLowerCase();
+        if (blockedHeaders.has(lower))
+            continue;
+        if (lower === "origin") {
+            headerLines.push(`Origin: ${targetUrl.origin}\r\n`);
+            continue;
+        }
+        headerLines.push(`${key}: ${value}\r\n`);
+    }
+    const hostValue = targetUrl.port ? `${targetUrl.hostname}:${targetUrl.port}` : targetUrl.hostname;
+    headerLines.push(`Host: ${hostValue}\r\n`);
+    headerLines.push("\r\n");
+    return requestLine + headerLines.join("");
+}
+function isWebSocketUpgradeRequest(request) {
+    const upgrade = request.headers.upgrade;
+    if (typeof upgrade !== "string" || upgrade.toLowerCase() !== "websocket") {
+        return false;
+    }
+    const connection = request.headers.connection;
+    const connectionValue = Array.isArray(connection) ? connection.join(",") : connection ?? "";
+    return connectionValue.toLowerCase().split(",").map((part) => part.trim()).includes("upgrade");
+}
+function rejectUpgrade(socket, statusCode, statusText) {
+    if (socket.destroyed) {
+        return;
+    }
+    socket.write(`HTTP/1.1 ${statusCode} ${statusText}\r\nConnection: close\r\nContent-Length: 0\r\n\r\n`);
+    socket.destroy();
+}
+function rewriteSideCarResponseHeaders(headers, sidecarId, targetOrigin, prefixMode) {
+    if (prefixMode === "preserve") {
+        return headers;
+    }
+    const next = { ...headers };
+    const locationHeader = next.location;
+    const location = Array.isArray(locationHeader) ? locationHeader[0] : locationHeader;
+    if (!location) {
+        return next;
+    }
+    const publicBase = `/sidecars/${encodeURIComponent(sidecarId)}`;
+    if (location.startsWith("/")) {
+        next.location = `${publicBase}${location}`;
+        return next;
+    }
+    try {
+        const parsed = new URL(location);
+        if (parsed.origin === targetOrigin) {
+            next.location = `${publicBase}${parsed.pathname}${parsed.search}${parsed.hash}`;
+        }
+    }
+    catch {
+        // Relative redirects should continue to resolve against the public sidecar path.
+    }
+    return next;
+}
+function sanitizeSideCarProxyRequestHeaders(headers, targetOrigin) {
+    const blockedHeaders = getBlockedSideCarRequestHeaders();
+    const next = {};
+    for (const [key, value] of Object.entries(headers)) {
+        if (!value)
+            continue;
+        if (blockedHeaders.has(key.toLowerCase()))
+            continue;
+        next[key] = value;
+    }
+    next.origin = targetOrigin;
+    return next;
+}
+function getBlockedSideCarRequestHeaders() {
+    return new Set([
+        "host",
+        "authorization",
+        "proxy-authorization",
+        "forwarded",
+        "x-forwarded-for",
+        "x-forwarded-host",
+        "x-forwarded-port",
+        "x-forwarded-proto",
+    ]);
+}

package/dist/server/routes/sidecars.js

@@ -0,0 +1,46 @@
+import { z } from "zod";
+const SideCarCreateSchema = z.object({
+    kind: z.literal("port").default("port"),
+    name: z.string().trim().min(1),
+    port: z.number().int().min(1).max(65535),
+    insecure: z.boolean().default(false),
+    prefixMode: z.enum(["strip", "preserve"]).default("strip"),
+});
+const SideCarUpdateSchema = SideCarCreateSchema.omit({ kind: true }).partial().refine((value) => Object.keys(value).length > 0, {
+    message: "At least one field is required",
+});
+export function registerSideCarRoutes(app, deps) {
+    app.get("/api/sidecars", async () => {
+        return { sidecars: await deps.sidecarManager.list() };
+    });
+    app.post("/api/sidecars", async (request, reply) => {
+        try {
+            const body = SideCarCreateSchema.parse(request.body ?? {});
+            const sidecar = await deps.sidecarManager.create(body);
+            reply.code(201);
+            return sidecar;
+        }
+        catch (error) {
+            reply.code(400);
+            return { error: error instanceof Error ? error.message : "Failed to create SideCar" };
+        }
+    });
+    app.put("/api/sidecars/:id", async (request, reply) => {
+        try {
+            const body = SideCarUpdateSchema.parse(request.body ?? {});
+            return await deps.sidecarManager.update(request.params.id, body);
+        }
+        catch (error) {
+            reply.code(400);
+            return { error: error instanceof Error ? error.message : "Failed to update SideCar" };
+        }
+    });
+    app.delete("/api/sidecars/:id", async (request, reply) => {
+        const removed = await deps.sidecarManager.delete(request.params.id);
+        if (!removed) {
+            reply.code(404);
+            return { error: "SideCar not found" };
+        }
+        reply.code(204);
+    });
+}

package/dist/sidecars/manager.js

@@ -0,0 +1,193 @@
+import { connect } from "net";
+export class SideCarManager {
+    constructor(options) {
+        this.options = options;
+        this.configs = new Map();
+        this.runtime = new Map();
+        for (const record of this.loadConfiguredSideCars()) {
+            this.configs.set(record.id, record);
+            this.runtime.set(record.id, { status: "stopped" });
+        }
+        queueMicrotask(() => {
+            for (const record of this.configs.values()) {
+                void this.refreshPortSideCar(record.id).catch((error) => {
+                    this.options.logger.warn({ sidecarId: record.id, err: error }, "Failed to probe sidecar port");
+                });
+            }
+        });
+    }
+    async list() {
+        await this.refreshPortStatuses();
+        return Array.from(this.configs.values()).map((record) => this.toSideCar(record));
+    }
+    async get(id) {
+        if (!this.configs.has(id))
+            return undefined;
+        await this.refreshPortSideCar(id);
+        return this.toSideCar(this.requireConfig(id));
+    }
+    async create(input) {
+        const normalizedName = input.name.trim();
+        const id = this.buildSideCarId(normalizedName);
+        if (this.configs.has(id)) {
+            throw new Error(`SideCar '${id}' already exists`);
+        }
+        const now = new Date().toISOString();
+        const record = {
+            id,
+            kind: input.kind,
+            name: normalizedName,
+            port: input.port,
+            insecure: input.insecure,
+            prefixMode: input.prefixMode,
+            createdAt: now,
+            updatedAt: now,
+        };
+        this.configs.set(record.id, record);
+        this.runtime.set(record.id, { status: "stopped" });
+        this.persistConfigs();
+        await this.refreshPortSideCar(record.id);
+        return this.toSideCar(record);
+    }
+    async update(id, input) {
+        const record = this.requireConfig(id);
+        record.name = typeof input.name === "string" ? input.name.trim() : record.name;
+        record.port = typeof input.port === "number" ? input.port : record.port;
+        record.insecure = typeof input.insecure === "boolean" ? input.insecure : record.insecure;
+        record.prefixMode = typeof input.prefixMode === "string" ? input.prefixMode : record.prefixMode;
+        record.updatedAt = new Date().toISOString();
+        this.persistConfigs();
+        await this.refreshPortSideCar(id);
+        return this.toSideCar(record);
+    }
+    async delete(id) {
+        const record = this.configs.get(id);
+        if (!record)
+            return false;
+        this.configs.delete(id);
+        this.runtime.delete(id);
+        this.persistConfigs();
+        this.options.eventBus.publish({ type: "sidecar.removed", sidecarId: id });
+        return true;
+    }
+    async shutdown() {
+        return;
+    }
+    buildTargetOrigin(sidecar) {
+        const protocol = sidecar.insecure ? "http" : "https";
+        return `${protocol}://127.0.0.1:${sidecar.port}`;
+    }
+    buildProxyBasePath(id) {
+        return `/sidecars/${encodeURIComponent(id)}`;
+    }
+    buildTargetPath(id, incomingPath, search = "") {
+        const record = this.requireConfig(id);
+        const publicBase = this.buildProxyBasePath(id);
+        const normalizedPath = incomingPath || publicBase;
+        if (record.prefixMode === "preserve") {
+            return `${normalizedPath}${search}`;
+        }
+        let stripped = normalizedPath.startsWith(publicBase) ? normalizedPath.slice(publicBase.length) : normalizedPath;
+        if (!stripped || stripped === "/") {
+            stripped = "/";
+        }
+        else if (!stripped.startsWith("/")) {
+            stripped = `/${stripped}`;
+        }
+        return `${stripped}${search}`;
+    }
+    async refreshPortStatuses() {
+        await Promise.all(Array.from(this.configs.values()).map((record) => this.refreshPortSideCar(record.id)));
+    }
+    async refreshPortSideCar(id) {
+        const record = this.configs.get(id);
+        if (!record)
+            return;
+        const isAvailable = await this.isPortAvailable(record.port);
+        const current = this.runtime.get(id);
+        const nextStatus = isAvailable ? "running" : "stopped";
+        if (current?.status === nextStatus) {
+            return;
+        }
+        this.runtime.set(id, { status: nextStatus });
+        record.updatedAt = new Date().toISOString();
+        this.publish(id);
+    }
+    publish(id) {
+        const record = this.configs.get(id);
+        if (!record)
+            return;
+        this.options.eventBus.publish({ type: "sidecar.updated", sidecar: this.toSideCar(record) });
+    }
+    toSideCar(record) {
+        const runtime = this.runtime.get(record.id);
+        return {
+            id: record.id,
+            kind: record.kind,
+            name: record.name,
+            port: record.port,
+            insecure: record.insecure,
+            prefixMode: record.prefixMode,
+            status: runtime?.status ?? "stopped",
+            createdAt: record.createdAt,
+            updatedAt: record.updatedAt,
+        };
+    }
+    requireConfig(id) {
+        const record = this.configs.get(id);
+        if (!record) {
+            throw new Error("SideCar not found");
+        }
+        return record;
+    }
+    persistConfigs() {
+        const sidecars = Array.from(this.configs.values()).map((record) => ({ ...record }));
+        this.options.settings.mergePatchOwner("config", "server", { sidecars });
+    }
+    loadConfiguredSideCars() {
+        const serverConfig = this.options.settings.getOwner("config", "server");
+        const list = Array.isArray(serverConfig?.sidecars) ? serverConfig.sidecars : [];
+        const records = [];
+        for (const item of list) {
+            if (!item || typeof item !== "object")
+                continue;
+            const record = item;
+            const kind = record.kind === "port" ? "port" : null;
+            const id = typeof record.id === "string" && record.id.trim() ? record.id.trim() : null;
+            const name = typeof record.name === "string" && record.name.trim() ? record.name.trim() : null;
+            const port = typeof record.port === "number" && Number.isInteger(record.port) ? record.port : null;
+            if (!kind || !id || !name || !port)
+                continue;
+            const insecure = record.insecure === true;
+            const prefixMode = record.prefixMode === "preserve" ? "preserve" : "strip";
+            const createdAt = typeof record.createdAt === "string" && record.createdAt ? record.createdAt : new Date().toISOString();
+            const updatedAt = typeof record.updatedAt === "string" && record.updatedAt ? record.updatedAt : createdAt;
+            records.push({ id, kind, name, port, insecure, prefixMode, createdAt, updatedAt });
+        }
+        return records;
+    }
+    isPortAvailable(port) {
+        return new Promise((resolve) => {
+            const socket = connect({ port, host: "127.0.0.1" }, () => {
+                socket.end();
+                resolve(true);
+            });
+            socket.once("error", () => {
+                socket.destroy();
+                resolve(false);
+            });
+        });
+    }
+    buildSideCarId(name) {
+        const normalized = name
+            .trim()
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, "-")
+            .replace(/-{2,}/g, "-")
+            .replace(/^-|-$/g, "");
+        if (!normalized) {
+            throw new Error("SideCar name must include letters or numbers");
+        }
+        return normalized;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neuralnomads/codenomad-dev",
-  "version": "0.13.3-dev-20260402-19a4c3df",
+  "version": "0.13.3-dev-20260404-7996e514",
   "description": "CodeNomad Server",
   "license": "MIT",
   "author": {