@codori/server 0.0.1

package/dist/process-manager.js

@@ -0,0 +1,157 @@
+import { spawn } from 'node:child_process';
+import os from 'node:os';
+import { resolveConfig } from './config.js';
+import { CodoriError } from './errors.js';
+import { findAvailablePort } from './ports.js';
+import { scanProjects } from './project-scanner.js';
+import { RuntimeStore } from './runtime-store.js';
+const CODORI_STOP_TIMEOUT_MS = 3_000;
+const CODORI_STOP_POLL_MS = 50;
+const defaultCommandFactory = (port) => ({
+    command: process.env.CODORI_CODEX_BIN ?? 'codex',
+    args: ['app-server', '--listen', `ws://0.0.0.0:${port}`]
+});
+const isProcessAlive = (pid) => {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+const wait = async (ms) => new Promise((resolvePromise) => {
+    setTimeout(resolvePromise, ms);
+});
+const waitForExit = async (pid, timeoutMs) => {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (!isProcessAlive(pid)) {
+            return true;
+        }
+        await wait(CODORI_STOP_POLL_MS);
+    }
+    return !isProcessAlive(pid);
+};
+const spawnDetached = async (command, args, cwd) => new Promise((resolvePromise, reject) => {
+    const child = spawn(command, args, {
+        cwd,
+        detached: true,
+        stdio: 'ignore',
+        windowsHide: true
+    });
+    child.once('error', reject);
+    child.once('spawn', () => {
+        child.unref();
+        resolvePromise(child);
+    });
+});
+export class RuntimeManager {
+    config;
+    store;
+    commandFactory;
+    constructor(options = {}) {
+        this.config = options.config ?? resolveConfig(options.configOverrides, options.homeDir);
+        this.store = new RuntimeStore(options.homeDir);
+        this.commandFactory = options.commandFactory ?? defaultCommandFactory;
+    }
+    listProjects() {
+        return scanProjects(this.config.root);
+    }
+    resolveProject(projectId) {
+        const project = this.listProjects().find(entry => entry.id === projectId);
+        if (!project) {
+            throw new CodoriError('PROJECT_NOT_FOUND', `Project "${projectId}" was not found under ${this.config.root}.`);
+        }
+        return project;
+    }
+    normalizeStatus(project, runtime, error) {
+        return {
+            projectId: project.id,
+            projectPath: project.path,
+            status: error ? 'error' : runtime ? 'running' : 'stopped',
+            pid: runtime?.pid ?? null,
+            port: runtime?.port ?? null,
+            startedAt: runtime?.startedAt ?? null,
+            error
+        };
+    }
+    readRunningRuntime(project) {
+        const loaded = this.store.load(project.path);
+        if (loaded.kind === 'missing') {
+            return this.normalizeStatus(project, null, null);
+        }
+        if (loaded.kind === 'invalid') {
+            return this.normalizeStatus(project, null, loaded.error);
+        }
+        if (!isProcessAlive(loaded.record.pid)) {
+            this.store.remove(project.path);
+            return this.normalizeStatus(project, null, null);
+        }
+        return this.normalizeStatus(project, loaded.record, null);
+    }
+    listProjectStatuses() {
+        return this.listProjects().map(project => this.readRunningRuntime(project));
+    }
+    getProjectStatus(projectId) {
+        return this.readRunningRuntime(this.resolveProject(projectId));
+    }
+    async startProject(projectId) {
+        const project = this.resolveProject(projectId);
+        const loaded = this.store.load(project.path);
+        if (loaded.kind === 'valid' && isProcessAlive(loaded.record.pid)) {
+            return {
+                ...this.normalizeStatus(project, loaded.record, null),
+                reusedExisting: true
+            };
+        }
+        if (loaded.kind !== 'missing') {
+            this.store.remove(project.path);
+        }
+        const port = await findAvailablePort(this.config.ports.start, this.config.ports.end);
+        const command = this.commandFactory(port, project);
+        const child = await spawnDetached(command.command, command.args, project.path);
+        if (typeof child.pid !== 'number') {
+            throw new CodoriError('PROCESS_START_FAILED', `Failed to determine PID for project "${projectId}".`);
+        }
+        const runtime = {
+            projectId: project.id,
+            projectPath: project.path,
+            pid: child.pid,
+            port,
+            startedAt: Date.now()
+        };
+        this.store.write(runtime);
+        return {
+            ...this.normalizeStatus(project, runtime, null),
+            reusedExisting: false
+        };
+    }
+    async stopProject(projectId) {
+        const project = this.resolveProject(projectId);
+        const loaded = this.store.load(project.path);
+        if (loaded.kind === 'missing') {
+            return this.normalizeStatus(project, null, null);
+        }
+        if (loaded.kind === 'invalid') {
+            this.store.remove(project.path);
+            return this.normalizeStatus(project, null, null);
+        }
+        if (isProcessAlive(loaded.record.pid)) {
+            process.kill(loaded.record.pid, 'SIGTERM');
+            const exited = await waitForExit(loaded.record.pid, CODORI_STOP_TIMEOUT_MS);
+            if (!exited) {
+                process.kill(loaded.record.pid, 'SIGKILL');
+                await waitForExit(loaded.record.pid, CODORI_STOP_TIMEOUT_MS);
+            }
+        }
+        this.store.remove(project.path);
+        return this.normalizeStatus(project, null, null);
+    }
+}
+export const createRuntimeManager = (options = {}) => new RuntimeManager({
+    homeDir: options.homeDir ?? os.homedir(),
+    configOverrides: options.configOverrides,
+    config: options.config,
+    commandFactory: options.commandFactory
+});

