@nylorun/cli 0.2.1-beta → 0.4.0-beta

package/dist/tenant/commands.js

@@ -0,0 +1,321 @@
+import { createInterface } from "node:readline/promises";
+import { randomUUID } from "node:crypto";
+import { createAdmin } from "@nylorun/admin";
+import { createClient, isTenantId } from "@nylorun/agents";
+import { CliError } from "../errors.js";
+import { resolveHome } from "../home.js";
+import { readCredentials, removeCredentials, } from "../project/credentials.js";
+import { readLink, removeLink, writeLink, } from "../project/link.js";
+import { findProjectRoot, requireProjectRoot } from "../project/root.js";
+import { createProjectTenant, defaultTenantName, } from "../project/create-tenant.js";
+import { seedTenantFromProject } from "../project/seed.js";
+import { loadProjectEnvironment } from "../environment.js";
+import { shellQuote } from "../project/env.js";
+/** Exact-and-unique name or id match. */
+export function matchTenant(tenants, nameOrId) {
+    if (isTenantId(nameOrId)) {
+        const byId = tenants.find((t) => t.id === nameOrId);
+        if (!byId)
+            throw new CliError(`No Tenant with id ${nameOrId}.`, 1);
+        return byId;
+    }
+    const matches = tenants.filter((t) => t.name === nameOrId);
+    if (matches.length === 0) {
+        throw new CliError(`No Tenant named ${JSON.stringify(nameOrId)}.`, 1);
+    }
+    if (matches.length > 1) {
+        throw new CliError(`Tenant name ${JSON.stringify(nameOrId)} is not unique (${matches.length} matches). Use the Tenant id.`, 1);
+    }
+    return matches[0];
+}
+function localAdmin(home) {
+    return createAdmin(home ? { home } : undefined);
+}
+/**
+ * `nylo tenant create [name]`. Inside a Project: create the Tenant, write the
+ * Project link and credentials, and seed it from the Project's `.env` (sandbox
+ * and model provider). Outside one: create the Tenant and print its
+ * connection variables once, since the Host keeps only a hash of the key.
+ */
+async function createTenant(options) {
+    const admin = localAdmin(options.home);
+    let hostId;
+    try {
+        hostId = (await admin.status()).host?.hostId;
+    }
+    catch (error) {
+        throw new CliError(`No Runtime answers at ${admin.url} (${error instanceof Error ? error.message : String(error)}). Start the local stack with "npx nylorun up".`, 6);
+    }
+    if (!hostId)
+        throw new CliError(`Host at ${admin.url} did not report hostId in admin status.`, 1);
+    const projectRoot = findProjectRoot();
+    if (!projectRoot) {
+        const created = await admin.createTenant({ name: options.name ?? "tenant" });
+        console.log(`Tenant    ${created.tenant.name}  ${created.tenant.id}  (created)`);
+        console.log("# Not in a Project: nothing was linked. The key is shown only once.");
+        console.log(`export NYLORUN_RUNTIME_URL=${shellQuote(admin.url.replace(/\/$/, ""))}`);
+        console.log(`export NYLORUN_SERVER_KEY=${shellQuote(created.applicationKey)}`);
+        console.log(`export NYLORUN_TENANT=${shellQuote(created.tenant.id)}`);
+        return;
+    }
+    const link = await readLink(projectRoot);
+    if (link)
+        throw new CliError(`This Project is already linked to Tenant ${link.tenantId}. Use "nylo tenant use <name-or-id>" to switch, or "nylo tenant delete" first.`, 1);
+    const created = await createProjectTenant({
+        admin,
+        hostId,
+        projectRoot,
+        name: options.name ?? (await defaultTenantName(projectRoot)),
+    });
+    console.log(`Tenant    ${created.envelope.name}  ${created.envelope.id}  (created)`);
+    console.log(`Linked    ${projectRoot}/.nylorun/`);
+    const seeded = await seedTenantFromProject({
+        hostUrl: created.link.hostUrl,
+        tenantId: created.link.tenantId,
+        applicationKey: created.credentials.applicationKey,
+        projectRoot,
+        env: loadProjectEnvironment(projectRoot),
+    });
+    console.log(seeded.model
+        ? `Model     ${seeded.model} (from .env)`
+        : "Model     not configured: set it in Studio, or run nylo configure");
+}
+export async function tenantCommand(args) {
+    const [verb, ...rest] = args;
+    if (!verb || verb === "--help" || verb === "-h") {
+        console.log(`nylo tenant create [name]|current|list [--json]|use <name-or-id>|status [--json]|reset [--sessions|--sandboxes|--all] [--yes]|delete <name-or-id> [--yes]`);
+        return;
+    }
+    const home = resolveHome();
+    if (verb === "create") {
+        if (rest.length > 1 || rest.some((arg) => arg.startsWith("-")))
+            throw new CliError("Usage: nylo tenant create [name]", 2);
+        await createTenant({ home, ...(rest[0] ? { name: rest[0] } : {}) });
+        return;
+    }
+    if (verb === "current") {
+        const root = requireProjectRoot();
+        const link = await readLink(root);
+        if (!link) {
+            console.log("No Project link. Run nylo tenant create to create one.");
+            return;
+        }
+        const admin = localAdmin(home);
+        const tenants = await admin.listTenants();
+        const match = tenants.find((t) => t.id === link.tenantId);
+        const name = match?.name ?? match?.envelope?.name ?? "(unknown)";
+        console.log(`${name}  ${link.tenantId}`);
+        console.log(`Host  ${link.hostUrl}  ${link.hostId}`);
+        return;
+    }
+    if (verb === "list") {
+        const json = rest.includes("--json");
+        if (rest.some((a) => a !== "--json")) {
+            throw new CliError("Usage: nylo tenant list [--json]", 2);
+        }
+        const admin = localAdmin(home);
+        const tenants = await admin.listTenants();
+        if (json) {
+            console.log(JSON.stringify(tenants, null, 2));
+            return;
+        }
+        if (tenants.length === 0) {
+            console.log("No Tenants on this Host.");
+            return;
+        }
+        for (const tenant of tenants) {
+            const name = tenant.name ?? "(unreadable)";
+            console.log(`${name}  ${tenant.id}  ${tenant.state}`);
+        }
+        return;
+    }
+    if (verb === "use") {
+        const nameOrId = rest[0];
+        if (!nameOrId || rest.length > 1) {
+            throw new CliError("Usage: nylo tenant use <name-or-id>", 2);
+        }
+        const root = requireProjectRoot();
+        const admin = localAdmin(home);
+        const status = await admin.status();
+        const hostId = status.host?.hostId;
+        if (!hostId) {
+            throw new CliError(`Host at ${admin.url} did not report hostId in admin status.`, 1);
+        }
+        const tenants = await admin.listTenants();
+        const selected = matchTenant(tenants, nameOrId);
+        console.warn("Sharing a Tenant shares executor registrations across Projects that link to it.");
+        const credentials = await readCredentials(root);
+        if (!credentials) {
+            throw new CliError("No Project credentials. Run nylo tenant create to create a Tenant first, or copy credentials for the target Tenant.", 1);
+        }
+        const client = createClient({
+            url: admin.url,
+            key: credentials.applicationKey,
+            tenant: selected.id,
+        });
+        try {
+            await client.transport.json("/v1/tenant", "GET");
+        }
+        catch {
+            throw new CliError(`Credentials do not authorize Tenant ${selected.id}. Create a new Tenant with nylo tenant create instead of reusing another Project's Tenant without its key.`, 1);
+        }
+        await writeLink(root, {
+            format: 1,
+            hostUrl: admin.url,
+            hostId,
+            tenantId: selected.id,
+        });
+        console.log(`Linked to ${selected.name ?? selected.id}  ${selected.id}`);
+        return;
+    }
+    if (verb === "status") {
+        const json = rest.includes("--json");
+        if (rest.some((a) => a !== "--json")) {
+            throw new CliError("Usage: nylo tenant status [--json]", 2);
+        }
+        const root = requireProjectRoot();
+        const link = await readLink(root);
+        const credentials = await readCredentials(root);
+        if (!link || !credentials) {
+            throw new CliError("No Project link. Run nylo tenant create to create one.", 1);
+        }
+        const client = createClient({
+            url: link.hostUrl,
+            key: credentials.applicationKey,
+            tenant: link.tenantId,
+        });
+        try {
+            const body = await client.transport.json("/v1/tenant", "GET");
+            if (json) {
+                console.log(JSON.stringify(body, null, 2));
+                return;
+            }
+            console.log(`${body.tenant.name}  ${body.tenant.id}`);
+            console.log(`path     ${body.path}`);
+            console.log(`checks   ${Object.entries(body.checks)
+                .map(([k, v]) => `${k}=${v ? "ok" : "fail"}`)
+                .join(" ")}`);
+            console.log(`counts   sessions=${body.counts.sessions} running=${body.counts.runningSessions} pending=${body.counts.pendingActions}`);
+            console.log(`sandbox  ${body.sandbox.backend ?? "none"}`);
+            return;
+        }
+        catch {
+            // Quarantined / opaque — fall back to admin status.
+        }
+        const admin = localAdmin(home);
+        try {
+            const body = await admin.getTenant(link.tenantId);
+            if (json) {
+                console.log(JSON.stringify(body, null, 2));
+                return;
+            }
+            console.log(`${body.name ?? "(unreadable)"}  ${body.id}  ${body.state}`);
+            if (body.quarantine) {
+                console.log(`reason   ${body.quarantine.code}: ${body.quarantine.message}`);
+                console.log(`repair   ${body.quarantine.repair}`);
+            }
+            return;
+        }
+        catch (error) {
+            throw new CliError(error instanceof Error
+                ? error.message
+                : `Tenant ${link.tenantId} is not reachable.`, 1);
+        }
+    }
+    if (verb === "reset") {
+        const yes = rest.includes("--yes");
+        const flags = rest.filter((a) => a !== "--yes");
+        let scope = "sessions";
+        if (flags.includes("--all"))
+            scope = "all";
+        else if (flags.includes("--sandboxes"))
+            scope = "sandboxes";
+        else if (flags.includes("--sessions") || flags.length === 0)
+            scope = "sessions";
+        else
+            throw new CliError("Usage: nylo tenant reset [--sessions|--sandboxes|--all] [--yes]", 2);
+        if (flags.filter((f) => ["--sessions", "--sandboxes", "--all"].includes(f)).length > 1) {
+            throw new CliError("Pass only one of --sessions, --sandboxes, --all.", 2);
+        }
+        const root = requireProjectRoot();
+        const link = await readLink(root);
+        const credentials = await readCredentials(root);
+        if (!link || !credentials) {
+            throw new CliError("No Project link. Run nylo tenant create first.", 1);
+        }
+        const admin = localAdmin(home);
+        const tenants = await admin.listTenants();
+        const match = tenants.find((t) => t.id === link.tenantId);
+        const name = match?.name ?? link.tenantId;
+        if (scope === "all" && !yes) {
+            await confirmOrThrow(`Reset ALL data for Tenant ${name} (${link.tenantId})? Link and credentials are kept. [y/N] `);
+        }
+        const client = createClient({
+            url: link.hostUrl,
+            key: credentials.applicationKey,
+            tenant: link.tenantId,
+        });
+        try {
+            await client.transport.json("/v1/tenant/reset", "POST", {
+                requestId: randomUUID(),
+                scope,
+                activeWork: "drain",
+            });
+        }
+        catch (error) {
+            throw new CliError(error instanceof Error
+                ? error.message
+                : `Tenant reset failed: ${String(error)}`, 1);
+        }
+        console.log(`Reset Tenant ${name} (${scope}).`);
+        return;
+    }
+    if (verb === "delete") {
+        const yes = rest.includes("--yes");
+        const nameOrId = rest.find((a) => a !== "--yes");
+        if (!nameOrId || rest.filter((a) => a !== "--yes").length !== 1) {
+            throw new CliError("Usage: nylo tenant delete <name-or-id> [--yes]", 2);
+        }
+        const root = requireProjectRoot();
+        const admin = localAdmin(home);
+        const tenants = await admin.listTenants();
+        const selected = matchTenant(tenants, nameOrId);
+        if (!yes) {
+            await confirmOrThrow(`Delete Tenant ${selected.name ?? selected.id} (${selected.id})?\nThe KEK moves to trash with the Tenant directory. [y/N] `);
+        }
+        try {
+            await admin.deleteTenant(selected.id, { activeWork: "refuse" });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (/active_work|409|live work/i.test(message)) {
+                throw new CliError(`Tenant ${selected.id} has live work. Retry with the Host idle, or drain sessions first.`, 1);
+            }
+            throw new CliError(message, 1);
+        }
+        const link = await readLink(root);
+        if (link?.tenantId === selected.id) {
+            await removeLink(root);
+            await removeCredentials(root);
+            console.log("Removed Project link and credentials for the deleted Tenant.");
+        }
+        console.log(`Deleted Tenant ${selected.name ?? selected.id}.`);
+        return;
+    }
+    throw new CliError(`Unknown tenant command ${verb}.\nUsage: nylo tenant current|list|use|status|reset|delete`, 2);
+}
+async function confirmOrThrow(prompt) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        throw new CliError("Confirmation required; pass --yes for non-interactive use.", 2);
+    }
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const answer = (await rl.question(prompt)).trim().toLowerCase();
+        if (answer !== "y" && answer !== "yes") {
+            throw new CliError("Cancelled.", 1);
+        }
+    }
+    finally {
+        rl.close();
+    }
+}

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@nylorun/cli",
-  "version": "0.2.1-beta",
+  "version": "0.4.0-beta",
   "type": "module",
   "license": "Apache-2.0",
