@nylorun/runtime 0.10.0-beta → 0.12.0-beta

package/dist/launcher/main.js

@@ -1,66 +0,0 @@
-#!/usr/bin/env node
-/**
- * Launcher process entry: the `nylorun-runtime` bin of `@nylorun/runtime`.
- *
- * The only file under runtime/src/launcher/ allowed to read ambient process/OS
- * state (process.env, process.cwd(), os.homedir(), os.tmpdir()). Values are
- * resolved here and passed down explicitly.
- */
-import { homedir } from "node:os";
-import { resolve } from "node:path";
-import { runLauncher } from "./commands.js";
-function resolveHome(env) {
-    const fromEnv = env.NYLORUN_HOME;
-    if (fromEnv !== undefined && fromEnv.trim() !== "")
-        return resolve(fromEnv);
-    return resolve(homedir(), ".nylorun");
-}
-/** Copy allowlisted ambient keys for Host spawn (Tenants §12). */
-function baselineFromEnv(env) {
-    const out = {};
-    for (const key of Object.keys(env)) {
-        if (key === "PATH" || key === "LANG" || key === "TZ" || key.startsWith("LC_")) {
-            out[key] = env[key];
-        }
-    }
-    // Release/dev smokes set NYLORUN_DEV_MODEL=fixture; pass through so the Host
-    // can open Tenants with the credential-free fixture provider.
-    const devModel = env.NYLORUN_DEV_MODEL?.trim();
-    if (devModel)
-        out.NYLORUN_DEV_MODEL = devModel;
-    return out;
-}
-export async function main(argv = process.argv.slice(2), env = process.env) {
-    return runLauncher(argv, {
-        home: resolveHome(env),
-        platform: process.platform,
-        // The Host runs on the same Node as the launcher; no Node is bundled.
-        nodeBinary: process.execPath,
-        nodeVersion: process.versions.node,
-        baselineEnv: baselineFromEnv(env),
-        sink: {
-            json: false,
-            stdout: (line) => {
-                process.stdout.write(`${line}\n`);
-            },
-            stderr: (line) => {
-                process.stderr.write(`${line}\n`);
-            },
-        },
-    });
-}
-const entry = process.argv[1];
-// Windows argv paths use backslashes; normalize before suffix checks so the
-// npm `.cmd` shim (`node.exe …\launcher\main.js`) still counts as the entry.
-// POSIX npm installs link `bin/nylorun-runtime` to this file.
-const normalizedEntry = entry?.replaceAll("\\", "/");
-const isEntry = normalizedEntry !== undefined &&
-    (normalizedEntry.endsWith("launcher/main.ts") ||
-        normalizedEntry.endsWith("launcher/main.js") ||
-        normalizedEntry.endsWith("nylorun-runtime") ||
-        normalizedEntry.endsWith("nylorun-runtime.cmd"));
-if (isEntry) {
-    main().then((code) => {
-        process.exitCode = code;
-    });
-}

package/dist/launcher/output.d.ts

@@ -1,11 +0,0 @@
-import { LauncherError, UsageError } from "./errors.js";
-import type { LauncherEvent } from "./protocol.js";
-export interface OutputSink {
-    stdout: (line: string) => void;
-    stderr: (line: string) => void;
-    json: boolean;
-}
-export declare function emitEvent(sink: OutputSink, event: LauncherEvent): void;
-export declare function emitResult(sink: OutputSink, fields: Record<string, unknown>): void;
-export declare function emitError(sink: OutputSink, error: LauncherError | UsageError | Error): void;
-export declare function exitCodeFor(error: unknown): 1 | 2;

package/dist/launcher/output.js

