@xfey/tenso 0.1.130

package/dist/server-shell/package-installation/discovery.d.ts

@@ -0,0 +1,51 @@
+import { type PackageCommandPlan, type PackageCommandRunner } from "./command.js";
+import { PUBLISHED_TUTTI_PACKAGE_NAME, type GlobalPackageInstallation, type GlobalPackageInstallationResolution, type PackageInstallationUnavailableReason } from "./installation.js";
+import { type ExactSemver } from "./semver.js";
+export type PublishedPackageTarget = {
+    packageName: typeof PUBLISHED_TUTTI_PACKAGE_NAME;
+    version: ExactSemver;
+};
+export type PackageUpdateDiscovery = {
+    status: "up_to_date";
+    currentVersion: string;
+    latestVersion: string;
+} | {
+    status: "update_available";
+    currentVersion: string;
+    latestVersion: string;
+    target: PublishedPackageTarget;
+} | {
+    status: "unavailable";
+    currentVersion: string;
+    reasonCode: PackageInstallationUnavailableReason | "registry_unavailable";
+};
+export type GlobalInstallPlan = PackageCommandPlan & {
+    args: readonly [
+        "install",
+        "--global",
+        `${typeof PUBLISHED_TUTTI_PACKAGE_NAME}@${string}`,
+        "--no-audit",
+        "--no-fund"
+    ];
+};
+export declare function discoverPublishedPackageUpdate(options: {
+    installation: GlobalPackageInstallation;
+    runner?: PackageCommandRunner;
+}): Promise<PackageUpdateDiscovery>;
+export declare function buildGlobalInstallPlan(options: {
+    installation: GlobalPackageInstallation;
+    target: PublishedPackageTarget;
+}): GlobalInstallPlan;
+export declare class PackageUpdateDiscoveryService {
+    #private;
+    constructor(options?: {
+        runner?: PackageCommandRunner;
+        now?: () => number;
+        cacheTtlMs?: number;
+    });
+    discover(resolution: GlobalPackageInstallationResolution, options?: {
+        refresh?: boolean;
+    }): Promise<PackageUpdateDiscovery>;
+    clear(): void;
+}
+//# sourceMappingURL=discovery.d.ts.map

package/dist/server-shell/package-installation/discovery.js

