@xfey/tenso 0.1.130

package/dist/server-shell/local-console/server.js

@@ -0,0 +1,592 @@
+import { timingSafeEqual } from "node:crypto";
+import { registerConsoleBrowserBridge } from "./browser-bridge.js";
+import { LocalConsoleManagedProjectService } from "./managed-project-service.js";
+import { registerLocalConsoleManagedProjectRoutes } from "./managed-project-routes.js";
+import { existsSync, statSync } from "node:fs";
+import { resolve } from "node:path";
+import fastify from "fastify";
+import { createIdempotencyKey } from "@tutti/shared/ids";
+import { resolveTuttiHome } from "../../providers/openai/index.js";
+import { readCliVersion } from "../cli/version.js";
+import { registerHostWebStaticRoutes, resolvePackagedWebStaticRoot } from "../http/static-web.js";
+import { detectLocalFolderPicker, pickLocalFolder } from "./folder-picker.js";
+import { LOCAL_CONSOLE_INVOCATION_ENV_KEYS, createLocalConsoleServiceEnvironment, } from "./invocation-context.js";
+import { spawnPackageUpdateWorkerProcess } from "./package-update-process.js";
+import { consumePackageUpdateCompletion, } from "./package-update-record.js";
+import { LocalConsolePackageUpdateService, } from "./package-update-service.js";
+import { createPackageUpdateWorkerInput } from "./package-update-worker.js";
+import { LocalConsoleProjectError, LocalConsoleProjectService, } from "./project-service.js";
+import { LocalConsoleOperationConflictError, LocalConsoleOperationCoordinator, } from "./operation-coordinator.js";
+import { LOCAL_CONSOLE_SESSION_COOKIE, LocalConsoleSessionRegistry, localConsoleSessionCookie, parseCookieHeader, } from "./session.js";
+import { createLocalConsoleSecret, deleteLocalConsoleRuntimeEndpoint, writeLocalConsoleRuntimeEndpoint, } from "./runtime-endpoint.js";
+export const LOCAL_CONSOLE_API_BASE = "/local-console/v1";
+class LocalConsoleHttpError extends Error {
+    statusCode;
+    code;
+    constructor(statusCode, code, message) {
+        super(message);
+        this.statusCode = statusCode;
+        this.code = code;
+        this.name = "LocalConsoleHttpError";
+    }
+}
+function isValidationError(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "validation" in error &&
+        Array.isArray(error.validation));
+}
+function headerValue(value) {
+    return typeof value === "string" || value === undefined ? value : value[0];
+}
+function bearerToken(value) {
+    const header = headerValue(value);
+    const match = header === undefined ? null : /^Bearer\s+(.+)$/iu.exec(header.trim());
+    return match?.[1] ?? null;
+}
+function tokenEquals(value, expected) {
+    if (value === null || value.length === 0 || expected.length === 0) {
+        return false;
+    }
+    const actualBuffer = Buffer.from(value);
+    const expectedBuffer = Buffer.from(expected);
+    return (actualBuffer.length === expectedBuffer.length && timingSafeEqual(actualBuffer, expectedBuffer));
+}
+function requestOrigin(request) {
+    return `http://${headerValue(request.headers.host) ?? ""}`;
+}
+function requireSameOrigin(request) {
+    const origin = headerValue(request.headers.origin);
+    const fetchSite = headerValue(request.headers["sec-fetch-site"]);
+    if (origin !== requestOrigin(request) ||
+        (fetchSite !== undefined && fetchSite !== "same-origin" && fetchSite !== "none")) {
+        throw new LocalConsoleHttpError(403, "origin_rejected", "Local Console origin was rejected.");
+    }
+}
+function requireLoopbackHost(request) {
+    const host = headerValue(request.headers.host) ?? "";
+    if (!/^127\.0\.0\.1:\d+$/u.test(host)) {
+        throw new LocalConsoleHttpError(400, "host_rejected", "Local Console requires 127.0.0.1.");
+    }
+}
+export function createLocalConsoleServer(options) {
+    const app = fastify({
+        logger: false,
+        bodyLimit: 64 * 1024,
+        genReqId: () => createIdempotencyKey(),
+    });
+    const tuttiHome = options.tuttiHome ?? resolveTuttiHome(options.env?.TUTTI_HOME, options.cwd);
+    const sessions = new LocalConsoleSessionRegistry({
+        ...(options.now === undefined ? {} : { now: options.now }),
+    });
+    const operations = options.operationCoordinator ?? new LocalConsoleOperationCoordinator();
+    const projects = new LocalConsoleProjectService({
+        tuttiHome,
+        operations,
+        ...(options.now === undefined ? {} : { now: options.now }),
+        ...(options.env === undefined ? {} : { serviceEnvironment: options.env }),
+    });
+    const packageUpdates = options.packageUpdateService ??
+        new LocalConsolePackageUpdateService({
+            tuttiHome,
+            operations,
+            ...(options.env === undefined ? {} : { env: options.env }),
+        });
+    let pendingPackageUpdateCompletion = options.packageUpdateCompletion;
+    const startPackageUpdate = options.startPackageUpdate ??
+        (async (preparation) => {
+            try {
+                const entrypoint = options.runtime?.entrypoint;
+                if (entrypoint === undefined) {
+                    throw new Error("Local Console package update entrypoint is unavailable.");
+                }
+                const completionEnvironment = createLocalConsoleServiceEnvironment({
+                    env: options.env ?? process.env,
+                    tuttiHome,
+                });
+                completionEnvironment.PATH = preparation.installation.npmEnvironment.PATH;
+                const noProxy = preparation.installation.npmEnvironment.NO_PROXY;
+                if (noProxy !== undefined && noProxy !== "") {
+                    completionEnvironment.NO_PROXY = noProxy;
+                }
+                return await spawnPackageUpdateWorkerProcess({
+                    input: createPackageUpdateWorkerInput({
+                        tuttiHome,
+                        cliEntrypoint: entrypoint,
+                        installation: preparation.installation,
+                        target: preparation.target,
+                        restoreProjectIds: preparation.restore_project_ids,
+                        completionEnvironment,
+                    }),
+                    lease: preparation.lease,
+                });
+            }
+            catch (error) {
+                preparation.lease.release();
+                throw error;
+            }
+        });
+    app.addHook("onRequest", (request, reply, done) => {
+        reply.header("x-tutti-request-id", request.id);
+        try {
+            requireLoopbackHost(request);
+            void reply
+                .header("x-content-type-options", "nosniff")
+                .header("x-frame-options", "DENY")
+                .header("referrer-policy", "no-referrer")
+                .header("content-security-policy", "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline' https://fonts.googleapis.com; img-src 'self' data:; font-src 'self' data: https://fonts.gstatic.com; connect-src 'self'; frame-ancestors 'none'; base-uri 'self'; form-action 'self'");
+            if (request.url.startsWith(LOCAL_CONSOLE_API_BASE)) {
+                void reply.header("cache-control", "no-store");
+            }
+            done();
+        }
+        catch (error) {
+            done(error);
+        }
+    });
+    app.setErrorHandler((error, request, reply) => {
+        const normalized = error instanceof LocalConsoleHttpError ||
+            error instanceof LocalConsoleProjectError ||
+            error instanceof LocalConsoleOperationConflictError
+            ? error
+            : isValidationError(error)
+                ? new LocalConsoleHttpError(400, "bad_request", "Local Console request is invalid.")
+                : new LocalConsoleHttpError(500, "local_console_failed", "Local Console request failed.");
+        void reply.status(normalized.statusCode).send({
+            error: {
+                code: normalized.code,
+                message: normalized.message,
+                retryable: normalized.statusCode >= 500,
+                request_id: request.id,
+            },
+        });
+    });
+    function requireControl(request) {
+        if (!tokenEquals(bearerToken(request.headers.authorization), options.controlToken)) {
+            throw new LocalConsoleHttpError(401, "unauthorized", "Local Console control token is invalid.");
+        }
+        options.onActivity?.();
+    }
+    function requireSession(request, csrf = false) {
+        const cookie = parseCookieHeader(headerValue(request.headers.cookie));
+        const session = sessions.readSession(cookie[LOCAL_CONSOLE_SESSION_COOKIE], headerValue(request.headers["x-local-console-context"]));
+        if (session === null) {
+            throw new LocalConsoleHttpError(401, "session_required", "Open Tenso from the CLI again.");
+        }
+        if (csrf) {
+            requireSameOrigin(request);
+            const csrfToken = headerValue(request.headers["x-local-console-csrf"]);
+            if (!tokenEquals(csrfToken ?? null, session.csrfToken)) {
+                throw new LocalConsoleHttpError(403, "csrf_rejected", "Local Console request was rejected.");
+            }
+        }
+        options.onActivity?.();
+        return session;
+    }
+    registerLocalConsoleManagedProjectRoutes(app, {
+        tuttiHome,
+        requireSession,
+        service: new LocalConsoleManagedProjectService({
+            tuttiHome,
+            operations,
+            projects,
+            ...(options.env === undefined ? {} : { serviceEnvironment: options.env }),
+            ...(options.now === undefined ? {} : { now: options.now }),
+        }),
+    });
+    registerConsoleBrowserBridge(app, {
+        sessions,
+        tuttiHome,
+        ...(options.now === undefined ? {} : { now: options.now }),
+    });
+    app.get(`${LOCAL_CONSOLE_API_BASE}/health`, () => ({
+        status: "ready",
+        protocol_version: 2,
+        ...(options.runtime === undefined
+            ? {}
+            : {
+                instance_id: options.runtime.instanceId,
+                version: options.runtime.version,
+                pid: options.runtime.pid,
+            }),
+    }));
+    app.get(`${LOCAL_CONSOLE_API_BASE}/control/status`, (request) => {
+        requireControl(request);
+        return {
+            status: "running",
+            protocol_version: 2,
+            ...(options.runtime === undefined
+                ? {}
+                : {
+                    instance_id: options.runtime.instanceId,
+                    version: options.runtime.version,
+                    entrypoint: options.runtime.entrypoint,
+                    started_at: options.runtime.startedAt,
+                    pid: options.runtime.pid,
+                }),
+        };
+    });
+    app.post(`${LOCAL_CONSOLE_API_BASE}/control/shutdown`, (request) => {
+        requireControl(request);
+        setImmediate(() => options.onShutdown?.());
+        return { status: "stopping" };
+    });
+    app.post(`${LOCAL_CONSOLE_API_BASE}/access-tokens`, {
+        schema: {
+            body: {
+                type: "object",
+                required: ["source"],
+                additionalProperties: false,
+                properties: {
+                    source: { type: "string", enum: ["terminal", "desktop"] },
+                    current_directory: { type: "string", minLength: 1, maxLength: 4096 },
+                    environment: {
+                        type: "object",
+                        additionalProperties: false,
+                        properties: Object.fromEntries(LOCAL_CONSOLE_INVOCATION_ENV_KEYS.map((key) => [
+                            key,
+                            { type: "string", minLength: 1, maxLength: 4096 },
+                        ])),
+                    },
+                },
+            },
+        },
+    }, (request) => {
+        requireControl(request);
+        if ((request.body.source === "terminal" && request.body.current_directory === undefined) ||
+            (request.body.source === "desktop" && request.body.current_directory !== undefined)) {
+            throw new LocalConsoleHttpError(400, "bad_request", "Local Console invocation context is invalid.");
+        }
+        const context = request.body.source === "terminal"
+            ? {
+                source: "terminal",
+                currentDirectory: resolve(request.body.current_directory),
+                environment: request.body.environment ?? {},
+            }
+            : {
+                source: "desktop",
+                environment: request.body.environment ?? {},
+            };
+        const access = sessions.issueAccessToken(context);
+        return { access_token: access.token, expires_at: access.expires_at };
+    });
+    app.post(`${LOCAL_CONSOLE_API_BASE}/session`, {
+        schema: {
+            body: {
+                type: "object",
+                required: ["access_token"],
+                additionalProperties: false,
+                properties: {
+                    access_token: { type: "string", minLength: 1 },
+                    account_display_name: { type: "string", minLength: 1, maxLength: 80 },
+                },
+            },
+        },
+    }, (request, reply) => {
+        requireSameOrigin(request);
+        const cookie = parseCookieHeader(headerValue(request.headers.cookie));
+        const session = sessions.exchangeAccessToken(request.body.access_token, cookie[LOCAL_CONSOLE_SESSION_COOKIE], request.body.account_display_name);
+        if (session === null) {
+            throw new LocalConsoleHttpError(401, "access_token_invalid", "This Local Console access link has expired. Run `tenso` again.");
+        }
+        if (session.sessionToken !== undefined) {
+            void reply.header("set-cookie", localConsoleSessionCookie(session.sessionToken, session.expires_at));
+        }
+        options.onActivity?.();
+        return {
+            csrf_token: session.csrfToken,
+            context_token: session.contextToken,
+            expires_at: session.expires_at,
+        };
+    });
+    app.get(`${LOCAL_CONSOLE_API_BASE}/bootstrap`, (request) => {
+        const session = requireSession(request);
+        const packageUpdateCompletion = session.accountReady
+            ? pendingPackageUpdateCompletion
+            : undefined;
+        if (packageUpdateCompletion !== undefined) {
+            pendingPackageUpdateCompletion = undefined;
+        }
+        return {
+            account_gate: session.accountReady
+                ? {
+                    status: "ready",
+                    ...(session.accountDisplayName === undefined
+                        ? {}
+                        : { account: { display_name: session.accountDisplayName } }),
+                }
+                : { status: "required" },
+            csrf_token: session.csrfToken,
+            version: options.runtime?.version ?? readCliVersion(),
+            invocation: session.context.source === "terminal"
+                ? {
+                    source: "terminal",
+                    current_directory: session.context.currentDirectory,
+                }
+                : { source: "desktop" },
+            platform: process.platform,
+            folder_picker: detectLocalFolderPicker(process.platform, session.context.environment).kind,
+            ...(packageUpdateCompletion === undefined
+                ? {}
+                : { package_update_completion: packageUpdateCompletion }),
+        };
+    });
+    app.post(`${LOCAL_CONSOLE_API_BASE}/account-continuations`, (request) => {
+        const session = requireSession(request, true);
+        if (request.body !== undefined) {
+            throw new LocalConsoleHttpError(400, "bad_request", "Account continuation does not accept browser-controlled input.");
+        }
+        const continuation = sessions.issueAccountContinuation(session.context);
+        return {
+            access_token: continuation.token,
+            expires_at: continuation.expires_at,
+        };
+    });
+    app.get(`${LOCAL_CONSOLE_API_BASE}/package-update`, {
+        schema: {
+            querystring: {
+                type: "object",
+                additionalProperties: false,
+                properties: { refresh: { type: "string", enum: ["true"] } },
+            },
+        },
+    }, async (request) => {
+        requireSession(request);
+        return await packageUpdates.getStatus({ refresh: request.query.refresh === "true" });
+    });
+    app.post(`${LOCAL_CONSOLE_API_BASE}/package-update`, async (request, reply) => {
+        requireSession(request, true);
+        if (request.body !== undefined) {
+            throw new LocalConsoleHttpError(400, "bad_request", "Package update does not accept browser-controlled input.");
+        }
+        const begin = await packageUpdates.beginUpdate();
+        if (begin.status === "blocked") {
+            throw new LocalConsoleHttpError(409, begin.update.reason_code ?? "package_update_blocked", "Package update is currently unavailable.");
+        }
+        await startPackageUpdate(begin.preparation);
+        setImmediate(() => options.onShutdown?.());
+        return await reply.status(202).send({
+            current_version: begin.preparation.installation.currentVersion,
+            latest_version: begin.preparation.target.version,
+            status: "updating",
+            can_update: false,
+            phase: "preparing",
+        });
+    });
+    app.get(`${LOCAL_CONSOLE_API_BASE}/projects`, async (request) => {
+        const session = requireSession(request);
+        return { projects: await projects.listProjects(session.context) };
+    });
+    app.get(`${LOCAL_CONSOLE_API_BASE}/projects/:projectId/feishu-setup`, async (request) => {
+        const session = requireSession(request);
+        return await projects.readFeishuSetup(request.params.projectId, session.context);
+    });
+    app.get(`${LOCAL_CONSOLE_API_BASE}/heartbeat`, (request) => {
+        requireSession(request);
+        return { status: "ok" };
+    });
+    app.post(`${LOCAL_CONSOLE_API_BASE}/folders/pick`, async (request) => {
+        const session = requireSession(request, true);
+        return await operations.runProjectOperation(async () => await pickLocalFolder({ env: session.context.environment }));
+    });
+    app.post(`${LOCAL_CONSOLE_API_BASE}/providers/models`, {
+        schema: {
+            body: {
+                type: "object",
+                required: ["base_url", "api_key"],
+                additionalProperties: false,
+                properties: {
+                    base_url: { type: "string", minLength: 1, maxLength: 2048 },
+                    api_key: { type: "string", minLength: 1, maxLength: 4096 },
+                },
+            },
+        },
+    }, async (request) => {
+        requireSession(request, true);
+        return await operations.runProjectOperation(async () => await projects.discoverModels({
+            baseUrl: request.body.base_url,
+            apiKey: request.body.api_key,
+        }));
+    });
+    app.post(`${LOCAL_CONSOLE_API_BASE}/projects/launch`, {
+        schema: {
+            body: {
+                type: "object",
+                required: ["workspace_path"],
+                additionalProperties: false,
+                properties: {
+                    workspace_path: { type: "string", minLength: 1, maxLength: 4096 },
+                    project: {
+                        type: "object",
+                        required: ["display_name"],
+                        additionalProperties: false,
+                        properties: {
+                            display_name: { type: "string", minLength: 1, maxLength: 80 },
+                            description: { type: "string", maxLength: 160 },
+                        },
+                    },
+                    provider: {
+                        type: "object",
+                        required: ["base_url", "api_key", "model"],
+                        additionalProperties: false,
+                        properties: {
+                            base_url: { type: "string", minLength: 1, maxLength: 2048 },
+                            api_key: { type: "string", minLength: 1, maxLength: 4096 },
+                            model: { type: "string", minLength: 1, maxLength: 240 },
+                        },
+                    },
+                    surface: {
+                        type: "string",
+                        enum: ["standalone", "feishu"],
+                    },
+                },
+            },
+        },
+    }, async (request) => {
+        const session = requireSession(request, true);
+        return await projects.launchProject({
+            workspacePath: request.body.workspace_path,
+            ...(request.body.project === undefined ? {} : { project: request.body.project }),
+            ...(request.body.provider === undefined ? {} : { provider: request.body.provider }),
+            ...(request.body.surface === undefined ? {} : { surface: request.body.surface }),
+        }, session.context, session.accountHandoff);
+    });
+    app.post(`${LOCAL_CONSOLE_API_BASE}/projects/:projectId/open`, async (request) => {
+        const session = requireSession(request, true);
+        return await projects.openProject(request.params.projectId, session.context);
+    });
+    app.post(`${LOCAL_CONSOLE_API_BASE}/projects/:projectId/invite`, async (request) => {
+        const session = requireSession(request, true);
+        return await projects.refreshInvite(request.params.projectId, session.context);
+    });
+    app.post(`${LOCAL_CONSOLE_API_BASE}/projects/:projectId/stop`, async (request) => {
+        const session = requireSession(request, true);
+        return await projects.stopProject(request.params.projectId, session.context);
+    });
+    const webStaticRoot = options.webStaticRoot === false
+        ? undefined
+        : (options.webStaticRoot ?? resolvePackagedWebStaticRoot(options.env));
+    if (webStaticRoot !== undefined) {
+        registerHostWebStaticRoutes(app, { root: webStaticRoot });
+    }
+    return app;
+}
+function listeningPort(app) {
+    const address = app.server.address();
+    if (typeof address !== "object" || address === null) {
+        throw new Error("Local Console did not expose a loopback port.");
+    }
+    return address.port;
+}
+function entrypointIdentity(path) {
+    try {
+        const stats = statSync(path);
+        return `${stats.dev}:${stats.ino}:${stats.size}:${stats.mtimeMs}`;
+    }
+    catch {
+        return null;
+    }
+}
+export async function runLocalConsoleProcess(options = {}) {
+    const cwd = resolve(options.cwd ?? process.cwd());
+    const env = options.env ?? process.env;
+    const tuttiHome = resolveTuttiHome(env.TUTTI_HOME, cwd);
+    const serviceEnvironment = createLocalConsoleServiceEnvironment({ env, tuttiHome });
+    const controlToken = createLocalConsoleSecret();
+    const instanceId = createLocalConsoleSecret();
+    const now = options.now ?? (() => new Date());
+    const startedAt = now().toISOString();
+    const version = readCliVersion();
+    const entrypointArgument = process.argv[1];
+    if (entrypointArgument === undefined || entrypointArgument.trim() === "") {
+        throw new Error("Cannot locate the Tenso CLI entrypoint.");
+    }
+    const entrypoint = resolve(entrypointArgument);
+    const initialEntrypointIdentity = entrypointIdentity(entrypoint);
+    if (initialEntrypointIdentity === null) {
+        throw new Error("The Tenso CLI entrypoint is unavailable.");
+    }
+    let lastActivityAt = now().getTime();
+    const packageUpdateCompletion = consumePackageUpdateCompletion({
+        tuttiHome,
+        currentVersion: version,
+    });
+    let requestClose = () => undefined;
+    const app = createLocalConsoleServer({
+        controlToken,
+        cwd,
+        tuttiHome,
+        env: serviceEnvironment,
+        runtime: {
+            instanceId,
+            version,
+            entrypoint,
+            startedAt,
+            pid: process.pid,
+        },
+        onActivity: () => {
+            lastActivityAt = now().getTime();
+        },
+        onShutdown: () => requestClose(),
+        ...(packageUpdateCompletion === undefined ? {} : { packageUpdateCompletion }),
+        ...(options.now === undefined ? {} : { now: options.now }),
+    });
+    await app.listen({ host: "127.0.0.1", port: 0 });
+    writeLocalConsoleRuntimeEndpoint({
+        tuttiHome,
+        instanceId,
+        pid: process.pid,
+        baseUrl: `http://127.0.0.1:${listeningPort(app)}`,
+        controlToken,
+        version,
+        entrypoint,
+        now,
+    });
+    let closing = false;
+    const close = async () => {
+        if (closing) {
+            return;
+        }
+        closing = true;
+        deleteLocalConsoleRuntimeEndpoint({
+            tuttiHome,
+            expectedControlToken: controlToken,
+        });
+        const forceClose = setTimeout(() => app.server.closeAllConnections(), 5_000);
+        forceClose.unref();
+        try {
+            await app.close();
+        }
+        finally {
+            clearTimeout(forceClose);
+        }
+    };
+    requestClose = () => void close();
+    const idleTimeoutMs = options.idleTimeoutMs ?? 60 * 60 * 1_000;
+    const idleCheck = setInterval(() => {
+        let installedVersion = null;
+        try {
+            installedVersion = readCliVersion();
+        }
+        catch {
+            // Package removal is handled as a runtime identity change.
+        }
+        if (!existsSync(entrypoint) ||
+            entrypointIdentity(entrypoint) !== initialEntrypointIdentity ||
+            installedVersion !== version) {
+            void close();
+            return;
+        }
+        if (now().getTime() - lastActivityAt >= idleTimeoutMs) {
+            void close();
+        }
+    }, Math.min(60_000, Math.max(1_000, Math.floor(idleTimeoutMs / 4))));
+    idleCheck.unref();
+    process.once("SIGINT", () => void close());
+    process.once("SIGTERM", () => void close());
+    await new Promise((resolveClosed) => {
+        app.server.once("close", resolveClosed);
+    });
+    clearInterval(idleCheck);
+}
+//# sourceMappingURL=server.js.map