-  "description": "Nylorun local development CLI",
+  "description": "Nylorun Runtime client: Tenants, Project links and model providers",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/nylorun/harness.git",
@@ -30,9 +30,9 @@
     "prepack": "npm run build"
   },
   "dependencies": {
-    "@nylorun/agents": "0.5.0-beta",
-    "@nylorun/runtime": "0.9.0-beta",
-    "@earendil-works/pi-ai": "0.85.1"
+    "@nylorun/agents": "0.7.0-beta",
+    "@nylorun/admin": "0.3.0-beta",
+    "@earendil-works/pi-ai": "0.87.0"
   },
   "devDependencies": {
     "typescript": "npm:@typescript/typescript6@^6.0.2",
@@ -40,6 +40,6 @@
     "vitest": "^5.0.1"
   },
   "bin": {
-    "nylorun": "dist/cli.js"
+    "nylo": "dist/cli.js"
   }
 }

package/dist/dev-entry.d.ts

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

package/dist/dev-entry.js

@@ -1,6 +0,0 @@
-import { runProject } from "./project-runner.js";
-await runProject("agents/index.ts", {
-    studio: !process.argv.includes("--no-studio"),
-    open: !process.argv.includes("--no-open"),
-    autostart: !process.argv.includes("--no-autostart"),
-});

