@nylorun/cli 0.5.0-beta → 0.7.0-beta

package/dist/doctor.d.ts

@@ -11,6 +11,13 @@ export type SandboxReport = {
         version?: string;
     }[];
     defaultImage?: string;
+    /** The Tenant's sandbox configuration (Runtimes with Sandboxes v3). */
+    config?: {
+        default: "none" | "virtual" | Record<string, unknown>;
+        limits?: {
+            network?: readonly string[];
+        };
+    };
 };
 /** `nylo doctor sandbox`: Tenant sandbox report via the Tenant API (F2-4). */
 export declare function doctorSandbox(options: {

package/dist/doctor.js

@@ -11,11 +11,7 @@ function platformLine() {
 }
 async function fetchSandboxReport(options) {
     const connection = await resolveConnection(options);
-    const client = createClient({
-        url: connection.url,
-        key: connection.key,
-        tenant: connection.tenant,
-    });
+    const client = createClient({ url: connection.url, key: connection.key });
     return client.transport.json("/v1/tenant/sandbox", "GET", undefined);
 }
 /** `nylo doctor sandbox`: Tenant sandbox report via the Tenant API (F2-4). */
@@ -42,9 +38,18 @@ export async function doctorSandbox(options) {
     rows.push([
         "preference",
         report.preference === "auto"
-            ? "auto (seed Tenant sandbox.backend via nylo tenant create / .env NYLORUN_SANDBOX)"
+            ? "auto (npx nylorun start seeds the Tenant's sandbox.backend from .env NYLORUN_SANDBOX)"
             : report.preference,
     ]);
+    if (report.config)
+        rows.push([
+            "default",
+            report.config.default === "none"
+                ? "none: sessions get a sandbox only when opened with one (set a default with PUT /v1/tenant/sandbox)"
+                : report.config.default === "virtual"
+                    ? "virtual: sessions that name no sandbox get one"
+                    : "a Tenant sandbox: sessions that name no sandbox get it",
+        ]);
     rows.push([
         "selected",
         report.backend

package/dist/home.d.ts

@@ -1,6 +1,6 @@
 /**
- * The Host root: an explicit home, `NYLORUN_HOME`, or `~/.nylorun`. The stack
- * bind-mounts it into the Runtime and Studio containers, and `@nylorun/admin`
- * reads `host.json` and the admin key from it.
+ * Where `nylo` keeps its own files (the installation id): an explicit home,
+ * `NYLORUN_HOME`, or `~/.nylorun`, which holds the local stacks' Host roots
+ * (`stacks/<name>/`). `@nylorun/admin` resolves a stack's Host root itself.
  */
 export declare function resolveHome(home?: string, env?: Readonly<Record<string, string | undefined>>): string;

package/dist/home.js

@@ -1,9 +1,9 @@
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";
 /**
- * The Host root: an explicit home, `NYLORUN_HOME`, or `~/.nylorun`. The stack
- * bind-mounts it into the Runtime and Studio containers, and `@nylorun/admin`
- * reads `host.json` and the admin key from it.
+ * Where `nylo` keeps its own files (the installation id): an explicit home,
+ * `NYLORUN_HOME`, or `~/.nylorun`, which holds the local stacks' Host roots
+ * (`stacks/<name>/`). `@nylorun/admin` resolves a stack's Host root itself.
  */
 export function resolveHome(home, env = process.env) {
     if (home !== undefined && home.trim() !== "")

package/dist/installation/commands.d.ts

@@ -0,0 +1,20 @@
+/** `nylo status [--json]`: the Tenant, its checks and counts; the Host's cause when it is not open. */
+export declare function statusCommand(args: readonly string[]): Promise<void>;
+/** `nylo reset [--sessions|--sandboxes|--all] [--yes]`; `--all` asks first. */
+export declare function resetCommand(args: readonly string[]): Promise<void>;
+/** `nylo endpoints [--json]` and `nylo endpoints ping <agent>`. */
+export declare function endpointsCommand(args: readonly string[]): Promise<void>;
+/** One line of `nylo endpoints`: the agent, its URL and version, and how it is doing. */
+export declare function endpointLine(endpoint: {
+    agentId: string;
+    url: string;
+    implementationVersion: string;
+    health: {
+        consecutiveFailures: number;
+        lastSuccessAt?: string;
+        lastError?: {
+            code: string;
+            message: string;
+        };
+    };
+}): string;

package/dist/installation/commands.js

@@ -0,0 +1,146 @@
+/**
+ * `nylo status`, `nylo reset` and `nylo endpoints`: the linked installation's one Tenant,
+ * through the Tenant API with the Project's application key.
+ */
+import { createInterface } from "node:readline/promises";
+import { randomUUID } from "node:crypto";
+import { createAdmin } from "@nylorun/admin";
+import { createClient } from "@nylorun/agents";
+import { CliError } from "../errors.js";
+import { linkedConnection } from "../project/connection.js";
+import { findProjectRoot } from "../project/root.js";
+const projectRoot = () => findProjectRoot() ?? process.cwd();
+const clientFor = (connection) => createClient({ url: connection.url, key: connection.key });
+/** `nylo status [--json]`: the Tenant, its checks and counts; the Host's cause when it is not open. */
+export async function statusCommand(args) {
+    const json = args.includes("--json");
+    if (args.some((a) => a !== "--json"))
+        throw new CliError("Usage: nylo status [--json]", 2);
+    const root = projectRoot();
+    const connection = await linkedConnection(root);
+    const stack = connection.link?.stack;
+    let reason;
+    try {
+        const body = await clientFor(connection).transport.json("/v1/tenant", "GET");
+        if (json) {
+            console.log(JSON.stringify({ ...(stack ? { stack } : {}), ...body }, null, 2));
+            return;
+        }
+        console.log(`${body.tenant.name}  ${body.tenant.id}`);
+        if (stack)
+            console.log(`stack    ${stack}`);
+        console.log(`runtime  ${connection.url}`);
+        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 (error) {
+        // A Tenant that is not open does not answer: the Admin API says why.
+        reason = error;
+    }
+    let tenant;
+    try {
+        tenant = (await createAdmin({ cwd: root }).status()).tenant;
+    }
+    catch {
+        throw new CliError(reason instanceof Error
+            ? reason.message
+            : `The Tenant at ${connection.url} is not reachable.`, 1);
+    }
+    if (json) {
+        console.log(JSON.stringify({ ...(stack ? { stack } : {}), tenant }, null, 2));
+        return;
+    }
+    console.log(`${tenant.name ?? "(unreadable)"}  ${tenant.id ?? "(unknown)"}  ${tenant.state}`);
+    if (stack)
+        console.log(`stack    ${stack}`);
+    console.log(`runtime  ${connection.url}`);
+    if (tenant.cause) {
+        console.log(`reason   ${tenant.cause.code}: ${tenant.cause.message}`);
+        console.log(`repair   ${tenant.cause.repair}`);
+    }
+}
+const RESET_USAGE = "Usage: nylo reset [--sessions|--sandboxes|--all] [--yes]";
+const SCOPES = { "--sessions": "sessions", "--sandboxes": "sandboxes", "--all": "all" };
+/** `nylo reset [--sessions|--sandboxes|--all] [--yes]`; `--all` asks first. */
+export async function resetCommand(args) {
+    const yes = args.includes("--yes");
+    const flags = args.filter((a) => a !== "--yes");
+    if (flags.some((f) => !(f in SCOPES)) || args.filter((a) => a === "--yes").length > 1)
+        throw new CliError(RESET_USAGE, 2);
+    if (flags.length > 1)
+        throw new CliError("Pass only one of --sessions, --sandboxes, --all.", 2);
+    const scope = flags.length ? SCOPES[flags[0]] : "sessions";
+    const connection = await linkedConnection(projectRoot());
+    const stack = connection.link?.stack;
+    const where = stack ? `stack ${stack} (${connection.url})` : connection.url;
+    if (scope === "all" && !yes)
+        await confirmOrThrow(`Reset ALL data of the Tenant on ${where}? The Project link and credentials are kept. [y/N] `);
+    try {
+        await clientFor(connection).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 the Tenant on ${where} (${scope}).`);
+}
+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();
+    }
+}
+/** `nylo endpoints [--json]` and `nylo endpoints ping <agent>`. */
+export async function endpointsCommand(args) {
+    if (args[0] === "ping") {
+        const agentId = args[1];
+        if (!agentId || args.length > 2)
+            throw new CliError("Usage: nylo endpoints ping <agent>", 2);
+        const client = clientFor(await linkedConnection(projectRoot()));
+        const answer = await client.transport.json(`/v1/endpoints/${encodeURIComponent(agentId)}/ping`, "POST");
+        console.log(`${answer.agentId}  serves ${answer.implementationVersion}${answer.manifestHash ? `  ${answer.manifestHash}` : ""}`);
+        return;
+    }
+    const json = args.includes("--json");
+    if (args.some((a) => a !== "--json"))
+        throw new CliError("Usage: nylo endpoints [--json] | nylo endpoints ping <agent>", 2);
+    const client = clientFor(await linkedConnection(projectRoot()));
+    const body = await client.transport.json("/v1/endpoints", "GET");
+    if (json) {
+        console.log(JSON.stringify(body, null, 2));
+        return;
+    }
+    if (body.endpoints.length === 0) {
+        console.log("No Action endpoints. Register one with createActionHandler(...).register({ url }).");
+        return;
+    }
+    for (const endpoint of body.endpoints)
+        console.log(endpointLine(endpoint));
+}
+/** One line of `nylo endpoints`: the agent, its URL and version, and how it is doing. */
+export function endpointLine(endpoint) {
+    const { health } = endpoint;
+    const state = health.consecutiveFailures > 0
+        ? `failing (${health.consecutiveFailures}): ${health.lastError?.message || health.lastError?.code || "unknown"}`
+        : health.lastSuccessAt
+            ? `ok (last ${health.lastSuccessAt})`
+            : "no deliveries yet";
+    return `${endpoint.agentId}  ${endpoint.url}  ${endpoint.implementationVersion}  ${state}`;
+}

package/dist/model/configure.d.ts

@@ -9,6 +9,11 @@ export type PromptedModel = {
     provider: string;
     model: string;
     baseUrl?: string;
+    /** A custom endpoint's context window and output limit, when given. */
+    settings?: {
+        contextWindow?: number;
+        maxTokens?: number;
+    };
     auth: Credential;
 };
 export type ModelCatalog = {
@@ -36,7 +41,6 @@ export type Selection = Readonly<{
 export declare function fetchModelCatalog(options: {
     url: string;
     key: string;
-    tenantId: string;
     fetchImpl?: typeof fetch;
 }): Promise<ModelCatalog>;
 export declare function configureProvider(options?: {
@@ -46,4 +50,11 @@ export declare function configureProvider(options?: {
     output?: Writable;
     /** Tenant API catalog from GET /v1/tenant/models. */
     catalog?: ModelCatalog;
+    /** This installation's stable id, for OAuth flows that need one (OpenAI). */
+    deviceId?: () => string;
 }): Promise<PromptedModel>;
+/**
+ * A stable id for this CLI installation, created on first use under the Host root.
+ * OpenAI's "Sign in with ChatGPT" sends it as the agent host id.
+ */
+export declare function installationId(home?: string): string;

package/dist/model/configure.js

@@ -1,7 +1,11 @@
 import { createInterface } from "node:readline/promises";
+import { randomUUID } from "node:crypto";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
 import { builtinModels } from "@earendil-works/pi-ai/providers/all";
 import { createProvider, } from "@earendil-works/pi-ai";
 import { stream, streamSimple, } from "@earendil-works/pi-ai/api/openai-completions";
+import { resolveHome } from "../home.js";
 export class ConfigurationCancelled extends Error {
     signal;
     exitCode;
@@ -36,8 +40,14 @@ function modelsFor(selection, credentials, catalog) {
             baseUrl: selection.custom.baseUrl,
             auth: {
                 apiKey: {
-                    label: "Custom API key",
-                    schemas: [],
+                    name: "Custom API key",
+                    async login(interaction) {
+                        const key = await interaction.prompt({
+                            type: "secret",
+                            message: "API key",
+                        });
+                        return { type: "api_key", key: key.trim() };
+                    },
                     async resolve() {
                         const credential = await credentials.read("custom");
                         if (!credential || credential.type !== "api_key")
@@ -102,11 +112,10 @@ function modelsFor(selection, credentials, catalog) {
 /** Fetch GET /v1/tenant/models when a connection is available. */
 export async function fetchModelCatalog(options) {
     const fetchImpl = options.fetchImpl ?? fetch;
-    const { PROTOCOL_HEADER, PROTOCOL_VERSION, TENANT_HEADER } = await import("@nylorun/agents");
+    const { PROTOCOL_HEADER, PROTOCOL_VERSION } = await import("@nylorun/agents");
     const response = await fetchImpl(`${options.url.replace(/\/$/, "")}/v1/tenant/models`, {
         headers: {
             authorization: `Bearer ${options.key}`,
-            [TENANT_HEADER]: options.tenantId,
             [PROTOCOL_HEADER]: String(PROTOCOL_VERSION),
             Accept: "application/json",
         },
@@ -119,6 +128,7 @@ export async function fetchModelCatalog(options) {
 }
 // Internal options also allow isolated prompt tests without changing process globals.
 export async function configureProvider(options = {}) {
+    const login = { getDeviceId: options.deviceId ?? installationId };
     const output = options.output ?? process.stdout;
     const controller = new AbortController();
     const signal = controller.signal;
@@ -161,6 +171,16 @@ export async function configureProvider(options = {}) {
         signal.throwIfAborted();
         return prompt.question(message, { signal });
     }
+    /** A positive whole number of tokens, or undefined for the default. */
+    async function tokens(message) {
+        const answer = (await question(message)).trim();
+        if (!answer)
+            return undefined;
+        const value = Number(answer);
+        if (!Number.isInteger(value) || value < 1)
+            throw new Error(`${message.split(" (")[0]} must be a whole number of tokens.`);
+        return value;
+    }
     try {
         signal.throwIfAborted();
         output.write("0. Custom OpenAI-compatible provider\n");
@@ -173,6 +193,12 @@ export async function configureProvider(options = {}) {
             const model = (await question("Model id: ")).trim();
             if (!baseUrl || !model)
                 throw new Error("A base URL and model id are required.");
+            const contextWindow = await tokens("Context window in tokens (Enter for 32768): ");
+            const maxTokens = await tokens("Max output tokens (Enter for 8192): ");
+            const settings = {
+                ...(contextWindow ? { contextWindow } : {}),
+                ...(maxTokens ? { maxTokens } : {}),
+            };
             const selection = {
                 provider: "custom",
                 model,
@@ -180,8 +206,11 @@ export async function configureProvider(options = {}) {
             };
             const custom = modelsFor(selection, store, options.catalog);
             if (!(await custom.models.checkAuth("custom", { signal })))
-                await custom.models.login("custom", "api_key", interaction());
-            return prompted(selection);
+                await custom.models.login("custom", "api_key", interaction(), login);
+            return {
+                ...prompted(selection),
+                ...(Object.keys(settings).length ? { settings } : {}),
+            };
         }
         else {
             const chosen = providers[choice - 1];
@@ -203,7 +232,7 @@ export async function configureProvider(options = {}) {
                     if (answer === "2")
                         method = "oauth";
                 }
-                await registry.models.login(chosen.id, method, interaction());
+                await registry.models.login(chosen.id, method, interaction(), login);
             }
             return prompted({ provider: chosen.id, model: model.id });
         }
@@ -256,3 +285,22 @@ export async function configureProvider(options = {}) {
         };
     }
 }
+/**
+ * A stable id for this CLI installation, created on first use under the Host root.
+ * OpenAI's "Sign in with ChatGPT" sends it as the agent host id.
+ */
+export function installationId(home = resolveHome()) {
+    const file = join(home, "cli-installation-id");
+    try {
+        const existing = readFileSync(file, "utf8").trim();
+        if (existing)
+            return existing;
+    }
+    catch {
+        /* Created below on first use. */
+    }
+    const id = randomUUID();
+    mkdirSync(home, { recursive: true });
+    writeFileSync(file, `${id}\n`, { mode: 0o600 });
+    return id;
+}

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

@@ -1,4 +1,4 @@
-import { type PromptedModel } from "./configure.js";
+import type { PromptedModel } from "./configure.js";
 /** Wire shape of GET/PUT `/v1/tenant/model` — local copy so CLI stays off `@nylorun/core`. */
 type HostModelView = {
     readonly configured: false;
@@ -8,15 +8,11 @@ type HostModelView = {
     readonly model: string;
     readonly authType: "api_key" | "oauth";
     readonly baseUrl?: string;
+    readonly settings?: {
+        contextWindow?: number;
+        maxTokens?: number;
+    };
 };
-export declare function getHostModel(runtimeUrl: string, serverKey: string, tenantId?: string): Promise<HostModelView>;
-export declare function putHostModel(runtimeUrl: string, serverKey: string, model: PromptedModel, tenantId?: string): Promise<HostModelView>;
-export declare function ensureHostModel(options: {
-    runtimeUrl: string;
-    serverKey: string;
-    tenantId: string;
-    root?: string;
-    env?: Readonly<Record<string, string>>;
-    signal?: AbortSignal;
-}): Promise<void>;
+/** Set the installation's Tenant model provider (`PUT /v1/tenant/model`). */
+export declare function putHostModel(runtimeUrl: string, serverKey: string, model: PromptedModel, fetchImpl?: typeof fetch): Promise<HostModelView>;
 export {};

package/dist/model/host-model.js

@@ -1,38 +1,12 @@
 import { randomUUID } from "node:crypto";
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-import { PROTOCOL_HEADER, PROTOCOL_VERSION, TENANT_HEADER, } from "@nylorun/agents";
-import { configureProvider } from "./configure.js";
-import { loadProjectEnvironment } from "../environment.js";
-function tenantHeaders(serverKey, tenantId) {
-    return {
-        authorization: `Bearer ${serverKey}`,
-        [TENANT_HEADER]: tenantId,
-        [PROTOCOL_HEADER]: String(PROTOCOL_VERSION),
-    };
-}
-function resolveTenantId(explicit) {
-    const tenant = explicit?.trim() || process.env.NYLORUN_TENANT?.trim();
-    if (!tenant) {
-        throw new Error("Set NYLORUN_TENANT (or pass tenant via Project link) before calling Tenant model routes");
-    }
-    return tenant;
-}
-export async function getHostModel(runtimeUrl, serverKey, tenantId) {
-    const tenant = resolveTenantId(tenantId);
-    const response = await fetch(`${runtimeUrl}/v1/tenant/model`, {
-        headers: tenantHeaders(serverKey, tenant),
-    });
-    if (!response.ok)
-        throw new Error(`Runtime model status returned ${response.status}`);
-    return response.json();
-}
-export async function putHostModel(runtimeUrl, serverKey, model, tenantId) {
-    const tenant = resolveTenantId(tenantId);
-    const response = await fetch(`${runtimeUrl}/v1/tenant/model`, {
+import { PROTOCOL_HEADER, PROTOCOL_VERSION } from "@nylorun/agents";
+/** Set the installation's Tenant model provider (`PUT /v1/tenant/model`). */
+export async function putHostModel(runtimeUrl, serverKey, model, fetchImpl = fetch) {
+    const response = await fetchImpl(`${runtimeUrl}/v1/tenant/model`, {
         method: "PUT",
         headers: {
-            ...tenantHeaders(serverKey, tenant),
+            authorization: `Bearer ${serverKey}`,
+            [PROTOCOL_HEADER]: String(PROTOCOL_VERSION),
             "content-type": "application/json",
         },
         body: JSON.stringify({
@@ -41,6 +15,7 @@ export async function putHostModel(runtimeUrl, serverKey, model, tenantId) {
             provider: model.provider,
             model: model.model,
             ...(model.baseUrl ? { baseUrl: model.baseUrl } : {}),
+            ...(model.settings ? { settings: model.settings } : {}),
             auth: model.auth,
         }),
     });
@@ -49,57 +24,3 @@ export async function putHostModel(runtimeUrl, serverKey, model, tenantId) {
         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, options.tenantId);
-    if (current.configured)
-        return;
-    const env = options.env ?? loadProjectEnvironment(options.root ?? process.cwd());
-    if (env.NYLORUN_DEV_MODEL?.trim() === "fixture")
-        return;
-    const seeded = seedFromEnv(env, options.root ?? process.cwd());
-    if (seeded) {
-        await putHostModel(options.runtimeUrl, options.serverKey, seeded, options.tenantId);
-        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, options.tenantId);
-        return;
-    }
-    throw new Error("Model provider is not configured. Run nylo configure in a terminal to set it up, or open Studio.");
-}
-function seedFromEnv(env, root) {
-    const provider = env.MODEL_PROVIDER?.trim();
-    const model = env.MODEL?.trim();
-    if (!provider || !model)
-        return undefined;
-    const baseUrl = env.MODEL_PROVIDER_BASE_URL?.trim();
-    const key = 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/connection.d.ts

@@ -0,0 +1,13 @@
+import { type ProjectLink } from "./link.js";
+/** The installation `nylo` acts on: a Runtime URL and an application key. */
+export interface LinkedConnection {
+    url: string;
+    key: string;
+    /** The Project link it came from, when it came from one. */
+    link?: ProjectLink;
+}
+/**
+ * The Project's link and credentials, else `NYLORUN_RUNTIME_URL` and `NYLORUN_SERVER_KEY`. The
+ * installation serves one Tenant, so nothing names it.
+ */
+export declare function linkedConnection(projectRoot: string, env?: Readonly<Record<string, string | undefined>>): Promise<LinkedConnection>;

package/dist/project/connection.js

@@ -0,0 +1,18 @@
+import { CliError } from "../errors.js";
+import { readCredentials } from "./credentials.js";
+import { readLink } from "./link.js";
+/**
+ * The Project's link and credentials, else `NYLORUN_RUNTIME_URL` and `NYLORUN_SERVER_KEY`. The
+ * installation serves one Tenant, so nothing names it.
+ */
+export async function linkedConnection(projectRoot, env = process.env) {
+    const link = await readLink(projectRoot);
+    const credentials = await readCredentials(projectRoot);
+    if (link && credentials)
+        return { url: link.hostUrl, key: credentials.applicationKey, link };
+    const url = env.NYLORUN_RUNTIME_URL?.trim();
+    const key = env.NYLORUN_SERVER_KEY?.trim();
+    if (url && key)
+        return { url: url.replace(/\/$/, ""), key };
+    throw new CliError(`No Project link in ${projectRoot}. Run "npx nylorun start" in this project to start its stack and link it, or set NYLORUN_RUNTIME_URL and NYLORUN_SERVER_KEY.`, 1);
+}

package/dist/project/credentials.d.ts

@@ -1,19 +1,11 @@
 /**
- * Project-local credentials (mode 0600). Format 1 drops `executors`.
- * Format 0 may still contain an executors map; readers ignore it (D§3.7).
+ * Project-local credentials (mode 0600): the application key and its principal. A format 0
+ * file may still carry a legacy `executors` map from before protocol 3; it is ignored.
  */
 export interface ProjectCredentials {
     format: 0 | 1;
     applicationKey: string;
     principalId: string;
-    /** Present only on format 0 files; ignored by version 1. */
-    executors?: Record<string, string>;
 }
-/** The Project's credentials, or with `tenantId` the key kept for that Tenant. */
-export declare function readCredentials(projectRoot: string, tenantId?: string): Promise<ProjectCredentials | undefined>;
-export declare function writeCredentials(projectRoot: string, credentials: {
-    applicationKey: string;
-    principalId: string;
-    format?: 0 | 1;
-}, tenantId?: string): Promise<void>;
-export declare function removeCredentials(projectRoot: string, tenantId?: string): Promise<void>;
+/** The Project's credentials, which `nylorun start` writes beside the link. */
+export declare function readCredentials(projectRoot: string): Promise<ProjectCredentials | undefined>;

package/dist/project/credentials.js

@@ -1,17 +1,16 @@
-import { chmod, readFile, rename, rm, writeFile } from "node:fs/promises";
-import { randomUUID } from "node:crypto";
+import { chmod, readFile } from "node:fs/promises";
 import { CliError } from "../errors.js";
-import { credentialsPath, ensureProjectNylorunDir, } from "./link.js";
-/** The Project's credentials, or with `tenantId` the key kept for that Tenant. */
-export async function readCredentials(projectRoot, tenantId) {
-    const path = credentialsPath(projectRoot, tenantId);
+import { credentialsPath } from "./link.js";
+/** The Project's credentials, which `nylorun start` writes beside the link. */
+export async function readCredentials(projectRoot) {
+    const path = credentialsPath(projectRoot);
     try {
         const value = JSON.parse(await readFile(path, "utf8"));
         if (typeof value?.applicationKey !== "string" ||
             !/^[0-9a-f]{64}$/.test(value.applicationKey) ||
             typeof value?.principalId !== "string" ||
             value.principalId.length === 0) {
-            throw new CliError(`Invalid Project credentials at ${path}. Remove .nylorun/credentials.json and run nylo tenant create.`, 1);
+            throw new CliError(`Invalid Project credentials at ${path}. Remove .nylorun/credentials.json and run "npx nylorun start".`, 1);
         }
         const format = value.format === undefined || value.format === 0
             ? 0
@@ -22,17 +21,10 @@ export async function readCredentials(projectRoot, tenantId) {
             throw new CliError(`Project credentials at ${path} have an unsupported format. Upgrade the CLI.`, 1);
         }
         await chmod(path, 0o600);
-        const executors = format === 0 &&
-            value.executors &&
-            typeof value.executors === "object" &&
-            !Array.isArray(value.executors)
-            ? value.executors
-            : undefined;
         return {
             format,
             applicationKey: value.applicationKey,
             principalId: value.principalId,
-            ...(executors ? { executors } : {}),
         };
     }
     catch (error) {
@@ -41,25 +33,3 @@ export async function readCredentials(projectRoot, tenantId) {
         throw error;
     }
 }
-export async function writeCredentials(projectRoot, credentials, tenantId) {
-    await ensureProjectNylorunDir(projectRoot);
-    const path = credentialsPath(projectRoot, tenantId);
-    const temporary = `${path}.${randomUUID()}.tmp`;
-    // Version 1 writes format 1 without executors (D§3.7).
-    const body = `${JSON.stringify({
-        format: credentials.format ?? 1,
-        applicationKey: credentials.applicationKey,
-        principalId: credentials.principalId,
-    }, null, 2)}\n`;
-    try {
-        await writeFile(temporary, body, { mode: 0o600 });
-        await rename(temporary, path);
-        await chmod(path, 0o600);
-    }
-    finally {
-        await rm(temporary, { force: true });
-    }
-}
-export async function removeCredentials(projectRoot, tenantId) {
-    await rm(credentialsPath(projectRoot, tenantId), { force: true });
-}