@@ -0,0 +1,137 @@
+import { createPackageCommandPlan, runPackageCommand, } from "./command.js";
+import { PUBLISHED_TUTTI_PACKAGE_NAME, } from "./installation.js";
+import { compareExactSemver, parseExactSemver } from "./semver.js";
+const DEFAULT_DISCOVERY_CACHE_TTL_MS = 5 * 60 * 1_000;
+const GLOBAL_INSTALL_TIMEOUT_MS = 5 * 60 * 1_000;
+export async function discoverPublishedPackageUpdate(options) {
+    const result = await (options.runner ?? runPackageCommand)(createPackageCommandPlan({
+        executable: options.installation.npmExecutable,
+        args: ["view", PUBLISHED_TUTTI_PACKAGE_NAME, "dist-tags.latest", "--json"],
+        env: options.installation.npmEnvironment,
+    }));
+    if (result.status !== 0) {
+        return {
+            status: "unavailable",
+            currentVersion: options.installation.currentVersion,
+            reasonCode: "registry_unavailable",
+        };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(result.stdout);
+    }
+    catch {
+        parsed = null;
+    }
+    const latestVersion = parseExactSemver(parsed);
+    if (latestVersion === null) {
+        return {
+            status: "unavailable",
+            currentVersion: options.installation.currentVersion,
+            reasonCode: "registry_unavailable",
+        };
+    }
+    const comparison = compareExactSemver(latestVersion, options.installation.currentVersion);
+    if (comparison < 0) {
+        return {
+            status: "unavailable",
+            currentVersion: options.installation.currentVersion,
+            reasonCode: "registry_unavailable",
+        };
+    }
+    if (comparison === 0) {
+        return {
+            status: "up_to_date",
+            currentVersion: options.installation.currentVersion,
+            latestVersion,
+        };
+    }
+    return {
+        status: "update_available",
+        currentVersion: options.installation.currentVersion,
+        latestVersion,
+        target: { packageName: PUBLISHED_TUTTI_PACKAGE_NAME, version: latestVersion },
+    };
+}
+export function buildGlobalInstallPlan(options) {
+    if (options.target.packageName !== PUBLISHED_TUTTI_PACKAGE_NAME) {
+        throw new Error("The package update target is invalid.");
+    }
+    const version = parseExactSemver(options.target.version);
+    if (version === null || compareExactSemver(version, options.installation.currentVersion) <= 0) {
+        throw new Error("The package update target must be a newer exact version.");
+    }
+    const plan = createPackageCommandPlan({
+        executable: options.installation.npmExecutable,
+        args: [
+            "install",
+            "--global",
+            `${PUBLISHED_TUTTI_PACKAGE_NAME}@${version}`,
+            "--no-audit",
+            "--no-fund",
+        ],
+        env: options.installation.npmEnvironment,
+        timeoutMs: GLOBAL_INSTALL_TIMEOUT_MS,
+    });
+    return {
+        ...plan,
+        args: [
+            "install",
+            "--global",
+            `${PUBLISHED_TUTTI_PACKAGE_NAME}@${version}`,
+            "--no-audit",
+            "--no-fund",
+        ],
+    };
+}
+export class PackageUpdateDiscoveryService {
+    #runner;
+    #now;
+    #cacheTtlMs;
+    #cache;
+    #pending;
+    constructor(options = {}) {
+        this.#runner = options.runner ?? runPackageCommand;
+        this.#now = options.now ?? Date.now;
+        this.#cacheTtlMs = options.cacheTtlMs ?? DEFAULT_DISCOVERY_CACHE_TTL_MS;
+    }
+    async discover(resolution, options = {}) {
+        if (resolution.status === "unavailable") {
+            return {
+                status: "unavailable",
+                currentVersion: "0.0.0",
+                reasonCode: resolution.reasonCode,
+            };
+        }
+        const installation = resolution.installation;
+        const key = [
+            installation.npmExecutable,
+            installation.globalRoot,
+            installation.currentVersion,
+        ].join("\n");
+        if (options.refresh !== true &&
+            this.#cache?.key === key &&
+            this.#cache.expiresAt > this.#now()) {
+            return this.#cache.result;
+        }
+        if (options.refresh !== true && this.#pending?.key === key) {
+            return await this.#pending.result;
+        }
+        const result = discoverPublishedPackageUpdate({ installation, runner: this.#runner });
+        this.#pending = { key, result };
+        try {
+            const discovered = await result;
+            this.#cache = { key, expiresAt: this.#now() + this.#cacheTtlMs, result: discovered };
+            return discovered;
+        }
+        finally {
+            if (this.#pending?.result === result) {
+                this.#pending = undefined;
+            }
+        }
+    }
+    clear() {
+        this.#cache = undefined;
+    }
+}
+//# sourceMappingURL=discovery.js.map

package/dist/server-shell/package-installation/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./command.js";
+export * from "./discovery.js";
+export * from "./installation.js";
+export * from "./semver.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/server-shell/package-installation/index.js

@@ -0,0 +1,5 @@
+export * from "./command.js";
+export * from "./discovery.js";
+export * from "./installation.js";
+export * from "./semver.js";
+//# sourceMappingURL=index.js.map

package/dist/server-shell/package-installation/installation.d.ts

@@ -0,0 +1,34 @@
+import type { CliPackageIdentity } from "../cli/version.js";
+import { type SyncPackageCommandRunner } from "./command.js";
+import { type ExactSemver } from "./semver.js";
+export declare const PUBLISHED_TUTTI_PACKAGE_NAME = "@xfey/tenso";
+export declare const DEFAULT_NODE_ENGINE = ">=24 <26";
+export declare const DEFAULT_NPM_ENGINE = ">=11 <12";
+export type PackageInstallationUnavailableReason = "installation_not_global" | "custom_home" | "npm_unavailable" | "npm_global_root_mismatch" | "npm_version_unsupported" | "global_prefix_read_only";
+export type GlobalPackageInstallation = {
+    packageName: typeof PUBLISHED_TUTTI_PACKAGE_NAME;
+    currentVersion: ExactSemver;
+    packageRoot: string;
+    globalRoot: string;
+    npmExecutable: string;
+    nodeExecutable: string;
+    npmEnvironment: NodeJS.ProcessEnv;
+};
+export type GlobalPackageInstallationResolution = {
+    status: "eligible";
+    installation: GlobalPackageInstallation;
+} | {
+    status: "unavailable";
+    reasonCode: PackageInstallationUnavailableReason;
+};
+export declare function resolveGlobalPackageInstallation(options: {
+    packageIdentity: CliPackageIdentity;
+    tuttiHome: string;
+    env: NodeJS.ProcessEnv;
+    nodeExecutable?: string;
+    nodeVersion?: string;
+    defaultTuttiHome?: string;
+    runner?: SyncPackageCommandRunner;
+    pathWritable?: (path: string) => boolean;
+}): GlobalPackageInstallationResolution;
+//# sourceMappingURL=installation.d.ts.map

package/dist/server-shell/package-installation/installation.js

@@ -0,0 +1,123 @@
+import { accessSync, constants, existsSync, lstatSync, realpathSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { collectNpmExecutableCandidates, createNpmCommandEnvironment, createPackageCommandPlan, runPackageCommandSync, } from "./command.js";
+import { parseExactSemver, semverMajor } from "./semver.js";
+export const PUBLISHED_TUTTI_PACKAGE_NAME = "@xfey/tenso";
+export const DEFAULT_NODE_ENGINE = ">=24 <26";
+export const DEFAULT_NPM_ENGINE = ">=11 <12";
+function defaultTuttiHome() {
+    return join(homedir(), ".tutti");
+}
+function isWritable(path) {
+    try {
+        accessSync(path, constants.W_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function hasSupportedEngine(version, minimumMajor, maximumMajor) {
+    const exact = parseExactSemver(version.startsWith("v") ? version.slice(1) : version);
+    if (exact === null) {
+        return false;
+    }
+    const major = semverMajor(exact);
+    return major !== null && major >= minimumMajor && major < maximumMajor;
+}
+function strictAbsoluteLine(value) {
+    const trimmed = value.trim();
+    return trimmed !== "" && !trimmed.includes("\n") && !trimmed.includes("\r") && isAbsolute(trimmed)
+        ? trimmed
+        : null;
+}
+export function resolveGlobalPackageInstallation(options) {
+    const packageRoot = resolve(options.packageIdentity.root);
+    const currentVersion = parseExactSemver(options.packageIdentity.version);
+    if (options.packageIdentity.name !== PUBLISHED_TUTTI_PACKAGE_NAME ||
+        currentVersion === null ||
+        !isAbsolute(packageRoot)) {
+        return { status: "unavailable", reasonCode: "installation_not_global" };
+    }
+    if (resolve(options.tuttiHome) !== resolve(options.defaultTuttiHome ?? defaultTuttiHome())) {
+        return { status: "unavailable", reasonCode: "custom_home" };
+    }
+    const nodeExecutable = resolve(options.nodeExecutable ?? process.execPath);
+    if (!hasSupportedEngine(options.nodeVersion ?? process.version, 24, 26)) {
+        return { status: "unavailable", reasonCode: "npm_version_unsupported" };
+    }
+    const npmEnvironment = createNpmCommandEnvironment({ env: options.env, nodeExecutable });
+    const candidates = collectNpmExecutableCandidates({
+        env: options.env,
+        nodeExecutable,
+        packageRoot,
+        packageName: PUBLISHED_TUTTI_PACKAGE_NAME,
+    });
+    if (candidates.length === 0) {
+        return { status: "unavailable", reasonCode: "npm_unavailable" };
+    }
+    const runner = options.runner ?? runPackageCommandSync;
+    let observedGlobalRoot = false;
+    for (const npmExecutable of candidates) {
+        const rootResult = runner(createPackageCommandPlan({
+            executable: npmExecutable,
+            args: ["root", "--global"],
+            env: npmEnvironment,
+        }));
+        const globalRoot = rootResult.status === 0 ? strictAbsoluteLine(rootResult.stdout) : null;
+        if (globalRoot === null) {
+            continue;
+        }
+        observedGlobalRoot = true;
+        const expectedPackageRoot = join(globalRoot, ...PUBLISHED_TUTTI_PACKAGE_NAME.split("/"));
+        if (!existsSync(expectedPackageRoot)) {
+            continue;
+        }
+        try {
+            const expectedRealpath = realpathSync(expectedPackageRoot);
+            const packageRealpath = realpathSync(packageRoot);
+            if (lstatSync(expectedPackageRoot).isSymbolicLink()) {
+                if (expectedRealpath === packageRealpath) {
+                    return { status: "unavailable", reasonCode: "installation_not_global" };
+                }
+                continue;
+            }
+            if (expectedRealpath !== packageRealpath) {
+                continue;
+            }
+        }
+        catch {
+            continue;
+        }
+        const versionResult = runner(createPackageCommandPlan({
+            executable: npmExecutable,
+            args: ["--version"],
+            env: npmEnvironment,
+        }));
+        if (versionResult.status !== 0 || !hasSupportedEngine(versionResult.stdout.trim(), 11, 12)) {
+            return { status: "unavailable", reasonCode: "npm_version_unsupported" };
+        }
+        const pathWritable = options.pathWritable ?? isWritable;
+        if (!pathWritable(globalRoot) || !pathWritable(dirname(expectedPackageRoot))) {
+            return { status: "unavailable", reasonCode: "global_prefix_read_only" };
+        }
+        return {
+            status: "eligible",
+            installation: {
+                packageName: PUBLISHED_TUTTI_PACKAGE_NAME,
+                currentVersion,
+                packageRoot,
+                globalRoot,
+                npmExecutable,
+                nodeExecutable,
+                npmEnvironment,
+            },
+        };
+    }
+    return {
+        status: "unavailable",
+        reasonCode: observedGlobalRoot ? "npm_global_root_mismatch" : "npm_unavailable",
+    };
+}
+//# sourceMappingURL=installation.js.map

package/dist/server-shell/package-installation/semver.d.ts

@@ -0,0 +1,9 @@
+declare const exactSemverBrand: unique symbol;
+export type ExactSemver = string & {
+    readonly [exactSemverBrand]: true;
+};
+export declare function parseExactSemver(value: unknown): ExactSemver | null;
+export declare function compareExactSemver(left: ExactSemver, right: ExactSemver): number;
+export declare function semverMajor(version: ExactSemver): number | null;
+export {};
+//# sourceMappingURL=semver.d.ts.map

package/dist/server-shell/package-installation/semver.js

@@ -0,0 +1,84 @@
+const NUMERIC_IDENTIFIER = "(?:0|[1-9]\\d*)";
+const NON_NUMERIC_IDENTIFIER = "(?:\\d*[A-Za-z-][0-9A-Za-z-]*)";
+const PRERELEASE_IDENTIFIER = `(?:${NUMERIC_IDENTIFIER}|${NON_NUMERIC_IDENTIFIER})`;
+const EXACT_SEMVER_PATTERN = new RegExp(`^(${NUMERIC_IDENTIFIER})\\.(${NUMERIC_IDENTIFIER})\\.(${NUMERIC_IDENTIFIER})` +
+    `(?:-(${PRERELEASE_IDENTIFIER}(?:\\.${PRERELEASE_IDENTIFIER})*))?` +
+    "(?:\\+([0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*))?$", "u");
+function parse(value) {
+    const match = EXACT_SEMVER_PATTERN.exec(value);
+    if (match === null) {
+        return null;
+    }
+    const major = match[1];
+    const minor = match[2];
+    const patch = match[3];
+    if (major === undefined || minor === undefined || patch === undefined) {
+        return null;
+    }
+    return {
+        raw: value,
+        core: [major, minor, patch],
+        prerelease: match[4] === undefined ? [] : match[4].split("."),
+    };
+}
+export function parseExactSemver(value) {
+    if (typeof value !== "string" || value.trim() !== value) {
+        return null;
+    }
+    return parse(value)?.raw ?? null;
+}
+function compareNumeric(left, right) {
+    if (left.length !== right.length) {
+        return left.length < right.length ? -1 : 1;
+    }
+    return left === right ? 0 : left < right ? -1 : 1;
+}
+export function compareExactSemver(left, right) {
+    const parsedLeft = parse(left);
+    const parsedRight = parse(right);
+    if (parsedLeft === null || parsedRight === null) {
+        throw new Error("Cannot compare invalid SemVer values.");
+    }
+    for (let index = 0; index < parsedLeft.core.length; index += 1) {
+        const comparison = compareNumeric(parsedLeft.core[index] ?? "", parsedRight.core[index] ?? "");
+        if (comparison !== 0) {
+            return comparison;
+        }
+    }
+    if (parsedLeft.prerelease.length === 0 || parsedRight.prerelease.length === 0) {
+        if (parsedLeft.prerelease.length === parsedRight.prerelease.length) {
+            return 0;
+        }
+        return parsedLeft.prerelease.length === 0 ? 1 : -1;
+    }
+    const length = Math.max(parsedLeft.prerelease.length, parsedRight.prerelease.length);
+    for (let index = 0; index < length; index += 1) {
+        const leftIdentifier = parsedLeft.prerelease[index];
+        const rightIdentifier = parsedRight.prerelease[index];
+        if (leftIdentifier === undefined || rightIdentifier === undefined) {
+            return leftIdentifier === undefined ? -1 : 1;
+        }
+        if (leftIdentifier === rightIdentifier) {
+            continue;
+        }
+        const leftNumeric = /^\d+$/u.test(leftIdentifier);
+        const rightNumeric = /^\d+$/u.test(rightIdentifier);
+        if (leftNumeric && rightNumeric) {
+            return compareNumeric(leftIdentifier, rightIdentifier);
+        }
+        if (leftNumeric !== rightNumeric) {
+            return leftNumeric ? -1 : 1;
+        }
+        return leftIdentifier < rightIdentifier ? -1 : 1;
+    }
+    return 0;
+}
+export function semverMajor(version) {
+    const major = parse(version)?.core[0];
+    if (major === undefined || major.length > 6) {
+        return null;
+    }
+    const parsed = Number.parseInt(major, 10);
+    return Number.isSafeInteger(parsed) ? parsed : null;
+}
+//# sourceMappingURL=semver.js.map

package/dist/server-shell/session/relay-session-context.d.ts

@@ -0,0 +1,36 @@
+import { type FeishuPlatformSessionContext, type RelaySessionContext } from "@tutti/shared/schemas/internal";
+export declare const RELAY_SESSION_CONTEXT_METADATA_KEY = "relay_session_context";
+export declare const FEISHU_PLATFORM_SESSION_CONTEXT_METADATA_KEY = "feishu_platform_session_context";
+export declare const TRUSTED_RELAY_METADATA_REQUEST_HEADER = "x-tutti-internal-relay-metadata-id";
+export type RelaySessionContextReadResult = {
+    kind: "present";
+    context: RelaySessionContext;
+} | {
+    kind: "missing";
+} | {
+    kind: "invalid";
+};
+export type FeishuPlatformSessionContextReadResult = {
+    kind: "present";
+    context: FeishuPlatformSessionContext;
+} | {
+    kind: "missing";
+} | {
+    kind: "invalid";
+};
+export declare class RelaySessionInvalidError extends Error {
+    readonly statusCode = 401;
+    readonly code = "relay_session_invalid";
+    constructor(message?: string);
+}
+export declare class TrustedRelaySessionMetadataStore {
+    #private;
+    stage(metadata: unknown): string;
+    consume(requestId: string): unknown;
+}
+export declare function createTrustedRelaySessionMetadataStore(): TrustedRelaySessionMetadataStore;
+export declare function readRelaySessionContext(metadata: unknown): RelaySessionContextReadResult;
+export declare function requireRelaySessionContext(metadata: unknown): RelaySessionContext;
+export declare function readFeishuPlatformSessionContext(metadata: unknown): FeishuPlatformSessionContextReadResult;
+export declare function requireFeishuPlatformSessionContext(metadata: unknown): FeishuPlatformSessionContext;
+//# sourceMappingURL=relay-session-context.d.ts.map

package/dist/server-shell/session/relay-session-context.js

@@ -0,0 +1,67 @@
+import { randomUUID } from "node:crypto";
+import { parseFeishuPlatformSessionContext, parseRelaySessionContext, } from "@tutti/shared/schemas/internal";
+export const RELAY_SESSION_CONTEXT_METADATA_KEY = "relay_session_context";
+export const FEISHU_PLATFORM_SESSION_CONTEXT_METADATA_KEY = "feishu_platform_session_context";
+export const TRUSTED_RELAY_METADATA_REQUEST_HEADER = "x-tutti-internal-relay-metadata-id";
+export class RelaySessionInvalidError extends Error {
+    statusCode = 401;
+    code = "relay_session_invalid";
+    constructor(message = "Relay session context is missing or invalid") {
+        super(message);
+        this.name = "RelaySessionInvalidError";
+    }
+}
+export class TrustedRelaySessionMetadataStore {
+    #entries = new Map();
+    stage(metadata) {
+        const requestId = randomUUID();
+        this.#entries.set(requestId, metadata);
+        return requestId;
+    }
+    consume(requestId) {
+        const metadata = this.#entries.get(requestId);
+        this.#entries.delete(requestId);
+        return metadata;
+    }
+}
+export function createTrustedRelaySessionMetadataStore() {
+    return new TrustedRelaySessionMetadataStore();
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function readRelaySessionContext(metadata) {
+    if (!isRecord(metadata) || !(RELAY_SESSION_CONTEXT_METADATA_KEY in metadata)) {
+        return { kind: "missing" };
+    }
+    const context = parseRelaySessionContext(metadata[RELAY_SESSION_CONTEXT_METADATA_KEY]);
+    if (context === null) {
+        return { kind: "invalid" };
+    }
+    return { kind: "present", context };
+}
+export function requireRelaySessionContext(metadata) {
+    const result = readRelaySessionContext(metadata);
+    if (result.kind !== "present") {
+        throw new RelaySessionInvalidError();
+    }
+    return result.context;
+}
+export function readFeishuPlatformSessionContext(metadata) {
+    if (!isRecord(metadata) || !(FEISHU_PLATFORM_SESSION_CONTEXT_METADATA_KEY in metadata)) {
+        return { kind: "missing" };
+    }
+    const context = parseFeishuPlatformSessionContext(metadata[FEISHU_PLATFORM_SESSION_CONTEXT_METADATA_KEY]);
+    if (context === null) {
+        return { kind: "invalid" };
+    }
+    return { kind: "present", context };
+}
+export function requireFeishuPlatformSessionContext(metadata) {
+    const result = readFeishuPlatformSessionContext(metadata);
+    if (result.kind !== "present") {
+        throw new RelaySessionInvalidError();
+    }
+    return result.context;
+}
+//# sourceMappingURL=relay-session-context.js.map

package/dist/server-shell/smoke/e2e-client.d.ts

@@ -0,0 +1,64 @@
+import { type HostProjectApiClient, type EmailLoginChallengeProjection, type LoginResponse, type OpenProjectResponse, type RelayApiClient, type TuttiApiFetch, type AcceptJoinResponse, type JoinEntryProjection, type TuttiApiResponse } from "@tutti/api-client";
+import type { RelayProjectRef } from "@tutti/shared/ids";
+export type SmokeEmailLoginInput = {
+    email: string;
+    display_name?: string;
+    readCode: (challenge: EmailLoginChallengeProjection) => Promise<string>;
+};
+export type E2ESmokeLogSink = (line: string) => void;
+export type E2ESmokeClientOptions = {
+    relayBaseUrl: string;
+    origin?: string;
+    fetch?: TuttiApiFetch;
+    now?: () => Date;
+    log?: E2ESmokeLogSink;
+};
+export type E2ESmokeSession = {
+    relayBaseUrl: string;
+    origin: string;
+    relay: RelayApiClient;
+    cookieJar: E2ESmokeCookieJar;
+    fetch: TuttiApiFetch;
+    now: () => Date;
+    log?: E2ESmokeLogSink;
+    hostForProject: (relayProjectRef: RelayProjectRef) => HostProjectApiClient;
+};
+export type LoginJoinAndOpenWorkspaceInput = {
+    joinToken: string;
+    login: SmokeEmailLoginInput;
+};
+export type LoginJoinAndOpenWorkspaceResult = {
+    joinEntry: JoinEntryProjection;
+    login: LoginResponse;
+    acceptJoin: AcceptJoinResponse;
+    openProject: OpenProjectResponse;
+    relayProjectRef: RelayProjectRef;
+    host: HostProjectApiClient;
+};
+export type E2ESmokePollOptions<TValue> = {
+    label: string;
+    read: () => Promise<TValue>;
+    predicate: (value: TValue) => boolean;
+    timeoutMs?: number;
+    intervalMs?: number;
+    log?: E2ESmokeLogSink;
+    now?: () => Date;
+    sleep?: (ms: number) => Promise<void>;
+    describe?: (value: TValue) => Record<string, unknown>;
+};
+export declare class E2ESmokeFlowError extends Error {
+    readonly code: "missing_fetch" | "join_entry_invalid" | "join_accept_missing_project" | "project_open_failed" | "poll_timeout";
+    readonly details: Record<string, unknown>;
+    constructor(code: "missing_fetch" | "join_entry_invalid" | "join_accept_missing_project" | "project_open_failed" | "poll_timeout", message: string, details?: Record<string, unknown>);
+}
+export declare class E2ESmokeCookieJar {
+    private readonly cookies;
+    getCookieHeader(): string | undefined;
+    storeFromResponse(response: TuttiApiResponse): void;
+    private storeSetCookieHeader;
+}
+export declare function createE2ESmokeSession(options: E2ESmokeClientOptions): E2ESmokeSession;
+export declare function loginRelaySmokeAccount(session: E2ESmokeSession, input: SmokeEmailLoginInput): Promise<LoginResponse>;
+export declare function loginJoinAndOpenWorkspace(session: E2ESmokeSession, input: LoginJoinAndOpenWorkspaceInput): Promise<LoginJoinAndOpenWorkspaceResult>;
+export declare function pollE2ESmoke<TValue>(options: E2ESmokePollOptions<TValue>): Promise<TValue>;
+//# sourceMappingURL=e2e-client.d.ts.map