@xfey/tutti 0.1.119 → 0.1.120

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

@@ -0,0 +1,114 @@
+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_tier_fixed",
+    "delegated_installation_fixed",
+    "session_not_found",
+    "session_tier_fixed",
+    "tier_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

package/dist/server-shell/managed-access/private-store.js

@@ -0,0 +1,275 @@
+import { randomBytes } from "node:crypto";
+import { closeSync, constants, existsSync, fstatSync, fsyncSync, linkSync, lstatSync, mkdirSync, openSync, readSync, realpathSync, renameSync, unlinkSync, writeFileSync, } from "node:fs";
+import { dirname, isAbsolute, join, relative } from "node:path";
+import { fileURLToPath } from "node:url";
+import Database from "better-sqlite3";
+const MAX_PRIVATE_BYTES = 32 * 1024;
+const packageRoot = realpathSync(fileURLToPath(new URL("../../../", import.meta.url)));
+export class ManagedLocalStateError extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.code = code;
+        this.name = "ManagedLocalStateError";
+    }
+}
+function systemCode(error) {
+    return typeof error === "object" && error !== null && "code" in error ? error.code : undefined;
+}
+function unlinkIfPresent(path) {
+    try {
+        unlinkSync(path);
+    }
+    catch (error) {
+        if (systemCode(error) !== "ENOENT")
+            throw error;
+    }
+}
+export function isWithin(parent, target) {
+    const path = relative(parent, target);
+    return path === "" || (!path.startsWith("../") && path !== ".." && !isAbsolute(path));
+}
+function guard(run) {
+    try {
+        return run();
+    }
+    catch (error) {
+        if (error instanceof ManagedLocalStateError)
+            throw error;
+        throw new ManagedLocalStateError("managed_private_state_unavailable");
+    }
+}
+// Ancestors such as /var -> /private/var may be OS aliases. The selected Home and
+// every directory we own below it must be actual owner-only directories, not links.
+export function ensureManagedPrivateRoot(tuttiHome, originHash) {
+    return guard(() => {
+        if (!isAbsolute(tuttiHome) || !/^[a-f0-9]{64}$/.test(originHash))
+            throw new ManagedLocalStateError("managed_private_directory_invalid");
+        let ancestor = tuttiHome;
+        while (!existsSync(ancestor) && dirname(ancestor) !== ancestor)
+            ancestor = dirname(ancestor);
+        const proposed = join(realpathSync(ancestor), relative(ancestor, tuttiHome));
+        if (isWithin(packageRoot, proposed))
+            throw new ManagedLocalStateError("managed_state_in_repository");
+        for (let path = proposed; dirname(path) !== path; path = dirname(path)) {
+            if (existsSync(join(path, ".git")))
+                throw new ManagedLocalStateError("managed_state_in_repository");
+        }
+        for (const path of [
+            tuttiHome,
+            join(tuttiHome, "credentials"),
+            join(tuttiHome, "credentials", "managed"),
+            join(tuttiHome, "credentials", "managed", originHash),
+        ]) {
+            mkdirSync(path, { recursive: true, mode: 0o700 });
+            const stat = lstatSync(path);
+            if (!stat.isDirectory() ||
+                stat.isSymbolicLink() ||
+                stat.uid !== process.getuid?.() ||
+                stat.mode & 0o077)
+                throw new ManagedLocalStateError("managed_private_directory_invalid");
+        }
+        return realpathSync(join(tuttiHome, "credentials", "managed", originHash));
+    });
+}
+export class ManagedPrivateStore {
+    root;
+    identity;
+    constructor(root) {
+        // Normalize OS ancestor aliases, but do not accept a linked selected directory.
+        if (guard(() => lstatSync(root).isSymbolicLink()))
+            throw new ManagedLocalStateError("managed_private_directory_invalid");
+        this.root = guard(() => realpathSync(root));
+        this.identity = guard(() => this.checkRoot());
+    }
+    checkRoot() {
+        const stat = lstatSync(this.root);
+        if (!stat.isDirectory() ||
+            stat.isSymbolicLink() ||
+            stat.uid !== process.getuid?.() ||
+            stat.mode & 0o077 ||
+            realpathSync(this.root) !== this.root ||
+            (this.identity !== undefined &&
+                (stat.dev !== this.identity.dev || stat.ino !== this.identity.ino)))
+            throw new ManagedLocalStateError("managed_private_directory_invalid");
+        return { dev: stat.dev, ino: stat.ino };
+    }
+    path(name) {
+        if (!/^[a-zA-Z0-9_-]{1,120}\.json$/.test(name))
+            throw new ManagedLocalStateError("managed_record_name_invalid");
+        return join(this.root, name);
+    }
+    read(name) {
+        return guard(() => {
+            this.checkRoot();
+            let fd;
+            try {
+                fd = openSync(this.path(name), constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+            }
+            catch (error) {
+                if (systemCode(error) === "ENOENT")
+                    return null;
+                throw error;
+            }
+            try {
+                const stat = fstatSync(fd);
+                if (!stat.isFile() ||
+                    stat.uid !== process.getuid?.() ||
+                    stat.mode & 0o077 ||
+                    stat.nlink !== 1 ||
+                    stat.size > MAX_PRIVATE_BYTES)
+                    throw new ManagedLocalStateError("managed_private_file_invalid");
+                // A file can grow after fstat. Bound the allocation and every read as well.
+                const bytes = Buffer.alloc(MAX_PRIVATE_BYTES + 1);
+                let size = 0;
+                while (size < bytes.length) {
+                    const count = readSync(fd, bytes, size, bytes.length - size, null);
+                    if (count === 0)
+                        break;
+                    size += count;
+                }
+                if (size > MAX_PRIVATE_BYTES)
+                    throw new ManagedLocalStateError("managed_private_file_invalid");
+                return JSON.parse(bytes.toString("utf8", 0, size));
+            }
+            finally {
+                closeSync(fd);
+            }
+        });
+    }
+    write(name, value, exclusive = false) {
+        return guard(() => {
+            const path = this.path(name);
+            const body = JSON.stringify(value) + "\n";
+            if (Buffer.byteLength(body) > MAX_PRIVATE_BYTES)
+                throw new ManagedLocalStateError("managed_private_file_invalid");
+            // Validate an existing destination instead of overwriting an unknown / linked file.
+            if (this.read(name) !== null && exclusive)
+                return false;
+            const temp = join(this.root, `.write-${randomBytes(16).toString("hex")}`);
+            try {
+                const fd = openSync(temp, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
+                try {
+                    writeFileSync(fd, body);
+                    fsyncSync(fd);
+                }
+                finally {
+                    closeSync(fd);
+                }
+                this.checkRoot();
+                if (exclusive) {
+                    try {
+                        linkSync(temp, path);
+                    }
+                    catch (error) {
+                        if (systemCode(error) === "EEXIST")
+                            return false;
+                        throw error;
+                    }
+                }
+                else {
+                    renameSync(temp, path);
+                }
+            }
+            finally {
+                unlinkIfPresent(temp);
+                this.syncDirectory();
+            }
+            return true;
+        });
+    }
+    // SQLite is only an OS-released cross-process mutex here: no schema, metadata or
+    // secrets are stored in it. Crash recovery never unlinks another process's lock.
+    // This callback is intentionally synchronous: never hold it across network I/O.
+    transaction(run) {
+        return guard(() => {
+            this.checkRoot();
+            const path = join(this.root, "serialization.sqlite");
+            try {
+                const fd = openSync(path, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
+                closeSync(fd);
+            }
+            catch (error) {
+                if (systemCode(error) !== "EEXIST")
+                    throw error;
+            }
+            const stat = lstatSync(path);
+            if (!stat.isFile() ||
+                stat.isSymbolicLink() ||
+                stat.uid !== process.getuid?.() ||
+                stat.mode & 0o077 ||
+                stat.nlink !== 1)
+                throw new ManagedLocalStateError("managed_private_file_invalid");
+            const lock = new Database(path, { timeout: 1000 });
+            try {
+                lock.exec("BEGIN IMMEDIATE");
+                const result = run();
+                if (result && typeof result === "object" && "then" in result)
+                    throw new ManagedLocalStateError("managed_transaction_must_be_synchronous");
+                lock.exec("COMMIT");
+                return result;
+            }
+            catch (error) {
+                if (systemCode(error) === "SQLITE_BUSY")
+                    throw new ManagedLocalStateError("managed_state_busy");
+                throw error;
+            }
+            finally {
+                lock.close();
+            }
+        });
+    }
+    // Separate per-model-session execution lease. Unlike the short journal mutex,
+    // this lock deliberately spans one bounded model invocation. It stores no data,
+    // fails immediately on contention, and is released by the OS if the Host dies.
+    acquireExecutionLease(name) {
+        return guard(() => {
+            if (!/^(model|workspace)-[a-f0-9]{64}$/.test(name))
+                throw new ManagedLocalStateError("managed_record_name_invalid");
+            this.checkRoot();
+            const path = join(this.root, `${name}.sqlite`);
+            try {
+                const fd = openSync(path, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
+                closeSync(fd);
+            }
+            catch (error) {
+                if (systemCode(error) !== "EEXIST")
+                    throw error;
+            }
+            const stat = lstatSync(path);
+            if (!stat.isFile() ||
+                stat.isSymbolicLink() ||
+                stat.uid !== process.getuid?.() ||
+                stat.mode & 0o077 ||
+                stat.nlink !== 1)
+                throw new ManagedLocalStateError("managed_private_file_invalid");
+            const lock = new Database(path, { timeout: 0 });
+            try {
+                lock.exec("BEGIN IMMEDIATE");
+            }
+            catch (error) {
+                lock.close();
+                if (systemCode(error) === "SQLITE_BUSY")
+                    throw new ManagedLocalStateError(name.startsWith("workspace-") ? "managed_workspace_busy" : "managed_session_busy");
+                throw error;
+            }
+            let released = false;
+            return () => {
+                if (!released) {
+                    released = true;
+                    lock.close();
+                }
+            };
+        });
+    }
+    syncDirectory() {
+        const fd = openSync(this.root, constants.O_RDONLY);
+        try {
+            fsyncSync(fd);
+        }
+        finally {
+            closeSync(fd);
+        }
+    }
+}
+//# sourceMappingURL=private-store.js.map

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

@@ -0,0 +1,18 @@
+import type { ProjectId } from "@tutti/shared/ids";
+import type { ProviderConfigProjection } from "@tutti/shared/schemas/api";
+import { NativeManagedRuntime, type ManagedRuntimeObservation } from "./runtime.js";
+export declare function readProjectModelAccess(options: {
+    tuttiHome: string;
+    relayUrl: string;
+    projectId: ProjectId;
+}): ProviderConfigProjection;
+export declare function hasProjectModelConfiguration(projection: ProviderConfigProjection): boolean;
+export declare function createNativeManagedHostRuntime(options: {
+    tuttiHome: string;
+    relayUrl: string;
+    projectId: ProjectId;
+    workspaceRoot: string;
+    surface: "standalone" | "feishu";
+    observe?: (event: ManagedRuntimeObservation) => void;
+}): NativeManagedRuntime | null;
+//# sourceMappingURL=project-provider.d.ts.map

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

@@ -0,0 +1,30 @@
+import { realpathSync } from "node:fs";
+import { readOpenAiProviderConfigProjection } from "../../providers/openai/provider-config.js";
+import { findNativeManagedProject } from "./state.js";
+import { readHostRegistrationSecret } from "../cli/machine-local.js";
+import { ManagedLocalStateError } from "./private-store.js";
+import { NativeManagedRuntime } from "./runtime.js";
+// A mode projection, not a promise that current remote authority or quota is
+// available. Every actual managed invocation independently verifies both.
+export function readProjectModelAccess(options) {
+    const native = findNativeManagedProject(options);
+    if (native !== null) {
+        return { status: "managed", funding_kind: "trial", tier: native.journal.tier };
+    }
+    return readOpenAiProviderConfigProjection(options);
+}
+export function hasProjectModelConfiguration(projection) {
+    return projection.status === "configured" || projection.status === "managed";
+}
+export function createNativeManagedHostRuntime(options) {
+    const managed = findNativeManagedProject(options);
+    if (managed === null)
+        return null;
+    if (managed.journal.workspace_root !== realpathSync(options.workspaceRoot) ||
+        managed.journal.surface !== options.surface ||
+        managed.journal.host_registration_secret !==
+            readHostRegistrationSecret(options.tuttiHome, options.projectId).secret)
+        throw new ManagedLocalStateError("managed_registration_mismatch");
+    return new NativeManagedRuntime(options);
+}
+//# sourceMappingURL=project-provider.js.map

package/dist/server-shell/managed-access/records.d.ts

@@ -0,0 +1,108 @@
+import { type Static } from "@sinclair/typebox";
+import type { ProjectId } from "@tutti/shared/ids";
+export declare const InstallationSchema: import("@sinclair/typebox").TObject<{
+    version: import("@sinclair/typebox").TLiteral<1>;
+    relay_origin: import("@sinclair/typebox").TString;
+    installation_ref: import("@sinclair/typebox").TString;
+    secret: import("@sinclair/typebox").TString;
+    created_at: import("@sinclair/typebox").TString;
+}>;
+export type Installation = Static<typeof InstallationSchema>;
+export declare const CreationJournalSchema: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
+    state: import("@sinclair/typebox").TLiteral<"awaiting_authorization">;
+    version: import("@sinclair/typebox").TLiteral<1>;
+    request_ref: import("@sinclair/typebox").TString;
+    project_id: import("@sinclair/typebox").TString;
+    relay_origin: import("@sinclair/typebox").TString;
+    installation_ref: import("@sinclair/typebox").TString;
+    workspace_root: import("@sinclair/typebox").TString;
+    display_name: import("@sinclair/typebox").TString;
+    description: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    surface: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"standalone">, import("@sinclair/typebox").TLiteral<"feishu">]>;
+    tier: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"light">, import("@sinclair/typebox").TLiteral<"high">, import("@sinclair/typebox").TLiteral<"max">]>;
+    existing_relay_project_ref: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    previous_request_ref: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    handoff_token: import("@sinclair/typebox").TString;
+    host_registration_secret: import("@sinclair/typebox").TString;
+    created_at: import("@sinclair/typebox").TString;
+    expires_at: import("@sinclair/typebox").TString;
+}>, import("@sinclair/typebox").TObject<{
+    state: import("@sinclair/typebox").TLiteral<"prepared">;
+    creation_ref: import("@sinclair/typebox").TString;
+    version: import("@sinclair/typebox").TLiteral<1>;
+    request_ref: import("@sinclair/typebox").TString;
+    project_id: import("@sinclair/typebox").TString;
+    relay_origin: import("@sinclair/typebox").TString;
+    installation_ref: import("@sinclair/typebox").TString;
+    workspace_root: import("@sinclair/typebox").TString;
+    display_name: import("@sinclair/typebox").TString;
+    description: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    surface: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"standalone">, import("@sinclair/typebox").TLiteral<"feishu">]>;
+    tier: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"light">, import("@sinclair/typebox").TLiteral<"high">, import("@sinclair/typebox").TLiteral<"max">]>;
+    existing_relay_project_ref: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    previous_request_ref: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    handoff_token: import("@sinclair/typebox").TString;
+    host_registration_secret: import("@sinclair/typebox").TString;
+    created_at: import("@sinclair/typebox").TString;
+    expires_at: import("@sinclair/typebox").TString;
+}>, import("@sinclair/typebox").TObject<{
+    state: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"validated">, import("@sinclair/typebox").TLiteral<"validation_unknown">, import("@sinclair/typebox").TLiteral<"validation_failed">]>;
+    creation_ref: import("@sinclair/typebox").TString;
+    version: import("@sinclair/typebox").TLiteral<1>;
+    request_ref: import("@sinclair/typebox").TString;
+    project_id: import("@sinclair/typebox").TString;
+    relay_origin: import("@sinclair/typebox").TString;
+    installation_ref: import("@sinclair/typebox").TString;
+    workspace_root: import("@sinclair/typebox").TString;
+    display_name: import("@sinclair/typebox").TString;
+    description: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    surface: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"standalone">, import("@sinclair/typebox").TLiteral<"feishu">]>;
+    tier: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"light">, import("@sinclair/typebox").TLiteral<"high">, import("@sinclair/typebox").TLiteral<"max">]>;
+    existing_relay_project_ref: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    previous_request_ref: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    handoff_token: import("@sinclair/typebox").TString;
+    host_registration_secret: import("@sinclair/typebox").TString;
+    created_at: import("@sinclair/typebox").TString;
+    expires_at: import("@sinclair/typebox").TString;
+}>, import("@sinclair/typebox").TObject<{
+    state: import("@sinclair/typebox").TLiteral<"registered">;
+    creation_ref: import("@sinclair/typebox").TString;
+    authority: import("@sinclair/typebox").TObject<{
+        delegation_ref: import("@sinclair/typebox").TString;
+        grant_ref: import("@sinclair/typebox").TString;
+        relay_project_ref: import("@sinclair/typebox").TString;
+        installation_ref: import("@sinclair/typebox").TString;
+        tier: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"light">, import("@sinclair/typebox").TLiteral<"high">, import("@sinclair/typebox").TLiteral<"max">]>;
+        funding_kind: import("@sinclair/typebox").TLiteral<"trial">;
+        expires_at: import("@sinclair/typebox").TNull;
+        state: import("@sinclair/typebox").TLiteral<"active">;
+        model_access: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"runtime_authority_required">, import("@sinclair/typebox").TLiteral<"not_enabled">]>;
+    }>;
+    version: import("@sinclair/typebox").TLiteral<1>;
+    request_ref: import("@sinclair/typebox").TString;
+    project_id: import("@sinclair/typebox").TString;
+    relay_origin: import("@sinclair/typebox").TString;
+    installation_ref: import("@sinclair/typebox").TString;
+    workspace_root: import("@sinclair/typebox").TString;
+    display_name: import("@sinclair/typebox").TString;
+    description: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    surface: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"standalone">, import("@sinclair/typebox").TLiteral<"feishu">]>;
+    tier: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"light">, import("@sinclair/typebox").TLiteral<"high">, import("@sinclair/typebox").TLiteral<"max">]>;
+    existing_relay_project_ref: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    previous_request_ref: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    handoff_token: import("@sinclair/typebox").TString;
+    host_registration_secret: import("@sinclair/typebox").TString;
+    created_at: import("@sinclair/typebox").TString;
+    expires_at: import("@sinclair/typebox").TString;
+}>]>;
+export type CreationJournal = Static<typeof CreationJournalSchema> & {
+    project_id: ProjectId;
+};
+export declare const NativeProjectPointerSchema: import("@sinclair/typebox").TObject<{
+    version: import("@sinclair/typebox").TLiteral<1>;
+    project_id: import("@sinclair/typebox").TString;
+    request_ref: import("@sinclair/typebox").TString;
+}>;
+export declare function parseInstallation(raw: unknown, origin: string): Installation;
+export declare function parseJournal(raw: unknown, origin: string, requestRef: string): CreationJournal;
+//# sourceMappingURL=records.d.ts.map

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