package/dist/dev.d.ts

@@ -1,6 +0,0 @@
-/**
- * Everything that can be checked without contacting the host, so a project that cannot run
- * never causes a Runtime to be started on its behalf.
- */
-export declare function developmentPreflight(args: readonly string[]): string;
-export declare function develop(args: readonly string[]): Promise<number>;

package/dist/dev.js

@@ -1,65 +0,0 @@
-import { spawn } from "node:child_process";
-import { createRequire } from "node:module";
-import { join } from "node:path";
-import { fileURLToPath } from "node:url";
-/**
- * Everything that can be checked without contacting the host, so a project that cannot run
- * never causes a Runtime to be started on its behalf.
- */
-export function developmentPreflight(args) {
-    if (new Set(args).size !== args.length ||
-        args.some((arg) => !["--no-studio", "--no-open", "--no-autostart"].includes(arg)))
-        throw new Error("Usage: nylorun dev [--no-studio] [--no-open] [--no-autostart]");
-    const require = createRequire(join(process.cwd(), "package.json"));
-    let tsx;
-    try {
-        tsx = require.resolve("tsx/cli");
-    }
-    catch {
-        throw new Error("Install tsx to use nylorun dev");
-    }
-    if (!args.includes("--no-studio"))
-        try {
-            require.resolve("@nylorun/studio");
-        }
-        catch {
-            throw new Error("Install @nylorun/studio or use --no-studio");
-        }
-    return tsx;
-}
-export async function develop(args) {
-    const tsx = developmentPreflight(args);
-    const child = spawn(process.execPath, [
-        tsx,
-        "watch",
-        "--clear-screen=false",
-        fileURLToPath(new URL("./dev-entry.js", import.meta.url)),
-        ...args,
-    ], 
-    // Deliver terminal shutdown once, through the supervisor, instead of twice through the terminal group.
-    {
-        stdio: "inherit",
-        env: process.env,
-        detached: process.platform !== "win32",
-    });
-    let stopping = false;
-    const stop = (signal) => {
-        if (stopping)
-            return;
-        stopping = true;
-        child.kill(signal);
-    };
-    const interrupt = () => stop("SIGINT"), terminate = () => stop("SIGTERM");
-    process.on("SIGINT", interrupt);
-    process.on("SIGTERM", terminate);
-    try {
-        return await new Promise((resolve, reject) => {
-            child.once("error", reject);
-            child.once("exit", (code, signal) => resolve(code ?? (signal === "SIGINT" ? 130 : 143)));
-        });
-    }
-    finally {
-        process.removeListener("SIGINT", interrupt);
-        process.removeListener("SIGTERM", terminate);
-    }
-}

