@nylorun/cli 0.2.0-beta → 0.3.0-beta

package/dist/runtime-host.js

@@ -1,355 +0,0 @@
-import { spawn } from "node:child_process";
-import { createServer } from "node:net";
-import { createRequire } from "node:module";
-import { openSync, closeSync, statSync, renameSync, existsSync, readFileSync, } from "node:fs";
-import { dirname, join } from "node:path";
-import { readFile, open } from "node:fs/promises";
-import { clearState, ensureDataDir, probeHealth, readState, writeState, } from "./scope.js";
-import { CliError } from "./errors.js";
-import { localCredentials } from "./project-runner.js";
-const require = createRequire(import.meta.url);
-const READY_TIMEOUT_MS = 20_000;
-const LOG_LIMIT_BYTES = 8 * 1024 * 1024;
-/**
- * Derived from the resolved server entry rather than a "./package.json" export, so the version
- * is readable for every installed Runtime — including one too old to declare that export,
- * which is exactly when skew detection matters.
- */
-export const cliRuntimeVersion = () => {
-    try {
-        return require("@nylorun/runtime/package.json").version;
-    }
-    catch {
-        /* fall through to the entry-relative read */
-    }
-    try {
-        let directory = dirname(require.resolve("@nylorun/runtime/server"));
-        for (let depth = 0; depth < 5; depth += 1) {
-            const candidate = join(directory, "package.json");
-            if (existsSync(candidate)) {
-                const pkg = JSON.parse(readFileSync(candidate, "utf8"));
-                if (pkg.name === "@nylorun/runtime")
-                    return pkg.version;
-            }
-            directory = dirname(directory);
-        }
-    }
-    catch {
-        /* an unresolvable Runtime is reported elsewhere */
-    }
-    return undefined;
-};
-const alive = (pid) => {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch (error) {
-        // EPERM means the pid exists but belongs to another user; only ESRCH proves it is gone.
-        return error.code !== "ESRCH";
-    }
-};
-/** A squatter that accepts connections without answering /health is still a port conflict. */
-async function bindable(host, port) {
-    const server = createServer();
-    return await new Promise((resolve) => {
-        server.once("error", () => resolve(false));
-        server.listen(port, host, () => server.close(() => resolve(true)));
-    });
-}
-export async function hostStatus(scope) {
-    const runtime = await readState(scope);
-    const probe = await probeHealth(scope.url);
-    const ours = probe.health !== undefined &&
-        (runtime?.scopeId === undefined ||
-            probe.health.scopeId === undefined ||
-            probe.health.scopeId === runtime.scopeId);
-    const common = {
-        scope,
-        ...(runtime ? { runtime } : {}),
-        ...(probe.health?.version ? { version: probe.health.version } : {}),
-        ...(probe.health?.scopeId ? { scopeId: probe.health.scopeId } : {}),
-        ...(probe.health?.pid ? { pid: probe.health.pid } : {}),
-    };
-    if (probe.foreign)
-        return { state: "port-conflict", ...common };
-    if (probe.health && ours)
-        return { state: "running", ...common };
-    if (probe.health && !ours)
-        return { state: "port-conflict", ...common };
-    if (runtime && alive(runtime.pid))
-        return { state: "unhealthy", ...common };
-    if (!(await bindable(scope.host, scope.port)))
-        return { state: "port-conflict", ...common };
-    if (!runtime)
-        return { state: "stopped", ...common };
-    return { state: "stale", ...common };
-}
-function rotateLog(path) {
-    try {
-        if (statSync(path).size > LOG_LIMIT_BYTES)
-            renameSync(path, `${path}.1`);
-    }
-    catch {
-        /* no log yet */
-    }
-}
-async function logTail(path, lines = 40) {
-    try {
-        const text = await readFile(path, "utf8");
-        return text.trimEnd().split("\n").slice(-lines).join("\n");
-    }
-    catch {
-        return "";
-    }
-}
-export async function startHost(scope, options = {}) {
-    await ensureDataDir(scope);
-    if (options.restart)
-        await stopHost(scope);
-    const status = await hostStatus(scope);
-    if (status.state === "running" && !options.foreground)
-        return status;
-    if (status.state === "port-conflict")
-        throw portConflict(scope, status);
-    if (status.state === "unhealthy")
-        throw new CliError(`A process for ${scope.label} is running (pid ${status.runtime?.pid}) but is not answering ${scope.url}. Inspect it with "nylorun logs", then stop it with "nylorun down".`, 1);
-    if (status.state === "stale")
-        await clearState(scope);
-    const credentials = await localCredentials(scope.credentialsPath);
-    const entry = require.resolve("@nylorun/runtime/server");
-    const environment = {
-        ...process.env,
-        HOST: scope.host,
-        PORT: String(scope.port),
-        NYLORUN_PROJECT_PROVIDER: "1",
-        NYLORUN_SERVER_KEY: credentials.serverKey,
-        NYLORUN_SQLITE_PATH: scope.sqlitePath,
-    };
-    // Executor scopes are no longer handed to the process at startup: the host outlives any one
-    // project run and learns its executors through PUT /v1/executors.
-    delete environment.NYLORUN_EXECUTORS_JSON;
-    if (options.foreground) {
-        const child = spawn(process.execPath, [entry], {
-            env: environment,
-            stdio: ["ignore", "inherit", "inherit", "ipc"],
-        });
-        await awaitReady(child, scope, "");
-        const ready = await recordState(scope, child.pid);
-        const stop = (signal) => child.kill(signal);
-        process.on("SIGINT", () => stop("SIGINT"));
-        process.on("SIGTERM", () => stop("SIGTERM"));
-        const code = await new Promise((resolve) => child.once("exit", (value, signal) => resolve(value ?? (signal === "SIGINT" ? 130 : 143))));
-        await clearState(scope);
-        if (code)
-            throw new CliError(`The Runtime exited (${code}).`, code);
-        return ready;
-    }
-    rotateLog(scope.logPath);
-    const fd = openSync(scope.logPath, "a", 0o600);
-    try {
-        const child = spawn(process.execPath, [entry], {
-            detached: process.platform !== "win32",
-            windowsHide: true,
-            cwd: scope.dataDir,
-            env: environment,
-            stdio: ["ignore", fd, fd, "ipc"],
-        });
-        await awaitReady(child, scope, scope.logPath);
-        child.disconnect();
-        child.unref();
-        return await recordState(scope, child.pid);
-    }
-    finally {
-        closeSync(fd);
-    }
-}
-function portConflict(scope, status) {
-    if (status.scopeId)
-        return new CliError(`Port ${scope.port} is already serving a different nylorun scope (${status.scopeId}). Start this one elsewhere with "nylorun up --port <n>", or stop the other from its project with "nylorun down".`, 4);
-    return new CliError(`Port ${scope.port} on ${scope.host} is in use by another process. Start ${scope.label} elsewhere with "nylorun up --port <n>".`, 4);
-}
-async function awaitReady(child, scope, logPath) {
-    // The IPC message is the fast path and the only way to see an early crash; /health is the
-    // authority, so a host that ever stops sending the message still starts correctly.
-    await new Promise((resolve, reject) => {
-        const timer = setTimeout(() => {
-            cleanup();
-            reject(new CliError(`The Runtime for ${scope.label} did not start within 20 seconds. See "nylorun logs".`, 7));
-        }, READY_TIMEOUT_MS);
-        const onMessage = (message) => {
-            if (message?.type !== "ready")
-                return;
-            cleanup();
-            resolve();
-        };
-        const onExit = async (code) => {
-            cleanup();
-            const tail = logPath ? await logTail(logPath) : "";
-            reject(new CliError(`The Runtime for ${scope.label} exited (${code}).${tail ? `\n${tail}` : ""}`, 7));
-        };
-        const onError = (error) => {
-            cleanup();
-            reject(error);
-        };
-        const cleanup = () => {
-            clearTimeout(timer);
-            child.off("message", onMessage);
-            child.off("exit", onExit);
-            child.off("error", onError);
-        };
-        child.on("message", onMessage);
-        child.once("exit", onExit);
-        child.once("error", onError);
-    });
-    const deadline = Date.now() + READY_TIMEOUT_MS;
-    for (;;) {
-        const probe = await probeHealth(scope.url);
-        if (probe.health)
-            return;
-        if (Date.now() > deadline)
-            throw new CliError(`The Runtime for ${scope.label} started but did not answer ${scope.url}. See "nylorun logs".`, 7);
-        await new Promise((resolve) => setTimeout(resolve, 250));
-    }
-}
-async function recordState(scope, pid) {
-    const probe = await probeHealth(scope.url);
-    const state = {
-        pid,
-        host: scope.host,
-        port: scope.port,
-        url: scope.url,
-        sqlitePath: scope.sqlitePath,
-        logPath: scope.logPath,
-        startedAt: new Date().toISOString(),
-        ...(probe.health?.scopeId ? { scopeId: probe.health.scopeId } : {}),
-        ...(probe.health?.version ? { runtimeVersion: probe.health.version } : {}),
-        ...(cliRuntimeVersion() ? { cliVersion: cliRuntimeVersion() } : {}),
-    };
-    await writeState(scope, state);
-    return {
-        state: "running",
-        scope,
-        runtime: state,
-        pid,
-        ...(probe.health?.version ? { version: probe.health.version } : {}),
-        ...(probe.health?.scopeId ? { scopeId: probe.health.scopeId } : {}),
-    };
-}
-export async function stopHost(scope, options = {}) {
-    const status = await hostStatus(scope);
-    const pid = status.runtime?.pid ?? status.pid;
-    if (status.state === "stopped" || status.state === "stale" || !pid) {
-        await clearState(scope);
-        return "not-running";
-    }
-    if (status.state === "port-conflict")
-        throw portConflict(scope, status);
-    // SIGTERM the process rather than the group: the Runtime's own shutdown is what closes
-    // SQLite cleanly and tears down MCP children.
-    try {
-        process.kill(pid, "SIGTERM");
-    }
-    catch (error) {
-        if (error.code !== "ESRCH")
-            throw error;
-    }
-    const deadline = Date.now() + (options.timeoutMs ?? 10_000);
-    while (Date.now() < deadline) {
-        if (!alive(pid)) {
-            await clearState(scope);
-            return "stopped";
-        }
-        await new Promise((resolve) => setTimeout(resolve, 100));
-    }
-    try {
-        if (process.platform === "win32")
-            process.kill(pid);
-        else
-            process.kill(-pid, "SIGKILL");
-    }
-    catch {
-        try {
-            process.kill(pid, "SIGKILL");
-        }
-        catch {
-            /* already gone */
-        }
-    }
-    await clearState(scope);
-    return "stopped";
-}
-export async function ensureRuntime(scope, options) {
-    const status = await hostStatus(scope);
-    if (status.state === "running") {
-        assertCompatible(scope, status);
-        return status;
-    }
-    if (status.state === "port-conflict")
-        throw portConflict(scope, status);
-    if (status.state === "unhealthy")
-        throw new CliError(`A process for ${scope.label} is running (pid ${status.runtime?.pid}) but is not answering ${scope.url}. See "nylorun logs".`, 1);
-    if (!options.autostart)
-        throw new CliError(`No Runtime is listening at ${scope.url} for ${scope.label}. Start one with "nylorun up", or drop --no-autostart.`, 6);
-    const started = await startHost(scope);
-    if (!options.quiet)
-        console.log(`Started the Runtime for ${scope.label} at ${scope.url} (pid ${started.pid}). It stays running; stop it with "nylorun down".`);
-    assertCompatible(scope, started);
-    return started;
-}
-/**
- * A daemon from an older install would reject executor registration with a bare 404, so the
- * commands that depend on that route fail early with the remedy instead.
- */
-export function assertCompatible(scope, status) {
-    const expected = cliRuntimeVersion();
-    if (!expected)
-        return;
-    if (!status.version)
-        throw new CliError(`The Runtime serving ${scope.url} predates executor registration. Restart it with "nylorun runtime start --restart".`, 5);
-    if (status.version !== expected)
-        throw new CliError(`Runtime ${status.version} is serving ${scope.label}; this CLI ships ${expected}. Restart it with "nylorun runtime start --restart".`, 5);
-}
-export function warnIncompatible(scope, status) {
-    try {
-        assertCompatible(scope, status);
-    }
-    catch (error) {
-        console.warn(error instanceof Error ? error.message : String(error));
-    }
-}
-export async function tailLog(scope, options) {
-    let size = 0;
-    try {
-        size = statSync(scope.logPath).size;
-    }
-    catch {
-        throw new CliError(`No Runtime log for ${scope.label}. Start one with "nylorun up".`, 3);
-    }
-    const text = await readFile(scope.logPath, "utf8");
-    process.stdout.write(`${text.trimEnd().split("\n").slice(-options.lines).join("\n")}\n`);
-    if (!options.follow)
-        return;
-    await new Promise((resolve) => {
-        process.once("SIGINT", () => resolve());
-        process.once("SIGTERM", () => resolve());
-        const poll = setInterval(async () => {
-            let next = 0;
-            try {
-                next = statSync(scope.logPath).size;
-            }
-            catch {
-                return;
-            }
-            if (next <= size)
-                return;
-            const handle = await open(scope.logPath, "r");
-            const buffer = Buffer.alloc(next - size);
-            await handle.read(buffer, 0, buffer.length, size);
-            await handle.close();
-            size = next;
-            process.stdout.write(buffer.toString("utf8"));
-        }, 500);
-        poll.unref();
-    });
-}

