@aria-cli/cli 1.0.50 → 1.0.51

package/dist/headless/auth-orchestrator.js

@@ -0,0 +1,508 @@
+import { randomUUID } from "node:crypto";
+import { buildAuthorizeUrl, completeGitHubCopilotDeviceFlow, exchangeCodeForTokens, generatePkce, generateState, getOAuthConfig, requestGitHubCopilotDeviceCode, upsertAuthProfile, } from "@aria-cli/auth";
+function failureFrame(requestId, op, code, message, details) {
+    return {
+        kind: "result",
+        requestId,
+        op,
+        ok: false,
+        error: {
+            code,
+            message,
+            ...(details ? { details } : {}),
+        },
+    };
+}
+function successFrame(requestId, op, result) {
+    return {
+        kind: "result",
+        requestId,
+        op,
+        ok: true,
+        result,
+    };
+}
+function providerSelectionOptions(providers) {
+    return providers.map((provider) => ({
+        id: provider.id,
+        label: provider.label,
+        ...(provider.email || provider.status
+            ? { description: [provider.status, provider.email].filter(Boolean).join(" · ") }
+            : {}),
+    }));
+}
+function methodSelectionOptions(options) {
+    return options.map((option) => ({
+        id: option.id,
+        label: option.label,
+        ...(option.description || option.status
+            ? { description: [option.description, option.status].filter(Boolean).join(" · ") }
+            : {}),
+    }));
+}
+function interactionDetails(frame) {
+    return {
+        interactionId: frame.interactionId,
+        source: frame.source,
+        interaction: frame.interaction,
+    };
+}
+function interactionRecordPrompt(interaction, pending) {
+    return {
+        ...interaction,
+        __authPending: pending,
+    };
+}
+function pendingFromPrompt(prompt) {
+    const candidate = prompt.__authPending;
+    if (!candidate || typeof candidate !== "object") {
+        return null;
+    }
+    return candidate;
+}
+export class HeadlessAuthOrchestrator {
+    auth;
+    sessionLedger;
+    getActiveArionName;
+    constructor(auth, sessionLedger, getActiveArionName) {
+        this.auth = auth;
+        this.sessionLedger = sessionLedger;
+        this.getActiveArionName = getActiveArionName;
+    }
+    async *login(requestId, input, context) {
+        if (!this.auth?.login || !this.auth.status) {
+            yield failureFrame(requestId, "auth.login", "MISSING_SERVICE", "Kernel service auth is not configured for auth.login.");
+            return;
+        }
+        const result = (await this.auth.login(input));
+        yield* this.framesForInitialLoginResult(requestId, "auth.login", result, context);
+    }
+    async *logout(requestId, input) {
+        if (!this.auth?.logout) {
+            yield failureFrame(requestId, "auth.logout", "MISSING_SERVICE", "Kernel service auth is not configured for auth.logout.");
+            return;
+        }
+        const result = (await this.auth.logout(input));
+        if (result.mode === "direct") {
+            if (result.result.success) {
+                yield successFrame(requestId, "auth.logout", result.result);
+                return;
+            }
+            yield failureFrame(requestId, "auth.logout", "AUTH_LOGOUT_FAILED", result.result.message);
+            return;
+        }
+        const interaction = await this.persistNewInteraction(requestId, {
+            pending: { type: "logout-provider" },
+            interaction: {
+                kind: "selection",
+                prompt: "Choose a provider to disconnect.",
+                options: providerSelectionOptions(result.providers),
+            },
+        });
+        yield interaction;
+        yield failureFrame(requestId, "auth.logout", "INTERACTION_REQUIRED", "auth.logout requires additional interaction before it can continue.", interactionDetails(interaction));
+    }
+    async *respond(response, context) {
+        const interactionRecord = this.sessionLedger.getInteraction(response.interactionId);
+        if (!interactionRecord || interactionRecord.source !== "auth") {
+            yield failureFrame(response.requestId, "interaction.respond", "INTERACTION_NOT_FOUND", `Unknown interaction ${response.interactionId}`);
+            return;
+        }
+        const pending = pendingFromPrompt(interactionRecord.prompt);
+        if (!pending) {
+            yield failureFrame(response.requestId, "interaction.respond", "INVALID_INTERACTION_STATE", `Interaction ${response.interactionId} is missing auth resume state.`);
+            return;
+        }
+        const ownerId = `auth:${response.requestId}`;
+        const claimed = this.sessionLedger.claimSessionForMutation(interactionRecord.sessionId, ownerId, 30_000);
+        let released = false;
+        const release = () => {
+            if (released) {
+                return;
+            }
+            released = true;
+            this.sessionLedger.releaseSessionClaim(interactionRecord.sessionId, ownerId);
+        };
+        try {
+            if (response.response.kind === "cancel") {
+                this.sessionLedger.cancelInteraction(interactionRecord.sessionId, interactionRecord.interactionId, {
+                    ownerId,
+                    expectedRevision: claimed.revision,
+                });
+                release();
+                yield failureFrame(response.requestId, "interaction.respond", "INTERACTION_CANCELED", "Interaction canceled.");
+                return;
+            }
+            switch (pending.type) {
+                case "login-provider": {
+                    if (response.response.kind !== "selection") {
+                        release();
+                        yield failureFrame(response.requestId, "interaction.respond", "INVALID_INTERACTION_RESPONSE", "Provider selection requires a selection response.");
+                        return;
+                    }
+                    const result = (await this.auth?.login?.({
+                        args: response.response.selected,
+                    }));
+                    this.sessionLedger.recordInteractionResponse(interactionRecord.sessionId, interactionRecord.interactionId, response.response, {
+                        ownerId,
+                        expectedRevision: claimed.revision,
+                    });
+                    yield* this.framesForContinuedLoginResult(response.requestId, result, interactionRecord.sessionId, ownerId, claimed.revision + 1, context);
+                    return;
+                }
+                case "logout-provider": {
+                    if (response.response.kind !== "selection") {
+                        release();
+                        yield failureFrame(response.requestId, "interaction.respond", "INVALID_INTERACTION_RESPONSE", "Provider selection requires a selection response.");
+                        return;
+                    }
+                    const result = (await this.auth?.logout?.({
+                        args: response.response.selected,
+                    }));
+                    this.sessionLedger.recordInteractionResponse(interactionRecord.sessionId, interactionRecord.interactionId, response.response, {
+                        ownerId,
+                        expectedRevision: claimed.revision,
+                    });
+                    this.sessionLedger.completeRun(interactionRecord.sessionId, {
+                        success: result.mode === "direct" ? result.result.success : false,
+                        message: result.mode === "direct"
+                            ? result.result.message
+                            : "auth.logout requires additional interaction.",
+                    }, {
+                        ownerId,
+                        expectedRevision: claimed.revision + 1,
+                    });
+                    release();
+                    if (result.mode === "direct" && result.result.success) {
+                        yield successFrame(response.requestId, "interaction.respond", result.result);
+                        return;
+                    }
+                    yield failureFrame(response.requestId, "interaction.respond", "AUTH_LOGOUT_FAILED", result.mode === "direct" ? result.result.message : "auth.logout requires interaction.");
+                    return;
+                }
+                case "login-method": {
+                    if (response.response.kind !== "selection") {
+                        release();
+                        yield failureFrame(response.requestId, "interaction.respond", "INVALID_INTERACTION_RESPONSE", "Method selection requires a selection response.");
+                        return;
+                    }
+                    const result = (await this.auth?.login?.({
+                        args: `${pending.provider} --method ${response.response.selected}`,
+                    }));
+                    this.sessionLedger.recordInteractionResponse(interactionRecord.sessionId, interactionRecord.interactionId, response.response, {
+                        ownerId,
+                        expectedRevision: claimed.revision,
+                    });
+                    yield* this.framesForContinuedLoginResult(response.requestId, result, interactionRecord.sessionId, ownerId, claimed.revision + 1, context);
+                    return;
+                }
+                case "copilot-source": {
+                    if (response.response.kind !== "selection") {
+                        release();
+                        yield failureFrame(response.requestId, "interaction.respond", "INVALID_INTERACTION_RESPONSE", "GitHub Copilot source selection requires a selection response.");
+                        return;
+                    }
+                    const result = (await this.auth?.login?.({
+                        args: `github-copilot --from ${response.response.selected}`,
+                    }));
+                    this.sessionLedger.recordInteractionResponse(interactionRecord.sessionId, interactionRecord.interactionId, response.response, {
+                        ownerId,
+                        expectedRevision: claimed.revision,
+                    });
+                    yield* this.framesForContinuedLoginResult(response.requestId, result, interactionRecord.sessionId, ownerId, claimed.revision + 1, context);
+                    return;
+                }
+                case "credential-input": {
+                    if (response.response.kind !== "credential_input") {
+                        release();
+                        yield failureFrame(response.requestId, "interaction.respond", "INVALID_INTERACTION_RESPONSE", "Credential input requires a credential_input response.");
+                        return;
+                    }
+                    const value = response.response.values[pending.fieldKey];
+                    if (typeof value !== "string" || value.trim().length === 0) {
+                        release();
+                        yield failureFrame(response.requestId, "interaction.respond", "INVALID_INTERACTION_RESPONSE", `Missing credential field ${pending.fieldKey}.`);
+                        return;
+                    }
+                    const result = (await this.auth?.login?.({
+                        args: `${pending.commandPrefix} ${value.trim()}`.trim(),
+                    }));
+                    this.sessionLedger.recordInteractionResponse(interactionRecord.sessionId, interactionRecord.interactionId, response.response, {
+                        ownerId,
+                        expectedRevision: claimed.revision,
+                    });
+                    yield* this.framesForContinuedLoginResult(response.requestId, result, interactionRecord.sessionId, ownerId, claimed.revision + 1, context);
+                    return;
+                }
+                case "oauth-code": {
+                    if (response.response.kind !== "credential_input") {
+                        release();
+                        yield failureFrame(response.requestId, "interaction.respond", "INVALID_INTERACTION_RESPONSE", "OAuth code entry requires a credential_input response.");
+                        return;
+                    }
+                    const code = response.response.values[pending.fieldKey];
+                    if (typeof code !== "string" || code.trim().length === 0) {
+                        release();
+                        yield failureFrame(response.requestId, "interaction.respond", "INVALID_INTERACTION_RESPONSE", `Missing credential field ${pending.fieldKey}.`);
+                        return;
+                    }
+                    this.sessionLedger.recordInteractionResponse(interactionRecord.sessionId, interactionRecord.interactionId, response.response, {
+                        ownerId,
+                        expectedRevision: claimed.revision,
+                    });
+                    const exchanged = await exchangeCodeForTokens(pending.provider, code.trim(), pending.codeVerifier);
+                    upsertAuthProfile({
+                        profileId: `${pending.provider}:oauth`,
+                        credential: {
+                            type: "oauth",
+                            provider: pending.provider,
+                            access: exchanged.access,
+                            refresh: exchanged.refresh,
+                            expires: exchanged.expires,
+                        },
+                    });
+                    this.sessionLedger.completeRun(interactionRecord.sessionId, { success: true, message: `Logged in to ${pending.provider} successfully` }, {
+                        ownerId,
+                        expectedRevision: claimed.revision + 1,
+                    });
+                    release();
+                    yield successFrame(response.requestId, "interaction.respond", {
+                        success: true,
+                        message: `Logged in to ${pending.provider} successfully`,
+                    });
+                    return;
+                }
+                case "copilot-device": {
+                    if (response.response.kind !== "oauth_device") {
+                        release();
+                        yield failureFrame(response.requestId, "interaction.respond", "INVALID_INTERACTION_RESPONSE", "GitHub Copilot device flow requires an oauth_device response.");
+                        return;
+                    }
+                    this.sessionLedger.recordInteractionResponse(interactionRecord.sessionId, interactionRecord.interactionId, response.response, {
+                        ownerId,
+                        expectedRevision: claimed.revision,
+                    });
+                    const result = await completeGitHubCopilotDeviceFlow({
+                        deviceCode: pending.deviceCode,
+                        profileLabel: pending.profileLabel,
+                        signal: context?.signal,
+                    });
+                    this.sessionLedger.completeRun(interactionRecord.sessionId, result, {
+                        ownerId,
+                        expectedRevision: claimed.revision + 1,
+                    });
+                    release();
+                    if (result.success) {
+                        yield successFrame(response.requestId, "interaction.respond", result);
+                        return;
+                    }
+                    yield failureFrame(response.requestId, "interaction.respond", "AUTH_LOGIN_FAILED", result.message);
+                    return;
+                }
+            }
+        }
+        catch (error) {
+            release();
+            yield failureFrame(response.requestId, "interaction.respond", "AUTH_INTERACTION_FAILED", error instanceof Error ? error.message : String(error));
+        }
+    }
+    async *framesForInitialLoginResult(requestId, op, result, context) {
+        if (result.mode === "direct") {
+            if (result.result.success) {
+                yield successFrame(requestId, op, result.result);
+                return;
+            }
+            yield failureFrame(requestId, op, "AUTH_LOGIN_FAILED", result.result.message);
+            return;
+        }
+        const spec = await this.buildLoginInteractionSpec(result, context);
+        const interaction = await this.persistNewInteraction(requestId, spec);
+        yield interaction;
+        yield failureFrame(requestId, op, "INTERACTION_REQUIRED", "auth.login requires additional interaction before it can continue.", interactionDetails(interaction));
+    }
+    async *framesForContinuedLoginResult(requestId, result, sessionId, ownerId, expectedRevision, context) {
+        if (result.mode === "direct") {
+            this.sessionLedger.completeRun(sessionId, result.result, {
+                ownerId,
+                expectedRevision,
+            });
+            this.sessionLedger.releaseSessionClaim(sessionId, ownerId);
+            if (result.result.success) {
+                yield successFrame(requestId, "interaction.respond", result.result);
+                return;
+            }
+            yield failureFrame(requestId, "interaction.respond", "AUTH_LOGIN_FAILED", result.result.message);
+            return;
+        }
+        const spec = await this.buildLoginInteractionSpec(result, context);
+        const interaction = this.persistContinuedInteraction(requestId, spec, sessionId, ownerId, expectedRevision);
+        yield interaction;
+        yield failureFrame(requestId, "interaction.respond", "INTERACTION_REQUIRED", "auth.login requires additional interaction before it can continue.", interactionDetails(interaction));
+    }
+    async buildLoginInteractionSpec(result, context) {
+        switch (result.mode) {
+            case "picker":
+                return {
+                    pending: { type: "login-provider" },
+                    interaction: {
+                        kind: "selection",
+                        prompt: "Choose a provider to sign in with.",
+                        options: providerSelectionOptions(result.providers),
+                    },
+                };
+            case "anthropic_method_picker":
+            case "openai_method_picker":
+            case "google_method_picker":
+                return {
+                    pending: { type: "login-method", provider: result.provider },
+                    interaction: {
+                        kind: "selection",
+                        prompt: `Choose how to sign in to ${result.provider}.`,
+                        options: methodSelectionOptions(result.options),
+                    },
+                };
+            case "copilot_source_picker":
+                return {
+                    pending: { type: "copilot-source" },
+                    interaction: {
+                        kind: "selection",
+                        prompt: "Choose a GitHub Copilot credential source.",
+                        options: methodSelectionOptions(result.options),
+                    },
+                };
+            case "anthropic_key_input":
+            case "openai_key_input":
+            case "google_key_input":
+                return {
+                    pending: {
+                        type: "credential-input",
+                        commandPrefix: result.provider,
+                        fieldKey: "apiKey",
+                    },
+                    interaction: {
+                        kind: "credential_input",
+                        prompt: `Enter the API key for ${result.provider}.`,
+                        provider: result.provider,
+                        fields: [this.secretField("apiKey", `${result.provider} API key`)],
+                    },
+                };
+            case "anthropic_setup_token":
+                return {
+                    pending: {
+                        type: "credential-input",
+                        commandPrefix: "anthropic --setup-token",
+                        fieldKey: "setupToken",
+                    },
+                    interaction: {
+                        kind: "credential_input",
+                        prompt: "Enter the Anthropic setup token.",
+                        provider: "anthropic",
+                        fields: [this.secretField("setupToken", "Anthropic setup token")],
+                    },
+                };
+            case "oauth": {
+                const { codeVerifier, codeChallenge } = generatePkce();
+                const config = getOAuthConfig(result.provider);
+                const state = config.redirectUri.startsWith("http://127.0.0.1")
+                    ? generateState()
+                    : codeVerifier;
+                const authorizeUrl = buildAuthorizeUrl(result.provider, codeChallenge, state);
+                return {
+                    pending: {
+                        type: "oauth-code",
+                        provider: result.provider,
+                        fieldKey: "authorizationCode",
+                        codeVerifier,
+                    },
+                    interaction: {
+                        kind: "credential_input",
+                        prompt: `Sign in to ${result.provider} to continue.`,
+                        provider: result.provider,
+                        mode: "oauth_authorization_code",
+                        authorizeUrl,
+                        callbackMode: config.redirectUri.startsWith("http://127.0.0.1")
+                            ? "local_callback"
+                            : "manual_code",
+                        ...(config.redirectUri.startsWith("http://127.0.0.1") ? { expectedState: state } : {}),
+                        fields: [
+                            {
+                                key: "authorizationCode",
+                                label: "Authorization code",
+                            },
+                        ],
+                    },
+                };
+            }
+            case "copilot_device": {
+                const deviceCode = await requestGitHubCopilotDeviceCode({
+                    signal: context?.signal,
+                });
+                return {
+                    pending: {
+                        type: "copilot-device",
+                        profileLabel: result.profileLabel,
+                        deviceCode,
+                    },
+                    interaction: {
+                        kind: "oauth_device",
+                        prompt: result.message ??
+                            "Open the verification URL, enter the device code, then confirm to continue.",
+                        provider: "github-copilot",
+                        ...(result.profileLabel ? { profileLabel: result.profileLabel } : {}),
+                        verificationUri: deviceCode.verificationUri,
+                        userCode: deviceCode.userCode,
+                        expiresAt: new Date(deviceCode.expiresAt).toISOString(),
+                        intervalSeconds: Math.ceil(deviceCode.intervalMs / 1000),
+                    },
+                };
+            }
+        }
+    }
+    async persistNewInteraction(requestId, spec) {
+        const sessionId = `auth:${randomUUID()}`;
+        if (!this.sessionLedger.loadSession(sessionId)) {
+            this.sessionLedger.createSession(await this.getActiveArionName(), "auth", sessionId);
+        }
+        const ownerId = `auth:${requestId}`;
+        const claimed = this.sessionLedger.claimSessionForMutation(sessionId, ownerId, 30_000);
+        try {
+            return this.persistInteractionRecord(requestId, sessionId, ownerId, claimed.revision, spec.pending, spec.interaction);
+        }
+        finally {
+            this.sessionLedger.releaseSessionClaim(sessionId, ownerId);
+        }
+    }
+    persistContinuedInteraction(requestId, spec, sessionId, ownerId, expectedRevision) {
+        const frame = this.persistInteractionRecord(requestId, sessionId, ownerId, expectedRevision, spec.pending, spec.interaction);
+        this.sessionLedger.releaseSessionClaim(sessionId, ownerId);
+        return frame;
+    }
+    persistInteractionRecord(requestId, sessionId, ownerId, expectedRevision, pending, interaction) {
+        const interactionId = `auth:${randomUUID()}`;
+        this.sessionLedger.recordPausedRun(sessionId, `auth:${sessionId}`, { kind: "auth" }, { kind: "auth" }, {
+            interactionId,
+            requestId,
+            source: "auth",
+            kind: interaction.kind,
+            prompt: interactionRecordPrompt(interaction, pending),
+        }, {
+            ownerId,
+            expectedRevision,
+        });
+        return {
+            kind: "interaction.required",
+            requestId,
+            interactionId,
+            source: "auth",
+            interaction,
+        };
+    }
+    secretField(key, label) {
+        return {
+            key,
+            label,
+            secret: true,
+        };
+    }
+}
+//# sourceMappingURL=auth-orchestrator.js.map

