@cjhyy/code-shell-server 0.9.22 → 0.9.23

package/dist/serve/automation-worker.js

@@ -0,0 +1,126 @@
+import { randomUUID } from "node:crypto";
+import { HubAutomationUncertainError, HubAutomationCancelledError, } from "../panels/hub-automations.js";
+/** Borrows the project's live Worker so persisted Session state has one writer. */
+export function createHubAutomationWorker(options) {
+    const active = new Map();
+    const rpc = (method, params, id = `automation-control-${randomUUID()}`) => options.bridge.request(method, params, {
+        id,
+        consume: true,
+        settleOnExit: true,
+        failFast: true,
+        timeoutMs: 5000,
+        meta: { origin: "host", producer: "hub-automation" },
+    });
+    /** Called before the interactive approval lease router. */
+    function handleApproval(params) {
+        const entry = active.get(params.sessionId);
+        if (!entry)
+            return false;
+        if (typeof params.requestId !== "string" ||
+            !params.request ||
+            typeof params.request.toolName !== "string")
+            return true;
+        if (entry.approvals.has(params.requestId))
+            return true;
+        entry.approvals.add(params.requestId);
+        void (async () => {
+            const request = params.request;
+            const decision = request.toolName.startsWith("__")
+                ? {
+                    approved: false,
+                    failure: "unavailable",
+                    reason: "Unattended runs cannot use a page-owned capability",
+                }
+                : await entry.request.approvalBackend.requestApproval(request);
+            if (active.get(params.sessionId) !== entry || entry.request.signal?.aborted)
+                return;
+            const outcome = await rpc("agent/approve", {
+                sessionId: params.sessionId,
+                requestId: params.requestId,
+                connectionId: params.connectionId,
+                generation: params.generation,
+                decision,
+            });
+            if (outcome.status !== "result" && active.get(params.sessionId) === entry) {
+                await rpc("agent/cancel", { sessionId: params.sessionId });
+            }
+        })().catch(async () => {
+            if (active.get(params.sessionId) === entry)
+                await rpc("agent/cancel", { sessionId: params.sessionId });
+        });
+        return true;
+    }
+    async function execute(request) {
+        request.signal?.throwIfAborted();
+        const sessionId = request.job.resumeSessionId;
+        if (!sessionId || request.job.cwd !== options.cwd || !request.job.lastRunId)
+            throw Error("Automation requires a persisted run identity and project Session");
+        if (active.has(sessionId))
+            throw Error("The Session already has an active automation");
+        const requestId = `automation-run-${request.job.lastRunId}`;
+        const release = options.reserve(request.job, requestId);
+        const entry = { request, requestId, approvals: new Set() };
+        active.set(sessionId, entry);
+        let cancel;
+        try {
+            const model = options.model();
+            if (!model)
+                throw Error("Configure a default text model before running automations");
+            request.signal?.throwIfAborted();
+            const result = options.bridge.request("agent/run", {
+                sessionId,
+                cwd: options.cwd,
+                task: request.prompt,
+                model,
+                requireExisting: true,
+                clientMessageId: requestId,
+                displayText: request.prompt,
+                disableGoal: true,
+                permissionMode: request.permissionMode,
+                sandboxMode: request.sandboxMode,
+                allowBackgroundShells: false,
+            }, {
+                id: requestId,
+                timeoutMs: options.admissionTimeoutMs ?? 60000,
+                consume: true,
+                settleOnExit: true,
+                failFast: true,
+                waitForRunCompletion: true,
+                ensureWorker: true,
+                ensureWorkerCwd: options.cwd,
+                meta: { origin: "host", producer: "hub-automation" },
+            });
+            cancel = () => {
+                void rpc("agent/cancel", { sessionId });
+            };
+            request.signal?.addEventListener("abort", cancel, { once: true });
+            if (request.signal?.aborted)
+                cancel();
+            const outcome = await result;
+            if (outcome.status === "timeout" || outcome.status === "sendFailed") {
+                // Admission may have reached the child despite a lost ACK/write error.
+                // Never release the Session based only on a local transport timeout.
+                await options.bridge.stopAndWait();
+                throw new HubAutomationUncertainError("Worker admission was not confirmed; inspect results before resuming");
+            }
+            if (outcome.status === "workerExit")
+                throw new HubAutomationUncertainError("Worker exited before recording the automation outcome");
+            if (outcome.status === "error")
+                throw Error(outcome.error.message ?? "Automation Worker rejected the run");
+            const value = outcome.result;
+            if (request.signal?.aborted)
+                return;
+            if (value?.reason === "aborted_streaming" || value?.reason === "aborted_tools")
+                throw new HubAutomationCancelledError("Automation was cancelled");
+            if (value?.reason !== "completed")
+                throw Error(`Automation ended without completion (${value?.reason ?? "unknown"})`);
+        }
+        finally {
+            if (cancel)
+                request.signal?.removeEventListener("abort", cancel);
+            active.delete(sessionId);
+            release();
+        }
+    }
+    return { execute, handleApproval, ownsSession: (sessionId) => active.has(sessionId) };
+}

