@neuralnomads/codenomad 0.2.6-dev → 0.2.8-dev

package/dist/config/schema.js

@@ -15,6 +15,8 @@ const PreferencesSchema = z.object({
     toolOutputExpansion: z.enum(["expanded", "collapsed"]).default("expanded"),
     diagnosticsExpansion: z.enum(["expanded", "collapsed"]).default("expanded"),
     showUsageMetrics: z.boolean().default(true),
+    autoCleanupBlankSessions: z.boolean().default(true),
+    listeningMode: z.enum(["local", "all"]).default("local"),
 });
 const RecentFolderSchema = z.object({
     path: z.string(),

package/dist/config/store.js

@@ -44,9 +44,10 @@ export class ConfigStore {
         this.cache = next;
         this.loaded = true;
         this.persist();
+        const published = Boolean(this.eventBus);
         this.eventBus?.publish({ type: "config.appChanged", config: this.cache });
-        this.logger.info("Config updated");
-        this.logger.debug({ config: this.cache }, "Config payload");
+        this.logger.debug({ broadcast: published }, "Config SSE event emitted");
+        this.logger.trace({ config: this.cache }, "Config payload");
     }
     persist() {
         try {

package/dist/events/bus.js

@@ -6,7 +6,10 @@ export class EventBus extends EventEmitter {
     }
     publish(event) {
         if (event.type !== "instance.event" && event.type !== "instance.eventStatus") {
-            this.logger?.debug({ event }, "Publishing workspace event");
+            this.logger?.debug({ type: event.type }, "Publishing workspace event");
+            if (this.logger?.isLevelEnabled("trace")) {
+                this.logger.trace({ event }, "Workspace event payload");
+            }
         }
         return super.emit(event.type, event);
     }
@@ -22,6 +25,7 @@ export class EventBus extends EventEmitter {
         this.on("instance.dataChanged", handler);
         this.on("instance.event", handler);
         this.on("instance.eventStatus", handler);
+        this.on("app.releaseAvailable", handler);
         return () => {
             this.off("workspace.created", handler);
             this.off("workspace.started", handler);
@@ -33,6 +37,7 @@ export class EventBus extends EventEmitter {
             this.off("instance.dataChanged", handler);
             this.off("instance.event", handler);
             this.off("instance.eventStatus", handler);
+            this.off("app.releaseAvailable", handler);
         };
     }
 }

package/dist/index.js

@@ -16,6 +16,7 @@ import { InstanceStore } from "./storage/instance-store";
 import { InstanceEventBridge } from "./workspaces/instance-events";
 import { createLogger } from "./logger";
 import { launchInBrowser } from "./launcher";
+import { startReleaseMonitor } from "./releases/release-monitor";
 const require = createRequire(import.meta.url);
 const packageJson = require("../package.json");
 const __filename = fileURLToPath(import.meta.url);
@@ -97,9 +98,26 @@ async function main() {
     const serverMeta = {
         httpBaseUrl: `http://${options.host}:${options.port}`,
         eventsUrl: `/api/events`,
+        host: options.host,
+        listeningMode: options.host === "0.0.0.0" ? "all" : "local",
+        port: options.port,
         hostLabel: options.host,
         workspaceRoot: options.rootDir,
+        addresses: [],
     };
+    const releaseMonitor = startReleaseMonitor({
+        currentVersion: packageJson.version,
+        logger: logger.child({ component: "release-monitor" }),
+        onUpdate: (release) => {
+            if (release) {
+                serverMeta.latestRelease = release;
+                eventBus.publish({ type: "app.releaseAvailable", release });
+            }
+            else {
+                delete serverMeta.latestRelease;
+            }
+        },
+    });
     const server = createHttpServer({
         host: options.host,
         port: options.port,
@@ -143,6 +161,7 @@ async function main() {
         catch (error) {
             logger.error({ err: error }, "Workspace manager shutdown failed");
         }
+        releaseMonitor.stop();
         logger.info("Exiting process");
         process.exit(0);
     };

package/dist/releases/release-monitor.js

@@ -0,0 +1,100 @@
+import { fetch } from "undici";
+const RELEASES_API_URL = "https://api.github.com/repos/NeuralNomadsAI/CodeNomad/releases/latest";
+export function startReleaseMonitor(options) {
+    let stopped = false;
+    const refreshRelease = async () => {
+        if (stopped)
+            return;
+        try {
+            const release = await fetchLatestRelease(options);
+            options.onUpdate(release);
+        }
+        catch (error) {
+            options.logger.warn({ err: error }, "Failed to refresh release information");
+        }
+    };
+    void refreshRelease();
+    return {
+        stop() {
+            stopped = true;
+        },
+    };
+}
+async function fetchLatestRelease(options) {
+    const response = await fetch(RELEASES_API_URL, {
+        headers: {
+            Accept: "application/vnd.github+json",
+            "User-Agent": "CodeNomad-CLI",
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`Release API responded with ${response.status}`);
+    }
+    const json = (await response.json());
+    const tagFromServer = json.tag_name || json.name;
+    if (!tagFromServer) {
+        return null;
+    }
+    const normalizedVersion = stripTagPrefix(tagFromServer);
+    if (!normalizedVersion) {
+        return null;
+    }
+    const current = parseVersion(options.currentVersion);
+    const remote = parseVersion(normalizedVersion);
+    if (compareVersions(remote, current) <= 0) {
+        return null;
+    }
+    return {
+        version: normalizedVersion,
+        tag: tagFromServer,
+        url: json.html_url ?? `https://github.com/NeuralNomadsAI/CodeNomad/releases/tag/${encodeURIComponent(tagFromServer)}`,
+        channel: json.prerelease || normalizedVersion.includes("-") ? "dev" : "stable",
+        publishedAt: json.published_at ?? json.created_at,
+        notes: json.body,
+    };
+}
+function stripTagPrefix(tag) {
+    if (!tag)
+        return null;
+    const trimmed = tag.trim();
+    if (!trimmed)
+        return null;
+    return trimmed.replace(/^v/i, "");
+}
+function parseVersion(value) {
+    const normalized = stripTagPrefix(value) ?? "0.0.0";
+    const [core, prerelease = null] = normalized.split("-", 2);
+    const [major = 0, minor = 0, patch = 0] = core.split(".").map((segment) => {
+        const parsed = Number.parseInt(segment, 10);
+        return Number.isFinite(parsed) ? parsed : 0;
+    });
+    return {
+        major,
+        minor,
+        patch,
+        prerelease,
+    };
+}
+function compareVersions(a, b) {
+    if (a.major !== b.major) {
+        return a.major > b.major ? 1 : -1;
+    }
+    if (a.minor !== b.minor) {
+        return a.minor > b.minor ? 1 : -1;
+    }
+    if (a.patch !== b.patch) {
+        return a.patch > b.patch ? 1 : -1;
+    }
+    const aPre = a.prerelease && a.prerelease.length > 0 ? a.prerelease : null;
+    const bPre = b.prerelease && b.prerelease.length > 0 ? b.prerelease : null;
+    if (aPre === bPre) {
+        return 0;
+    }
+    if (!aPre) {
+        return 1;
+    }
+    if (!bPre) {
+        return -1;
+    }
+    return aPre.localeCompare(bPre);
+}

package/dist/server/http-server.js

@@ -11,9 +11,12 @@ import { registerFilesystemRoutes } from "./routes/filesystem";
 import { registerMetaRoutes } from "./routes/meta";
 import { registerEventRoutes } from "./routes/events";
 import { registerStorageRoutes } from "./routes/storage";
+const DEFAULT_HTTP_PORT = 9898;
 export function createHttpServer(deps) {
     const app = Fastify({ logger: false });
     const proxyLogger = deps.logger.child({ component: "proxy" });
+    const apiLogger = deps.logger.child({ component: "http" });
+    const sseLogger = deps.logger.child({ component: "sse" });
     const sseClients = new Set();
     const registerSseClient = (cleanup) => {
         sseClients.add(cleanup);
@@ -25,6 +28,28 @@ export function createHttpServer(deps) {
         }
         sseClients.clear();
     };
+    app.addHook("onRequest", (request, _reply, done) => {
+        ;
+        request.__logMeta = {
+            start: process.hrtime.bigint(),
+        };
+        done();
+    });
+    app.addHook("onResponse", (request, reply, done) => {
+        const meta = request.__logMeta;
+        const durationMs = meta ? Number((process.hrtime.bigint() - meta.start) / BigInt(1000000)) : undefined;
+        const base = {
+            method: request.method,
+            url: request.url,
+            status: reply.statusCode,
+            durationMs,
+        };
+        apiLogger.debug(base, "HTTP request completed");
+        if (apiLogger.isLevelEnabled("trace")) {
+            apiLogger.trace({ ...base, params: request.params, query: request.query, body: request.body }, "HTTP request payload");
+        }
+        done();
+    });
     app.register(cors, {
         origin: true,
         credentials: true,
@@ -42,7 +67,7 @@ export function createHttpServer(deps) {
     registerConfigRoutes(app, { configStore: deps.configStore, binaryRegistry: deps.binaryRegistry });
     registerFilesystemRoutes(app, { fileSystemBrowser: deps.fileSystemBrowser });
     registerMetaRoutes(app, { serverMeta: deps.serverMeta });
-    registerEventRoutes(app, { eventBus: deps.eventBus, registerClient: registerSseClient });
+    registerEventRoutes(app, { eventBus: deps.eventBus, registerClient: registerSseClient, logger: sseLogger });
     registerStorageRoutes(app, {
         instanceStore: deps.instanceStore,
         eventBus: deps.eventBus,
@@ -58,15 +83,37 @@ export function createHttpServer(deps) {
     return {
         instance: app,
         start: async () => {
-            const addressInfo = await app.listen({ port: deps.port, host: deps.host });
-            let actualPort = deps.port;
-            if (typeof addressInfo === "string") {
+            const attemptListen = async (requestedPort) => {
+                const addressInfo = await app.listen({ port: requestedPort, host: deps.host });
+                return { addressInfo, requestedPort };
+            };
+            const autoPortRequested = deps.port === 0;
+            const primaryPort = autoPortRequested ? DEFAULT_HTTP_PORT : deps.port;
+            const shouldRetryWithEphemeral = (error) => {
+                if (!autoPortRequested)
+                    return false;
+                const err = error;
+                return Boolean(err && err.code === "EADDRINUSE");
+            };
+            let listenResult;
+            try {
+                listenResult = await attemptListen(primaryPort);
+            }
+            catch (error) {
+                if (!shouldRetryWithEphemeral(error)) {
+                    throw error;
+                }
+                deps.logger.warn({ err: error, port: primaryPort }, "Preferred port unavailable, retrying on ephemeral port");
+                listenResult = await attemptListen(0);
+            }
+            let actualPort = listenResult.requestedPort;
+            if (typeof listenResult.addressInfo === "string") {
                 try {
-                    const parsed = new URL(addressInfo);
-                    actualPort = Number(parsed.port) || deps.port;
+                    const parsed = new URL(listenResult.addressInfo);
+                    actualPort = Number(parsed.port) || listenResult.requestedPort;
                 }
                 catch {
-                    actualPort = deps.port;
+                    actualPort = listenResult.requestedPort;
                 }
             }
             else {
@@ -78,6 +125,9 @@ export function createHttpServer(deps) {
             const displayHost = deps.host === "0.0.0.0" ? "127.0.0.1" : deps.host === "127.0.0.1" ? "localhost" : deps.host;
             const serverUrl = `http://${displayHost}:${actualPort}`;
             deps.serverMeta.httpBaseUrl = serverUrl;
+            deps.serverMeta.host = deps.host;
+            deps.serverMeta.port = actualPort;
+            deps.serverMeta.listeningMode = deps.host === "0.0.0.0" ? "all" : "local";
             deps.logger.info({ port: actualPort, host: deps.host }, "HTTP server listening");
             console.log(`CodeNomad Server is ready at ${serverUrl}`);
             return { port: actualPort, url: serverUrl, displayHost };
@@ -132,6 +182,10 @@ async function proxyWorkspaceRequest(args) {
     const queryIndex = (request.raw.url ?? "").indexOf("?");
     const search = queryIndex >= 0 ? (request.raw.url ?? "").slice(queryIndex) : "";
     const targetUrl = `http://${INSTANCE_PROXY_HOST}:${port}${normalizedSuffix}${search}`;
+    logger.debug({ workspaceId, method: request.method, targetUrl }, "Proxying request to instance");
+    if (logger.isLevelEnabled("trace")) {
+        logger.trace({ workspaceId, targetUrl, body: request.body }, "Instance proxy payload");
+    }
     return reply.from(targetUrl, {
         onError: (proxyReply, { error }) => {
             logger.error({ err: error, workspaceId, targetUrl }, "Failed to proxy workspace request");

package/dist/server/routes/events.js

@@ -1,5 +1,8 @@
+let nextClientId = 0;
 export function registerEventRoutes(app, deps) {
     app.get("/api/events", (request, reply) => {
+        const clientId = ++nextClientId;
+        deps.logger.debug({ clientId }, "SSE client connected");
         const origin = request.headers.origin ?? "*";
         reply.raw.setHeader("Access-Control-Allow-Origin", origin);
         reply.raw.setHeader("Access-Control-Allow-Credentials", "true");
@@ -9,6 +12,10 @@ export function registerEventRoutes(app, deps) {
         reply.raw.flushHeaders?.();
         reply.hijack();
         const send = (event) => {
+            deps.logger.debug({ clientId, type: event.type }, "SSE event dispatched");
+            if (deps.logger.isLevelEnabled("trace")) {
+                deps.logger.trace({ clientId, event }, "SSE event payload");
+            }
             reply.raw.write(`data: ${JSON.stringify(event)}\n\n`);
         };
         const unsubscribe = deps.eventBus.onEvent(send);
@@ -23,6 +30,7 @@ export function registerEventRoutes(app, deps) {
             clearInterval(heartbeat);
             unsubscribe();
             reply.raw.end?.();
+            deps.logger.debug({ clientId }, "SSE client disconnected");
         };
         const unregister = deps.registerClient(close);
         const handleClose = () => {

package/dist/server/routes/meta.js

@@ -1,3 +1,97 @@
+import os from "os";
 export function registerMetaRoutes(app, deps) {
-    app.get("/api/meta", async () => deps.serverMeta);
+    app.get("/api/meta", async () => buildMetaResponse(deps.serverMeta));
+}
+function buildMetaResponse(meta) {
+    const port = resolvePort(meta);
+    const addresses = port > 0 ? resolveAddresses(port, meta.host) : [];
+    return {
+        ...meta,
+        port,
+        listeningMode: meta.host === "0.0.0.0" ? "all" : "local",
+        addresses,
+    };
+}
+function resolvePort(meta) {
+    if (Number.isInteger(meta.port) && meta.port > 0) {
+        return meta.port;
+    }
+    try {
+        const parsed = new URL(meta.httpBaseUrl);
+        const port = Number(parsed.port);
+        return Number.isInteger(port) && port > 0 ? port : 0;
+    }
+    catch {
+        return 0;
+    }
+}
+function resolveAddresses(port, host) {
+    const interfaces = os.networkInterfaces();
+    const seen = new Set();
+    const results = [];
+    const addAddress = (ip, scope) => {
+        if (!ip || ip === "0.0.0.0")
+            return;
+        const key = `ipv4-${ip}`;
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        results.push({ ip, family: "ipv4", scope, url: `http://${ip}:${port}` });
+    };
+    const normalizeFamily = (value) => {
+        if (typeof value === "string") {
+            const lowered = value.toLowerCase();
+            if (lowered === "ipv4") {
+                return "ipv4";
+            }
+        }
+        if (value === 4)
+            return "ipv4";
+        return null;
+    };
+    if (host === "0.0.0.0") {
+        // Enumerate system interfaces (IPv4 only)
+        for (const entries of Object.values(interfaces)) {
+            if (!entries)
+                continue;
+            for (const entry of entries) {
+                const family = normalizeFamily(entry.family);
+                if (!family)
+                    continue;
+                if (!entry.address || entry.address === "0.0.0.0")
+                    continue;
+                const scope = entry.internal ? "loopback" : "external";
+                addAddress(entry.address, scope);
+            }
+        }
+    }
+    // Always include loopback address
+    addAddress("127.0.0.1", "loopback");
+    // Include explicitly configured host if it was IPv4
+    if (isIPv4Address(host) && host !== "0.0.0.0") {
+        const isLoopback = host.startsWith("127.");
+        addAddress(host, isLoopback ? "loopback" : "external");
+    }
+    const scopeWeight = { external: 0, internal: 1, loopback: 2 };
+    return results.sort((a, b) => {
+        const scopeDelta = scopeWeight[a.scope] - scopeWeight[b.scope];
+        if (scopeDelta !== 0)
+            return scopeDelta;
+        return a.ip.localeCompare(b.ip);
+    });
+}
+function isIPv4Address(value) {
+    if (!value)
+        return false;
+    const parts = value.split(".");
+    if (parts.length !== 4)
+        return false;
+    return parts.every((part) => {
+        if (part.length === 0 || part.length > 3)
+            return false;
+        if (!/^[0-9]+$/.test(part))
+            return false;
+        const num = Number(part);
+        return Number.isInteger(num) && num >= 0 && num <= 255;
+    });
 }

package/dist/workspaces/instance-events.js

@@ -122,6 +122,10 @@ export class InstanceEventBridge {
         }
         try {
             const event = JSON.parse(payload);
+            this.options.logger.debug({ workspaceId, eventType: event.type }, "Instance SSE event received");
+            if (this.options.logger.isLevelEnabled("trace")) {
+                this.options.logger.trace({ workspaceId, event }, "Instance SSE event payload");
+            }
             this.options.eventBus.publish({ type: "instance.event", instanceId: workspaceId, event });
         }
         catch (error) {
@@ -129,6 +133,7 @@ export class InstanceEventBridge {
         }
     }
     publishStatus(instanceId, status, reason) {
+        this.options.logger.debug({ instanceId, status, reason }, "Instance SSE status updated");
         this.options.eventBus.publish({ type: "instance.eventStatus", instanceId, status, reason });
     }
     delay(duration, signal) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neuralnomads/codenomad",
-  "version": "0.2.6-dev",
+  "version": "0.2.8-dev",
   "description": "CodeNomad Server",
   "author": {
     "name": "Neural Nomads",