@neuralnomads/codenomad 0.1.0

package/dist/filesystem/search.js

@@ -0,0 +1,135 @@
+import fs from "fs";
+import path from "path";
+import fuzzysort from "fuzzysort";
+import { clearWorkspaceSearchCache, getWorkspaceCandidates, refreshWorkspaceCandidates } from "./search-cache";
+const DEFAULT_LIMIT = 100;
+const MAX_LIMIT = 200;
+const MAX_CANDIDATES = 8000;
+const IGNORED_DIRECTORIES = new Set([".git", ".hg", ".svn", "node_modules", "dist", "build", ".next", ".nuxt", ".turbo", ".cache", "coverage"].map((name) => name.toLowerCase()));
+export function searchWorkspaceFiles(rootDir, query, options = {}) {
+    const trimmedQuery = query.trim();
+    if (!trimmedQuery) {
+        throw new Error("Search query is required");
+    }
+    const normalizedRoot = path.resolve(rootDir);
+    const limit = normalizeLimit(options.limit);
+    const typeFilter = options.type ?? "all";
+    const refreshRequested = options.refresh === true;
+    let entries;
+    try {
+        if (!refreshRequested) {
+            entries = getWorkspaceCandidates(normalizedRoot);
+        }
+        if (!entries) {
+            entries = refreshWorkspaceCandidates(normalizedRoot, () => collectCandidates(normalizedRoot));
+        }
+    }
+    catch (error) {
+        clearWorkspaceSearchCache(normalizedRoot);
+        throw error;
+    }
+    if (!entries || entries.length === 0) {
+        clearWorkspaceSearchCache(normalizedRoot);
+        return [];
+    }
+    const candidates = buildCandidateEntries(entries, typeFilter);
+    if (candidates.length === 0) {
+        return [];
+    }
+    const matches = fuzzysort.go(trimmedQuery, candidates, {
+        key: "key",
+        limit,
+    });
+    if (!matches || matches.length === 0) {
+        return [];
+    }
+    return matches.map((match) => match.obj.entry);
+}
+function collectCandidates(rootDir) {
+    const queue = [""];
+    const entries = [];
+    while (queue.length > 0 && entries.length < MAX_CANDIDATES) {
+        const relativeDir = queue.pop() || "";
+        const absoluteDir = relativeDir ? path.join(rootDir, relativeDir) : rootDir;
+        let dirents;
+        try {
+            dirents = fs.readdirSync(absoluteDir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const dirent of dirents) {
+            const entryName = dirent.name;
+            const lowerName = entryName.toLowerCase();
+            const relativePath = relativeDir ? `${relativeDir}/${entryName}` : entryName;
+            const absolutePath = path.join(absoluteDir, entryName);
+            if (dirent.isDirectory() && IGNORED_DIRECTORIES.has(lowerName)) {
+                continue;
+            }
+            let stats;
+            try {
+                stats = fs.statSync(absolutePath);
+            }
+            catch {
+                continue;
+            }
+            const isDirectory = stats.isDirectory();
+            if (isDirectory && !IGNORED_DIRECTORIES.has(lowerName)) {
+                if (entries.length < MAX_CANDIDATES) {
+                    queue.push(relativePath);
+                }
+            }
+            const entryType = isDirectory ? "directory" : "file";
+            const normalizedPath = normalizeRelativeEntryPath(relativePath);
+            const entry = {
+                name: entryName,
+                path: normalizedPath,
+                absolutePath: path.resolve(rootDir, normalizedPath === "." ? "" : normalizedPath),
+                type: entryType,
+                size: entryType === "file" ? stats.size : undefined,
+                modifiedAt: stats.mtime.toISOString(),
+            };
+            entries.push(entry);
+            if (entries.length >= MAX_CANDIDATES) {
+                break;
+            }
+        }
+    }
+    return entries;
+}
+function buildCandidateEntries(entries, filter) {
+    const filtered = [];
+    for (const entry of entries) {
+        if (!shouldInclude(entry.type, filter)) {
+            continue;
+        }
+        filtered.push({ entry, key: buildSearchKey(entry) });
+    }
+    return filtered;
+}
+function normalizeLimit(limit) {
+    if (!limit || Number.isNaN(limit)) {
+        return DEFAULT_LIMIT;
+    }
+    const clamped = Math.min(Math.max(limit, 1), MAX_LIMIT);
+    return clamped;
+}
+function shouldInclude(entryType, filter) {
+    return filter === "all" || entryType === filter;
+}
+function normalizeRelativeEntryPath(relativePath) {
+    if (!relativePath) {
+        return ".";
+    }
+    let normalized = relativePath.replace(/\\+/g, "/");
+    if (normalized.startsWith("./")) {
+        normalized = normalized.replace(/^\.\/+/, "");
+    }
+    if (normalized.startsWith("/")) {
+        normalized = normalized.replace(/^\/+/g, "");
+    }
+    return normalized || ".";
+}
+function buildSearchKey(entry) {
+    return entry.path.toLowerCase();
+}

package/dist/index.js

@@ -0,0 +1,142 @@
+/**
+ * CLI entry point.
+ * For now this only wires the typed modules together; actual command handling comes later.
+ */
+import { Command, InvalidArgumentError, Option } from "commander";
+import path from "path";
+import { fileURLToPath } from "url";
+import { createRequire } from "module";
+import { createHttpServer } from "./server/http-server";
+import { WorkspaceManager } from "./workspaces/manager";
+import { ConfigStore } from "./config/store";
+import { BinaryRegistry } from "./config/binaries";
+import { FileSystemBrowser } from "./filesystem/browser";
+import { EventBus } from "./events/bus";
+import { InstanceStore } from "./storage/instance-store";
+import { createLogger } from "./logger";
+import { launchInBrowser } from "./launcher";
+const require = createRequire(import.meta.url);
+const packageJson = require("../package.json");
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const DEFAULT_UI_STATIC_DIR = path.resolve(__dirname, "../public");
+const DEFAULT_PORT = 9898;
+const DEFAULT_HOST = "127.0.0.1";
+const DEFAULT_CONFIG_PATH = "~/.config/codenomad/config.json";
+function parseCliOptions(argv) {
+    const program = new Command()
+        .name("codenomad")
+        .description("CodeNomad CLI server")
+        .version(packageJson.version, "-v, --version", "Show the CLI version")
+        .addOption(new Option("--host <host>", "Host interface to bind").env("CLI_HOST").default(DEFAULT_HOST))
+        .addOption(new Option("--port <number>", "Port for the HTTP server").env("CLI_PORT").default(DEFAULT_PORT).argParser(parsePort))
+        .addOption(new Option("--workspace-root <path>", "Workspace root directory").env("CLI_WORKSPACE_ROOT").default(process.cwd()))
+        .addOption(new Option("--root <path>").env("CLI_ROOT").hideHelp(true))
+        .addOption(new Option("--unrestricted-root", "Allow browsing the full filesystem").env("CLI_UNRESTRICTED_ROOT").default(false))
+        .addOption(new Option("--config <path>", "Path to the config file").env("CLI_CONFIG").default(DEFAULT_CONFIG_PATH))
+        .addOption(new Option("--log-level <level>", "Log level (trace|debug|info|warn|error)").env("CLI_LOG_LEVEL"))
+        .addOption(new Option("--log-destination <path>", "Log destination file (defaults to stdout)").env("CLI_LOG_DESTINATION"))
+        .addOption(new Option("--ui-dir <path>", "Directory containing the built UI bundle").env("CLI_UI_DIR").default(DEFAULT_UI_STATIC_DIR))
+        .addOption(new Option("--ui-dev-server <url>", "Proxy UI requests to a running dev server").env("CLI_UI_DEV_SERVER"))
+        .addOption(new Option("--launch", "Launch the UI in a browser after start").env("CLI_LAUNCH").default(false));
+    program.parse(argv, { from: "user" });
+    const parsed = program.opts();
+    const resolvedRoot = parsed.workspaceRoot ?? parsed.root ?? process.cwd();
+    return {
+        port: parsed.port,
+        host: parsed.host,
+        rootDir: resolvedRoot,
+        configPath: parsed.config,
+        unrestrictedRoot: Boolean(parsed.unrestrictedRoot),
+        logLevel: parsed.logLevel,
+        logDestination: parsed.logDestination,
+        uiStaticDir: parsed.uiDir,
+        uiDevServer: parsed.uiDevServer,
+        launch: Boolean(parsed.launch),
+    };
+}
+function parsePort(input) {
+    const value = Number(input);
+    if (!Number.isInteger(value) || value < 0 || value > 65535) {
+        throw new InvalidArgumentError("Port must be an integer between 0 and 65535");
+    }
+    return value;
+}
+async function main() {
+    const options = parseCliOptions(process.argv.slice(2));
+    const logger = createLogger({ level: options.logLevel, destination: options.logDestination, component: "app" });
+    const workspaceLogger = logger.child({ component: "workspace" });
+    const configLogger = logger.child({ component: "config" });
+    const eventLogger = logger.child({ component: "events" });
+    logger.info({ options }, "Starting CodeNomad CLI server");
+    const eventBus = new EventBus(eventLogger);
+    const configStore = new ConfigStore(options.configPath, eventBus, configLogger);
+    const binaryRegistry = new BinaryRegistry(configStore, eventBus, configLogger);
+    const workspaceManager = new WorkspaceManager({
+        rootDir: options.rootDir,
+        configStore,
+        binaryRegistry,
+        eventBus,
+        logger: workspaceLogger,
+    });
+    const fileSystemBrowser = new FileSystemBrowser({ rootDir: options.rootDir, unrestricted: options.unrestrictedRoot });
+    const instanceStore = new InstanceStore();
+    const serverMeta = {
+        httpBaseUrl: `http://${options.host}:${options.port}`,
+        eventsUrl: `/api/events`,
+        hostLabel: options.host,
+        workspaceRoot: options.rootDir,
+    };
+    const server = createHttpServer({
+        host: options.host,
+        port: options.port,
+        workspaceManager,
+        configStore,
+        binaryRegistry,
+        fileSystemBrowser,
+        eventBus,
+        serverMeta,
+        instanceStore,
+        uiStaticDir: options.uiStaticDir,
+        uiDevServerUrl: options.uiDevServer,
+        logger,
+    });
+    const startInfo = await server.start();
+    logger.info({ port: startInfo.port, host: options.host }, "HTTP server listening");
+    console.log(`CodeNomad Server is ready at ${startInfo.url}`);
+    if (options.launch) {
+        await launchInBrowser(startInfo.url, logger.child({ component: "launcher" }));
+    }
+    let shuttingDown = false;
+    const shutdown = async () => {
+        if (shuttingDown) {
+            logger.info("Shutdown already in progress, ignoring signal");
+            return;
+        }
+        shuttingDown = true;
+        logger.info("Received shutdown signal, closing server");
+        try {
+            await server.stop();
+            logger.info("HTTP server stopped");
+        }
+        catch (error) {
+            logger.error({ err: error }, "Failed to stop HTTP server");
+        }
+        try {
+            await workspaceManager.shutdown();
+            logger.info("Workspace manager shutdown complete");
+        }
+        catch (error) {
+            logger.error({ err: error }, "Workspace manager shutdown failed");
+        }
+        logger.info("Exiting process");
+        process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+}
+main().catch((error) => {
+    const logger = createLogger({ component: "app" });
+    logger.error({ err: error }, "CLI server crashed");
+    process.exit(1);
+});

package/dist/launcher.js

@@ -0,0 +1,149 @@
+import { spawn } from "child_process";
+import os from "os";
+import path from "path";
+const APP_ARGS = (url) => [`--app=${url}`, "--new-window"];
+export async function launchInBrowser(url, logger) {
+    const { platform, candidates, manualExamples } = buildPlatformCandidates(url);
+    console.log(`Attempting to launch browser (${platform}) using:`);
+    candidates.forEach((candidate) => console.log(`  - ${candidate.name}: ${candidate.command}`));
+    for (const candidate of candidates) {
+        const success = await tryLaunch(candidate, url, logger);
+        if (success) {
+            return true;
+        }
+    }
+    console.error("No supported browser found to launch. Run without --launch and use one of the commands below or install a compatible browser.");
+    if (manualExamples.length > 0) {
+        console.error("Manual launch commands:");
+        manualExamples.forEach((line) => console.error(`  ${line}`));
+    }
+    return false;
+}
+async function tryLaunch(candidate, url, logger) {
+    return new Promise((resolve) => {
+        let resolved = false;
+        try {
+            const args = candidate.args(url);
+            const child = spawn(candidate.command, args, { stdio: "ignore", detached: true });
+            child.once("error", (error) => {
+                if (resolved)
+                    return;
+                resolved = true;
+                logger.debug({ err: error, candidate: candidate.name, command: candidate.command, args }, "Browser launch failed");
+                resolve(false);
+            });
+            child.once("spawn", () => {
+                if (resolved)
+                    return;
+                resolved = true;
+                logger.info({
+                    browser: candidate.name,
+                    command: candidate.command,
+                    args,
+                    fullCommand: [candidate.command, ...args].join(" "),
+                }, "Launched browser in app mode");
+                child.unref();
+                resolve(true);
+            });
+        }
+        catch (error) {
+            if (resolved)
+                return;
+            resolved = true;
+            logger.debug({ err: error, candidate: candidate.name, command: candidate.command }, "Browser spawn threw");
+            resolve(false);
+        }
+    });
+}
+function buildPlatformCandidates(url) {
+    switch (os.platform()) {
+        case "darwin":
+            return {
+                platform: "macOS",
+                candidates: buildMacCandidates(),
+                manualExamples: buildMacManualExamples(url),
+            };
+        case "win32":
+            return {
+                platform: "Windows",
+                candidates: buildWindowsCandidates(),
+                manualExamples: buildWindowsManualExamples(url),
+            };
+        default:
+            return {
+                platform: "Linux",
+                candidates: buildLinuxCandidates(),
+                manualExamples: buildLinuxManualExamples(url),
+            };
+    }
+}
+function buildMacCandidates() {
+    const apps = [
+        { name: "Google Chrome", path: "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome" },
+        { name: "Google Chrome Canary", path: "/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary" },
+        { name: "Microsoft Edge", path: "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge" },
+        { name: "Brave Browser", path: "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser" },
+        { name: "Chromium", path: "/Applications/Chromium.app/Contents/MacOS/Chromium" },
+        { name: "Vivaldi", path: "/Applications/Vivaldi.app/Contents/MacOS/Vivaldi" },
+        { name: "Arc", path: "/Applications/Arc.app/Contents/MacOS/Arc" },
+    ];
+    return apps.map((entry) => ({ name: entry.name, command: entry.path, args: APP_ARGS }));
+}
+function buildWindowsCandidates() {
+    const programFiles = process.env["ProgramFiles"];
+    const programFilesX86 = process.env["ProgramFiles(x86)"];
+    const localAppData = process.env["LocalAppData"];
+    const paths = [
+        [programFiles, "Google/Chrome/Application/chrome.exe", "Google Chrome"],
+        [programFilesX86, "Google/Chrome/Application/chrome.exe", "Google Chrome (x86)"],
+        [localAppData, "Google/Chrome/Application/chrome.exe", "Google Chrome (User)"],
+        [programFiles, "Microsoft/Edge/Application/msedge.exe", "Microsoft Edge"],
+        [programFilesX86, "Microsoft/Edge/Application/msedge.exe", "Microsoft Edge (x86)"],
+        [localAppData, "Microsoft/Edge/Application/msedge.exe", "Microsoft Edge (User)"],
+        [programFiles, "BraveSoftware/Brave-Browser/Application/brave.exe", "Brave"],
+        [localAppData, "BraveSoftware/Brave-Browser/Application/brave.exe", "Brave (User)"],
+        [programFiles, "Chromium/Application/chromium.exe", "Chromium"],
+    ];
+    return paths
+        .filter(([root]) => Boolean(root))
+        .map(([root, rel, name]) => ({
+        name,
+        command: path.join(root, rel),
+        args: APP_ARGS,
+    }));
+}
+function buildLinuxCandidates() {
+    const names = [
+        "google-chrome",
+        "google-chrome-stable",
+        "chromium",
+        "chromium-browser",
+        "brave-browser",
+        "microsoft-edge",
+        "microsoft-edge-stable",
+        "vivaldi",
+    ];
+    return names.map((name) => ({ name, command: name, args: APP_ARGS }));
+}
+function buildMacManualExamples(url) {
+    return [
+        `"/Applications/Google Chrome.app/Contents/MacOS/Google Chrome" --app="${url}" --new-window`,
+        `"/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge" --app="${url}" --new-window`,
+        `"/Applications/Brave Browser.app/Contents/MacOS/Brave Browser" --app="${url}" --new-window`,
+    ];
+}
+function buildWindowsManualExamples(url) {
+    return [
+        `"%ProgramFiles%\\Google\\Chrome\\Application\\chrome.exe" --app="${url}" --new-window`,
+        `"%ProgramFiles%\\Microsoft\\Edge\\Application\\msedge.exe" --app="${url}" --new-window`,
+        `"%ProgramFiles%\\BraveSoftware\\Brave-Browser\\Application\\brave.exe" --app="${url}" --new-window`,
+    ];
+}
+function buildLinuxManualExamples(url) {
+    return [
+        `google-chrome --app="${url}" --new-window`,
+        `chromium --app="${url}" --new-window`,
+        `brave-browser --app="${url}" --new-window`,
+        `microsoft-edge --app="${url}" --new-window`,
+    ];
+}

package/dist/loader.js

@@ -0,0 +1,21 @@
+export async function resolve(specifier, context, defaultResolve) {
+    try {
+        return await defaultResolve(specifier, context, defaultResolve);
+    }
+    catch (error) {
+        if (shouldRetry(specifier, error)) {
+            const retried = specifier.endsWith(".js") ? specifier : `${specifier}.js`;
+            return defaultResolve(retried, context, defaultResolve);
+        }
+        throw error;
+    }
+}
+function shouldRetry(specifier, error) {
+    if (!error || error.code !== "ERR_MODULE_NOT_FOUND") {
+        return false;
+    }
+    if (specifier.startsWith("./") || specifier.startsWith("../")) {
+        return true;
+    }
+    return false;
+}

package/dist/logger.js

@@ -0,0 +1,109 @@
+import { Transform } from "node:stream";
+import pino from "pino";
+const LEVEL_LABELS = {
+    10: "trace",
+    20: "debug",
+    30: "info",
+    40: "warn",
+    50: "error",
+    60: "fatal",
+};
+const LIFECYCLE_COMPONENTS = new Set(["app", "workspace"]);
+const OMITTED_FIELDS = new Set(["time", "msg", "level", "component", "module"]);
+export function createLogger(options = {}) {
+    const level = (options.level ?? process.env.CLI_LOG_LEVEL ?? "info").toLowerCase();
+    const destination = options.destination ?? process.env.CLI_LOG_DESTINATION ?? "stdout";
+    const baseComponent = options.component ?? "app";
+    const loggerOptions = {
+        level,
+        base: { component: baseComponent },
+        timestamp: false,
+    };
+    if (destination && destination !== "stdout") {
+        const stream = pino.destination({ dest: destination, mkdir: true, sync: false });
+        return pino(loggerOptions, stream);
+    }
+    const lifecycleStream = new LifecycleLogStream({ restrictInfoToLifecycle: level === "info" });
+    lifecycleStream.pipe(process.stdout);
+    return pino(loggerOptions, lifecycleStream);
+}
+class LifecycleLogStream extends Transform {
+    constructor(options) {
+        super();
+        this.options = options;
+        this.buffer = "";
+    }
+    _transform(chunk, _encoding, callback) {
+        this.buffer += chunk.toString();
+        let newlineIndex = this.buffer.indexOf("\n");
+        while (newlineIndex >= 0) {
+            const line = this.buffer.slice(0, newlineIndex);
+            this.buffer = this.buffer.slice(newlineIndex + 1);
+            this.pushFormatted(line);
+            newlineIndex = this.buffer.indexOf("\n");
+        }
+        callback();
+    }
+    _flush(callback) {
+        if (this.buffer.length > 0) {
+            this.pushFormatted(this.buffer);
+            this.buffer = "";
+        }
+        callback();
+    }
+    pushFormatted(line) {
+        if (!line.trim()) {
+            return;
+        }
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        const levelNumber = typeof entry.level === "number" ? entry.level : 30;
+        const levelLabel = LEVEL_LABELS[levelNumber] ?? "info";
+        const component = entry.component ?? entry.module ?? "app";
+        if (this.options.restrictInfoToLifecycle && levelNumber <= 30 && !LIFECYCLE_COMPONENTS.has(component)) {
+            return;
+        }
+        const message = typeof entry.msg === "string" ? entry.msg : "";
+        const metadata = this.formatMetadata(entry);
+        const formatted = metadata.length > 0 ? `[${levelLabel.toUpperCase()}] [${component}] ${message} ${metadata}` : `[${levelLabel.toUpperCase()}] [${component}] ${message}`;
+        this.push(`${formatted}\n`);
+    }
+    formatMetadata(entry) {
+        const pairs = [];
+        for (const [key, value] of Object.entries(entry)) {
+            if (OMITTED_FIELDS.has(key)) {
+                continue;
+            }
+            if (key === "err" && value && typeof value === "object") {
+                const err = value;
+                const errLabel = err.type ?? "Error";
+                const errMessage = err.message ? `: ${err.message}` : "";
+                pairs.push(`err=${errLabel}${errMessage}`);
+                if (err.stack) {
+                    pairs.push(`stack="${err.stack}"`);
+                }
+                continue;
+            }
+            pairs.push(`${key}=${this.stringifyValue(value)}`);
+        }
+        return pairs.join(" ").trim();
+    }
+    stringifyValue(value) {
+        if (value === undefined)
+            return "undefined";
+        if (value === null)
+            return "null";
+        if (typeof value === "string")
+            return value;
+        if (typeof value === "number" || typeof value === "boolean")
+            return String(value);
+        if (value instanceof Error)
+            return value.message ?? value.name;
+        return JSON.stringify(value);
+    }
+}