package/dist/serve/cli.d.ts

@@ -1,3 +1,4 @@
+import type { RemoteLinkConfiguration } from "@cjhyy/code-shell-core";
 interface CliArgs {
     cwd: string;
     host: string;
@@ -6,8 +7,10 @@ interface CliArgs {
     authMode: "hub" | "passcode";
     runtime: "local" | "docker";
     runtimeImage?: string;
+    runtimeSeccompProfile?: string;
     debugLogs?: boolean;
     publicOrigin?: string;
+    remoteLink?: RemoteLinkConfiguration;
     dataDir: string;
     staticRootDir?: string;
 }

package/dist/serve/cli.js

@@ -1,3 +1,4 @@
+import { remoteLinkFromEnvironment } from "../links/remote-configuration.js";
 // packages/server/src/serve/cli.ts
 //
 // `code-shell-serve` boots a single-workspace Hub under Node.js.
@@ -20,6 +21,7 @@ Options:
   --auth <mode>        hub (default) or legacy passcode
   --runtime <mode>     local (default) or Docker project sandboxes
   --runtime-image <tag> Prebuilt project image (default: codeshell-project-runtime:local)
+  --runtime-seccomp-profile <path> Administrator-owned Docker seccomp JSON
   --public-url <url>   External HTTPS origin for reverse-proxy deployments
   --passcode <code>    Set or rotate the legacy passcode (selects passcode mode)
   --data-dir <path>    Persistent server data (auth, uploads and worker sessions)
@@ -34,6 +36,7 @@ const VALUE_FLAGS = new Set([
     "--auth",
     "--runtime",
     "--runtime-image",
+    "--runtime-seccomp-profile",
     "--public-url",
     "--data-dir",
     "--static-root",
@@ -73,6 +76,10 @@ export function parseServeArgs(argv, env = process.env) {
         throw new Error("Docker projects require --auth hub");
     if (args["runtime-image"] && runtime !== "docker")
         throw new Error("--runtime-image requires --runtime docker");
+    if (args["runtime-seccomp-profile"] !== undefined && runtime !== "docker")
+        throw new Error("--runtime-seccomp-profile requires --runtime docker");
+    if (args["runtime-seccomp-profile"] === "")
+        throw new Error("Empty runtime seccomp profile");
     let publicOrigin;
     const publicUrl = args["public-url"] ?? env.CODE_SHELL_SERVE_PUBLIC_URL;
     if (publicUrl) {
@@ -88,10 +95,17 @@ export function parseServeArgs(argv, env = process.env) {
         }
         publicOrigin = url.origin;
     }
+    const remoteLink = remoteLinkFromEnvironment(env, publicOrigin);
+    if (remoteLink && authMode !== "hub")
+        throw new Error("Remote Link requires --auth hub");
     return {
         authMode,
+        ...(remoteLink ? { remoteLink } : {}),
         runtime,
         ...(args["runtime-image"] ? { runtimeImage: args["runtime-image"] } : {}),
+        ...(args["runtime-seccomp-profile"]
+            ? { runtimeSeccompProfile: resolve(args["runtime-seccomp-profile"]) }
+            : {}),
         ...(args["debug-logs"] ? { debugLogs: true } : {}),
         ...(publicOrigin ? { publicOrigin } : {}),
         cwd: resolve(args.cwd ?? process.cwd()),
@@ -143,8 +157,10 @@ export async function runServeCli(argv = process.argv.slice(2)) {
             port: parsed.port,
             dataDir: parsed.dataDir,
             publicOrigin: parsed.publicOrigin,
+            remoteLink: parsed.remoteLink,
             staticRootDir,
             runtimeImage: parsed.runtimeImage,
+            runtimeSeccompProfile: parsed.runtimeSeccompProfile,
         })
         : await startHeadlessServer({
             host: parsed.host,
@@ -152,6 +168,7 @@ export async function runServeCli(argv = process.argv.slice(2)) {
             cwd: parsed.cwd,
             dataDir: parsed.dataDir,
             authMode: parsed.authMode,
+            remoteLink: parsed.remoteLink,
             debugLogs: parsed.debugLogs,
             ...(parsed.publicOrigin ? { publicOrigin: parsed.publicOrigin } : {}),
             workerEntryPath: resolveWorkerEntry(),

package/dist/serve/headless-server.d.ts

@@ -1,3 +1,4 @@
+import type { RemoteLinkConfiguration } from "@cjhyy/code-shell-core";
 import { AccessPasscode } from "../mobile-remote/access-passcode.js";
 import { WorkerBridgeCore, type WorkerBridgeLog } from "../worker-bridge-core.js";
 export interface HeadlessServeOptions {
@@ -36,6 +37,8 @@ export interface HeadlessServeOptions {
     debugLogs?: boolean;
     /** Exact external origin; required for HTTPS reverse proxies. Never trust forwarded headers. */
     publicOrigin?: string;
+    /** Trusted deployment configuration; not a browser-supplied provider URL. */
+    remoteLink?: RemoteLinkConfiguration;
     /** Trusted project gateway prefix; generated by the controller, never a request parameter. */
     publicPathPrefix?: string;
     /** Session revocation/expiry sweep interval; defaults to 5 seconds. */

package/dist/serve/headless-server.js

@@ -1,3 +1,7 @@
+import { createHubPanelAutomationHost } from "../panels/hub-automations.js";
+import { createHubAutomationWorker } from "./automation-worker.js";
+import { remoteLinkHostConfiguration } from "../links/remote-configuration.js";
+import { describeEnvironment, environmentIdentity } from "../environment-identity.js";
 // packages/server/src/serve/headless-server.ts
 //
 // Single-workspace Node host. The CLI uses Hub administrator sessions; the
@@ -34,8 +38,12 @@ import { createPanelHttp } from "../panels/http.js";
 import { createHubPanelBinding } from "../panels/hub-binding.js";
 import { createHubSessions, hubSessionPreview, readHubSessionState, readHubTranscript, } from "../hub/session-management.js";
 import { createHubFiles } from "../hub/files.js";
+import { createSessionHttpResponses } from "../session-http-responses.js";
 import { WorkerBridgeCore, previewLine } from "../worker-bridge-core.js";
 export async function startHeadlessServer(opts) {
+    const remoteLink = remoteLinkHostConfiguration(opts.remoteLink, opts.publicOrigin);
+    if (remoteLink && opts.authMode !== "hub")
+        throw new Error("Remote Link requires Hub authentication.");
     const host = opts.host ?? "127.0.0.1";
     const log = (event, data) => {
         if (!opts.log)
@@ -45,6 +53,9 @@ export async function startHeadlessServer(opts) {
         const { raw: _raw, text: _text, ...metadata } = data ?? {};
         opts.log(event, opts.debugLogs ? data : metadata);
     };
+    const environment = opts.authMode === "hub"
+        ? describeEnvironment(await environmentIdentity(opts.dataDir), "hub")
+        : undefined;
     const workspaceCwd = resolve(opts.cwd);
     const panelBinding = opts.authMode === "hub" ? createHubPanelBinding(workspaceCwd) : undefined;
     const workerDataRoot = resolve(opts.workerDataRoot ??
@@ -72,6 +83,10 @@ export async function startHeadlessServer(opts) {
         generatedPasscode = randomBytes(6).toString("base64url");
         passcode.set(generatedPasscode);
     }
+    let closing = false;
+    const responses = createSessionHttpResponses();
+    let panelAutomations;
+    let automationWorker;
     const tabs = new Set();
     // Auth revocation callbacks are registered before configuration modules are ready.
     // eslint-disable-next-line prefer-const
@@ -88,6 +103,7 @@ export async function startHeadlessServer(opts) {
             dataDir: opts.dataDir,
             publicOrigin: opts.publicOrigin,
             onRevoke: (sessionId) => {
+                responses.cancelOwner(sessionId);
                 mcp?.cancelOwner(sessionId);
                 configuration?.cancelOwner(sessionId);
                 links?.cancelOwner(sessionId);
@@ -112,7 +128,7 @@ export async function startHeadlessServer(opts) {
     let configurationChanging = false;
     let configurationReloadFailed = false;
     const runUploads = new Map();
-    const isRunning = (sessionId) => [...runningSessions.values()].includes(sessionId);
+    const isRunning = (sessionId) => [...runningSessions.values()].includes(sessionId) || !!automationWorker?.ownsSession(sessionId);
     let nextTabId = 1;
     let nextWorkerRequestId = 1;
     const outbound = new HubOutboundTransport({
@@ -254,23 +270,35 @@ export async function startHeadlessServer(opts) {
                 if (approval &&
                     typeof approval.requestId === "string" &&
                     typeof approval.sessionId === "string") {
+                    if (automationWorker?.handleApproval(approval))
+                        return;
                     const request = approval.request;
                     if (request?.toolName === "__panel_action__") {
                         const ownerId = runOwners.get(approval.sessionId);
                         const result = ownerId && panels
                             ? panels.panelAction(ownerId, approval.sessionId, request.args ?? {})
                             : Promise.resolve({ ok: false, detail: "当前对话没有可用的面板连接。" });
-                        void result.catch(() => ({ ok: false, detail: "面板操作未完成。" })).then((answer) => {
+                        void result
+                            .catch(() => ({ ok: false, detail: "面板操作未完成。" }))
+                            .then((answer) => {
                             if (!isRunning(approval.sessionId) || runOwners.get(approval.sessionId) !== ownerId)
                                 return;
                             return bridge.request("agent/approve", {
-                                sessionId: approval.sessionId, requestId: approval.requestId,
-                                connectionId: approval.connectionId, generation: approval.generation,
+                                sessionId: approval.sessionId,
+                                requestId: approval.requestId,
+                                connectionId: approval.connectionId,
+                                generation: approval.generation,
                                 decision: { approved: true, answer: JSON.stringify(answer) },
-                            }, { id: `panel-reply-${randomUUID()}`, consume: true, settleOnExit: true, failFast: true, timeoutMs: 5000,
+                            }, {
+                                id: `panel-reply-${randomUUID()}`,
+                                consume: true,
+                                settleOnExit: true,
+                                failFast: true,
+                                timeoutMs: 5000,
                                 meta: { origin: "host", producer: "hub-panel-action" },
                             });
-                        }).catch(() => { });
+                        })
+                            .catch(() => { });
                         return;
                     }
                     try {
@@ -346,6 +374,7 @@ export async function startHeadlessServer(opts) {
         fallbackCwd: () => opts.cwd,
         buildEnv: () => ({
             ...process.env,
+            CODE_SHELL_REMOTE_LINK_CLIENT_SECRET: undefined,
             CODE_SHELL_DATA_ROOT: workerDataRoot,
             CODE_SHELL_CREDENTIAL_ACCESS: "local",
             ...(opts.workerCapabilityModules
@@ -377,6 +406,7 @@ export async function startHeadlessServer(opts) {
             preparingRuns > 0 ||
             runningSessions.size > 0 ||
             (panels?.activeTaskCount() ?? 0) > 0 ||
+            (panelAutomations?.activeCount() ?? 0) > 0 ||
             pendingWorkerResponses.size > 0) {
             throw new HubConfigurationError(409, "请等待当前任务完成后再保存配置。");
         }
@@ -420,6 +450,7 @@ export async function startHeadlessServer(opts) {
     links = hubAuth
         ? createLinkHttp({
             ...configurationOptions,
+            remoteLink: () => remoteLink,
             onChanged: () => notify("serve/configurationChanged", {}),
         })
         : undefined;
@@ -429,14 +460,25 @@ export async function startHeadlessServer(opts) {
             ...panelBinding,
             dataDir: opts.dataDir,
             host: "hub",
+            automations: {
+                conditionalMutations: true,
+                call: (scope, method, params) => {
+                    if (!panelAutomations || closing)
+                        throw Error("Cloud automations are unavailable");
+                    return panelAutomations.host.call(scope, method, params);
+                },
+            },
             publicPathPrefix: opts.publicPathPrefix,
             agentTaskOptions: {
                 workerEntryPath: opts.workerEntryPath,
                 buildEnv: () => ({
                     ...process.env,
+                    CODE_SHELL_REMOTE_LINK_CLIENT_SECRET: undefined,
                     CODE_SHELL_DATA_ROOT: workerDataRoot,
                     CODE_SHELL_CREDENTIAL_ACCESS: "local",
-                    ...(opts.workerCapabilityModules ? { CODE_SHELL_CAPABILITY_MODULES: opts.workerCapabilityModules } : {}),
+                    ...(opts.workerCapabilityModules
+                        ? { CODE_SHELL_CAPABILITY_MODULES: opts.workerCapabilityModules }
+                        : {}),
                 }),
             },
             onChanged: () => notify("serve/configurationChanged", {}),
@@ -535,6 +577,15 @@ export async function startHeadlessServer(opts) {
                     hubJson(res, 403, { error: "origin rejected" });
                     return;
                 }
+                if (closing) {
+                    hubJson(res, 503, { error: "server is closing" });
+                    return;
+                }
+                responses.track(session.id, res);
+                if (pathname === "/api/v1/environment" && req.method === "GET") {
+                    hubJson(res, 200, environment);
+                    return;
+                }
                 if (await configuration.handle(req, res))
                     return;
                 if (await links.handle(req, res))
@@ -616,6 +667,10 @@ export async function startHeadlessServer(opts) {
                     ws.close(1009, "payload too large");
                     return;
                 }
+                if (closing) {
+                    ws.close(1012, "server stopping");
+                    return;
+                }
                 const line = String(data);
                 // Validate framing before touching the worker: a malformed frame from
                 // one tab must never kill the shared pipe.
@@ -798,7 +853,8 @@ export async function startHeadlessServer(opts) {
                             const runSession = workerMessage.params?.sessionId;
                             const ownerId = tabAuth.get(ws)?.sessionId;
                             const activeOwner = typeof runSession === "string" ? runOwners.get(runSession) : undefined;
-                            if (activeOwner && activeOwner !== ownerId) {
+                            if ((activeOwner && activeOwner !== ownerId) ||
+                                (typeof runSession === "string" && automationWorker?.ownsSession(runSession))) {
                                 sendToTab(ws, hostQueryError(workerMessage.id, -32009, "此对话正在另一台设备运行，请等待完成后再发送。"), "run-owner");
                                 return;
                             }
@@ -900,6 +956,69 @@ export async function startHeadlessServer(opts) {
         void upgrade(req, socket, head).catch(() => socket.destroy());
     });
     try {
+        if (hubAuth) {
+            automationWorker = createHubAutomationWorker({
+                bridge,
+                cwd: workspaceCwd,
+                model: () => new SettingsManager(workspaceCwd, "full").get().defaults.text,
+                reserve: (job, requestId) => {
+                    if (closing || configurationChanging || configurationReloadFailed || preparingRuns > 0)
+                        throw Error("Project configuration or run preparation is busy");
+                    const sessionId = job.resumeSessionId;
+                    if (isRunning(sessionId) || runningSessions.size >= 64)
+                        throw Error("The automation Session is busy; this occurrence was not dispatched");
+                    if (resolve(readHubSessionState(sessionRootDir, sessionId).cwd) !== workspaceCwd)
+                        throw Error("Automation Session changed workspace");
+                    const baseline = readHubTranscript(sessionRootDir, sessionId).length;
+                    runningSessions.set(requestId, sessionId);
+                    runOwners.set(sessionId, requestId);
+                    runReplay.begin(sessionId, requestId, baseline);
+                    runInputs.set(requestId, {
+                        sessionId,
+                        echoed: false,
+                        event: {
+                            type: "session_user_message",
+                            text: job.prompt,
+                            clientMessageId: requestId,
+                            attachments: [],
+                        },
+                    });
+                    notify("serve/sessionStatus", { sessionId, running: true });
+                    return () => {
+                        runningSessions.delete(requestId);
+                        runInputs.delete(requestId);
+                        if (runOwners.get(sessionId) === requestId)
+                            runOwners.delete(sessionId);
+                        runReplay.finish(sessionId, requestId);
+                        notify("serve/sessionStatus", { sessionId, running: isRunning(sessionId) });
+                    };
+                },
+            });
+            panelAutomations = createHubPanelAutomationHost({
+                cwd: workspaceCwd,
+                bindingCwd: panelBinding?.bindingCwd,
+                dataDir: opts.dataDir,
+                sessionRootDir,
+                assertExecutable: async (job) => {
+                    panelBinding?.assertBinding();
+                    const panel = (await panels.service.snapshot()).panels.find((app) => app.id === job.panelSource?.appId);
+                    panelBinding?.assertBinding();
+                    if (!panel?.enabled ||
+                        panel.revision !== job.panelSource?.revision ||
+                        !["automations.manage", "context.workspace", "context.session"].every((permission) => panel.permissions.includes(permission)))
+                        throw Error("The Panel package or automation permission is no longer authorized");
+                },
+                execute: (request) => automationWorker.execute(request),
+                onJobEvent: (event) => notify("serve/automationStatus", {
+                    type: event.type,
+                    jobId: event.job.id,
+                    sessionId: event.job.resumeSessionId,
+                    appId: event.job.panelSource?.appId,
+                    ...("reason" in event ? { reason: event.reason } : {}),
+                    ...("error" in event ? { error: event.error } : {}),
+                }),
+            });
+        }
         await new Promise((resolve, reject) => {
             server.once("error", reject);
             server.listen(opts.port ?? 8790, host, () => {
@@ -909,6 +1028,9 @@ export async function startHeadlessServer(opts) {
         });
     }
     catch (error) {
+        closing = true;
+        responses.clear();
+        await panelAutomations?.close();
         clearInterval(pendingResponseReaper);
         if (authReaper)
             clearInterval(authReaper);
@@ -919,7 +1041,7 @@ export async function startHeadlessServer(opts) {
         links?.close();
         await panels?.close();
         files?.close();
-        bridge.kill();
+        await bridge.stopAndWait();
         wss.close();
         server.close();
         throw error;
@@ -939,6 +1061,9 @@ export async function startHeadlessServer(opts) {
         tabCount: () => tabs.size,
         pendingResponseCount: () => pendingWorkerResponses.size,
         close: async () => {
+            closing = true;
+            responses.clear();
+            await panelAutomations?.close();
             clearInterval(pendingResponseReaper);
             if (authReaper)
                 clearInterval(authReaper);
@@ -958,7 +1083,7 @@ export async function startHeadlessServer(opts) {
                 }
             }
             tabs.clear();
-            bridge.kill();
+            await bridge.stopAndWait();
             await new Promise((resolve) => {
                 wss.close(() => {
                     server.close(() => resolve());
@@ -1077,6 +1202,11 @@ function authorizeServeRequest(message, sessionManager, workspaceCwd, isRunning
     if (!message.method || !SERVE_ALLOWED_WORKER_METHODS.has(message.method)) {
         return hostQueryError(message.id ?? null, -32601, "Method is not available in Web serve mode");
     }
+    if (message.method === "agent/run" &&
+        (Object.hasOwn(message.params ?? {}, "sandboxMode") ||
+            Object.hasOwn(message.params ?? {}, "allowBackgroundShells"))) {
+        return hostQueryError(message.id ?? null, -32602, "Execution policy is selected by the host");
+    }
     const rawSessionId = message.params?.sessionId;
     const sessionId = typeof rawSessionId === "string" && rawSessionId.length > 0 ? rawSessionId : null;
     if (message.method === "agent/run" && sessionId === null)

package/dist/serve/settings-recovery-cli.d.ts

@@ -0,0 +1,29 @@
+import type { RecoveryScope } from "@cjhyy/code-shell-core/internal";
+type RecoveryArguments = {
+    action: "help";
+} | {
+    action: "inspect";
+    cwd: string;
+    scope: RecoveryScope;
+    candidatePath?: string;
+} | {
+    action: "repair";
+    cwd: string;
+    scope: RecoveryScope;
+    candidatePath: string;
+    expectedRevision: string;
+    candidateSha256: string;
+} | {
+    action: "restore";
+    cwd: string;
+    scope: RecoveryScope;
+    backupId: string;
+    expectedRevision: string;
+};
+export declare function parseSettingsRecoveryArgs(argv: string[], cwd: () => string): RecoveryArguments;
+export declare function runSettingsRecoveryCli(argv?: string[], io?: {
+    cwd?: () => string;
+    write?: (text: string) => void;
+    error?: (text: string) => void;
+}): Promise<number>;
+export {};