@@ -1,68 +0,0 @@
-import { LauncherError, UsageError } from "./errors.js";
-export function emitEvent(sink, event) {
-    if (sink.json) {
-        sink.stdout(JSON.stringify(event));
-        return;
-    }
-    switch (event.type) {
-        case "progress": {
-            const parts = [event.phase];
-            if (event.message)
-                parts.push(event.message);
-            sink.stderr(parts.join(" "));
-            return;
-        }
-        case "result": {
-            sink.stdout(JSON.stringify(event, null, 2));
-            return;
-        }
-        case "error": {
-            sink.stderr(`${event.message}\n${event.remedy}`);
-            return;
-        }
-        case "log": {
-            if (event.source === "tenant" && event.tenantId) {
-                sink.stdout(`[${event.tenantId}] ${event.line}`);
-            }
-            else {
-                sink.stdout(event.line);
-            }
-            return;
-        }
-    }
-}
-export function emitResult(sink, fields) {
-    emitEvent(sink, { type: "result", ...fields });
-}
-export function emitError(sink, error) {
-    if (error instanceof LauncherError) {
-        emitEvent(sink, {
-            type: "error",
-            code: error.code,
-            message: error.message,
-            remedy: error.remedy,
-            ...(error.details !== undefined ? { details: error.details } : {}),
-        });
-        return;
-    }
-    if (error instanceof UsageError) {
-        // Usage is exit 2. No ErrorCode fits; print message+remedy on stderr even
-        // with --json so we do not mint a fake registry code.
-        const text = error.remedy
-            ? `${error.message}\n${error.remedy}`
-            : error.message;
-        sink.stderr(text);
-        return;
-    }
-    emitEvent(sink, {
-        type: "error",
-        code: "launcher_failed",
-        message: error.message,
-        remedy: "Retry the command. If it keeps failing, check runtime.log.",
-    });
-}
-export function exitCodeFor(error) {
-    if (error instanceof UsageError)
-        return 2;
-    return 1;
-}

package/dist/launcher/paths.d.ts

@@ -1,20 +0,0 @@
-/** Layout under the Host root (matches design D§3.6). */
-export interface HostPaths {
-    root: string;
-    config: string;
-    state: string;
-    credentials: string;
-    log: string;
-    home: string;
-    tmp: string;
-    tenants: string;
-    trash: string;
-    lifecycleLock: string;
-}
-export declare function hostPaths(hostRoot: string): HostPaths;
-export declare function ensureHostLayout(paths: HostPaths): Promise<void>;
-export declare function ensureDirSync(path: string): void;
-export declare function hostUrl(config: {
-    host: string;
-    port: number;
-}): string;

package/dist/launcher/paths.js

@@ -1,36 +0,0 @@
-import { existsSync, mkdirSync } from "node:fs";
-import { mkdir } from "node:fs/promises";
-import { join, resolve } from "node:path";
-export function hostPaths(hostRoot) {
-    const root = resolve(hostRoot);
-    return {
-        root,
-        config: join(root, "host.json"),
-        state: join(root, "host-state.json"),
-        credentials: join(root, "host-credentials.json"),
-        log: join(root, "runtime.log"),
-        home: join(root, "home"),
-        tmp: join(root, "tmp"),
-        tenants: join(root, "tenants"),
-        trash: join(root, "trash"),
-        lifecycleLock: join(root, ".lifecycle.lock"),
-    };
-}
-export async function ensureHostLayout(paths) {
-    for (const dir of [
-        paths.root,
-        paths.home,
-        paths.tmp,
-        paths.tenants,
-        paths.trash,
-    ]) {
-        await mkdir(dir, { recursive: true, mode: 0o700 });
-    }
-}
-export function ensureDirSync(path) {
-    if (!existsSync(path))
-        mkdirSync(path, { recursive: true, mode: 0o700 });
-}
-export function hostUrl(config) {
-    return `http://${config.host}:${config.port}`;
-}

package/dist/launcher/probe.d.ts

@@ -1,23 +0,0 @@
-import { processAlive } from "./locks.js";
-export interface ProbeHealthResult {
-    reachable: boolean;
-    health?: {
-        status: string;
-        service: string;
-        version?: string;
-        hostId?: string;
-        pid?: number;
-        protocol?: {
-            min: number;
-            max: number;
-            features: string[];
-        };
-    };
-    /** Something answered but is not a Nylorun Runtime Host. */
-    foreign?: boolean;
-}
-export declare function probeHostHealth(url: string, timeoutMs?: number): Promise<ProbeHealthResult>;
-/** True when the address accepts a new listen (nothing bound). */
-export declare function portBindable(host: string, port: number): Promise<boolean>;
-export declare function probeReady(url: string, timeoutMs?: number): Promise<boolean>;
-export { processAlive };

package/dist/launcher/probe.js