package/dist/server-shell/local-console/session.d.ts

@@ -0,0 +1,39 @@
+import type { LocalConsoleInvocationContext } from "./invocation-context.js";
+export declare const LOCAL_CONSOLE_SESSION_COOKIE = "tutti_local_console_session";
+export type IssuedLocalConsoleAccessToken = {
+    token: string;
+    expires_at: string;
+};
+export type ExchangedLocalConsoleSession = {
+    sessionToken?: string;
+    contextToken: string;
+    csrfToken: string;
+    expires_at: string;
+};
+export type ReadLocalConsoleSession = {
+    accountReady: boolean;
+    accountDisplayName?: string;
+    accountHandoff?: {
+        token: string;
+        expires_at: string;
+    };
+    csrfToken: string;
+    context: LocalConsoleInvocationContext;
+};
+export declare class LocalConsoleSessionRegistry {
+    #private;
+    constructor(options?: {
+        now?: () => Date;
+    });
+    issueAccessToken(context: LocalConsoleInvocationContext): IssuedLocalConsoleAccessToken;
+    issueAccountContinuation(context: LocalConsoleInvocationContext): IssuedLocalConsoleAccessToken;
+    exchangeAccessToken(token: string, existingSessionToken?: string, accountDisplayName?: string, isolated?: boolean): ExchangedLocalConsoleSession | null;
+    /** Inspect only a fresh native entry, never an account-ready continuation. */
+    readEntryContext(token: string): LocalConsoleInvocationContext | null;
+    revokeAccessToken(token: string): void;
+    revokeSession(token: string): void;
+    readSession(token: string | undefined, contextToken?: string): ReadLocalConsoleSession | null;
+}
+export declare function parseCookieHeader(header: string | undefined): Record<string, string>;
+export declare function localConsoleSessionCookie(token: string, expiresAt: string): string;
+//# sourceMappingURL=session.d.ts.map