@xfey/tutti 0.1.119 → 0.1.120

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

@@ -0,0 +1,163 @@
+import { Value } from "@sinclair/typebox/value";
+import { Type } from "@sinclair/typebox";
+import { IdempotencyKeySchema, ProjectIdSchema } from "@tutti/shared/schemas/domain";
+import { ManagedTierSchema } from "@tutti/shared/schemas/internal";
+import { resolveLaunchLocalContext } from "../cli/launch.js";
+import { NativeManagedState } from "../managed-access/state.js";
+import { findNativeManagedProject } from "../managed-access/state.js";
+import { readExistingManagedTarget } from "../managed-access/existing-project.js";
+import { ManagedLocalStateError } from "../managed-access/private-store.js";
+import { reconcileNativePreparation, validateNativePreparation, } from "../managed-access/transport.js";
+import { createLocalConsoleOperationEnvironment, } from "./invocation-context.js";
+export const ManagedDraftInputSchema = Type.Object({
+    request_ref: IdempotencyKeySchema,
+    workspace_path: Type.String({ minLength: 1, maxLength: 4096 }),
+    display_name: Type.String({ minLength: 1, maxLength: 80 }),
+    description: Type.Optional(Type.String({ maxLength: 160 })),
+    surface: Type.Union([Type.Literal("standalone"), Type.Literal("feishu")]),
+    tier: ManagedTierSchema,
+    existing_project_id: Type.Optional(ProjectIdSchema),
+}, { additionalProperties: false });
+function projection(row) {
+    return {
+        request_ref: row.request_ref,
+        project_id: row.project_id,
+        display_name: row.display_name,
+        workspace_path: row.workspace_root,
+        ...(row.description === undefined ? {} : { description: row.description }),
+        surface: row.surface,
+        tier: row.tier,
+        ...(row.existing_relay_project_ref === undefined
+            ? {}
+            : { existing_project_id: row.project_id }),
+        state: row.state,
+        expires_at: row.expires_at,
+    };
+}
+// Native orchestration only. No project SQLite, Git writes, model key or browser account authority.
+export class LocalConsoleManagedProjectService {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    environment(context) {
+        return createLocalConsoleOperationEnvironment({
+            serviceEnvironment: this.options.serviceEnvironment ?? process.env,
+            invocationEnvironment: context.environment,
+            tuttiHome: this.options.tuttiHome,
+        });
+    }
+    state(context) {
+        const env = this.environment(context);
+        return new NativeManagedState({
+            tuttiHome: this.options.tuttiHome,
+            relayUrl: env.TUTTI_RELAY_URL ?? "https://tutti.now",
+        });
+    }
+    prepare(input, context) {
+        return this.options.operations.runProjectOperation(() => {
+            if (!Value.Check(ManagedDraftInputSchema, input) || !input.display_name.trim())
+                throw new ManagedLocalStateError("managed_creation_input_invalid");
+            const local = resolveLaunchLocalContext({
+                workspacePath: input.workspace_path,
+                env: this.environment(context),
+                cwd: context.source === "terminal" ? context.currentDirectory : this.options.tuttiHome,
+            });
+            if (local.existing_identity.kind !== "missing" && input.existing_project_id === undefined)
+                throw new ManagedLocalStateError("managed_existing_project_requires_opt_in");
+            const state = this.state(context);
+            let existing;
+            if (input.existing_project_id !== undefined) {
+                const target = readExistingManagedTarget({
+                    tuttiHome: this.options.tuttiHome,
+                    relayOrigin: state.origin,
+                    projectId: input.existing_project_id,
+                    workspaceRoot: local.workspace_root,
+                    surface: input.surface,
+                });
+                const previous = findNativeManagedProject({
+                    tuttiHome: this.options.tuttiHome,
+                    relayUrl: state.origin,
+                    projectId: input.existing_project_id,
+                });
+                if (previous !== null &&
+                    (previous.journal.state !== "registered" || previous.journal.tier !== input.tier))
+                    throw new ManagedLocalStateError("managed_reauthorization_conflict");
+                existing = {
+                    ...target,
+                    ...(previous === null ? {} : { previousRequestRef: previous.journal.request_ref }),
+                };
+            }
+            const row = state.createDraft({
+                requestRef: input.request_ref,
+                workspaceRoot: local.workspace_root,
+                displayName: input.display_name.trim(),
+                ...(input.description === undefined ? {} : { description: input.description.trim() }),
+                surface: input.surface,
+                tier: input.tier,
+                ...(existing === undefined ? {} : { projectId: input.existing_project_id, existing }),
+                now: this.options.now?.() ?? new Date(),
+            });
+            return {
+                draft: projection(row),
+                relay_origin: state.origin,
+                preparation: state.preparationBody(row.request_ref),
+            };
+        });
+    }
+    read(requestRef, context) {
+        const state = this.state(context);
+        return {
+            draft: projection(state.read(requestRef)),
+            relay_origin: state.origin,
+            preparation: state.preparationBody(requestRef),
+        };
+    }
+    async reconcile(requestRef, context) {
+        return this.options.operations.runProjectOperation(async () => {
+            const state = this.state(context);
+            await reconcileNativePreparation({
+                state,
+                requestRef,
+                now: this.options.now?.() ?? new Date(),
+                ...(this.options.fetchImpl === undefined ? {} : { fetchImpl: this.options.fetchImpl }),
+            });
+            return this.read(requestRef, context);
+        });
+    }
+    async validate(requestRef, context) {
+        return this.options.operations.runProjectOperation(async () => {
+            const state = this.state(context);
+            await reconcileNativePreparation({
+                state,
+                requestRef,
+                now: this.options.now?.() ?? new Date(),
+                ...(this.options.fetchImpl === undefined ? {} : { fetchImpl: this.options.fetchImpl }),
+            });
+            const validation = await validateNativePreparation({
+                state,
+                requestRef,
+                ...(this.options.fetchImpl === undefined ? {} : { fetchImpl: this.options.fetchImpl }),
+            });
+            return { ...this.read(requestRef, context), validation };
+        });
+    }
+    async launch(requestRef, context) {
+        return this.options.operations.runProjectOperation(async () => {
+            const projects = this.options.projects;
+            if (projects === undefined)
+                throw new ManagedLocalStateError("managed_launch_unavailable");
+            const state = this.state(context);
+            // Re-check current Relay authority immediately before any workspace mutation.
+            await reconcileNativePreparation({
+                state,
+                requestRef,
+                now: this.options.now?.() ?? new Date(),
+                ...(this.options.fetchImpl === undefined ? {} : { fetchImpl: this.options.fetchImpl }),
+            });
+            state.bootstrap(requestRef, this.options.now?.() ?? new Date());
+            return projects.launchAuthorizedProject(state, requestRef, context);
+        });
+    }
+}
+//# sourceMappingURL=managed-project-service.js.map

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

