@xfey/tutti 0.1.32 → 0.1.33

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

@@ -0,0 +1,217 @@
+import { existsSync, statSync } from "node:fs";
+import { resolve } from "node:path";
+import { configureProjectOpenAiProvider, discoverOpenAiModels, readOpenAiProviderConfigProjection, resolveTuttiHome, } from "../../providers/openai/index.js";
+import { formatCliErrorReason, LaunchError } from "../cli/errors.js";
+import { prepareLaunchProject } from "../cli/launch.js";
+import { rotateHostLocalInvite } from "../cli/local-control-client.js";
+import { spawnDetachedHost, waitForManagedHostReady } from "../cli/managed-host.js";
+import { resolveManagedProjectContext } from "../cli/project-resolver.js";
+import { listRuntimeProjects, runStopCommand, } from "../cli/runtime-commands.js";
+export class LocalConsoleProjectError extends Error {
+    code;
+    statusCode;
+    constructor(code, message, statusCode = 422) {
+        super(message);
+        this.code = code;
+        this.statusCode = statusCode;
+        this.name = "LocalConsoleProjectError";
+    }
+}
+function validateWorkspacePath(value) {
+    const path = resolve(value.trim());
+    if (value.trim() === "" || !existsSync(path) || !statSync(path).isDirectory()) {
+        throw new LocalConsoleProjectError("project_folder_invalid", "Choose an existing project folder before launching.");
+    }
+    return path;
+}
+function validateProvider(input) {
+    const provider = {
+        base_url: input.base_url.trim(),
+        api_key: input.api_key.trim(),
+        model: input.model.trim(),
+    };
+    if (provider.base_url === "" || provider.api_key === "" || provider.model === "") {
+        throw new LocalConsoleProjectError("provider_configuration_required", "Base URL, API key, and model are required for a new Provider configuration.");
+    }
+    try {
+        const url = new URL(provider.base_url);
+        if (url.protocol !== "http:" && url.protocol !== "https:") {
+            throw new Error("unsupported protocol");
+        }
+    }
+    catch {
+        throw new LocalConsoleProjectError("provider_base_url_invalid", "Enter a valid HTTP or HTTPS Provider Base URL.");
+    }
+    return provider;
+}
+function projectFromRuntimeRow(row, providerStatus) {
+    return {
+        project_id: row.project_id,
+        display_name: row.display_name,
+        workspace_path: row.workspace_root,
+        status: row.status,
+        provider_status: providerStatus,
+        ...(row.relay_project_ref === undefined ? {} : { relay_project_ref: row.relay_project_ref }),
+        ...(row.join_url === undefined ? {} : { join_url: row.join_url }),
+        ...(row.relay_connection_status === undefined
+            ? {}
+            : { relay_connection_status: row.relay_connection_status }),
+    };
+}
+export class LocalConsoleProjectService {
+    #cwd;
+    #env;
+    #launches = new Map();
+    constructor(options = {}) {
+        this.#cwd = resolve(options.cwd ?? process.cwd());
+        this.#env = options.env ?? process.env;
+    }
+    async listProjects() {
+        const tuttiHome = resolveTuttiHome(this.#env.TUTTI_HOME, this.#cwd);
+        const rows = await listRuntimeProjects({
+            all: true,
+            cwd: this.#cwd,
+            env: this.#env,
+        });
+        return rows.map((row) => {
+            const provider = readOpenAiProviderConfigProjection({
+                tuttiHome,
+                projectId: row.project_id,
+            });
+            return projectFromRuntimeRow(row, provider.status);
+        });
+    }
+    async discoverModels(input) {
+        const provider = validateProvider({
+            base_url: input.baseUrl,
+            api_key: input.apiKey,
+            model: "model-discovery",
+        });
+        return await discoverOpenAiModels({
+            apiBaseUrl: provider.base_url,
+            apiKey: provider.api_key,
+        });
+    }
+    async launchProject(input) {
+        const workspacePath = validateWorkspacePath(input.workspacePath);
+        const active = this.#launches.get(workspacePath);
+        if (active !== undefined) {
+            return await active;
+        }
+        const launch = this.#launchProject({
+            workspacePath,
+            ...(input.provider === undefined ? {} : { provider: validateProvider(input.provider) }),
+        }).finally(() => {
+            this.#launches.delete(workspacePath);
+        });
+        this.#launches.set(workspacePath, launch);
+        return await launch;
+    }
+    async #launchProject(input) {
+        let preparation;
+        try {
+            preparation = await prepareLaunchProject({
+                workspacePath: input.workspacePath,
+                yes: true,
+                cwd: this.#cwd,
+                env: this.#env,
+            });
+        }
+        catch (error) {
+            throw this.#normalizeError(error);
+        }
+        if (input.provider !== undefined) {
+            const configured = await configureProjectOpenAiProvider({
+                tuttiHome: preparation.tutti_home,
+                projectId: preparation.project_id,
+                apiBaseUrl: input.provider.base_url,
+                apiKey: input.provider.api_key,
+                defaultModel: input.provider.model,
+            });
+            if (configured.kind === "validation_failed") {
+                throw new LocalConsoleProjectError(configured.reason, "Provider validation failed. Check the Base URL, API key, and selected model.");
+            }
+        }
+        else if (preparation.provider_status !== "configured") {
+            throw new LocalConsoleProjectError("provider_configuration_required", "This project does not have a valid saved Provider. Configure it in the launch form.");
+        }
+        try {
+            spawnDetachedHost({
+                workspaceRoot: preparation.workspace_root,
+                env: this.#env,
+            });
+            const ready = await waitForManagedHostReady({
+                tuttiHome: preparation.tutti_home,
+                projectId: preparation.project_id,
+                workspaceRoot: preparation.workspace_root,
+            });
+            if (ready.join_url === undefined) {
+                throw new LocalConsoleProjectError("relay_registration_failed", "The host started, but Relay did not return a visible join link.");
+            }
+            const projects = await this.listProjects();
+            const project = projects.find((item) => item.project_id === preparation.project_id);
+            if (project === undefined) {
+                throw new LocalConsoleProjectError("project_not_found", "The launched project could not be read from the machine project list.");
+            }
+            return {
+                project,
+                join_url: ready.join_url,
+                ...(ready.join_token_expires_at === undefined
+                    ? {}
+                    : { join_token_expires_at: ready.join_token_expires_at }),
+            };
+        }
+        catch (error) {
+            throw this.#normalizeError(error);
+        }
+    }
+    async refreshInvite(projectId) {
+        const project = resolveManagedProjectContext({
+            target: projectId,
+            cwd: this.#cwd,
+            env: this.#env,
+        });
+        if (project.runtime_endpoint === null) {
+            throw new LocalConsoleProjectError("host_not_running", "Launch this project before creating an invite link.");
+        }
+        try {
+            const status = await rotateHostLocalInvite({ endpoint: project.runtime_endpoint });
+            const joinUrl = status.relay?.join_url;
+            if (joinUrl === undefined) {
+                throw new LocalConsoleProjectError("relay_registration_failed", "Relay did not return a visible invite link.");
+            }
+            return {
+                join_url: joinUrl,
+                ...(status.relay?.join_token_expires_at === undefined
+                    ? {}
+                    : { expires_at: status.relay.join_token_expires_at }),
+            };
+        }
+        catch (error) {
+            throw this.#normalizeError(error);
+        }
+    }
+    async stopProject(projectId) {
+        try {
+            return {
+                message: await runStopCommand(projectId, {
+                    cwd: this.#cwd,
+                    env: this.#env,
+                }),
+            };
+        }
+        catch (error) {
+            throw this.#normalizeError(error);
+        }
+    }
+    #normalizeError(error) {
+        if (error instanceof LocalConsoleProjectError) {
+            return error;
+        }
+        if (error instanceof LaunchError) {
+            return new LocalConsoleProjectError(error.code, error.message);
+        }
+        return new LocalConsoleProjectError("local_console_failed", formatCliErrorReason(error), 500);
+    }
+}
+//# sourceMappingURL=project-service.js.map