@@ -0,0 +1,73 @@
+import { Type } from "@sinclair/typebox";
+import { Value } from "@sinclair/typebox/value";
+import { IdempotencyKeySchema, ProjectIdSchema, RelayProjectRefSchema, } from "@tutti/shared/schemas/domain";
+import { AuthoritySecretSchema, AuthorityTimestampSchema, isAuthorityTimestamp, HostInstallationRefSchema, HostDelegationProjectionSchema, ManagedCreationRefSchema, ManagedTierSchema, } from "@tutti/shared/schemas/internal";
+import { ManagedLocalStateError } from "./private-store.js";
+export const InstallationSchema = Type.Object({
+    version: Type.Literal(1),
+    relay_origin: Type.String({ maxLength: 500 }),
+    installation_ref: HostInstallationRefSchema,
+    secret: AuthoritySecretSchema,
+    created_at: AuthorityTimestampSchema,
+}, { additionalProperties: false });
+const DraftFields = {
+    version: Type.Literal(1),
+    request_ref: IdempotencyKeySchema,
+    project_id: ProjectIdSchema,
+    relay_origin: Type.String({ maxLength: 500 }),
+    installation_ref: HostInstallationRefSchema,
+    workspace_root: 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_relay_project_ref: Type.Optional(RelayProjectRefSchema),
+    previous_request_ref: Type.Optional(IdempotencyKeySchema),
+    handoff_token: AuthoritySecretSchema,
+    host_registration_secret: AuthoritySecretSchema,
+    created_at: AuthorityTimestampSchema,
+    expires_at: AuthorityTimestampSchema,
+};
+export const CreationJournalSchema = Type.Union([
+    Type.Object({ ...DraftFields, state: Type.Literal("awaiting_authorization") }, { additionalProperties: false }),
+    Type.Object({ ...DraftFields, state: Type.Literal("prepared"), creation_ref: ManagedCreationRefSchema }, { additionalProperties: false }),
+    Type.Object({
+        ...DraftFields,
+        state: Type.Union([
+            Type.Literal("validated"),
+            Type.Literal("validation_unknown"),
+            Type.Literal("validation_failed"),
+        ]),
+        creation_ref: ManagedCreationRefSchema,
+    }, { additionalProperties: false }),
+    Type.Object({
+        ...DraftFields,
+        state: Type.Literal("registered"),
+        creation_ref: ManagedCreationRefSchema,
+        authority: HostDelegationProjectionSchema,
+    }, { additionalProperties: false }),
+]);
+export const NativeProjectPointerSchema = Type.Object({
+    version: Type.Literal(1),
+    project_id: ProjectIdSchema,
+    request_ref: IdempotencyKeySchema,
+}, { additionalProperties: false });
+export function parseInstallation(raw, origin) {
+    if (!Value.Check(InstallationSchema, raw) ||
+        raw.relay_origin !== origin ||
+        !isAuthorityTimestamp(raw.created_at))
+        throw new ManagedLocalStateError("managed_installation_invalid");
+    return raw;
+}
+export function parseJournal(raw, origin, requestRef) {
+    if (!Value.Check(CreationJournalSchema, raw) ||
+        raw.relay_origin !== origin ||
+        raw.request_ref !== requestRef ||
+        !isAuthorityTimestamp(raw.created_at) ||
+        !isAuthorityTimestamp(raw.expires_at) ||
+        raw.expires_at <= raw.created_at)
+        throw new ManagedLocalStateError("managed_journal_invalid");
+    // ProjectIdSchema checked the complete branded ID pattern above.
+    return raw;
+}
+//# sourceMappingURL=records.js.map

