@xfey/tutti 0.1.119 → 0.1.121

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" };
+    }
+    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,103 @@
+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<2>;
+    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">]>;
+    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<2>;
+    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">]>;
+    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<2>;
+    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">]>;
+    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;
+        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<2>;
+    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">]>;
+    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,74 @@
+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, } from "@tutti/shared/schemas/internal";
+import { ManagedLocalStateError } from "./private-store.js";
+import { upgradeTieredPrivateRecord } from "./legacy-records.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(2),
+    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")]),
+    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) {
+    raw = upgradeTieredPrivateRecord(raw, true);
+    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

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

@@ -0,0 +1,103 @@
+import { createHash, randomUUID } from "node:crypto";
+import { createOpenAiProcedureWorkflowRunner, } from "../../control-plane/workflows/openai.js";
+import { createOpenAiReadOnlyChatAssistantModel, } from "../../providers/openai/chat-assistant.js";
+import { createOpenAiStructuredOutputClient } from "../../providers/openai/sdk-procedure-runner.js";
+import { inspectCodexLinuxSandboxReadiness } from "../../providers/openai/app-server/linux-sandbox-readiness.js";
+import { createOpenAiRunPipelineRunner, } from "../../run-pipeline/openai.js";
+import { getProjectUserSkillsRoot } from "../../skills/index.js";
+import { bindManagedExecution } from "./execution-binding.js";
+import { failedBeforeChecks } from "../../run-pipeline/result-projections.js";
+import { ManagedLocalStateError } from "./private-store.js";
+import { ManagedControlError } from "./model-control-client.js";
+import { NativeAuthorityTransportError } from "@tutti/relay-client";
+// Shell composition only. The provider adapters know nothing about account,
+// delegation, New API, or private native journals.
+export function createManagedWorkflowRunner(runtime, options) {
+    async function resolve(ref) {
+        const access = await bindManagedExecution(runtime, { kind: "workflow", ref });
+        return createOpenAiProcedureWorkflowRunner({
+            config: access.config,
+            client: createOpenAiStructuredOutputClient({
+                credentialLease: access.credentialLease,
+                apiBaseUrl: access.config.api_base_url,
+            }),
+            ...(options.promptsRoot === undefined ? {} : { promptsRoot: options.promptsRoot }),
+            ...(options.recordUsage === undefined ? {} : { recordUsage: options.recordUsage }),
+            readOnlyAppServer: {
+                ...options,
+                credentialLease: access.credentialLease,
+                userSkillsRoot: getProjectUserSkillsRoot(options.tuttiHome, options.projectId),
+            },
+        });
+    }
+    return {
+        async runScratchpadRefresh(input, context) {
+            return (await resolve(context.workflow_ref)).runScratchpadRefresh(input, context);
+        },
+        async runTaskCompile(input, context) {
+            return (await resolve(input.workflow_ref)).runTaskCompile(input, context);
+        },
+        async runProjectContextBootstrap(input, context) {
+            const runner = await resolve(context?.workflow_ref ?? randomUUID());
+            return runner.runProjectContextBootstrap(input, context);
+        },
+        async runContextSync(input, context) {
+            return (await resolve(input.workflow_ref)).runContextSync(input, context);
+        },
+        async runReferenceFileSummary(input, context) {
+            // One workflow drains multiple targets concurrently. Do not make two files
+            // share a model-session lease, or expose filesystem paths as owner refs.
+            const ref = createHash("sha256")
+                .update(JSON.stringify([input.workflow_ref, input.file.path, input.file.blob_oid]))
+                .digest("hex");
+            return (await resolve(ref)).runReferenceFileSummary(input, context);
+        },
+        async runProjectBriefRefresh(input, context) {
+            return (await resolve(context?.workflow_ref ?? randomUUID())).runProjectBriefRefresh(input, context);
+        },
+        async runFollowUpCheck(input, context) {
+            return (await resolve(input.workflow_ref)).runFollowUpCheck(input, context);
+        },
+    };
+}
+export function createManagedRunPipeline(runtime, options) {
+    return {
+        async runTask(input) {
+            let access;
+            try {
+                access = await bindManagedExecution(runtime, { kind: "task", ref: input.task.id });
+            }
+            catch (error) {
+                const known = error instanceof ManagedLocalStateError ||
+                    error instanceof ManagedControlError ||
+                    error instanceof NativeAuthorityTransportError;
+                return failedBeforeChecks({
+                    summary: "Tutti trial access is unavailable. Check project authorization and trial allowance before retrying.",
+                    errorCode: known ? error.code : "managed_selection_unavailable",
+                    retryable: true,
+                });
+            }
+            return createOpenAiRunPipelineRunner({
+                ...options,
+                ...access,
+                userSkillsRoot: getProjectUserSkillsRoot(options.tuttiHome, options.projectId),
+                ...(process.platform === "linux"
+                    ? { codexSandboxReadiness: () => inspectCodexLinuxSandboxReadiness() }
+                    : {}),
+            }).runTask(input);
+        },
+    };
+}
+export function createManagedChatModel(runtime, options) {
+    return {
+        async answer(input) {
+            const access = await bindManagedExecution(runtime, { kind: "chat", ref: randomUUID() });
+            return createOpenAiReadOnlyChatAssistantModel({
+                ...options,
+                ...access,
+                userSkillsRoot: getProjectUserSkillsRoot(options.tuttiHome, options.projectId),
+            }).answer(input);
+        },
+    };
+}
+//# sourceMappingURL=runners.js.map