@@ -1,72 +0,0 @@
-import { createServer } from "node:net";
-import { processAlive } from "./locks.js";
-export async function probeHostHealth(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 body = (await response.json());
-        if (body?.status !== "ok" || typeof body.service !== "string") {
-            return { reachable: true, foreign: true };
-        }
-        if (body.service !== "oss-runtime" && body.service !== "nylorun-runtime") {
-            return { reachable: true, foreign: true };
-        }
-        const protocol = body.protocol;
-        return {
-            reachable: true,
-            health: {
-                status: "ok",
-                service: body.service,
-                ...(typeof body.version === "string" ? { version: body.version } : {}),
-                ...(typeof body.hostId === "string" ? { hostId: body.hostId } : {}),
-                ...(typeof body.pid === "number" ? { pid: body.pid } : {}),
-                ...(protocol &&
-                    typeof protocol.min === "number" &&
-                    typeof protocol.max === "number" &&
-                    Array.isArray(protocol.features)
-                    ? {
-                        protocol: {
-                            min: protocol.min,
-                            max: protocol.max,
-                            features: protocol.features.map(String),
-                        },
-                    }
-                    : {}),
-            },
-        };
-    }
-    catch {
-        return { reachable: true, foreign: true };
-    }
-}
-/** True when the address accepts a new listen (nothing bound). */
-export async function portBindable(host, port) {
-    const server = createServer();
-    return await new Promise((resolvePromise) => {
-        server.once("error", () => resolvePromise(false));
-        server.listen(port, host, () => server.close(() => resolvePromise(true)));
-    });
-}
-export async function probeReady(url, timeoutMs = 2000) {
-    try {
-        const response = await fetch(`${url}/ready`, {
-            signal: AbortSignal.timeout(timeoutMs),
-        });
-        if (!response.ok)
-            return false;
-        const body = (await response.json());
-        return body.status === "ready";
-    }
-    catch {
-        return false;
-    }
-}
-export { processAlive };

package/dist/launcher/protocol.d.ts

@@ -1,62 +0,0 @@
-import type { ErrorCode, ProtocolRange } from "@nylorun/core/compatibility";
-export type LauncherEvent = {
-    type: "progress";
-    phase: "start" | "stop" | "wait";
-    message?: string;
-} | {
-    type: "result";
-    [field: string]: unknown;
-} | {
-    type: "error";
-    code: ErrorCode;
-    message: string;
-    remedy: string;
-    details?: unknown;
-} | {
-    type: "log";
-    source: "host" | "tenant";
-    tenantId?: string;
-    line: string;
-};
-export interface UpResult {
-    url: string;
-    hostId: string;
-    pid: number;
-    version: string;
-    started: boolean;
-}
-export interface DownResult {
-    stopped: boolean;
-}
-export interface StatusResult {
-    launcherProtocol: 1;
-    home: string;
-    state: "running" | "stopped" | "absent" | "unresponsive" | "foreign-port";
-    url?: string;
-    hostId?: string;
-    pid?: number;
-    version?: string;
-    runtimeVersion?: string;
-    /** Version of the installed `@nylorun/runtime` running this launcher. */
-    launcherVersion: string;
-}
-/** `nylorun-runtime version`: what is installed and what it speaks. */
-export interface VersionResult {
-    runtimeVersion: string;
-    launcherProtocol: 1;
-    protocol: ProtocolRange;
-    node: string;
-}
-export interface HostConfigFileV1 {
-    format: 1;
-    hostId: string;
-    host: string;
-    port: number;
-    runtimeVersion?: string;
-    allowNonLoopback?: boolean;
-    proxy?: {
-        httpsProxy?: string;
-        noProxy?: string;
-        nodeExtraCaCerts?: string;
-    };
-}

package/dist/launcher/protocol.js

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

package/dist/launcher/schema-guard.d.ts

@@ -1,6 +0,0 @@
-import type { HostPaths } from "./paths.js";
-/**
- * Every tenants/<id>/tenant.json schemaVersion must be at most the target
- * installed Runtime's Tenant schema.
- */
-export declare function assertSchemaGuard(paths: HostPaths, tenantSchemaMax: number): void;

package/dist/launcher/schema-guard.js

