@codori/server 0.0.1

package/dist/cli.js

@@ -0,0 +1,138 @@
+#!/usr/bin/env node
+import { parseArgs } from 'node:util';
+import { asErrorMessage, CodoriError } from './errors.js';
+import { startHttpServer } from './http-server.js';
+import { createRuntimeManager } from './process-manager.js';
+const printJson = (value) => {
+    process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+};
+const printStatuses = (records) => {
+    for (const record of records) {
+        const runtimeDetails = [
+            record.status,
+            record.port ? `port=${record.port}` : null,
+            record.pid ? `pid=${record.pid}` : null
+        ].filter(Boolean).join(' ');
+        process.stdout.write(`${record.projectId}\t${runtimeDetails}\n`);
+        if (record.error) {
+            process.stdout.write(`  error: ${record.error}\n`);
+        }
+    }
+};
+const printStartResult = (result) => {
+    const action = result.reusedExisting ? 'reused' : 'started';
+    process.stdout.write(`${result.projectId}\t${action}\tport=${result.port}\tpid=${result.pid}\n`);
+};
+const optionConfig = {
+    root: {
+        type: 'string'
+    },
+    host: {
+        type: 'string'
+    },
+    port: {
+        type: 'string'
+    },
+    json: {
+        type: 'boolean'
+    }
+};
+const coercePort = (value) => {
+    if (!value) {
+        return undefined;
+    }
+    const parsed = Number.parseInt(value, 10);
+    return Number.isFinite(parsed) ? parsed : undefined;
+};
+const resolveCliRoot = (value) => value ?? process.cwd();
+const main = async () => {
+    const parsed = parseArgs({
+        allowPositionals: true,
+        options: optionConfig
+    });
+    const [command = 'serve', maybeProjectId] = parsed.positionals;
+    const manager = createRuntimeManager({
+        configOverrides: {
+            root: resolveCliRoot(parsed.values.root),
+            host: parsed.values.host,
+            port: coercePort(parsed.values.port)
+        }
+    });
+    const json = parsed.values.json ?? false;
+    switch (command) {
+        case 'list': {
+            const statuses = manager.listProjectStatuses();
+            if (json) {
+                printJson(statuses);
+            }
+            else {
+                printStatuses(statuses);
+            }
+            return;
+        }
+        case 'status': {
+            if (maybeProjectId) {
+                const status = manager.getProjectStatus(maybeProjectId);
+                if (json) {
+                    printJson(status);
+                }
+                else {
+                    printStatuses([status]);
+                }
+                return;
+            }
+            const statuses = manager.listProjectStatuses();
+            if (json) {
+                printJson(statuses);
+            }
+            else {
+                printStatuses(statuses);
+            }
+            return;
+        }
+        case 'start': {
+            if (!maybeProjectId) {
+                throw new CodoriError('MISSING_PROJECT_ID', 'The start command requires a project id.');
+            }
+            const result = await manager.startProject(maybeProjectId);
+            if (json) {
+                printJson(result);
+            }
+            else {
+                printStartResult(result);
+            }
+            return;
+        }
+        case 'stop': {
+            if (!maybeProjectId) {
+                throw new CodoriError('MISSING_PROJECT_ID', 'The stop command requires a project id.');
+            }
+            const result = await manager.stopProject(maybeProjectId);
+            if (json) {
+                printJson(result);
+            }
+            else {
+                printStatuses([result]);
+            }
+            return;
+        }
+        case 'serve': {
+            const app = await startHttpServer(manager);
+            process.stdout.write(`Running codori server with project root directory: ${manager.config.root}\n`);
+            process.stdout.write(`Codori listening on http://${manager.config.server.host}:${manager.config.server.port}\n`);
+            await app.ready();
+            return;
+        }
+        default:
+            process.stdout.write('Usage: npx @codori/server [serve|list|status|start|stop] [projectId] --root <path> [--host <host>] [--port <port>] [--json]\n');
+    }
+};
+void main().catch((error) => {
+    if (error instanceof CodoriError) {
+        process.stderr.write(`${error.code}: ${error.message}\n`);
+    }
+    else {
+        process.stderr.write(`${asErrorMessage(error)}\n`);
+    }
+    process.exitCode = 1;
+});

package/dist/config.d.ts