package/dist/launcher.d.ts

@@ -1,5 +0,0 @@
-import type { Scope } from "./scope.js";
-export declare function serve(entry?: string, options?: {
-    autostart?: boolean;
-    scope?: Scope;
-}): Promise<void>;

package/dist/launcher.js

@@ -1,4 +0,0 @@
-import { runProject } from "./project-runner.js";
-export async function serve(entry = "dist/agents/index.js", options = {}) {
-    await runProject(entry, options);
-}

package/dist/project-runner.d.ts

@@ -1,20 +0,0 @@
-import { type Scope } from "./scope.js";
-export interface LocalCredentials {
-    serverKey: string;
-    executors: Record<string, string>;
-}
-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;
-    autostart?: boolean;
-    scope?: Scope;
-}
-export declare function runProject(entry: string, options?: RunProjectOptions): Promise<void>;

package/dist/project-runner.js

@@ -1,141 +0,0 @@
-import { createRequire } from "node:module";
-import { randomBytes } from "node:crypto";
-import { mkdir, readFile, writeFile, chmod } from "node:fs/promises";
-import { dirname, join, resolve } from "node:path";
-import { pathToFileURL } from "node:url";
-import { createClient, connectAgents, } from "@nylorun/agents";
-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)
-            throw new Error("Invalid local credentials");
-        await chmod(path, 0o600);
-        return value;
-    }
-    catch (error) {
-        if (error.code !== "ENOENT")
-            throw error;
-        const value = { serverKey: randomBytes(32).toString("hex"), executors: {} };
-        await writeFile(path, JSON.stringify(value), { mode: 0o600, flag: "wx" });
-        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 = {}) {
-    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;
-    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 };
-    });
-    await writeFile(scope.credentialsPath, JSON.stringify(credentials), {
-        mode: 0o600,
-    });
-    const url = scope.url;
-    let studio;
-    const connections = [];
-    let watchdog;
-    let stopping;
-    const close = () => (stopping ??= (async () => {
-        if (watchdog)
-            clearInterval(watchdog);
-        await Promise.allSettled(connections.map((c) => c.close()));
-        await studio?.close().catch(() => { });
-        for (const agent of agents)
-            await agent.close?.();
-    })());
-    // 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 {
-        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], {
-                implementationVersion: version,
-            });
-            const connection = connectAgents({
-                agents: [agents[index]],
-                implementationVersion: version,
-                runtime: { url, key: scopes[index].token },
-                onError: (error) => console.error("Executor:", error instanceof Error ? error.message : error),
-            });
-            connections.push(connection);
-            await connection.ready;
-        }
-        if (options.studio) {
-            const modulePath = createRequire(join(process.cwd(), "package.json")).resolve("@nylorun/studio");
-            const module = await import(pathToFileURL(modulePath).href);
-            studio = await module.startStudio({
-                runtimeUrl: url,
-                serverKey: credentials.serverKey,
-                open: options.open !== false,
-            });
-            console.log(`Studio on ${studio.address}`);
-        }
-        console.log(`Local project ready at ${url}; ${agents.length} connected agent(s).`);
-        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 {
-        process.removeListener("SIGINT", stop);
-        process.removeListener("SIGTERM", stop);
-        await close();
-    }
-}

package/dist/runtime-host.d.ts

@@ -1,39 +0,0 @@
-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>;