@@ -10,7 +10,7 @@ export type LocalConsoleOperationState = "idle" | "project_busy" | "package_upda
 export declare class LocalConsoleOperationCoordinator {
     #private;
     state(): LocalConsoleOperationState;
-    runProjectOperation<T>(operation: () => Promise<T>): Promise<T>;
+    runProjectOperation<T>(operation: () => T | Promise<T>): Promise<T>;
     tryBeginPackageUpdate(): LocalConsolePackageUpdateOperationLease | null;
 }
 //# sourceMappingURL=operation-coordinator.d.ts.map

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

@@ -3,6 +3,7 @@ import { readHostLocalPackageUpdateReadiness, requestHostLocalIdleShutdown, } fr
 import { createRuntimeEndpointProbe, waitForHostShutdown } from "../cli/host-runtime-endpoint.js";
 import { spawnDetachedHost, waitForManagedHostReady } from "../cli/managed-host.js";
 import { resolveManagedProjectContext } from "../cli/project-resolver.js";
+import { hasProjectModelConfiguration } from "../managed-access/project-provider.js";
 const PACKAGE_UPDATE_HOST_SHUTDOWN_WAIT_MS = 5_000;
 export async function stopPackageUpdateHost(options) {
     const fetchImpl = options.fetchImpl ?? fetch;
@@ -65,7 +66,7 @@ export async function restorePackageUpdateHosts(options) {
                 target: projectId,
                 env: { ...options.env, TUTTI_HOME: options.tuttiHome },
             });
