@nylorun/cli 0.1.2-beta → 0.2.1-beta

package/dist/model/configure.js

@@ -1,7 +1,4 @@
-import { join } from "node:path";
 import { createInterface } from "node:readline/promises";
-import { saveEnvironment } from "../environment.js";
-import { ProjectCredentialStore } from "@nylorun/runtime/configuration";
 import { modelsFor } from "@nylorun/runtime/configuration";
 export class ConfigurationCancelled extends Error {
     signal;
@@ -14,32 +11,32 @@ export class ConfigurationCancelled extends Error {
 }
 // Internal options also allow isolated prompt tests without changing process globals.
 export async function configureProvider(options = {}) {
-    const root = options.root ?? process.cwd();
     const output = options.output ?? process.stdout;
     const controller = new AbortController();
     const signal = controller.signal;
     const forwardAbort = () => controller.abort(options.signal.reason);
     options.signal?.throwIfAborted();
-    let enteredKey;
-    let enteredEnvironment = {};
-    const oauthStore = new ProjectCredentialStore(join(root, ".nylorun", "auth.json"), join(root, ".env", "auth.json"));
+    let captured;
     const store = {
-        read: (id) => oauthStore.read(id),
-        list: () => oauthStore.list(),
-        delete: (id) => oauthStore.delete(id),
-        async modify(id, fn) {
-            const next = await fn(await oauthStore.read(id));
-            if (next?.type === "api_key") {
-                if (next.key === "")
-                    throw new Error("An API key is required.");
-                enteredKey = next.key;
-                enteredEnvironment = { ...next.env };
-                return next;
-            }
-            return oauthStore.modify(id, async () => next);
+        async read() {
+            return undefined;
+        },
+        async list() {
+            return [];
+        },
+        async delete() { },
+        async modify(_id, fn) {
+            const next = await fn(captured);
+            if (next?.type === "api_key" && !next.key)
+                throw new Error("An API key is required.");
+            if (next)
+                captured = next;
+            return next ?? captured;
         },
     };
-    const models = modelsFor({ provider: "", model: "" }, store);
+    const models = modelsFor({ provider: "", model: "" }, store, {
+        environment: false,
+    });
     const providers = models.getProviders();
     const prompt = createInterface({
         input: options.input ?? process.stdin,
@@ -75,10 +72,10 @@ export async function configureProvider(options = {}) {
                 model,
                 custom: { baseUrl },
             };
-            const customModels = modelsFor(selection, store);
+            const customModels = modelsFor(selection, store, { environment: false });
             if (!(await customModels.checkAuth("custom", { signal })))
                 await customModels.login("custom", "api_key", interaction());
-            await save(selection);
+            return prompted(selection);
         }
         else {
             const chosen = providers[choice - 1];
@@ -102,10 +99,8 @@ export async function configureProvider(options = {}) {
                 }
                 await models.login(chosen.id, method, interaction());
             }
-            await save({ provider: chosen.id, model: model.id });
+            return prompted({ provider: chosen.id, model: model.id });
         }
-        signal.throwIfAborted();
-        output.write("Provider configuration saved.\n");
     }
     catch (error) {
         throw signal.aborted ? signal.reason : error;
@@ -140,16 +135,18 @@ export async function configureProvider(options = {}) {
             },
         };
     }
-    async function save(selection) {
+    function prompted(selection) {
         signal.throwIfAborted();
-        await saveEnvironment(root, {
-            ...enteredEnvironment,
-            MODEL_PROVIDER: selection.provider,
-            MODEL: selection.model,
-            MODEL_PROVIDER_BASE_URL: selection.custom?.baseUrl,
-            ...(enteredKey === undefined
-                ? {}
-                : { MODEL_PROVIDER_API_KEY: enteredKey }),
-        }, signal);
+        if (!captured)
+            throw new Error("An API key or OAuth credential is required.");
+        output.write("Provider configuration saved.\n");
+        return {
+            provider: selection.provider,
+            model: selection.model,
+            ...(selection.custom?.baseUrl
+                ? { baseUrl: selection.custom.baseUrl }
+                : {}),
+            auth: captured,
+        };
     }
 }

package/dist/model/host-model.d.ts

@@ -0,0 +1,20 @@
+import { type PromptedModel } from "./configure.js";
+/** Wire shape of GET/PUT `/v1/host/model` — local copy so CLI stays off `@nylorun/core`. */
+type HostModelView = {
+    readonly configured: false;
+} | {
+    readonly configured: true;
+    readonly provider: string;
+    readonly model: string;
+    readonly authType: "api_key" | "oauth";
+    readonly baseUrl?: string;
+};
+export declare function getHostModel(runtimeUrl: string, serverKey: string): Promise<HostModelView>;
+export declare function putHostModel(runtimeUrl: string, serverKey: string, model: PromptedModel): Promise<HostModelView>;
+export declare function ensureHostModel(options: {
+    runtimeUrl: string;
+    serverKey: string;
+    root?: string;
+    signal?: AbortSignal;
+}): Promise<void>;
+export {};

package/dist/model/host-model.js

@@ -0,0 +1,84 @@
+import { randomUUID } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { configureProvider } from "./configure.js";
+export async function getHostModel(runtimeUrl, serverKey) {
+    const response = await fetch(`${runtimeUrl}/v1/host/model`, {
+        headers: { authorization: `Bearer ${serverKey}` },
+    });
+    if (!response.ok)
+        throw new Error(`Runtime model status returned ${response.status}`);
+    return response.json();
+}
+export async function putHostModel(runtimeUrl, serverKey, model) {
+    const response = await fetch(`${runtimeUrl}/v1/host/model`, {
+        method: "PUT",
+        headers: {
+            authorization: `Bearer ${serverKey}`,
+            "content-type": "application/json",
+        },
+        body: JSON.stringify({
+            requestId: randomUUID(),
+            idempotencyKey: randomUUID(),
+            provider: model.provider,
+            model: model.model,
+            ...(model.baseUrl ? { baseUrl: model.baseUrl } : {}),
+            auth: model.auth,
+        }),
+    });
+    const body = (await response.json().catch(() => ({})));
+    if (!response.ok)
+        throw new Error(body.message ?? `Runtime rejected the model provider (${response.status})`);
+    return body;
+}
+export async function ensureHostModel(options) {
+    const current = await getHostModel(options.runtimeUrl, options.serverKey);
+    if (current.configured)
+        return;
+    const seeded = seedFromProject(options.root ?? process.cwd());
+    if (seeded) {
+        await putHostModel(options.runtimeUrl, options.serverKey, seeded);
+        return;
+    }
+    if (process.stdin.isTTY && process.stdout.isTTY) {
+        const prompted = await configureProvider({
+            root: options.root,
+            signal: options.signal,
+        });
+        await putHostModel(options.runtimeUrl, options.serverKey, prompted);
+        return;
+    }
+    throw new Error("Model provider is not configured. Run nylorun dev in a terminal to set it up, or open Studio.");
+}
+function seedFromProject(root) {
+    const provider = process.env.MODEL_PROVIDER?.trim();
+    const model = process.env.MODEL?.trim();
+    if (!provider || !model)
+        return undefined;
+    const baseUrl = process.env.MODEL_PROVIDER_BASE_URL?.trim();
+    const key = process.env.MODEL_PROVIDER_API_KEY;
+    const auth = key
+        ? { type: "api_key", key }
+        : legacyCredential(root, provider);
+    if (!auth)
+        return undefined;
+    return {
+        provider,
+        model,
+        ...(baseUrl ? { baseUrl } : {}),
+        auth,
+    };
+}
+function legacyCredential(root, provider) {
+    for (const relative of [".nylorun/auth.json", ".env/auth.json"]) {
+        try {
+            const all = JSON.parse(readFileSync(join(root, relative), "utf8"));
+            const credential = all[provider];
+            if (credential?.type === "api_key" || credential?.type === "oauth")
+                return credential;
+        }
+        catch {
+            /* A project without a legacy credential file is set up interactively. */
+        }
+    }
+}

package/dist/project-runner.d.ts

@@ -1,8 +1,20 @@
-export declare function localCredentials(root?: string): Promise<{
+import { type Scope } from "./scope.js";
+export interface LocalCredentials {
     serverKey: string;
     executors: Record<string, string>;
-}>;
-export declare function runProject(entry: string, options?: {
+}
+export declare function localCredentials(path: string): Promise<LocalCredentials>;
+export interface ExecutorScopeToken {
+    token: string;
+    agentId: string;
+    implementationVersion: string;
+}
+/** Registers or rotates this project's executor credentials on the running host. */
+export declare function putExecutors(url: string, serverKey: string, executors: readonly ExecutorScopeToken[]): Promise<void>;
+export interface RunProjectOptions {
     studio?: boolean;
     open?: boolean;
-}): Promise<void>;
+    autostart?: boolean;
+    scope?: Scope;
+}
+export declare function runProject(entry: string, options?: RunProjectOptions): Promise<void>;

package/dist/project-runner.js

@@ -1,16 +1,15 @@
-import { fork } from "node:child_process";
 import { createRequire } from "node:module";
 import { randomBytes } from "node:crypto";
 import { mkdir, readFile, writeFile, chmod } from "node:fs/promises";
-import { resolve, join } from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
+import { dirname, join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
 import { createClient, connectAgents, } from "@nylorun/agents";
-import { modelSelection } from "@nylorun/runtime/configuration";
-import { loadProjectEnvironment } from "./environment.js";
-export async function localCredentials(root = process.cwd()) {
-    const directory = join(root, ".nylorun");
-    await mkdir(directory, { recursive: true, mode: 0o700 });
-    const path = join(directory, "local-credentials.json");
+import { ensureHostModel } from "./model/host-model.js";
+import { CliError } from "./errors.js";
+import { ensureDataDir, loadScopeEnvironment, probeHealth, resolveScope, } from "./scope.js";
+import { ensureRuntime } from "./runtime-host.js";
+export async function localCredentials(path) {
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
     try {
         const value = JSON.parse(await readFile(path, "utf8"));
         if (typeof value.serverKey !== "string" || !value.executors)
@@ -26,100 +25,61 @@ export async function localCredentials(root = process.cwd()) {
         return value;
     }
 }
+/** Registers or rotates this project's executor credentials on the running host. */
+export async function putExecutors(url, serverKey, executors) {
+    const response = await fetch(`${url}/v1/executors`, {
+        method: "PUT",
+        headers: {
+            authorization: `Bearer ${serverKey}`,
+            "content-type": "application/json",
+        },
+        body: JSON.stringify({ executors }),
+    });
+    if (!response.ok)
+        throw new CliError(`The Runtime at ${url} rejected this project's executors (${response.status}): ${await response
+            .text()
+            .catch(() => "")}`);
+}
 export async function runProject(entry, options = {}) {
-    loadProjectEnvironment();
-    if (process.env.NYLORUN_DEV_MODEL !== "fixture")
-        modelSelection();
+    const scope = options.scope ?? resolveScope();
+    loadScopeEnvironment(scope);
     const registry = await import(pathToFileURL(resolve(entry)).href);
     if (!Array.isArray(registry.agents) || !registry.agents.length)
         throw new Error(`${entry} must export a non-empty agents array`);
     const agents = registry.agents;
-    const credentials = await localCredentials();
+    await ensureDataDir(scope);
+    const credentials = await localCredentials(scope.credentialsPath);
     const version = process.env.NYLORUN_IMPLEMENTATION_VERSION ?? "dev";
     const scopes = agents.map((agent) => {
         const token = (credentials.executors[agent.id] ??=
             randomBytes(32).toString("hex"));
-        return {
-            token,
-            agentId: agent.id,
-            implementationVersion: version,
-        };
+        return { token, agentId: agent.id, implementationVersion: version };
     });
-    await writeFile(join(process.cwd(), ".nylorun/local-credentials.json"), JSON.stringify(credentials), { mode: 0o600 });
-    const port = Number(process.env.PORT ?? 8787);
-    if (!Number.isInteger(port) || port < 1 || port > 65535)
-        throw new Error("PORT must be between 1 and 65535");
-    const url = `http://127.0.0.1:${port}`;
-    let child;
+    await writeFile(scope.credentialsPath, JSON.stringify(credentials), {
+        mode: 0o600,
+    });
+    const url = scope.url;
     let studio;
     const connections = [];
+    let watchdog;
     let stopping;
-    let intentionalStop = false;
     const close = () => (stopping ??= (async () => {
+        if (watchdog)
+            clearInterval(watchdog);
         await Promise.allSettled(connections.map((c) => c.close()));
         await studio?.close().catch(() => { });
-        if (child?.exitCode === null && child.signalCode === null) {
-            child.kill("SIGTERM");
-            await new Promise((resolve) => {
-                const timer = setTimeout(() => child?.kill("SIGKILL"), 5000);
-                child.once("exit", () => {
-                    clearTimeout(timer);
-                    resolve();
-                });
-            });
-        }
         for (const agent of agents)
             await agent.close?.();
     })());
-    const stop = () => {
-        intentionalStop = true;
-        void close().finally(() => {
-            process.exitCode = 0;
-        });
-    };
+    // The Runtime is a separate, persistent process now, so shutting this one down leaves it up.
+    const stop = () => void close().finally(() => (process.exitCode = 0));
     process.on("SIGINT", stop);
     process.on("SIGTERM", stop);
     try {
-        child = fork(createRequire(import.meta.url).resolve("@nylorun/runtime/server"), [], {
-            execArgv: [],
-            env: {
-                ...process.env,
-                HOST: "127.0.0.1",
-                PORT: String(port),
-                NYLORUN_PROJECT_PROVIDER: "1",
-                NYLORUN_SERVER_KEY: credentials.serverKey,
-                NYLORUN_EXECUTORS_JSON: JSON.stringify(scopes),
-                NYLORUN_SQLITE_PATH: process.env.NYLORUN_SQLITE_PATH ??
-                    join(process.cwd(), ".nylorun/runtime.sqlite"),
-            },
-            stdio: ["ignore", "inherit", "inherit", "ipc"],
-        });
-        await new Promise((resolve, reject) => {
-            const timer = setTimeout(() => reject(new Error("Local Runtime did not start within 20 seconds")), 20000);
-            const onReady = (message) => {
-                if (message?.type === "ready") {
-                    cleanup();
-                    resolve();
-                }
-            };
-            const onExit = (code) => {
-                cleanup();
-                reject(new Error(`Local Runtime exited (${code})`));
-            };
-            const onError = (error) => {
-                cleanup();
-                reject(error);
-            };
-            const cleanup = () => {
-                clearTimeout(timer);
-                child.off("message", onReady);
-                child.off("exit", onExit);
-                child.off("error", onError);
-            };
-            child.on("message", onReady);
-            child.once("exit", onExit);
-            child.once("error", onError);
-        });
+        await ensureRuntime(scope, { autostart: options.autostart !== false });
+        await putExecutors(url, credentials.serverKey, scopes);
+        if (process.env.NYLORUN_DEV_MODEL !== "fixture")
+            await ensureHostModel({ runtimeUrl: url, serverKey: credentials.serverKey });
         const client = createClient({ url, key: credentials.serverKey });
         for (let index = 0; index < agents.length; index++) {
             await client.saveAgent(agents[index], {
@@ -145,14 +105,32 @@ export async function runProject(entry, options = {}) {
             console.log(`Studio on ${studio.address}`);
         }
         console.log(`Local project ready at ${url}; ${agents.length} connected agent(s).`);
-        await new Promise((resolve) => {
-            child.once("exit", () => {
-                if (!intentionalStop && !stopping)
-                    process.exitCode = 1;
-                resolve();
-            });
-            if (child.exitCode !== null)
-                resolve();
+        const sandbox = await (await import("./doctor.js")).sandboxBanner(url, credentials.serverKey, agents.map((agent) => agent.manifest));
+        if (sandbox)
+            console.log(sandbox);
+        await new Promise((settle) => {
+            const finish = () => {
+                if (!stopping)
+                    void close();
+                settle();
+            };
+            process.once("SIGINT", finish);
+            process.once("SIGTERM", finish);
+            // Without a child to watch, a Runtime that dies would leave this process connected to
+            // nothing; three consecutive failed probes end the run with a pointer to the log.
+            let failures = 0;
+            watchdog = setInterval(async () => {
+                if (stopping)
+                    return;
+                if ((await probeHealth(url, 2000)).health)
+                    return void (failures = 0);
+                if (++failures < 3)
+                    return;
+                console.error('Runtime stopped unexpectedly; see "nylorun logs".');
+                process.exitCode = 1;
+                finish();
+            }, 5000);
+            watchdog.unref();
         });
     }
     finally {

package/dist/runtime-host.d.ts

@@ -0,0 +1,39 @@
+import { type RuntimeState, type Scope } from "./scope.js";
+export type HostState = "running" | "stopped" | "stale" | "unhealthy" | "pid-recycled" | "port-conflict";
+export interface Status {
+    state: HostState;
+    scope: Scope;
+    runtime?: RuntimeState;
+    version?: string;
+    scopeId?: string;
+    pid?: number;
+}
+/**
+ * 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 declare const cliRuntimeVersion: () => string | undefined;
+export declare function hostStatus(scope: Scope): Promise<Status>;
+export declare function startHost(scope: Scope, options?: {
+    foreground?: boolean;
+    restart?: boolean;
+}): Promise<Status>;
+export declare function stopHost(scope: Scope, options?: {
+    timeoutMs?: number;
+}): Promise<"stopped" | "not-running">;
+export interface EnsureOptions {
+    autostart: boolean;
+    quiet?: boolean;
+}
+export declare function ensureRuntime(scope: Scope, options: EnsureOptions): Promise<Status>;
+/**
+ * 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 declare function assertCompatible(scope: Scope, status: Status): void;
+export declare function warnIncompatible(scope: Scope, status: Status): void;
+export declare function tailLog(scope: Scope, options: {
+    follow: boolean;
+    lines: number;
+}): Promise<void>;