@xfey/tutti 0.1.119 → 0.1.121

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,27 @@ 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.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(),
+                }),
+            };
         });
     }
     async #readProject(projectId, context) {
@@ -325,12 +336,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 +372,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 +413,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 +429,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 +443,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 +528,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/legacy-records.d.ts

@@ -0,0 +1,2 @@
+export declare function upgradeTieredPrivateRecord(value: unknown, withAuthority?: boolean): unknown;
+//# sourceMappingURL=legacy-records.d.ts.map

package/dist/server-shell/managed-access/legacy-records.js

@@ -0,0 +1,24 @@
+// The only compatibility boundary for 0.1.120 private records. This is not a
+// network parser: callers still validate the complete current strict schema.
+export function upgradeTieredPrivateRecord(value, withAuthority = false) {
+    if (!value || typeof value !== "object" || !("version" in value) || value.version !== 1)
+        return value;
+    if (!("tier" in value) ||
+        typeof value.tier !== "string" ||
+        !["light", "high", "max"].includes(value.tier))
+        return value;
+    const { tier, ...fields } = value;
+    if (withAuthority && "authority" in fields) {
+        const authority = fields.authority;
+        if (!authority ||
+            typeof authority !== "object" ||
+            !("tier" in authority) ||
+            authority.tier !== tier)
+            return value;
+        const projection = { ...authority };
+        delete projection.tier;
+        return { ...fields, version: 2, authority: projection };
+    }
+    return { ...fields, version: 2 };
+}
+//# sourceMappingURL=legacy-records.js.map

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

@@ -0,0 +1,65 @@
+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";
+        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

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

@@ -0,0 +1,112 @@
+import { Value } from "@sinclair/typebox/value";
+import { ManagedSessionResultSchema, ManagedCredentialIssueResultSchema, ManagedCredentialRevokeResultSchema, ManagedRuntimeCredentialRefSchema, } from "@tutti/shared/schemas/internal";
+import { managedRelayOrigin } from "./state.js";
+import { ManagedLocalStateError } from "./private-store.js";
+export class ManagedControlError extends ManagedLocalStateError {
+    status;
+    requestId;
+    constructor(code, status, requestId) {
+        super(code);
+        this.status = status;
+        this.requestId = requestId;
+    }
+}
+const reasons = new Set([
+    "authority_invalid",
+    "host_delegation_revoked",
+    "delegated_installation_fixed",
+    "session_not_found",
+    "default_route_unavailable",
+    "pinned_route_unavailable",
+    "gateway_route_drift",
+    "credential_request_mismatch",
+    "credential_creation_unknown",
+    "credential_policy_mismatch",
+    "device_credential_exists",
+    "credential_limit",
+    "credential_revocation_unknown",
+    "gateway_transport_unknown",
+    "gateway_rate_limited",
+    "gateway_rejected",
+    "gateway_response_invalid",
+    "control_queue_full",
+]);
+export class NativeModelControlClient {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async request(path, body, schema) {
+        const authority = await this.options.authorize();
+        try {
+            const origin = managedRelayOrigin(authority.control_origin);
+            const response = await (this.options.fetchImpl ?? fetch)(new URL(path, origin), {
+                method: "POST",
+                redirect: "error",
+                signal: AbortSignal.timeout(55_000),
+                headers: {
+                    "content-type": "application/json",
+                    authorization: `Bearer ${authority.authorization}`,
+                },
+                body: JSON.stringify(body),
+            });
+            const header = response.headers.get("x-tutti-request-id");
+            const requestId = header && /^[A-Za-z0-9_-]{1,100}$/.test(header) ? header : undefined;
+            const reader = response.body?.getReader();
+            if (!reader)
+                throw new ManagedControlError("managed_control_invalid_response", response.status, requestId);
+            const chunks = [];
+            let size = 0;
+            try {
+                for (;;) {
+                    const item = await reader.read();
+                    if (item.done)
+                        break;
+                    if (!(item.value instanceof Uint8Array))
+                        throw new ManagedControlError("managed_control_invalid_response", response.status, requestId);
+                    size += item.value.byteLength;
+                    if (size > 16 * 1024)
+                        throw new ManagedControlError("managed_control_invalid_response", response.status, requestId);
+                    chunks.push(item.value);
+                }
+            }
+            finally {
+                await reader.cancel().catch(() => undefined);
+                reader.releaseLock();
+            }
+            let value;
+            try {
+                value = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+            }
+            catch {
+                throw new ManagedControlError("managed_control_invalid_response", response.status, requestId);
+            }
+            if (!response.ok) {
+                const reason = value?.error?.code;
+                throw new ManagedControlError(typeof reason === "string" && reasons.has(reason)
+                    ? reason
+                    : "managed_control_unavailable", response.status, requestId);
+            }
+            if (!Value.Check(schema, value))
+                throw new ManagedControlError("managed_control_invalid_response", response.status, requestId);
+            return value;
+        }
+        catch (error) {
+            if (error instanceof ManagedLocalStateError)
+                throw error;
+            throw new ManagedControlError("managed_control_unavailable");
+        }
+    }
+    pin(sessionRef, routeRef) {
+        return this.request("/v2/sessions", { session_ref: sessionRef, ...(routeRef === undefined ? {} : { route_ref: routeRef }) }, ManagedSessionResultSchema);
+    }
+    issue(sessionRef, requestRef) {
+        return this.request("/v2/credentials", { session_ref: sessionRef, request_ref: requestRef }, ManagedCredentialIssueResultSchema);
+    }
+    revoke(credentialRef) {
+        if (!Value.Check(ManagedRuntimeCredentialRefSchema, credentialRef))
+            throw new ManagedControlError("managed_control_invalid_request");
+        return this.request(`/v2/credentials/${credentialRef}/revoke`, {}, ManagedCredentialRevokeResultSchema);
+    }
+}
+//# sourceMappingURL=model-control-client.js.map

package/dist/server-shell/managed-access/private-store.d.ts

@@ -0,0 +1,19 @@
+export declare class ManagedLocalStateError extends Error {
+    readonly code: string;
+    constructor(code: string);
+}
+export declare function isWithin(parent: string, target: string): boolean;
+export declare function ensureManagedPrivateRoot(tuttiHome: string, originHash: string): string;
+export declare class ManagedPrivateStore {
+    readonly root: string;
+    private readonly identity;
+    constructor(root: string);
+    private checkRoot;
+    private path;
+    read(name: string): unknown;
+    write(name: string, value: unknown, exclusive?: boolean): boolean;
+    transaction<T>(run: () => T): T;
+    acquireExecutionLease(name: string): () => void;
+    private syncDirectory;
+}
+//# sourceMappingURL=private-store.d.ts.map