package/dist/server-shell/managed-access/runners.d.ts

@@ -0,0 +1,11 @@
+import type { ReadOnlyChatAssistantModel } from "../../chat-assistant/index.js";
+import type { RunPipelineRunner } from "../../control-plane/index.js";
+import { type ProjectOpenAiProcedureWorkflowRunnerOptions } from "../../control-plane/workflows/openai.js";
+import type { ProcedureWorkflowRunner } from "../../control-plane/workflows/types.js";
+import { type ProjectOpenAiReadOnlyChatAssistantModelOptions } from "../../providers/openai/chat-assistant.js";
+import { type ProjectOpenAiRunPipelineRunnerOptions } from "../../run-pipeline/openai.js";
+import { type ManagedExecutionRuntime } from "./execution-binding.js";
+export declare function createManagedWorkflowRunner(runtime: ManagedExecutionRuntime, options: ProjectOpenAiProcedureWorkflowRunnerOptions): ProcedureWorkflowRunner;
+export declare function createManagedRunPipeline(runtime: ManagedExecutionRuntime, options: ProjectOpenAiRunPipelineRunnerOptions): RunPipelineRunner;
+export declare function createManagedChatModel(runtime: ManagedExecutionRuntime, options: ProjectOpenAiReadOnlyChatAssistantModelOptions): ReadOnlyChatAssistantModel;
+//# sourceMappingURL=runners.d.ts.map