-            if (!project.workspace_exists || project.provider_config.status !== "configured") {
+            if (!project.workspace_exists || !hasProjectModelConfiguration(project.provider_config)) {
                 failed.push(projectId);
                 continue;
             }

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

@@ -1,6 +1,8 @@
 import { type ProjectSurface, type ProjectSurfaceProfile } from "@tutti/shared/domain";
 import { type ProjectId, type RelayProjectRef } from "@tutti/shared/ids";
 import type { FeishuSetupProjection } from "@tutti/shared/schemas/internal";
+import type { ProviderConfigProjection } from "@tutti/shared/schemas/api";
+import type { NativeManagedState } from "../managed-access/state.js";
 import { type ConfigureProjectOpenAiProviderResult, type OpenAiProviderCredentialValidator } from "../../providers/openai/index.js";
 import { type FetchLike } from "../cli/host-runtime-endpoint.js";
 import type { HostLaunchRelaySummary } from "../cli/relay-registration.js";
@@ -13,8 +15,9 @@ export type LocalConsoleProject = {
     display_name: string;
     workspace_path: string;
     status: RuntimeProjectRow["status"];
-    provider_status: "configured" | "not_configured" | "invalid";
+    provider_status: ProviderConfigProjection["status"];
     provider_model?: string;
+    provider_tier?: "light" | "high" | "max";
     relay_project_ref?: RelayProjectRef;
     open_url?: string;
     relay_connection_status?: string;
@@ -91,6 +94,7 @@ export declare class LocalConsoleProjectService {
         provider?: LocalConsoleProviderInput;
         surface?: ProjectSurface;
     }, context: LocalConsoleInvocationContext, accountHandoff?: LocalConsoleAccountHandoff): Promise<LocalConsoleLaunchResult>;
+    launchAuthorizedProject(state: NativeManagedState, requestRef: string, context: LocalConsoleInvocationContext): Promise<LocalConsoleLaunchResult>;
     openProject(projectId: string, context: LocalConsoleInvocationContext): Promise<LocalConsoleOpenResult>;
     refreshInvite(projectId: string, context: LocalConsoleInvocationContext): Promise<{
         join_url: string;

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

@@ -3,7 +3,9 @@ import { resolve } from "node:path";
 import { readRelayProjectMembershipState } from "@tutti/relay-client";
 import { createProjectSurfaceProfile, } from "@tutti/shared/domain";
 import { relayProjectRouteSegment } from "@tutti/shared/ids";
-import { configureProjectOpenAiProvider, discoverOpenAiModels, isOpenAiApiKey, readOpenAiProviderConfigProjection, validateOpenAiCredential, } from "../../providers/openai/index.js";
+import { hasProjectModelConfiguration, readProjectModelAccess, } from "../managed-access/project-provider.js";
+import { materializeManagedWorkspace } from "../managed-access/workspace.js";
+import { configureProjectOpenAiProvider, discoverOpenAiModels, isOpenAiApiKey, validateOpenAiCredential, } from "../../providers/openai/index.js";
 import { formatCliErrorReason, LaunchError } from "../cli/errors.js";
 import { createRuntimeEndpointProbe, waitForHostShutdown, } from "../cli/host-runtime-endpoint.js";
 import { prepareLaunchProject, resolveLaunchLocalContext, resolveRelayUrl } from "../cli/launch.js";
@@ -207,18 +209,28 @@ export class LocalConsoleProjectService {
                     // Damaged legacy metadata remains visible without an invented creation date.
                 }
             }
-            const provider = readOpenAiProviderConfigProjection({
+            const provider = readProjectModelAccess({
                 tuttiHome: this.#tuttiHome,
                 projectId: row.project_id,
+                relayUrl: binding?.relay_url ?? resolveRelayUrl(operation.env),
             });
-            const providerModel = provider.status === "not_configured" ? undefined : provider.default_model;
+            const providerModel = provider.status === "not_configured"
+                ? undefined
+                : provider.status === "managed"
+                    ? `Tutti ${provider.tier}`
+                    : provider.default_model;
             const activityAt = readProjectActivityAt(this.#tuttiHome, row, binding);
-            return projectFromRuntimeRow(row, provider.status, providerModel, {
-                ...(activityAt === undefined ? {} : { activityAt }),
-                ...(createdAt === undefined ? {} : { createdAt }),
-                relayUrl: binding?.relay_url ?? relayUrlFromJoinUrl(row.join_url) ?? resolveRelayUrl(operation.env),
-                surfaceProfile: binding?.surface_profile ?? createProjectSurfaceProfile(),
-            });
+            return {
+                ...projectFromRuntimeRow(row, provider.status, providerModel, {
+                    ...(activityAt === undefined ? {} : { activityAt }),
+                    ...(createdAt === undefined ? {} : { createdAt }),
+                    relayUrl: binding?.relay_url ??
+                        relayUrlFromJoinUrl(row.join_url) ??
+                        resolveRelayUrl(operation.env),
+                    surfaceProfile: binding?.surface_profile ?? createProjectSurfaceProfile(),
+                }),
+                ...(provider.status === "managed" ? { provider_tier: provider.tier } : {}),
+            };
         });
     }
     async #readProject(projectId, context) {
@@ -325,12 +337,14 @@ export class LocalConsoleProjectService {
     #requireStoredLaunchProvider(workspacePath, operation) {
         const context = resolveLaunchLocalContext({ workspacePath, ...operation });
         const provider = context.existing_identity.kind === "present"
-            ? readOpenAiProviderConfigProjection({
+            ? readProjectModelAccess({
                 tuttiHome: context.tutti_home,
                 projectId: context.existing_identity.project_id,
+                relayUrl: readMachineProjectBinding(context.tutti_home, context.existing_identity.project_id)
+                    ?.relay_url ?? resolveRelayUrl(operation.env),
             })
             : { status: "not_configured" };
-        if (provider.status !== "configured") {
+        if (!hasProjectModelConfiguration(provider)) {
             throw new LocalConsoleProjectError("provider_configuration_required", "This project does not have a valid saved Provider. Configure it in the launch form.");
         }
     }
@@ -359,6 +373,18 @@ export class LocalConsoleProjectService {
     }
     async #launchProject(input, context, accountHandoff) {
         const operation = this.#operationOptions(context);
+        if (input.provider !== undefined) {
+            const local = resolveLaunchLocalContext({ workspacePath: input.workspacePath, ...operation });
+            if (local.existing_identity.kind === "present" &&
+                readProjectModelAccess({
+                    tuttiHome: local.tutti_home,
+                    projectId: local.existing_identity.project_id,
+                    relayUrl: readMachineProjectBinding(local.tutti_home, local.existing_identity.project_id)
+                        ?.relay_url ?? resolveRelayUrl(operation.env),
+                }).status === "managed") {
+                throw new LocalConsoleProjectError("managed_model_fixed", "Managed projects cannot be changed through BYOK setup.", 409);
+            }
+        }
         if (input.provider === undefined) {
             try {
                 this.#requireStoredLaunchProvider(input.workspacePath, operation);
@@ -388,6 +414,9 @@ export class LocalConsoleProjectService {
         catch (error) {
             throw this.#normalizeError(error);
         }
+        if (provider !== undefined && preparation.provider_status === "managed") {
+            throw new LocalConsoleProjectError("managed_model_fixed", "Managed projects cannot be changed through BYOK setup.", 409);
+        }
         if (provider !== undefined) {
             const configured = await configureProjectOpenAiProvider({
                 tuttiHome: preparation.tutti_home,
@@ -401,10 +430,11 @@ export class LocalConsoleProjectService {
                 throw new LocalConsoleProjectError(configured.reason, localConsoleProviderValidationMessage(configured));
             }
         }
-        else if (preparation.provider_status !== "configured") {
+        else if (!hasProjectModelConfiguration(preparation.provider_config)) {
             throw new LocalConsoleProjectError("provider_configuration_required", "This project does not have a valid saved Provider. Configure it in the launch form.");
         }
         if (preparation.machine_local.binding.surface_profile.kind === "feishu" &&
+            preparation.provider_status !== "managed" &&
             accountHandoff !== undefined) {
             writeFeishuOwnerAccountHandoff({
                 tuttiHome: preparation.tutti_home,
@@ -414,12 +444,31 @@ export class LocalConsoleProjectService {
                 now: this.#now(),
             });
         }
+        return this.#finishLaunch(preparation, context, operation.env);
+    }
+    // Called only by the native authority service while holding the Console operation
+    // guard. It accepts a private, verified journal, never a browser-provided receipt.
+    async launchAuthorizedProject(state, requestRef, context) {
+        const operation = this.#operationOptions(context);
+        const preparation = await materializeManagedWorkspace({
+            state,
+            requestRef,
+            tuttiHome: this.#tuttiHome,
+            environment: operation.env,
+            now: this.#now,
+        });
+        return this.#finishLaunch(preparation, context, {
+            ...operation.env,
+            TUTTI_RELAY_URL: state.origin,
+        });
+    }
+    async #finishLaunch(preparation, context, environment) {
         try {
             const ready = await this.#startManagedHost({
                 workspaceRoot: preparation.workspace_root,
                 tuttiHome: preparation.tutti_home,
                 projectId: preparation.project_id,
-                env: operation.env,
+                env: environment,
             });
             if (preparation.machine_local.binding.surface_profile.kind === "standalone" &&
                 ready.join_url === undefined) {
@@ -480,7 +529,7 @@ export class LocalConsoleProjectService {
         }
         if (!managed.workspace_exists ||
             managed.runtime_endpoint === null ||
-            managed.provider_config.status !== "configured") {
+            !hasProjectModelConfiguration(managed.provider_config)) {
             return { project: current, hostUpdate: "deferred_unavailable" };
         }
         let shutdownDisposition;

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

@@ -1,7 +1,10 @@
 import { timingSafeEqual } from "node:crypto";
+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";
@@ -66,7 +69,11 @@ function requireLoopbackHost(request) {
     }
 }
 export function createLocalConsoleServer(options) {
-    const app = fastify({ logger: false, bodyLimit: 64 * 1024 });
+    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 }),
@@ -119,6 +126,7 @@ export function createLocalConsoleServer(options) {
             }
         });
     app.addHook("onRequest", (request, reply, done) => {
+        reply.header("x-tutti-request-id", request.id);
         try {
             requireLoopbackHost(request);
             void reply
@@ -135,7 +143,7 @@ export function createLocalConsoleServer(options) {
             done(error);
         }
     });
-    app.setErrorHandler((error, _request, reply) => {
+    app.setErrorHandler((error, request, reply) => {
         const normalized = error instanceof LocalConsoleHttpError ||
             error instanceof LocalConsoleProjectError ||
             error instanceof LocalConsoleOperationConflictError
@@ -148,6 +156,7 @@ export function createLocalConsoleServer(options) {
                 code: normalized.code,
                 message: normalized.message,
                 retryable: normalized.statusCode >= 500,
+                request_id: request.id,
             },
         });
     });
@@ -173,6 +182,17 @@ export function createLocalConsoleServer(options) {
         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 }),
+        }),
+    });
     app.get(`${LOCAL_CONSOLE_API_BASE}/health`, () => ({
         status: "ready",
         protocol_version: 2,

package/dist/server-shell/managed-access/execution-binding.d.ts

@@ -0,0 +1,9 @@
+import type { OpenAiCredentialLease, OpenAiExecutionConfig } from "../../providers/openai/execution-access.js";
+import type { NativeManagedRuntime } from "./runtime.js";
+import type { ModelSessionOwner } from "./runtime-records.js";
+export type ManagedExecutionRuntime = Pick<NativeManagedRuntime, "selection" | "run">;
+export declare function bindManagedExecution(runtime: ManagedExecutionRuntime, owner: ModelSessionOwner): Promise<{
+    config: OpenAiExecutionConfig;
+    credentialLease: OpenAiCredentialLease;
+}>;
+//# sourceMappingURL=execution-binding.d.ts.map

package/dist/server-shell/managed-access/execution-binding.js

@@ -0,0 +1,22 @@
+import { ManagedLocalStateError } from "./private-store.js";
+export async function bindManagedExecution(runtime, owner) {
+    // This happens before provider factories open any durable Thread. Retaining
+    // this selection through retries forbids silent route/model replacement.
+    const selected = await runtime.selection(owner);
+    const config = {
+        default_model: selected.provider.model,
+        api_base_url: selected.provider.base_url,
+    };
+    return {
+        config,
+        credentialLease: (durationMs, invoke) => runtime.run(owner, Math.ceil(durationMs / 1000), async (access) => {
+            if (access.session_ref !== selected.session_ref ||
+                access.route_ref !== selected.route_ref ||
+                access.provider.model !== selected.provider.model ||
+                access.provider.base_url !== selected.provider.base_url)
+                throw new ManagedLocalStateError("managed_route_changed");
+            return invoke(access.provider.api_key);
+        }),
+    };
+}
+//# sourceMappingURL=execution-binding.js.map

package/dist/server-shell/managed-access/existing-project.d.ts

@@ -0,0 +1,15 @@
+import type { ProjectId } from "@tutti/shared/ids";
+export declare function requireStoppedManagedTarget(tuttiHome: string, projectId: ProjectId): void;
+export declare function readExistingManagedTarget(options: {
+    tuttiHome: string;
+    relayOrigin: string;
+    projectId: ProjectId;
+    workspaceRoot: string;
+    surface: "standalone" | "feishu";
+    requireStopped?: boolean;
+}): {
+    relayProjectRef: `relay_project_${string}`;
+    workspacePath: string;
+    hostSecret: string;
+};
+//# sourceMappingURL=existing-project.d.ts.map

package/dist/server-shell/managed-access/existing-project.js

@@ -0,0 +1,41 @@
+import { realpathSync } from "node:fs";
+import { readHostRegistrationSecret, readMachineProjectBinding, readMachineRuntimeEndpoint, } from "../cli/machine-local.js";
+import { readProjectIdentity } from "../cli/project-identity.js";
+import { ManagedLocalStateError } from "./private-store.js";
+import { managedRelayOrigin } from "./state.js";
+// A provider cutover must never mutate the authority used by a live Host. A
+// process we cannot prove stopped is rejected; network health failure is not proof.
+export function requireStoppedManagedTarget(tuttiHome, projectId) {
+    const endpoint = readMachineRuntimeEndpoint(tuttiHome, projectId);
+    if (endpoint === null)
+        return;
+    try {
+        process.kill(endpoint.pid, 0);
+    }
+    catch (error) {
+        if (error.code === "ESRCH")
+            return;
+    }
+    throw new ManagedLocalStateError("managed_project_must_be_stopped");
+}
+export function readExistingManagedTarget(options) {
+    if (options.requireStopped !== false)
+        requireStoppedManagedTarget(options.tuttiHome, options.projectId);
+    const binding = readMachineProjectBinding(options.tuttiHome, options.projectId);
+    const identity = readProjectIdentity(options.workspaceRoot);
+    if (binding === null ||
+        binding.relay_project_ref === undefined ||
+        binding.relay_url === undefined ||
+        managedRelayOrigin(binding.relay_url) !== options.relayOrigin ||
+        realpathSync(binding.workspace_root) !== realpathSync(options.workspaceRoot) ||
+        binding.surface_profile.kind !== options.surface ||
+        identity.kind !== "present" ||
+        identity.project_id !== options.projectId)
+        throw new ManagedLocalStateError("managed_existing_project_mismatch");
+    return {
+        relayProjectRef: binding.relay_project_ref,
+        workspacePath: binding.workspace_root,
+        hostSecret: readHostRegistrationSecret(options.tuttiHome, options.projectId).secret,
+    };
+}
+//# sourceMappingURL=existing-project.js.map

package/dist/server-shell/managed-access/model-control-client.d.ts

@@ -0,0 +1,66 @@
+import { ManagedLocalStateError } from "./private-store.js";
+export declare class ManagedControlError extends ManagedLocalStateError {
+    readonly status?: number | undefined;
+    readonly requestId?: string | undefined;
+    constructor(code: string, status?: number | undefined, requestId?: string | undefined);
+}
+export declare class NativeModelControlClient {
+    private readonly options;
+    constructor(options: {
+        authorize: () => Promise<{
+            authorization: string;
+            control_origin: string;
+        }>;
+        fetchImpl?: typeof fetch;
+    });
+    private request;
+    pin(sessionRef: string, routeRef?: string): Promise<{
+        disposition: "created" | "existing";
+        tier: "light" | "high" | "max";
+        session_ref: string;
+        provider: {
+            model: string;
+            base_url: string;
+        };
+        route_ref: string;
+    }>;
+    issue(sessionRef: string, requestRef: string): Promise<{
+        disposition: "issued";
+        provider: {
+            api_key: string;
+            model: string;
+            base_url: string;
+        };
+        route_ref: string;
+        credential: {
+            state: "active" | "revoked" | "expired" | "creating" | "revoking";
+            session_ref: string;
+            expires_at: number;
+            credential_ref: string;
+            device_ref: string;
+            quota_cap: number;
+        };
+    } | {
+        disposition: "already_issued";
+        credential: {
+            state: "active" | "revoked" | "expired" | "creating" | "revoking";
+            session_ref: string;
+            expires_at: number;
+            credential_ref: string;
+            device_ref: string;
+            quota_cap: number;
+        };
+    }>;
+    revoke(credentialRef: string): Promise<{
+        disposition: "revoked";
+        credential: {
+            state: "active" | "revoked" | "expired" | "creating" | "revoking";
+            session_ref: string;
+            expires_at: number;
+            credential_ref: string;
+            device_ref: string;
+            quota_cap: number;
+        };
+    }>;
+}
+//# sourceMappingURL=model-control-client.d.ts.map