@@ -0,0 +1,8 @@
+import type { CodoriConfig, ConfigOverrides } from './types.js';
+export declare const resolveCodoriHome: (homeDir?: string) => string;
+export declare const resolveCodoriConfigPath: (homeDir?: string) => string;
+export declare const ensureCodoriDirectories: (homeDir?: string) => {
+    codoriHome: string;
+    runDir: string;
+};
+export declare const resolveConfig: (overrides?: ConfigOverrides, homeDir?: string) => CodoriConfig;

package/dist/config.js

@@ -0,0 +1,80 @@
+import { existsSync, mkdirSync, readFileSync } from 'node:fs';
+import os from 'node:os';
+import { join, resolve } from 'node:path';
+import { CodoriError } from './errors.js';
+const DEFAULT_SERVER_HOST = '127.0.0.1';
+const DEFAULT_SERVER_PORT = 4310;
+const DEFAULT_PORT_START = 46000;
+const DEFAULT_PORT_END = 46999;
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+export const resolveCodoriHome = (homeDir = os.homedir()) => join(homeDir, '.codori');
+export const resolveCodoriConfigPath = (homeDir = os.homedir()) => join(resolveCodoriHome(homeDir), 'config.json');
+export const ensureCodoriDirectories = (homeDir = os.homedir()) => {
+    const codoriHome = resolveCodoriHome(homeDir);
+    mkdirSync(codoriHome, { recursive: true });
+    mkdirSync(join(codoriHome, 'run'), { recursive: true });
+    return {
+        codoriHome,
+        runDir: join(codoriHome, 'run')
+    };
+};
+const loadUserConfig = (homeDir = os.homedir()) => {
+    const configPath = resolveCodoriConfigPath(homeDir);
+    if (!existsSync(configPath)) {
+        return {};
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(configPath, 'utf8'));
+    }
+    catch (error) {
+        throw new CodoriError('INVALID_CONFIG', `Failed to parse Codori config at ${configPath}.`, error);
+    }
+    if (!isRecord(parsed)) {
+        throw new CodoriError('INVALID_CONFIG', `Codori config at ${configPath} must be a JSON object.`);
+    }
+    return parsed;
+};
+const ensureValidPort = (value, label) => {
+    if (typeof value !== 'number' || !Number.isInteger(value) || value <= 0 || value > 65535) {
+        throw new CodoriError('INVALID_CONFIG', `${label} must be an integer between 1 and 65535.`);
+    }
+    return value;
+};
+export const resolveConfig = (overrides = {}, homeDir = os.homedir()) => {
+    const fileConfig = loadUserConfig(homeDir);
+    const root = overrides.root ?? fileConfig.root;
+    if (!root || typeof root !== 'string') {
+        throw new CodoriError('MISSING_ROOT', 'Project root is required. Pass --root or set ~/.codori/config.json.');
+    }
+    const host = overrides.host
+        ?? (typeof fileConfig.server?.host === 'string' ? fileConfig.server.host : undefined)
+        ?? DEFAULT_SERVER_HOST;
+    const port = overrides.port
+        ?? (typeof fileConfig.server?.port === 'number' ? fileConfig.server.port : undefined)
+        ?? DEFAULT_SERVER_PORT;
+    const portStart = typeof fileConfig.ports?.start === 'number'
+        ? fileConfig.ports.start
+        : DEFAULT_PORT_START;
+    const portEnd = typeof fileConfig.ports?.end === 'number'
+        ? fileConfig.ports.end
+        : DEFAULT_PORT_END;
+    const resolvedPort = ensureValidPort(port, 'server.port');
+    const resolvedPortStart = ensureValidPort(portStart, 'ports.start');
+    const resolvedPortEnd = ensureValidPort(portEnd, 'ports.end');
+    if (resolvedPortStart > resolvedPortEnd) {
+        throw new CodoriError('INVALID_CONFIG', 'ports.start must be less than or equal to ports.end.');
+    }
+    ensureCodoriDirectories(homeDir);
+    return {
+        root: resolve(root),
+        server: {
+            host,
+            port: resolvedPort
+        },
+        ports: {
+            start: resolvedPortStart,
+            end: resolvedPortEnd
+        }
+    };
+};

package/dist/errors.d.ts

@@ -0,0 +1,6 @@
+export declare class CodoriError extends Error {
+    readonly code: string;
+    readonly details?: unknown;
+    constructor(code: string, message: string, details?: unknown);
+}
+export declare const asErrorMessage: (error: unknown) => string;