@@ -1,36 +0,0 @@
-import { existsSync, readdirSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { LauncherError } from "./errors.js";
-/**
- * Every tenants/<id>/tenant.json schemaVersion must be at most the target
- * installed Runtime's Tenant schema.
- */
-export function assertSchemaGuard(paths, tenantSchemaMax) {
-    let names;
-    try {
-        names = readdirSync(paths.tenants);
-    }
-    catch {
-        return;
-    }
-    for (const id of names) {
-        if (id.startsWith("."))
-            continue;
-        const tenantJson = join(paths.tenants, id, "tenant.json");
-        if (!existsSync(tenantJson))
-            continue;
-        let schemaVersion;
-        try {
-            const body = JSON.parse(readFileSync(tenantJson, "utf8"));
-            if (typeof body.schemaVersion === "number") {
-                schemaVersion = body.schemaVersion;
-            }
-        }
-        catch {
-            continue;
-        }
-        if (schemaVersion !== undefined && schemaVersion > tenantSchemaMax) {
-            throw new LauncherError("host_schema_newer", `Tenant ${id} has schemaVersion ${schemaVersion}, which is newer than the installed Runtime supports (max ${tenantSchemaMax}).`, "Install a Runtime that supports this Tenant schema (npm install --global @nylorun/runtime@latest), or restore the Tenant from its migration snapshot.", { tenantId: id, schemaVersion, tenantSchemaMax });
-        }
-    }
-}

package/dist/launcher/spawn.d.ts

@@ -1,22 +0,0 @@
-import { type ChildProcess } from "node:child_process";
-export interface SpawnHostInput {
-    nodeBinary: string;
-    entry: string;
-    environment: NodeJS.ProcessEnv;
-    cwd: string;
-    detached: boolean;
-    logPath?: string;
-    platform?: NodeJS.Platform;
-}
-/**
- * Spawn the Host on the launcher's own Node (`process.execPath`). Detached background Hosts survive after
- * `up` exits (including Windows — without detached the Host dies with the
- * launcher parent and createTenant sees ECONNREFUSED). stdout/stderr append to
- * runtime.log when logPath is set.
- */
-export declare function spawnHostProcess(input: SpawnHostInput): ChildProcess;
-/**
- * Force-kill a Host process. SIGKILL / process group on POSIX; taskkill on Windows.
- * Exported for Windows-path unit coverage (E14).
- */
-export declare function forceKillHost(pid: number, platform?: NodeJS.Platform): void;

package/dist/launcher/spawn.js

@@ -1,85 +0,0 @@
-import { spawn } from "node:child_process";
-import { closeSync, openSync } from "node:fs";
-/**
- * Spawn the Host on the launcher's own Node (`process.execPath`). Detached background Hosts survive after
- * `up` exits (including Windows — without detached the Host dies with the
- * launcher parent and createTenant sees ECONNREFUSED). stdout/stderr append to
- * runtime.log when logPath is set.
- */
-export function spawnHostProcess(input) {
-    const detached = input.detached;
-    if (input.logPath) {
-        const fd = openSync(input.logPath, "a", 0o600);
-        try {
-            const child = spawn(input.nodeBinary, [input.entry], {
-                detached,
-                windowsHide: true,
-                cwd: input.cwd,
-                env: input.environment,
-                stdio: ["ignore", fd, fd],
-            });
-            child.once("exit", () => {
-                try {
-                    closeSync(fd);
-                }
-                catch {
-                    /* already closed */
-                }
-            });
-            return child;
-        }
-        catch (error) {
-            closeSync(fd);
-            throw error;
-        }
-    }
-    return spawn(input.nodeBinary, [input.entry], {
-        cwd: input.cwd,
-        env: input.environment,
-        windowsHide: true,
-        stdio: ["ignore", "inherit", "inherit"],
-        ...(detached ? { detached: true } : {}),
-    });
-}
-/**
- * Force-kill a Host process. SIGKILL / process group on POSIX; taskkill on Windows.
- * Exported for Windows-path unit coverage (E14).
- */
-export function forceKillHost(pid, platform = process.platform) {
-    if (platform === "win32") {
-        try {
-            const child = spawn("taskkill", ["/PID", String(pid), "/T", "/F"], {
-                stdio: "ignore",
-                windowsHide: true,
-            });
-            child.on("error", () => {
-                try {
-                    process.kill(pid);
-                }
-                catch {
-                    /* gone */
-                }
-            });
-        }
-        catch {
-            try {
-                process.kill(pid);
-            }
-            catch {
-                /* gone */
-            }
-        }
-        return;
-    }
-    try {
-        process.kill(-pid, "SIGKILL");
-    }
-    catch {
-        try {
-            process.kill(pid, "SIGKILL");
-        }
-        catch {
-            /* gone */
-        }
-    }
-}

package/dist/launcher/status.d.ts

@@ -1,6 +0,0 @@
-import { type HostPaths } from "./paths.js";
-import type { StatusResult } from "./protocol.js";
-/**
- * Status with no lock and no mutation (D§9.3).
- */
-export declare function status(paths: HostPaths, launcherVersion: string): Promise<StatusResult>;

package/dist/launcher/status.js

@@ -1,65 +0,0 @@
-import { LAUNCHER_PROTOCOL } from "@nylorun/core/compatibility";
-import { readHostConfig } from "./host-config.js";
-import { readHostState } from "./host-state.js";
-import { processAlive } from "./locks.js";
-import { hostUrl } from "./paths.js";
-import { portBindable, probeHostHealth } from "./probe.js";
-/**
- * Status with no lock and no mutation (D§9.3).
- */
-export async function status(paths, launcherVersion) {
-    const config = await readHostConfig(paths);
-    const stateFile = await readHostState(paths);
-    const runtimeVersion = config && typeof config.runtimeVersion === "string"
-        ? config.runtimeVersion
-        : undefined;
-    const base = {
-        launcherProtocol: LAUNCHER_PROTOCOL,
-        home: paths.root,
-        state: "absent",
-        launcherVersion,
-        ...(runtimeVersion ? { runtimeVersion } : {}),
-    };
-    if (!config) {
-        return base;
-    }
-    const url = hostUrl(config);
-    const withConfig = {
-        ...base,
-        state: "stopped",
-        url,
-        hostId: config.hostId,
-        ...(stateFile?.pid ? { pid: stateFile.pid } : {}),
-        ...(stateFile?.version ? { version: stateFile.version } : {}),
-    };
-    const probe = await probeHostHealth(url);
-    const ours = probe.health !== undefined &&
-        (probe.health.hostId === undefined ||
-            probe.health.hostId === config.hostId);
-    if (probe.foreign) {
-        return { ...withConfig, state: "foreign-port" };
-    }
-    if (probe.health && ours) {
-        return {
-            ...withConfig,
-            state: "running",
-            ...(probe.health.version ? { version: probe.health.version } : {}),
-            ...(probe.health.hostId ? { hostId: probe.health.hostId } : {}),
-            ...(probe.health.pid ? { pid: probe.health.pid } : {}),
-        };
-    }
-    if (probe.health && !ours) {
-        return {
-            ...withConfig,
-            state: "foreign-port",
-            ...(probe.health.hostId ? { hostId: probe.health.hostId } : {}),
-        };
-    }
-    if (stateFile && processAlive(stateFile.pid)) {
-        return { ...withConfig, state: "unresponsive", pid: stateFile.pid };
-    }
-    if (!(await portBindable(config.host, config.port))) {
-        return { ...withConfig, state: "foreign-port" };
-    }
-    return withConfig;
-}

package/dist/tenant/migration.d.ts

@@ -1,16 +0,0 @@
-import { DatabaseSync } from "node:sqlite";
-import type { TenantPaths } from "./types.js";
-import type { TenantEnvelope } from "@nylorun/core/contracts";
-export interface MigrationHooks {
-    schemaVersionOf?: (db: DatabaseSync) => number;
-    migrateTenantDatabase?: (db: DatabaseSync) => {
-        from: number;
-        to: number;
-    };
-    targetVersion?: number;
-}
-/**
- * Checkpoint WAL, snapshot database + envelope + KEK, migrate, update envelope.
- * On failure restore the snapshot, keep diagnostics, and throw migration-failed.
- */
-export declare function migrateTenantWithSnapshot(paths: TenantPaths, envelope: TenantEnvelope, hooks?: MigrationHooks, now?: Date): TenantEnvelope;