package/dist/scope.d.ts

@@ -1,65 +0,0 @@
-export type ScopeKind = "project" | "global";
-export interface Scope {
-    readonly kind: ScopeKind;
-    readonly root: string;
-    readonly dataDir: string;
-    readonly sqlitePath: string;
-    readonly credentialsPath: string;
-    readonly statePath: string;
-    readonly logPath: string;
-    readonly pidPath: string;
-    readonly host: string;
-    readonly port: number;
-    readonly url: string;
-    readonly label: string;
-}
-export interface RuntimeState {
-    pid: number;
-    host: string;
-    port: number;
-    url: string;
-    scopeId?: string;
-    runtimeVersion?: string;
-    cliVersion?: string;
-    sqlitePath: string;
-    logPath: string;
-    startedAt: string;
-}
-export interface ScopeRequest {
-    global?: boolean;
-    port?: number;
-    db?: string;
-    cwd?: string;
-}
-/**
- * The nearest `.nylorun` wins so an initialised project keeps working from a subdirectory;
- * otherwise the nearest package.json defines the project. The walk stops at the home
- * directory because `~/.nylorun` is the global data directory, never a project root.
- */
-export declare function findProjectRoot(cwd?: string): string | undefined;
-export declare function resolveScope(request?: ScopeRequest): Scope;
-export declare function ensureDataDir(scope: Scope): Promise<void>;
-export declare function readState(scope: Scope): Promise<RuntimeState | undefined>;
-export declare function writeState(scope: Scope, state: RuntimeState): Promise<void>;
-export declare function clearState(scope: Scope): Promise<void>;
-/**
- * The health fields this CLI relies on. Declared here rather than imported, because the CLI
- * may only depend on the agents SDK and the Runtime; version and scopeId are optional so a
- * Runtime that predates them still parses into a usable probe.
- */
-export interface HealthResponse {
-    status: string;
-    service: string;
-    version?: string;
-    scopeId?: string;
-    pid?: number;
-}
-export interface HealthProbe {
-    reachable: boolean;
-    health?: HealthResponse;
-    /** True when something answered the port but it is not a Runtime we can parse. */
-    foreign?: boolean;
-}
-export declare function probeHealth(url: string, timeoutMs?: number): Promise<HealthProbe>;
-export declare const scopeId: (sqlitePath: string) => string | undefined;
-export declare function loadScopeEnvironment(scope: Scope): void;

