@aria-cli/cli 1.0.51 → 1.0.54

package/dist/headless/auth-orchestrator.js

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

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

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