package/dist/headless/auth-service.js

@@ -0,0 +1,43 @@
+import { getProviderOptions, handleLoginCommand, } from "../commands/login-handler.js";
+import { handleLogoutCommand } from "../commands/logout-handler.js";
+export function getHeadlessAuthProviders() {
+    return getProviderOptions();
+}
+export async function runHeadlessLogin(args) {
+    return handleLoginCommand(args);
+}
+export function runHeadlessLogout(args) {
+    return handleLogoutCommand(args);
+}
+export function buildStructuredLoginArgs(input) {
+    if (typeof input.args === "string" && input.args.trim().length > 0) {
+        return input.args.trim();
+    }
+    const args = [];
+    if (typeof input.provider === "string" && input.provider.trim().length > 0) {
+        args.push(input.provider.trim());
+    }
+    if (typeof input.method === "string" && input.method.trim().length > 0) {
+        args.push(input.method.trim());
+    }
+    if (typeof input.source === "string" && input.source.trim().length > 0) {
+        args.push("--source", input.source.trim());
+    }
+    if (typeof input.profileLabel === "string" && input.profileLabel.trim().length > 0) {
+        args.push("--profile", input.profileLabel.trim());
+    }
+    if (typeof input.credential === "string" && input.credential.trim().length > 0) {
+        args.push(input.credential.trim());
+    }
+    return args.join(" ");
+}
+export function buildStructuredLogoutArgs(input) {
+    if (typeof input.args === "string" && input.args.trim().length > 0) {
+        return input.args.trim();
+    }
+    if (typeof input.provider === "string" && input.provider.trim().length > 0) {
+        return input.provider.trim();
+    }
+    return "";
+}
+//# sourceMappingURL=auth-service.js.map