package/dist/errors.js

@@ -0,0 +1,11 @@
+export class CodoriError extends Error {
+    code;
+    details;
+    constructor(code, message, details) {
+        super(message);
+        this.name = 'CodoriError';
+        this.code = code;
+        this.details = details;
+    }
+}
+export const asErrorMessage = (error) => error instanceof Error ? error.message : String(error);

package/dist/http-server.d.ts

@@ -0,0 +1,21 @@
+import Fastify, { type FastifyInstance } from 'fastify';
+import type { ProjectStatusRecord, StartProjectResult } from './types.js';
+type MaybePromise<T> = T | Promise<T>;
+export type RuntimeManagerLike = {
+    listProjectStatuses: () => MaybePromise<ProjectStatusRecord[]>;
+    getProjectStatus: (projectId: string) => MaybePromise<ProjectStatusRecord>;
+    startProject: (projectId: string) => MaybePromise<StartProjectResult>;
+    stopProject: (projectId: string) => MaybePromise<ProjectStatusRecord>;
+    config?: {
+        server: {
+            host: string;
+            port: number;
+        };
+    };
+};
+export type HttpServerOptions = {
+    clientBundleDir?: string | null;
+};
+export declare const createHttpServer: (manager: RuntimeManagerLike, options?: HttpServerOptions) => Promise<FastifyInstance>;
+export declare const startHttpServer: (manager?: import("./process-manager.js").RuntimeManager) => Promise<Fastify.FastifyInstance<Fastify.RawServerDefault, import("http").IncomingMessage, import("http").ServerResponse<import("http").IncomingMessage>, Fastify.FastifyBaseLogger, Fastify.FastifyTypeProviderDefault>>;
+export {};

package/dist/http-server.js