package/dist/scope.js

@@ -1,191 +0,0 @@
-import { existsSync, readFileSync, realpathSync } from "node:fs";
-import { mkdir, readFile, writeFile, rename, unlink } from "node:fs/promises";
-import { createHash, randomUUID } from "node:crypto";
-import { homedir } from "node:os";
-import { dirname, join, parse, resolve } from "node:path";
-import { loadProjectEnvironment } from "./environment.js";
-/** An environment variable set to the empty string means "unset", not "use an empty path". */
-const setting = (name) => {
-    const value = process.env[name];
-    return value === undefined || value.trim() === "" ? undefined : value;
-};
-const globalDataDir = () => {
-    const home = setting("NYLORUN_HOME");
-    return home ? resolve(home) : join(homedir(), ".nylorun");
-};
-/**
- * The nearest `.nylorun` wins so an initialised project keeps working from a subdirectory;
- * otherwise the nearest package.json defines the project. The walk stops at the home
- * directory because `~/.nylorun` is the global data directory, never a project root.
- */
-export function findProjectRoot(cwd = process.cwd()) {
-    const stop = (() => {
-        try {
-            return realpathSync(homedir());
-        }
-        catch {
-            return homedir();
-        }
-    })();
-    let directory = resolve(cwd);
-    try {
-        directory = realpathSync(directory);
-    }
-    catch {
-        /* a cwd that cannot be resolved simply falls through to the global scope */
-    }
-    const root = parse(directory).root;
-    let fallback;
-    for (;;) {
-        if (directory === stop)
-            return undefined;
-        if (existsSync(join(directory, ".nylorun")))
-            return directory;
-        if (!fallback && existsSync(join(directory, "package.json")))
-            fallback = directory;
-        if (directory === root)
-            break;
-        const parent = dirname(directory);
-        if (parent === directory)
-            break;
-        directory = parent;
-    }
-    return fallback;
-}
-function port(request, state) {
-    const candidate = request.port ??
-        numeric(setting("NYLORUN_PORT")) ??
-        numeric(setting("PORT")) ??
-        state?.port ??
-        8787;
-    if (!Number.isInteger(candidate) || candidate < 1 || candidate > 65535)
-        throw new Error("The Runtime port must be an integer between 1 and 65535.");
-    return candidate;
-}
-const numeric = (value) => {
-    if (value === undefined || value.trim() === "")
-        return undefined;
-    const parsed = Number(value);
-    return Number.isInteger(parsed) ? parsed : Number.NaN;
-};
-export function resolveScope(request = {}) {
-    const projectRoot = request.global ? undefined : findProjectRoot(request.cwd);
-    const kind = projectRoot ? "project" : "global";
-    const root = projectRoot ?? globalDataDir();
-    const dataDir = projectRoot ? join(projectRoot, ".nylorun") : globalDataDir();
-    const statePath = join(dataDir, "runtime.json");
-    const state = readStateSync(statePath);
-    const resolvedPort = port(request, state);
-    const host = setting("HOST") ?? "127.0.0.1";
-    return {
-        kind,
-        root,
-        dataDir,
-        sqlitePath: request.db ?? setting("NYLORUN_SQLITE_PATH") ?? join(dataDir, "runtime.sqlite"),
-        credentialsPath: join(dataDir, "local-credentials.json"),
-        statePath,
-        logPath: join(dataDir, "runtime.log"),
-        pidPath: join(dataDir, "runtime.pid"),
-        host,
-        port: resolvedPort,
-        url: `http://${host}:${resolvedPort}`,
-        label: projectRoot ? `project ${projectRoot}` : `global ${dataDir}`,
-    };
-}
-export async function ensureDataDir(scope) {
-    await mkdir(scope.dataDir, { recursive: true, mode: 0o700 });
-    if (scope.kind !== "project")
-        return;
-    // A project that already keeps a .gitignore should not start committing local credentials;
-    // creating one where the author chose not to have it would be a surprise, so we never do.
-    const path = join(scope.root, ".gitignore");
-    let current;
-    try {
-        current = await readFile(path, "utf8");
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return;
-        throw error;
-    }
-    if (/^\.nylorun\/?$/m.test(current))
-        return;
-    await writeFile(path, `${current}${current.endsWith("\n") || !current ? "" : "\n"}.nylorun/\n`);
-}
-function readStateSync(path) {
-    try {
-        // Only the port is read during scope resolution, so a torn or hand-edited file is ignored.
-        const value = JSON.parse(readFileSync(path, "utf8"));
-        return typeof value?.port === "number" ? value : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-export async function readState(scope) {
-    try {
-        const value = JSON.parse(await readFile(scope.statePath, "utf8"));
-        return typeof value?.pid === "number" ? value : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-export async function writeState(scope, state) {
-    const temporary = `${scope.statePath}.${randomUUID()}.tmp`;
-    await writeFile(temporary, JSON.stringify(state), { mode: 0o600 });
-    await rename(temporary, scope.statePath);
-    await writeFile(scope.pidPath, `${state.pid}\n`, { mode: 0o600 });
-}
-export async function clearState(scope) {
-    for (const path of [scope.statePath, scope.pidPath])
-        await unlink(path).catch(() => { });
-}
-const asHealth = (value) => {
-    const body = value;
-    if (!body || body.status !== "ok" || typeof body.service !== "string")
-        return undefined;
-    return {
-        status: body.status,
-        service: body.service,
-        ...(typeof body.version === "string" ? { version: body.version } : {}),
-        ...(typeof body.scopeId === "string" ? { scopeId: body.scopeId } : {}),
-        ...(typeof body.pid === "number" ? { pid: body.pid } : {}),
-    };
-};
-export async function probeHealth(url, timeoutMs = 2000) {
-    const signal = AbortSignal.timeout(timeoutMs);
-    let response;
-    try {
-        response = await fetch(`${url}/health`, { signal });
-    }
-    catch {
-        return { reachable: false };
-    }
-    if (!response.ok)
-        return { reachable: true, foreign: true };
-    try {
-        const health = asHealth(await response.json());
-        if (health?.service !== "oss-runtime")
-            return { reachable: true, foreign: true };
-        return { reachable: true, health };
-    }
-    catch {
-        return { reachable: true, foreign: true };
-    }
-}
-export const scopeId = (sqlitePath) => {
-    try {
-        return createHash("sha256")
-            .update(realpathSync(sqlitePath))
-            .digest("hex")
-            .slice(0, 16);
-    }
-    catch {
-        return undefined;
-    }
-};
-export function loadScopeEnvironment(scope) {
-    if (scope.kind === "project")
-        loadProjectEnvironment(scope.root);
-}