package/dist/server-shell/local-console/runtime-endpoint.d.ts

@@ -0,0 +1,21 @@
+export type LocalConsoleRuntimeEndpoint = {
+    schema_version: 1;
+    pid: number;
+    base_url: string;
+    control_token: string;
+    started_at: string;
+};
+export declare function createLocalConsoleSecret(): string;
+export declare function readLocalConsoleRuntimeEndpoint(tuttiHome: string): LocalConsoleRuntimeEndpoint | null;
+export declare function writeLocalConsoleRuntimeEndpoint(options: {
+    tuttiHome: string;
+    pid: number;
+    baseUrl: string;
+    controlToken: string;
+    now?: () => Date;
+}): LocalConsoleRuntimeEndpoint;
+export declare function deleteLocalConsoleRuntimeEndpoint(options: {
+    tuttiHome: string;
+    expectedControlToken?: string;
+}): void;
+//# sourceMappingURL=runtime-endpoint.d.ts.map

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

@@ -0,0 +1,74 @@
+import { randomBytes } from "node:crypto";
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync, } from "node:fs";
+import { dirname, join } from "node:path";
+function endpointPath(tuttiHome) {
+    return join(tuttiHome, "runtime", "local-console.json");
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isEndpoint(value) {
+    return (isRecord(value) &&
+        value.schema_version === 1 &&
+        typeof value.pid === "number" &&
+        Number.isInteger(value.pid) &&
+        typeof value.base_url === "string" &&
+        /^http:\/\/127\.0\.0\.1:\d+$/u.test(value.base_url) &&
+        typeof value.control_token === "string" &&
+        value.control_token.length >= 32 &&
+        typeof value.started_at === "string");
+}
+export function createLocalConsoleSecret() {
+    return randomBytes(32).toString("base64url");
+}
+export function readLocalConsoleRuntimeEndpoint(tuttiHome) {
+    const path = endpointPath(tuttiHome);
+    if (!existsSync(path)) {
+        return null;
+    }
+    try {
+        const value = JSON.parse(readFileSync(path, "utf8"));
+        return isEndpoint(value) ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function writeLocalConsoleRuntimeEndpoint(options) {
+    const record = {
+        schema_version: 1,
+        pid: options.pid,
+        base_url: options.baseUrl,
+        control_token: options.controlToken,
+        started_at: (options.now ?? (() => new Date()))().toISOString(),
+    };
+    if (!isEndpoint(record)) {
+        throw new Error("Local Console runtime endpoint is invalid.");
+    }
+    const path = endpointPath(options.tuttiHome);
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    chmodSync(dirname(path), 0o700);
+    const temporaryPath = `${path}.${process.pid}.tmp`;
+    writeFileSync(temporaryPath, `${JSON.stringify(record, null, 2)}\n`, {
+        encoding: "utf8",
+        mode: 0o600,
+    });
+    chmodSync(temporaryPath, 0o600);
+    renameSync(temporaryPath, path);
+    chmodSync(path, 0o600);
+    return record;
+}
+export function deleteLocalConsoleRuntimeEndpoint(options) {
+    const path = endpointPath(options.tuttiHome);
+    if (!existsSync(path)) {
+        return;
+    }
+    if (options.expectedControlToken !== undefined) {
+        const current = readLocalConsoleRuntimeEndpoint(options.tuttiHome);
+        if (current === null || current.control_token !== options.expectedControlToken) {
+            return;
+        }
+    }
+    unlinkSync(path);
+}
+//# sourceMappingURL=runtime-endpoint.js.map

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

@@ -0,0 +1,17 @@
+import { type FastifyInstance } from "fastify";
+export declare const LOCAL_CONSOLE_API_BASE = "/local-console/v1";
+type LocalConsoleServerOptions = {
+    controlToken: string;
+    cwd: string;
+    env?: NodeJS.ProcessEnv;
+    now?: () => Date;
+    webStaticRoot?: string | false;
+};
+export declare function createLocalConsoleServer(options: LocalConsoleServerOptions): FastifyInstance;
+export declare function runLocalConsoleProcess(options?: {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    now?: () => Date;
+}): Promise<void>;
+export {};
+//# sourceMappingURL=server.d.ts.map

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

@@ -0,0 +1,301 @@
+import { timingSafeEqual } from "node:crypto";
+import { resolve } from "node:path";
+import fastify from "fastify";
+import { resolveTuttiHome } from "../../providers/openai/index.js";
+import { registerHostWebStaticRoutes, resolvePackagedWebStaticRoot } from "../http/static-web.js";
+import { createLocalProjectFolder, detectLocalFolderPicker, pickLocalFolder, } from "./folder-picker.js";
+import { LocalConsoleProjectError, LocalConsoleProjectService, } from "./project-service.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 });
+    const sessions = new LocalConsoleSessionRegistry({
+        ...(options.now === undefined ? {} : { now: options.now }),
+    });
+    const projects = new LocalConsoleProjectService({
+        cwd: options.cwd,
+        ...(options.env === undefined ? {} : { env: options.env }),
+    });
+    app.addHook("onRequest", (request, reply, done) => {
+        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
+            : 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,
+            },
+        });
+    });
+    function requireControl(request) {
+        if (!tokenEquals(bearerToken(request.headers.authorization), options.controlToken)) {
+            throw new LocalConsoleHttpError(401, "unauthorized", "Local Console control token is invalid.");
+        }
+    }
+    function requireSession(request, csrf = false) {
+        const cookie = parseCookieHeader(headerValue(request.headers.cookie));
+        const session = sessions.readSession(cookie[LOCAL_CONSOLE_SESSION_COOKIE]);
+        if (session === null) {
+            throw new LocalConsoleHttpError(401, "session_required", "Open Tutti 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.");
+            }
+        }
+        return session;
+    }
+    app.get(`${LOCAL_CONSOLE_API_BASE}/health`, () => ({ status: "ready" }));
+    app.post(`${LOCAL_CONSOLE_API_BASE}/access-tokens`, {
+        schema: {
+            body: {
+                type: "object",
+                required: ["current_directory"],
+                additionalProperties: false,
+                properties: { current_directory: { type: "string", minLength: 1, maxLength: 4096 } },
+            },
+        },
+    }, (request) => {
+        requireControl(request);
+        const access = sessions.issueAccessToken({
+            currentDirectory: resolve(request.body.current_directory),
+        });
+        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 } },
+            },
+        },
+    }, (request, reply) => {
+        requireSameOrigin(request);
+        const session = sessions.exchangeAccessToken(request.body.access_token);
+        if (session === null) {
+            throw new LocalConsoleHttpError(401, "access_token_invalid", "This Local Console access link has expired. Run `tutti` again.");
+        }
+        void reply.header("set-cookie", localConsoleSessionCookie(session.sessionToken, session.expires_at));
+        return { csrf_token: session.csrfToken, expires_at: session.expires_at };
+    });
+    app.get(`${LOCAL_CONSOLE_API_BASE}/bootstrap`, (request) => {
+        const session = requireSession(request);
+        const picker = detectLocalFolderPicker(process.platform, options.env ?? process.env);
+        return {
+            csrf_token: session.csrfToken,
+            current_directory: session.currentDirectory,
+            platform: process.platform,
+            folder_picker: picker.kind,
+        };
+    });
+    app.get(`${LOCAL_CONSOLE_API_BASE}/projects`, async (request) => {
+        requireSession(request);
+        return { projects: await projects.listProjects() };
+    });
+    app.post(`${LOCAL_CONSOLE_API_BASE}/folders/pick`, async (request) => {
+        requireSession(request, true);
+        return await pickLocalFolder({ env: options.env ?? process.env });
+    });
+    app.post(`${LOCAL_CONSOLE_API_BASE}/folders/create`, {
+        schema: {
+            body: {
+                type: "object",
+                required: ["parent_path", "name"],
+                additionalProperties: false,
+                properties: {
+                    parent_path: { type: "string", minLength: 1 },
+                    name: { type: "string", minLength: 1, maxLength: 160 },
+                },
+            },
+        },
+    }, (request) => {
+        requireSession(request, true);
+        try {
+            return { path: createLocalProjectFolder(request.body.parent_path, request.body.name) };
+        }
+        catch (error) {
+            throw new LocalConsoleHttpError(422, "project_folder_create_failed", error instanceof Error ? error.message : "Project folder could not be created.");
+        }
+    });
+    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 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 },
+                    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 },
+                        },
+                    },
+                },
+            },
+        },
+    }, async (request) => {
+        requireSession(request, true);
+        return await projects.launchProject({
+            workspacePath: request.body.workspace_path,
+            ...(request.body.provider === undefined ? {} : { provider: request.body.provider }),
+        });
+    });
+    app.post(`${LOCAL_CONSOLE_API_BASE}/projects/:projectId/invite`, async (request) => {
+        requireSession(request, true);
+        return await projects.refreshInvite(request.params.projectId);
+    });
+    app.post(`${LOCAL_CONSOLE_API_BASE}/projects/:projectId/stop`, async (request) => {
+        requireSession(request, true);
+        return await projects.stopProject(request.params.projectId);
+    });
+    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;
+}
+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 controlToken = createLocalConsoleSecret();
+    const app = createLocalConsoleServer({
+        controlToken,
+        cwd,
+        env,
+        ...(options.now === undefined ? {} : { now: options.now }),
+    });
+    await app.listen({ host: "127.0.0.1", port: 0 });
+    writeLocalConsoleRuntimeEndpoint({
+        tuttiHome,
+        pid: process.pid,
+        baseUrl: `http://127.0.0.1:${listeningPort(app)}`,
+        controlToken,
+        ...(options.now === undefined ? {} : { now: options.now }),
+    });
+    let closing = false;
+    const close = async () => {
+        if (closing) {
+            return;
+        }
+        closing = true;
+        deleteLocalConsoleRuntimeEndpoint({
+            tuttiHome,
+            expectedControlToken: controlToken,
+        });
+        await app.close();
+    };
+    process.once("SIGINT", () => void close());
+    process.once("SIGTERM", () => void close());
+    await new Promise((resolveClosed) => {
+        app.server.once("close", resolveClosed);
+    });
+}
+//# sourceMappingURL=server.js.map

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

@@ -0,0 +1,33 @@
+export declare const LOCAL_CONSOLE_SESSION_COOKIE = "tutti_local_console_session";
+type ExpiringValue = {
+    hash: string;
+    expiresAt: number;
+};
+type LocalConsoleSession = ExpiringValue & {
+    csrfToken: string;
+    currentDirectory: string;
+};
+export type IssuedLocalConsoleAccessToken = {
+    token: string;
+    expires_at: string;
+};
+export type ExchangedLocalConsoleSession = {
+    sessionToken: string;
+    csrfToken: string;
+    expires_at: string;
+};
+export declare class LocalConsoleSessionRegistry {
+    #private;
+    constructor(options?: {
+        now?: () => Date;
+    });
+    issueAccessToken(options: {
+        currentDirectory: string;
+    }): IssuedLocalConsoleAccessToken;
+    exchangeAccessToken(token: string): ExchangedLocalConsoleSession | null;
+    readSession(token: string | undefined): LocalConsoleSession | null;
+}
+export declare function parseCookieHeader(header: string | undefined): Record<string, string>;
+export declare function localConsoleSessionCookie(token: string, expiresAt: string): string;
+export {};
+//# sourceMappingURL=session.d.ts.map