package/dist/headless/bootstrap-fast-path.js

@@ -0,0 +1,112 @@
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+import { buildSessionListResult, buildSessionLoadResult, buildSessionReadResult, } from "./operations/session.js";
+import { SessionHistory } from "../history/index.js";
+import { cliStallPhase } from "../history/stall-phase-bridge.js";
+function missingResult(requestId, operation) {
+    return {
+        kind: "result",
+        requestId,
+        op: operation,
+        ok: false,
+        error: {
+            code: "NO_RESULT",
+            message: `Operation ${operation} produced no result frame`,
+        },
+    };
+}
+export function resolveAriaHome(override) {
+    if (override?.trim()) {
+        return override.trim();
+    }
+    if (process.env.ARIA_HOME) {
+        return process.env.ARIA_HOME;
+    }
+    return path.join(process.env.HOME || homedir(), ".aria");
+}
+export function resolveBootstrapArionName(options = {}) {
+    const ariaHome = resolveAriaHome(options.ariaHome);
+    const requestedName = options.arionName?.trim();
+    if (requestedName) {
+        return resolveCanonicalArionName(ariaHome, requestedName);
+    }
+    const configPath = path.join(ariaHome, "config.json");
+    if (!existsSync(configPath)) {
+        return "ARIA";
+    }
+    try {
+        const raw = JSON.parse(readFileSync(configPath, "utf8"));
+        if (typeof raw.activeArion === "string" && raw.activeArion.trim().length > 0) {
+            return resolveCanonicalArionName(ariaHome, raw.activeArion.trim());
+        }
+    }
+    catch {
+        // Fall back to the default Arion name when config is unreadable.
+    }
+    return "ARIA";
+}
+export function resolveCanonicalArionName(ariaHome, requestedName) {
+    const trimmed = requestedName.trim();
+    if (!trimmed) {
+        return "ARIA";
+    }
+    const arionsDir = path.join(ariaHome, "arions");
+    if (!existsSync(arionsDir)) {
+        return trimmed;
+    }
+    try {
+        const target = trimmed.toLowerCase();
+        for (const entry of readdirSync(arionsDir, { withFileTypes: true })) {
+            if (entry.isDirectory() && entry.name.toLowerCase() === target) {
+                return entry.name;
+            }
+        }
+    }
+    catch {
+        // Fall back to the caller-provided spelling when discovery fails.
+    }
+    return trimmed;
+}
+export function runBootstrapSessionOperation(requestId, operation, input, options = {}) {
+    const ariaHome = resolveAriaHome(options.ariaHome);
+    const arionName = resolveBootstrapArionName({
+        ariaHome,
+        arionName: options.arionName,
+    });
+    const sessionLedger = new SessionHistory(SessionHistory.resolvePerArionPath(ariaHome, arionName), {
+        stallPhase: cliStallPhase,
+    });
+    try {
+        switch (operation) {
+            case "session.list":
+                return buildSessionListResult(requestId, sessionLedger, input);
+            case "session.read":
+                return buildSessionReadResult(requestId, sessionLedger, input);
+            case "session.load":
+                return buildSessionLoadResult(requestId, sessionLedger, input);
+            default:
+                return missingResult(requestId, operation);
+        }
+    }
+    finally {
+        sessionLedger.close();
+    }
+}
+export function runBootstrapSystemRestart(requestId, input) {
+    const reason = typeof input.reason === "string" &&
+        input.reason.trim().length > 0
+        ? input.reason.trim()
+        : "Restart requested";
+    return {
+        kind: "result",
+        requestId,
+        op: "system.restart",
+        ok: true,
+        result: {
+            accepted: true,
+            reason,
+        },
+    };
+}
+//# sourceMappingURL=bootstrap-fast-path.js.map