package/dist/project-scanner.d.ts

@@ -0,0 +1,2 @@
+import type { ProjectRecord } from './types.js';
+export declare const scanProjects: (rootDirectory: string) => ProjectRecord[];

package/dist/project-scanner.js

@@ -0,0 +1,40 @@
+import { readdirSync } from 'node:fs';
+import { join, relative, resolve, sep } from 'node:path';
+const IGNORED_DIRECTORY_NAMES = new Set([
+    '.git',
+    '.nuxt',
+    '.output',
+    'build',
+    'coverage',
+    'dist',
+    'node_modules'
+]);
+const toProjectId = (root, path) => relative(root, path).split(sep).join('/');
+export const scanProjects = (rootDirectory) => {
+    const root = resolve(rootDirectory);
+    const projects = [];
+    const queue = [root];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        const entries = readdirSync(current, { withFileTypes: true });
+        if (entries.some(entry => entry.isDirectory() && entry.name === '.git')) {
+            if (current !== root) {
+                projects.push({
+                    id: toProjectId(root, current),
+                    path: current
+                });
+            }
+            continue;
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory()) {
+                continue;
+            }
+            if (IGNORED_DIRECTORY_NAMES.has(entry.name)) {
+                continue;
+            }
+            queue.push(join(current, entry.name));
+        }
+    }
+    return projects.sort((left, right) => left.id.localeCompare(right.id));
+};

package/dist/runtime-store.d.ts

@@ -0,0 +1,21 @@
+import type { RuntimeRecord } from './types.js';
+export type RuntimeLoadResult = {
+    kind: 'missing';
+    path: string;
+} | {
+    kind: 'invalid';
+    path: string;
+    error: string;
+} | {
+    kind: 'valid';
+    path: string;
+    record: RuntimeRecord;
+};
+export declare class RuntimeStore {
+    readonly runDir: string;
+    constructor(homeDir?: string);
+    resolveRuntimePath(projectPath: string): string;
+    load(projectPath: string): RuntimeLoadResult;
+    write(record: RuntimeRecord): void;
+    remove(projectPath: string): void;
+}

package/dist/runtime-store.js

