npm - @neuralnomads/codenomad - Versions diffs - 0.2.7-dev → 0.3.0 - Mend

@neuralnomads/codenomad 0.2.7-dev → 0.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (19) hide show

package/dist/config/schema.js +2 -0
package/dist/config/store.js +3 -2
package/dist/events/bus.js +6 -1
package/dist/index.js +19 -0
package/dist/releases/release-monitor.js +100 -0
package/dist/server/http-server.js +61 -7
package/dist/server/routes/events.js +8 -0
package/dist/server/routes/meta.js +95 -1
package/dist/workspaces/instance-events.js +5 -0
package/package.json +1 -1
package/public/assets/index-CzNe2B6i.js +1 -0
package/public/assets/index-DY6if9Mf.css +1 -0
package/public/assets/{loading-CpZQzhuW.js → loading-DQtCWDVE.js} +1 -1
package/public/assets/main-BMLQpn81.js +168 -0
package/public/index.html +5 -4
package/public/loading.html +5 -4
package/public/assets/index-BQRSyrnM.css +0 -1
package/public/assets/index-RpvkZr1-.js +0 -1
package/public/assets/main-C1Xpvsif.js +0 -150

package/dist/config/schema.js CHANGED Viewed

@@ -8,6 +8,7 @@ const AgentModelSelectionsSchema = z.record(z.string(), AgentModelSelectionSchem
 const PreferencesSchema = z.object({
     showThinkingBlocks: z.boolean().default(false),
     thinkingBlocksExpansion: z.enum(["expanded", "collapsed"]).default("expanded"),
+    showTimelineTools: z.boolean().default(true),
     lastUsedBinary: z.string().optional(),
     environmentVariables: z.record(z.string()).default({}),
     modelRecents: z.array(ModelPreferenceSchema).default([]),
@@ -16,6 +17,7 @@ const PreferencesSchema = z.object({
     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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 ADDED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

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

package/public/assets/index-CzNe2B6i.js ADDED Viewed

@@ -0,0 +1 @@