@@ -0,0 +1,222 @@
+import net from 'node:net';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import fastifyStatic from '@fastify/static';
+import websocket from '@fastify/websocket';
+import Fastify, {} from 'fastify';
+import WebSocket from 'ws';
+import { CodoriError } from './errors.js';
+import { createRuntimeManager } from './process-manager.js';
+const isCodoriError = (error) => error instanceof CodoriError;
+const resolveBundledClientDir = () => {
+    const candidates = [
+        fileURLToPath(new URL('../client-dist', import.meta.url)),
+        fileURLToPath(new URL('../../client/.output/public', import.meta.url))
+    ];
+    for (const candidate of candidates) {
+        if (existsSync(join(candidate, 'index.html'))) {
+            return candidate;
+        }
+    }
+    return null;
+};
+const toRequestPath = (url) => url.split('?')[0]?.split('#')[0] ?? url;
+const isAssetRequest = (pathname) => /\.[a-z0-9]+$/i.test(pathname);
+const toStatusCode = (error) => {
+    switch (error.code) {
+        case 'PROJECT_NOT_FOUND':
+            return 404;
+        case 'INVALID_CONFIG':
+        case 'MISSING_PROJECT_ID':
+        case 'MISSING_ROOT':
+            return 400;
+        default:
+            return 500;
+    }
+};
+const getProjectIdFromRequest = (value) => {
+    if (!value) {
+        throw new CodoriError('MISSING_PROJECT_ID', 'Missing project id.');
+    }
+    return value;
+};
+const resolveValue = async (value) => value;
+const wait = async (ms) => new Promise((resolvePromise) => {
+    setTimeout(resolvePromise, ms);
+});
+const canConnectToPort = (port, host = '127.0.0.1', timeoutMs = 200) => new Promise((resolvePromise) => {
+    const socket = net.createConnection({ host, port });
+    let settled = false;
+    const settle = (value) => {
+        if (settled) {
+            return;
+        }
+        settled = true;
+        socket.removeAllListeners();
+        socket.destroy();
+        resolvePromise(value);
+    };
+    socket.once('connect', () => settle(true));
+    socket.once('error', () => settle(false));
+    socket.setTimeout(timeoutMs, () => settle(false));
+});
+const waitForPortReady = async (port, host = '127.0.0.1', timeoutMs = 5_000) => {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (await canConnectToPort(port, host)) {
+            return true;
+        }
+        await wait(100);
+    }
+    return false;
+};
+export const createHttpServer = async (manager, options = {}) => {
+    const app = Fastify({
+        logger: false
+    });
+    const clientBundleDir = options.clientBundleDir === undefined
+        ? resolveBundledClientDir()
+        : options.clientBundleDir;
+    await app.register(websocket);
+    if (clientBundleDir) {
+        await app.register(fastifyStatic, {
+            root: clientBundleDir
+        });
+    }
+    app.setErrorHandler((error, _request, reply) => {
+        if (isCodoriError(error)) {
+            reply.status(toStatusCode(error)).send({
+                error: {
+                    code: error.code,
+                    message: error.message,
+                    details: error.details ?? null
+                }
+            });
+            return;
+        }
+        reply.status(500).send({
+            error: {
+                code: 'INTERNAL_ERROR',
+                message: error instanceof Error ? error.message : 'Unknown error.'
+            }
+        });
+    });
+    app.get('/api/projects', async () => ({
+        projects: await resolveValue(manager.listProjectStatuses())
+    }));
+    app.get('/api/projects/:projectId', async (request) => ({
+        project: await resolveValue(manager.getProjectStatus(getProjectIdFromRequest(request.params.projectId)))
+    }));
+    app.get('/api/projects/:projectId/status', async (request) => ({
+        project: await resolveValue(manager.getProjectStatus(getProjectIdFromRequest(request.params.projectId)))
+    }));
+    app.post('/api/projects/:projectId/start', async (request) => ({
+        project: await resolveValue(manager.startProject(getProjectIdFromRequest(request.params.projectId)))
+    }));
+    app.post('/api/projects/:projectId/stop', async (request) => ({
+        project: await resolveValue(manager.stopProject(getProjectIdFromRequest(request.params.projectId)))
+    }));
+    app.get('/api/projects/:projectId/rpc', { websocket: true }, async (clientSocket, request) => {
+        const projectId = getProjectIdFromRequest(request.params.projectId);
+        const pendingClientMessages = [];
+        let upstream = null;
+        const closeBoth = (code = 1011, reason = 'proxy error') => {
+            if (clientSocket.readyState === clientSocket.OPEN || clientSocket.readyState === clientSocket.CONNECTING) {
+                clientSocket.close(code, reason);
+            }
+            if (upstream && (upstream.readyState === WebSocket.OPEN || upstream.readyState === WebSocket.CONNECTING)) {
+                upstream.close(code, reason);
+            }
+        };
+        clientSocket.on('message', (message, isBinary) => {
+            if (upstream?.readyState === WebSocket.OPEN) {
+                upstream.send(message, { binary: isBinary });
+                return;
+            }
+            pendingClientMessages.push({ message, isBinary });
+        });
+        clientSocket.on('error', () => {
+            closeBoth(1011, 'client websocket failed');
+        });
+        clientSocket.on('close', () => {
+            if (upstream && (upstream.readyState === WebSocket.OPEN || upstream.readyState === WebSocket.CONNECTING)) {
+                upstream.close();
+            }
+        });
+        void (async () => {
+            const started = await resolveValue(manager.startProject(projectId));
+            if (typeof started.port !== 'number') {
+                closeBoth(1011, 'runtime port unavailable');
+                return;
+            }
+            const ready = await waitForPortReady(started.port);
+            if (!ready) {
+                closeBoth(1011, 'runtime did not become ready');
+                return;
+            }
+            upstream = new WebSocket(`ws://127.0.0.1:${started.port}`);
+            upstream.once('open', () => {
+                for (const entry of pendingClientMessages.splice(0, pendingClientMessages.length)) {
+                    upstream?.send(entry.message, { binary: entry.isBinary });
+                }
+            });
+            upstream.on('message', (message, isBinary) => {
+                clientSocket.send(message, { binary: isBinary });
+            });
+            upstream.on('error', () => {
+                closeBoth(1011, 'upstream websocket failed');
+            });
+            upstream.on('close', () => {
+                if (clientSocket.readyState === clientSocket.OPEN || clientSocket.readyState === clientSocket.CONNECTING) {
+                    clientSocket.close();
+                }
+            });
+        })().catch(() => {
+            closeBoth(1011, 'upstream bootstrap failed');
+        });
+    });
+    if (clientBundleDir) {
+        app.setNotFoundHandler((request, reply) => {
+            const requestPath = toRequestPath(request.url);
+            const acceptsHtml = request.headers.accept?.includes('text/html') ?? false;
+            if (request.method !== 'GET') {
+                return reply.status(404).send({
+                    error: {
+                        code: 'NOT_FOUND',
+                        message: 'Route not found.'
+                    }
+                });
+            }
+            if (requestPath.startsWith('/api/')) {
+                return reply.status(404).send({
+                    error: {
+                        code: 'NOT_FOUND',
+                        message: 'Route not found.'
+                    }
+                });
+            }
+            if (isAssetRequest(requestPath) && !acceptsHtml) {
+                return reply.status(404).send({
+                    error: {
+                        code: 'NOT_FOUND',
+                        message: 'Asset not found.'
+                    }
+                });
+            }
+            return reply.type('text/html').sendFile('index.html');
+        });
+    }
+    return app;
+};
+export const startHttpServer = async (manager = createRuntimeManager()) => {
+    const app = await createHttpServer(manager);
+    if (!manager.config) {
+        throw new CodoriError('INVALID_CONFIG', 'Manager config is required to start the HTTP server.');
+    }
+    await app.listen({
+        host: manager.config.server.host,
+        port: manager.config.server.port
+    });
+    return app;
+};

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { resolveConfig, resolveCodoriConfigPath, resolveCodoriHome } from './config.js';
+export { CodoriError } from './errors.js';
+export { createHttpServer, startHttpServer } from './http-server.js';
+export { findAvailablePort } from './ports.js';
+export { createRuntimeManager, RuntimeManager } from './process-manager.js';
+export { scanProjects } from './project-scanner.js';
+export { RuntimeStore } from './runtime-store.js';
+export type * from './types.js';