@@ -0,0 +1,79 @@
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import os from 'node:os';
+import { join, resolve } from 'node:path';
+import { ensureCodoriDirectories, resolveCodoriHome } from './config.js';
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const normalizeRuntimeRecord = (value) => {
+    if (!isRecord(value)) {
+        return null;
+    }
+    const { projectId, projectPath, pid, port, startedAt } = value;
+    if (typeof projectId !== 'string'
+        || typeof projectPath !== 'string'
+        || typeof pid !== 'number'
+        || !Number.isInteger(pid)
+        || typeof port !== 'number'
+        || !Number.isInteger(port)
+        || typeof startedAt !== 'number') {
+        return null;
+    }
+    return {
+        projectId,
+        projectPath,
+        pid,
+        port,
+        startedAt
+    };
+};
+export class RuntimeStore {
+    runDir;
+    constructor(homeDir = os.homedir()) {
+        ensureCodoriDirectories(homeDir);
+        this.runDir = join(resolveCodoriHome(homeDir), 'run');
+    }
+    resolveRuntimePath(projectPath) {
+        const normalizedProjectPath = resolve(projectPath);
+        const digest = createHash('sha256').update(normalizedProjectPath).digest('hex').slice(0, 16);
+        return join(this.runDir, `${digest}.pid.json`);
+    }
+    load(projectPath) {
+        const runtimePath = this.resolveRuntimePath(projectPath);
+        if (!existsSync(runtimePath)) {
+            return {
+                kind: 'missing',
+                path: runtimePath
+            };
+        }
+        try {
+            const parsed = JSON.parse(readFileSync(runtimePath, 'utf8'));
+            const record = normalizeRuntimeRecord(parsed);
+            if (!record) {
+                return {
+                    kind: 'invalid',
+                    path: runtimePath,
+                    error: 'Runtime metadata is malformed.'
+                };
+            }
+            return {
+                kind: 'valid',
+                path: runtimePath,
+                record
+            };
+        }
+        catch (error) {
+            return {
+                kind: 'invalid',
+                path: runtimePath,
+                error: error instanceof Error ? error.message : String(error)
+            };
+        }
+    }
+    write(record) {
+        const runtimePath = this.resolveRuntimePath(record.projectPath);
+        writeFileSync(runtimePath, `${JSON.stringify(record, null, 2)}\n`, 'utf8');
+    }
+    remove(projectPath) {
+        rmSync(this.resolveRuntimePath(projectPath), { force: true });
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,40 @@
+export type CodoriConfig = {
+    root: string;
+    server: {
+        host: string;
+        port: number;
+    };
+    ports: {
+        start: number;
+        end: number;
+    };
+};
+export type ConfigOverrides = {
+    root?: string;
+    host?: string;
+    port?: number;
+};
+export type ProjectRecord = {
+    id: string;
+    path: string;
+};
+export type RuntimeRecord = {
+    projectId: string;
+    projectPath: string;
+    pid: number;
+    port: number;
+    startedAt: number;
+};
+export type ProjectRuntimeStatus = 'running' | 'stopped' | 'error';
+export type ProjectStatusRecord = {
+    projectId: string;
+    projectPath: string;
+    status: ProjectRuntimeStatus;
+    pid: number | null;
+    port: number | null;
+    startedAt: number | null;
+    error: string | null;
+};
+export type StartProjectResult = ProjectStatusRecord & {
+    reusedExisting: boolean;
+};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@codori/server",
+  "version": "0.0.1",
+  "private": false,
+  "description": "Codori server for Git project discovery, Codex runtime management, and bundled dashboard serving.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "codori": "dist/cli.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/comfuture/codori.git",
+    "directory": "packages/server"
+  },
+  "homepage": "https://github.com/comfuture/codori#readme",
+  "bugs": {
+    "url": "https://github.com/comfuture/codori/issues"
+  },
+  "keywords": [
+    "codori",
+    "codex",
+    "remote-coding",
+    "nuxt",
+    "fastify"
+  ],
+  "files": [
+    "dist",
+    "client-dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json && node ./scripts/sync-client-bundle.mjs",
+    "lint": "eslint src test --ext .ts",
+    "prepack": "pnpm --dir ../client build && pnpm run build",
+    "typecheck": "tsc -p tsconfig.json",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@fastify/static": "^9.1.0",
+    "@fastify/websocket": "^11.2.0",
+    "fastify": "^5.6.1",
+    "ws": "^8.18.3"
+  }
+}