@nylorun/cli 0.2.1-beta → 0.4.0-beta

package/dist/doctor.js

@@ -1,61 +1,59 @@
 import { release } from "node:os";
-import { probeSandboxBackends, } from "@nylorun/runtime/node";
-const LABEL = {
-    microsandbox: "microsandbox VM",
-    virtual: "virtual shell",
-};
-/** `nylorun doctor sandbox`: what this machine offers and what a Runtime here would pick. */
+import { createClient, resolveConnection } from "@nylorun/agents";
+import { CliError } from "./errors.js";
+function platformLine() {
+    const os = process.platform === "darwin"
+        ? "macOS"
+        : process.env.WSL_DISTRO_NAME
+            ? `Linux (WSL: ${process.env.WSL_DISTRO_NAME})`
+            : process.platform;
+    return `${os} (kernel ${release()}) · ${process.arch}`;
+}
+async function fetchSandboxReport(options) {
+    const connection = await resolveConnection(options);
+    const client = createClient({
+        url: connection.url,
+        key: connection.key,
+        tenant: connection.tenant,
+    });
+    return client.transport.json("/v1/tenant/sandbox", "GET", undefined);
+}
+/** `nylo doctor sandbox`: Tenant sandbox report via the Tenant API (F2-4). */
 export async function doctorSandbox(options) {
-    const report = await probeSandboxBackends();
+    let report;
+    try {
+        report = await fetchSandboxReport();
+    }
+    catch (error) {
+        throw new CliError(error instanceof Error
+            ? error.message
+            : `Could not read Tenant sandbox status: ${String(error)}`, 1);
+    }
     if (options.json) {
-        console.log(JSON.stringify({ platform: platform(), ...report }, null, 2));
+        console.log(JSON.stringify({ platform: platformLine(), ...report }, null, 2));
         return;
     }
-    const rows = [["platform", platform()]];
+    const rows = [["platform", platformLine()]];
     for (const probe of report.probes)
         rows.push([
             probe.name,
             `${probe.available ? "✓" : "✗"} ${probe.reason ?? ""}${probe.version ? ` · ${probe.version}` : ""}`,
         ]);
-    rows.push(["preference", report.preference === "auto" ? "auto (set NYLORUN_SANDBOX to force one)" : report.preference]);
-    rows.push(["selected", report.backend ? `${report.backend} (${report.isolation} isolation)` : `none: ${report.reason}`]);
+    rows.push([
+        "preference",
+        report.preference === "auto"
+            ? "auto (seed Tenant sandbox.backend via nylo tenant create / .env NYLORUN_SANDBOX)"
+            : report.preference,
+    ]);
+    rows.push([
+        "selected",
+        report.backend
+            ? `${report.backend} (${report.isolation} isolation)`
+            : `none: ${report.reason}`,
+    ]);
     const width = Math.max(...rows.map(([key]) => key.length)) + 2;
     for (const [key, value] of rows)
         console.log(`  ${key.padEnd(width)}${value}`);
     if (report.backend === "virtual")
-        console.log("\n  The virtual shell emulates bash in the Runtime process; it is not a VM boundary.\n" +
-            "  For hardware isolation use macOS on Apple Silicon or Linux with KVM.");
-}
-/** One line for the dev banner, or undefined when no connected agent declares a sandbox. */
-export async function sandboxBanner(runtimeUrl, serverKey, manifests) {
-    const capability = manifests
-        .flatMap((manifest) => manifest.capabilities)
-        .find((item) => item.sandbox);
-    if (!capability)
-        return undefined;
-    let report;
-    try {
-        const response = await fetch(`${runtimeUrl}/v1/host/sandbox`, {
-            headers: { authorization: `Bearer ${serverKey}` },
-            signal: AbortSignal.timeout(10_000),
-        });
-        if (response.ok)
-            report = await response.json();
-    }
-    catch { }
-    if (!report)
-        return undefined;
-    const doctor = "run `npx nylorun doctor sandbox` for options";
-    if (!report.backend)
-        return `sandbox: unavailable (${report.reason}) · ${doctor}`;
-    const image = capability.sandbox?.image ?? report.defaultImage;
-    const network = capability.sandbox?.network?.preset ?? "dev";
-    const fellBack = report.preference === "auto" && report.backend !== report.probes[0]?.name;
-    return fellBack
-        ? `sandbox: ${LABEL[report.backend] ?? report.backend} (${report.reason}) · ${doctor}`
-        : `sandbox: ${LABEL[report.backend] ?? report.backend}${report.backend === "microsandbox" && image ? ` · image ${image}` : ""} · network: ${network}`;
-}
-function platform() {
-    const os = process.platform === "darwin" ? "macOS" : process.platform === "win32" ? "Windows" : process.platform;
-    return `${os} (kernel ${release()}) · ${process.arch}`;
+        console.log("\n  The virtual shell emulates bash in the Runtime process; it is not a VM boundary.");
 }