package/dist/index.js

@@ -0,0 +1,7 @@
+export { resolveConfig, resolveCodoriConfigPath, resolveCodoriHome } from './config.js';
+export { CodoriError } from './errors.js';
+export { createHttpServer, startHttpServer } from './http-server.js';
+export { findAvailablePort } from './ports.js';
+export { createRuntimeManager, RuntimeManager } from './process-manager.js';
+export { scanProjects } from './project-scanner.js';
+export { RuntimeStore } from './runtime-store.js';

package/dist/ports.d.ts

@@ -0,0 +1 @@
+export declare const findAvailablePort: (start: number, end: number) => Promise<number>;

package/dist/ports.js

@@ -0,0 +1,20 @@
+import net from 'node:net';
+import { CodoriError } from './errors.js';
+const canListenOnPort = (port) => new Promise((resolve) => {
+    const server = net.createServer();
+    server.once('error', () => {
+        resolve(false);
+    });
+    server.once('listening', () => {
+        server.close(() => resolve(true));
+    });
+    server.listen(port, '0.0.0.0');
+});
+export const findAvailablePort = async (start, end) => {
+    for (let port = start; port <= end; port += 1) {
+        if (await canListenOnPort(port)) {
+            return port;
+        }
+    }
+    throw new CodoriError('NO_FREE_PORT', `No free TCP port is available in the configured range ${start}-${end}.`);
+};

package/dist/process-manager.d.ts

@@ -0,0 +1,28 @@
+import { RuntimeStore } from './runtime-store.js';
+import type { CodoriConfig, ConfigOverrides, ProjectRecord, ProjectStatusRecord, StartProjectResult } from './types.js';
+type CommandFactory = (port: number, project: ProjectRecord) => {
+    command: string;
+    args: string[];
+};
+type RuntimeManagerOptions = {
+    homeDir?: string;
+    configOverrides?: ConfigOverrides;
+    config?: CodoriConfig;
+    commandFactory?: CommandFactory;
+};
+export declare class RuntimeManager {
+    readonly config: CodoriConfig;
+    readonly store: RuntimeStore;
+    private readonly commandFactory;
+    constructor(options?: RuntimeManagerOptions);
+    listProjects(): ProjectRecord[];
+    private resolveProject;
+    private normalizeStatus;
+    private readRunningRuntime;
+    listProjectStatuses(): ProjectStatusRecord[];
+    getProjectStatus(projectId: string): ProjectStatusRecord;
+    startProject(projectId: string): Promise<StartProjectResult>;
+    stopProject(projectId: string): Promise<ProjectStatusRecord>;
+}
+export declare const createRuntimeManager: (options?: RuntimeManagerOptions) => RuntimeManager;
+export {};