package/dist/environment.d.ts

@@ -1,2 +1,5 @@
-export declare function loadProjectEnvironment(root?: string): void;
+/**
+ * Read the Project `.env` into a value map. Does not mutate `process.env` (F3).
+ */
+export declare function loadProjectEnvironment(root?: string): Record<string, string>;
 export declare function saveEnvironment(root: string, updates: Record<string, string | undefined>, signal?: AbortSignal): Promise<void>;

package/dist/environment.js

@@ -2,7 +2,10 @@ import { readFileSync, statSync } from "node:fs";
 import { writeFile, rename, rm } from "node:fs/promises";
 import { join } from "node:path";
 import { randomUUID } from "node:crypto";
-import { loadEnvFile } from "node:process";
+import { parseEnv } from "node:util";
+/**
+ * Read the Project `.env` into a value map. Does not mutate `process.env` (F3).
+ */
 export function loadProjectEnvironment(root = process.cwd()) {
     const file = join(root, ".env");
     try {
@@ -11,10 +14,16 @@ export function loadProjectEnvironment(root = process.cwd()) {
     }
     catch (error) {
         if (error.code === "ENOENT")
-            return;
+            return {};
         throw error;
     }
-    loadEnvFile(file);
+    const parsed = parseEnv(readFileSync(file, "utf8"));
+    const result = {};
+    for (const [key, value] of Object.entries(parsed)) {
+        if (value !== undefined)
+            result[key] = value;
+    }
+    return result;
 }
 // Match complete dotenv assignments, including quoted multiline values.
 const assignment = /^(?:export\s+)?([\w]+)[\t ]*=[\t ]*(?:"[^"]*"|'[^']*'|`[^`]*`|[^#\r\n]*)([^\r\n]*)(?:\r?\n|$)/gm;

package/dist/home.d.ts

@@ -0,0 +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.
+ */
+export declare function resolveHome(home?: string, env?: Readonly<Record<string, string | undefined>>): string;

package/dist/home.js

@@ -0,0 +1,15 @@
+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.
+ */
+export function resolveHome(home, env = process.env) {
+    if (home !== undefined && home.trim() !== "")
+        return resolve(home);
+    const fromEnv = env.NYLORUN_HOME?.trim();
+    if (fromEnv)
+        return resolve(fromEnv);
+    return resolve(join(homedir(), ".nylorun"));
+}

package/dist/model/configure.d.ts

@@ -11,9 +11,39 @@ export type PromptedModel = {
     baseUrl?: string;
     auth: Credential;
 };
+export type ModelCatalog = {
+    providers: {
+        id: string;
+        name: string;
+        models: {
+            id: string;
+            name: string;
+        }[];
+        auth?: {
+            apiKey?: unknown;
+            oauth?: unknown;
+        };
+    }[];
+};
+export type Selection = Readonly<{
+    provider: string;
+    model: string;
+    custom?: Readonly<{
+        baseUrl: string;
+    }>;
+}>;
+/** Fetch GET /v1/tenant/models when a connection is available. */
+export declare function fetchModelCatalog(options: {
+    url: string;
+    key: string;
+    tenantId: string;
+    fetchImpl?: typeof fetch;
+}): Promise<ModelCatalog>;
 export declare function configureProvider(options?: {
     signal?: AbortSignal;
     root?: string;
     input?: Readable;
     output?: Writable;
+    /** Tenant API catalog from GET /v1/tenant/models. */
+    catalog?: ModelCatalog;
 }): Promise<PromptedModel>;

package/dist/model/configure.js

@@ -1,5 +1,7 @@
 import { createInterface } from "node:readline/promises";
-import { modelsFor } from "@nylorun/runtime/configuration";
+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";
 export class ConfigurationCancelled extends Error {
     signal;
     exitCode;
@@ -9,6 +11,112 @@ export class ConfigurationCancelled extends Error {
         this.exitCode = signal === "SIGINT" ? 130 : 143;
     }
 }
+/**
+ * Build a pi-ai registry for interactive login. Catalog listing prefers the
+ * Tenant API payload when provided (F2-4).
+ */
+function modelsFor(selection, credentials, catalog) {
+    const models = builtinModels({ credentials });
+    if (selection.custom) {
+        const model = {
+            id: selection.model,
+            name: selection.model,
+            api: "openai-completions",
+            provider: "custom",
+            baseUrl: selection.custom.baseUrl,
+            reasoning: false,
+            input: ["text", "image"],
+            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+            contextWindow: 128000,
+            maxTokens: 16384,
+        };
+        models.setProvider(createProvider({
+            id: "custom",
+            name: "Custom OpenAI-compatible",
+            baseUrl: selection.custom.baseUrl,
+            auth: {
+                apiKey: {
+                    label: "Custom API key",
+                    schemas: [],
+                    async resolve() {
+                        const credential = await credentials.read("custom");
+                        if (!credential || credential.type !== "api_key")
+                            return undefined;
+                        const key = credential.key;
+                        if (!key)
+                            return undefined;
+                        return { type: "api_key", auth: { apiKey: key } };
+                    },
+                },
+            },
+            models: [model],
+            api: { stream, streamSimple },
+        }));
+    }
+    return {
+        models,
+        listProviders() {
+            if (catalog?.providers.length) {
+                return catalog.providers.map((provider) => {
+                    const live = models.getProvider(provider.id);
+                    return {
+                        id: provider.id,
+                        name: provider.name,
+                        auth: {
+                            ...(live?.auth?.apiKey || provider.auth?.apiKey
+                                ? { apiKey: live?.auth?.apiKey ?? {} }
+                                : {}),
+                            ...(live?.auth?.oauth || provider.auth?.oauth
+                                ? { oauth: live?.auth?.oauth ?? {} }
+                                : {}),
+                            ...(!live?.auth?.apiKey &&
+                                !live?.auth?.oauth &&
+                                !provider.auth?.apiKey &&
+                                !provider.auth?.oauth
+                                ? { apiKey: {} }
+                                : {}),
+                        },
+                    };
+                });
+            }
+            return models.getProviders().map((provider) => ({
+                id: provider.id,
+                name: provider.name,
+                auth: {
+                    ...(provider.auth?.apiKey ? { apiKey: provider.auth.apiKey } : {}),
+                    ...(provider.auth?.oauth ? { oauth: provider.auth.oauth } : {}),
+                },
+            }));
+        },
+        listModels(providerId) {
+            const fromCatalog = catalog?.providers.find((p) => p.id === providerId);
+            if (fromCatalog?.models.length)
+                return fromCatalog.models;
+            return models.getModels(providerId).map((model) => ({
+                id: model.id,
+                name: model.name,
+            }));
+        },
+    };
+}
+/** 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 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",
+        },
+        signal: AbortSignal.timeout(10_000),
+    });
+    if (!response.ok) {
+        throw new Error(`Runtime model catalog returned ${response.status}`);
+    }
+    return (await response.json());
+}
 // Internal options also allow isolated prompt tests without changing process globals.
 export async function configureProvider(options = {}) {
     const output = options.output ?? process.stdout;
@@ -34,10 +142,8 @@ export async function configureProvider(options = {}) {
             return next ?? captured;
         },
     };
-    const models = modelsFor({ provider: "", model: "" }, store, {
-        environment: false,
-    });
-    const providers = models.getProviders();
+    const registry = modelsFor({ provider: "", model: "" }, store, options.catalog);
+    const providers = registry.listProviders();
     const prompt = createInterface({
         input: options.input ?? process.stdin,
         output,
@@ -72,21 +178,21 @@ export async function configureProvider(options = {}) {
                 model,
                 custom: { baseUrl },
             };
-            const customModels = modelsFor(selection, store, { environment: false });
-            if (!(await customModels.checkAuth("custom", { signal })))
-                await customModels.login("custom", "api_key", interaction());
+            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);
         }
         else {
             const chosen = providers[choice - 1];
             if (!chosen)
                 throw new Error("Choose a listed provider.");
-            const available = models.getModels(chosen.id);
+            const available = registry.listModels(chosen.id);
             available.forEach((model, index) => output.write(`${index + 1}. ${model.name} (${model.id})\n`));
             const model = available[Number(await question("Choose a model: ")) - 1];
             if (!model)
                 throw new Error("Choose a listed model.");
-            if (!(await models.checkAuth(chosen.id, { signal }))) {
+            if (!(await registry.models.checkAuth(chosen.id, { signal }))) {
                 let method = chosen.auth.apiKey
                     ? "api_key"
                     : "oauth";
@@ -97,7 +203,7 @@ export async function configureProvider(options = {}) {
                     if (answer === "2")
                         method = "oauth";
                 }
-                await models.login(chosen.id, method, interaction());
+                await registry.models.login(chosen.id, method, interaction());
             }
             return prompted({ provider: chosen.id, model: model.id });
         }

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

@@ -1,5 +1,5 @@
 import { type PromptedModel } from "./configure.js";
-/** Wire shape of GET/PUT `/v1/host/model` — local copy so CLI stays off `@nylorun/core`. */
+/** Wire shape of GET/PUT `/v1/tenant/model` — local copy so CLI stays off `@nylorun/core`. */
 type HostModelView = {
     readonly configured: false;
 } | {
@@ -9,12 +9,14 @@ type HostModelView = {
     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 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>;
 export {};

package/dist/model/host-model.js

@@ -1,20 +1,38 @@
 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";
-export async function getHostModel(runtimeUrl, serverKey) {
-    const response = await fetch(`${runtimeUrl}/v1/host/model`, {
-        headers: { authorization: `Bearer ${serverKey}` },
+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) {
-    const response = await fetch(`${runtimeUrl}/v1/host/model`, {
+export async function putHostModel(runtimeUrl, serverKey, model, tenantId) {
+    const tenant = resolveTenantId(tenantId);
+    const response = await fetch(`${runtimeUrl}/v1/tenant/model`, {
         method: "PUT",
         headers: {
-            authorization: `Bearer ${serverKey}`,
+            ...tenantHeaders(serverKey, tenant),
             "content-type": "application/json",
         },
         body: JSON.stringify({
@@ -32,12 +50,15 @@ export async function putHostModel(runtimeUrl, serverKey, model) {
     return body;
 }
 export async function ensureHostModel(options) {
-    const current = await getHostModel(options.runtimeUrl, options.serverKey);
+    const current = await getHostModel(options.runtimeUrl, options.serverKey, options.tenantId);
     if (current.configured)
         return;
-    const seeded = seedFromProject(options.root ?? process.cwd());
+    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);
+        await putHostModel(options.runtimeUrl, options.serverKey, seeded, options.tenantId);
         return;
     }
     if (process.stdin.isTTY && process.stdout.isTTY) {
@@ -45,18 +66,18 @@ export async function ensureHostModel(options) {
             root: options.root,
             signal: options.signal,
         });
-        await putHostModel(options.runtimeUrl, options.serverKey, prompted);
+        await putHostModel(options.runtimeUrl, options.serverKey, prompted, options.tenantId);
         return;
     }
-    throw new Error("Model provider is not configured. Run nylorun dev in a terminal to set it up, or open Studio.");
+    throw new Error("Model provider is not configured. Run nylo configure 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();
+function seedFromEnv(env, root) {
+    const provider = env.MODEL_PROVIDER?.trim();
+    const model = 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 baseUrl = env.MODEL_PROVIDER_BASE_URL?.trim();
+    const key = env.MODEL_PROVIDER_API_KEY;
     const auth = key
         ? { type: "api_key", key }
         : legacyCredential(root, provider);

package/dist/project/create-tenant.d.ts

@@ -0,0 +1,28 @@
+import { type Admin } from "@nylorun/admin";
+import { type ProjectCredentials } from "./credentials.js";
+import { type ProjectLink } from "./link.js";
+export interface CreateTenantOptions {
+    /** Prefer an already-resolved Admin (local Host or explicit). */
+    admin: Admin;
+    hostId: string;
+    projectRoot: string;
+    name?: string;
+    /** Override Host URL written into the link (defaults to admin.url). */
+    hostUrl?: string;
+}
+export interface CreateTenantResult {
+    link: ProjectLink;
+    credentials: ProjectCredentials;
+    envelope: {
+        id: string;
+        name: string;
+    };
+}
+/** The Project's `package.json` name, else its directory name. */
+export declare function defaultTenantName(projectRoot: string): Promise<string>;
+/**
+ * Create a Tenant via `@nylorun/admin` and write format-1 link + credentials.
+ */
+export declare function createProjectTenant(options: CreateTenantOptions): Promise<CreateTenantResult>;
+/** Resolve Admin from the local Host root (host.json and the admin key). */
+export declare function localAdmin(home?: string): Admin;

package/dist/project/create-tenant.js

@@ -0,0 +1,66 @@
+import { readFile } from "node:fs/promises";
+import { basename, join } from "node:path";
+import { createAdmin } from "@nylorun/admin";
+import { newPrincipalId } from "@nylorun/agents";
+import { CliError } from "../errors.js";
+import { writeCredentials, } from "./credentials.js";
+import { writeLink } from "./link.js";
+/** The Project's `package.json` name, else its directory name. */
+export async function defaultTenantName(projectRoot) {
+    try {
+        const pkg = JSON.parse(await readFile(join(projectRoot, "package.json"), "utf8"));
+        if (typeof pkg.name === "string" && pkg.name.trim())
+            return pkg.name.trim();
+    }
+    catch {
+        /* fall through */
+    }
+    const base = basename(projectRoot);
+    return base && base.length > 0 ? base : "project";
+}
+/**
+ * Create a Tenant via `@nylorun/admin` and write format-1 link + credentials.
+ */
+export async function createProjectTenant(options) {
+    const name = options.name ?? (await defaultTenantName(options.projectRoot));
+    const admin = options.admin;
+    let created;
+    try {
+        created = await admin.createTenant({ name });
+    }
+    catch (error) {
+        throw new CliError(error instanceof Error
+            ? error.message
+            : `Could not create Tenant: ${String(error)}`, 1);
+    }
+    const hostUrl = (options.hostUrl ?? admin.url).replace(/\/$/, "");
+    // CLIENTS-CCR: admin.createTenant should also return principalId (D§4.2 /
+    // credentials.json). Until then, mint a local id for the credentials file;
+    // agents resolveConnection only needs applicationKey.
+    const principalId = "principalId" in created &&
+        typeof created.principalId === "string"
+        ? created.principalId
+        : newPrincipalId();
+    const credentials = {
+        format: 1,
+        applicationKey: created.applicationKey,
+        principalId,
+    };
+    const link = {
+        format: 1,
+        hostUrl,
+        hostId: options.hostId,
+        tenantId: created.tenant.id,
+    };
+    await writeCredentials(options.projectRoot, credentials);
+    await writeLink(options.projectRoot, link);
+    return {
+        link,
+        credentials,
+        envelope: { id: created.tenant.id, name: created.tenant.name },
+    };
+}
+/** Resolve Admin from the local Host root (host.json and the admin key). */
+export function localAdmin(home) {
+    return createAdmin(home ? { home } : undefined);
+}

package/dist/project/credentials.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Project-local credentials (mode 0600). Format 1 drops `executors`.
+ * Format 0 may still contain an executors map; readers ignore it (D§3.7).
+ */
+export interface ProjectCredentials {
+    format: 0 | 1;
+    applicationKey: string;
+    principalId: string;
+    /** Present only on format 0 files; ignored by version 1. */
+    executors?: Record<string, string>;
+}
+export declare function readCredentials(projectRoot: string): Promise<ProjectCredentials | undefined>;
+export declare function writeCredentials(projectRoot: string, credentials: {
+    applicationKey: string;
+    principalId: string;
+    format?: 0 | 1;
+}): Promise<void>;
+export declare function removeCredentials(projectRoot: string): Promise<void>;