@xfey/tutti 0.1.103 → 0.1.105

package/dist/server-shell/cli/managed-host.js

@@ -1,11 +1,16 @@
+import { randomUUID } from "node:crypto";
 import { spawn } from "node:child_process";
 import { resolve } from "node:path";
+import { ID_PREFIXES, isPrefixedId } from "@tutti/shared/ids";
 import { createRuntimeEndpointProbe } from "./host-runtime-endpoint.js";
-import { LaunchError } from "./errors.js";
-import { readMachineRuntimeEndpoint } from "./machine-local.js";
+import { formatCliErrorReason, LaunchError } from "./errors.js";
+import { appendHostLogLine, getHostLogFilePath, readMachineProjectBinding, readMachineRuntimeEndpoint, } from "./machine-local.js";
 import { readHostLocalLaunchStatus, rotateHostLocalInvite } from "./local-control-client.js";
 const DEFAULT_READY_TIMEOUT_MS = 60_000;
 const READY_POLL_INTERVAL_MS = 250;
+const HOST_STARTUP_ATTEMPT_ENV = "TUTTI_HOST_STARTUP_ATTEMPT_REF";
+const HOST_STARTUP_PROJECT_ENV = "TUTTI_HOST_STARTUP_PROJECT_ID";
+const HOST_STARTUP_ATTEMPT_PATTERN = /^host_startup_[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/u;
 function delay(ms) {
     return new Promise((resolveDelay) => {
         setTimeout(resolveDelay, ms);
@@ -16,48 +21,181 @@ function currentCliEntrypoint() {
     if (entrypoint === undefined || entrypoint.trim() === "") {
         throw new Error("Cannot locate the current Tutti CLI entrypoint.");
     }
-    return entrypoint;
+    return resolve(entrypoint);
+}
+export function normalizeDetachedHostExecArgv(execArgv, resolveImport = (specifier) => import.meta.resolve(specifier)) {
+    const normalized = [];
+    for (let index = 0; index < execArgv.length; index += 1) {
+        const argument = execArgv[index];
+        if (argument === "--import" && execArgv[index + 1] === "tsx") {
+            normalized.push(argument, resolveImport("tsx"));
+            index += 1;
+            continue;
+        }
+        if (argument === "--import=tsx") {
+            normalized.push(`--import=${resolveImport("tsx")}`);
+            continue;
+        }
+        if (argument !== undefined) {
+            normalized.push(argument);
+        }
+    }
+    return normalized;
+}
+function appendDetachedHostStartupEvent(tuttiHome, event) {
+    try {
+        appendHostLogLine(getHostLogFilePath(tuttiHome), JSON.stringify({
+            level: event.disposition === "failed" || event.disposition === "timed_out" ? 50 : 30,
+            time: Date.now(),
+            service: "tutti-host-manager",
+            component: "managed-host-startup",
+            ...event,
+        }));
+    }
+    catch {
+        // Logging must never turn a process lifecycle observation into a launch failure.
+    }
+}
+function readStartupAttemptRef(env) {
+    const value = env[HOST_STARTUP_ATTEMPT_ENV];
+    return value !== undefined && HOST_STARTUP_ATTEMPT_PATTERN.test(value) ? value : undefined;
 }
 export function spawnDetachedHost(options) {
-    const child = spawn(process.execPath, [
-        ...process.execArgv,
-        currentCliEntrypoint(),
-        "internal",
-        "host-run",
-        "--workspace",
-        resolve(options.workspaceRoot),
-        "--yes",
-    ], {
-        cwd: options.workspaceRoot,
-        detached: true,
-        env: options.inheritProcessEnv === false
-            ? options.env
-            : {
-                ...process.env,
-                ...(options.env ?? {}),
-            },
-        stdio: "ignore",
+    const startupAttemptRef = `host_startup_${randomUUID()}`;
+    const childEnv = options.inheritProcessEnv === false
+        ? { ...(options.env ?? {}) }
+        : {
+            ...process.env,
+            ...(options.env ?? {}),
+        };
+    childEnv.TUTTI_HOME = options.tuttiHome;
+    childEnv[HOST_STARTUP_ATTEMPT_ENV] = startupAttemptRef;
+    childEnv[HOST_STARTUP_PROJECT_ENV] = options.projectId;
+    let child;
+    try {
+        child = spawn(process.execPath, [
+            ...normalizeDetachedHostExecArgv(process.execArgv),
+            currentCliEntrypoint(),
+            "internal",
+            "host-run",
+            "--workspace",
+            resolve(options.workspaceRoot),
+            "--yes",
+        ], {
+            cwd: options.workspaceRoot,
+            detached: true,
+            env: childEnv,
+            stdio: "ignore",
+        });
+    }
+    catch (error) {
+        appendDetachedHostStartupEvent(options.tuttiHome, {
+            startup_attempt_ref: startupAttemptRef,
+            project_id: options.projectId,
+            stage: "spawn",
+            disposition: "failed",
+            reason_code: "spawn_failed",
+            detail: formatCliErrorReason(error),
+        });
+        throw error;
+    }
+    child.once("error", (error) => {
+        appendDetachedHostStartupEvent(options.tuttiHome, {
+            startup_attempt_ref: startupAttemptRef,
+            project_id: options.projectId,
+            stage: "spawn",
+            disposition: "failed",
+            reason_code: "spawn_error",
+            detail: formatCliErrorReason(error),
+        });
+    });
+    appendDetachedHostStartupEvent(options.tuttiHome, {
+        startup_attempt_ref: startupAttemptRef,
+        project_id: options.projectId,
+        stage: "spawn",
+        disposition: "started",
+        ...(child.pid === undefined ? {} : { pid: child.pid }),
     });
     child.unref();
+    return {
+        startup_attempt_ref: startupAttemptRef,
+        ...(child.pid === undefined ? {} : { pid: child.pid }),
+    };
+}
+export function recordInternalHostStartupFailure(options) {
+    const env = options.env ?? process.env;
+    const startupAttemptRef = readStartupAttemptRef(env);
+    if (startupAttemptRef === undefined) {
+        return;
+    }
+    const projectIdValue = env[HOST_STARTUP_PROJECT_ENV];
+    const projectId = projectIdValue !== undefined && isPrefixedId(projectIdValue, ID_PREFIXES.project)
+        ? projectIdValue
+        : undefined;
+    appendDetachedHostStartupEvent(options.tuttiHome, {
+        startup_attempt_ref: startupAttemptRef,
+        ...(projectId === undefined ? {} : { project_id: projectId }),
+        stage: "internal_host_run",
+        disposition: "failed",
+        reason_code: "host_startup_failed",
+        detail: formatCliErrorReason(options.error),
+    });
 }
 export async function waitForManagedHostReady(options) {
+    const projectSurface = readMachineProjectBinding(options.tuttiHome, options.projectId)?.surface_profile.kind ??
+        "standalone";
     const deadline = Date.now() + (options.timeoutMs ?? DEFAULT_READY_TIMEOUT_MS);
     const probe = createRuntimeEndpointProbe(options.fetchImpl ?? fetch);
     let lastReason = "runtime endpoint was not written";
+    let lastReasonCode = "runtime_endpoint_missing";
+    let lastLoggedWaitState;
+    const startedAt = Date.now();
+    const logWaitState = (reasonCode, detail) => {
+        if (options.startupAttemptRef === undefined || lastLoggedWaitState === reasonCode) {
+            return;
+        }
+        lastLoggedWaitState = reasonCode;
+        appendDetachedHostStartupEvent(options.tuttiHome, {
+            startup_attempt_ref: options.startupAttemptRef,
+            project_id: options.projectId,
+            stage: "wait",
+            disposition: "waiting",
+            reason_code: reasonCode,
+            ...(detail === undefined ? {} : { detail: formatCliErrorReason(detail) }),
+            latency_ms: Date.now() - startedAt,
+        });
+    };
+    const logReady = () => {
+        if (options.startupAttemptRef === undefined) {
+            return;
+        }
+        appendDetachedHostStartupEvent(options.tuttiHome, {
+            startup_attempt_ref: options.startupAttemptRef,
+            project_id: options.projectId,
+            stage: "wait",
+            disposition: "ready",
+            latency_ms: Date.now() - startedAt,
+        });
+    };
     while (Date.now() < deadline) {
         const endpoint = readMachineRuntimeEndpoint(options.tuttiHome, options.projectId);
         if (endpoint === null) {
+            logWaitState(lastReasonCode);
             await delay(READY_POLL_INTERVAL_MS);
             continue;
         }
         if (resolve(endpoint.workspace_root) !== resolve(options.workspaceRoot)) {
             lastReason = "runtime endpoint points at a different workspace";
+            lastReasonCode = "runtime_endpoint_workspace_mismatch";
+            logWaitState(lastReasonCode);
             await delay(READY_POLL_INTERVAL_MS);
             continue;
         }
         const health = await probe(endpoint);
         if (health.kind === "stale") {
             lastReason = health.reason;
+            lastReasonCode = "runtime_endpoint_stale";
+            logWaitState(lastReasonCode, health.reason);
             await delay(READY_POLL_INTERVAL_MS);
             continue;
         }
@@ -66,13 +204,16 @@ export async function waitForManagedHostReady(options) {
                 endpoint,
                 ...(options.fetchImpl === undefined ? {} : { fetchImpl: options.fetchImpl }),
             });
-            if (status.relay?.join_url === undefined && options.inviteMode !== "preserve") {
+            if (projectSurface === "standalone" &&
+                status.relay?.join_url === undefined &&
+                options.inviteMode !== "preserve") {
                 status = await rotateHostLocalInvite({
                     endpoint,
                     ...(options.fetchImpl === undefined ? {} : { fetchImpl: options.fetchImpl }),
                 });
             }
             if (status.relay?.join_url !== undefined) {
+                logReady();
                 return {
                     endpoint,
                     join_url: status.relay.join_url,
@@ -85,15 +226,42 @@ export async function waitForManagedHostReady(options) {
                 };
             }
             if (options.inviteMode === "preserve" && status.relay !== undefined) {
+                logReady();
                 return { endpoint };
             }
+            if (projectSurface === "feishu" && status.relay !== undefined) {
+                logReady();
+                return {
+                    endpoint,
+                    ...(status.relay.feishu_setup === undefined
+                        ? {}
+                        : { feishu_setup: status.relay.feishu_setup }),
+                };
+            }
             lastReason = "host is running but Relay invite is not visible yet";
+            lastReasonCode = "relay_launch_status_not_ready";
+            logWaitState(lastReasonCode);
         }
         catch (error) {
             lastReason = error instanceof Error ? error.message : "host-local launch status failed";
+            lastReasonCode = "host_local_launch_status_failed";
+            logWaitState(lastReasonCode, lastReason);
         }
         await delay(READY_POLL_INTERVAL_MS);
     }
-    throw new LaunchError("existing_server_unhealthy", `Tutti host did not become ready before timeout: ${lastReason}`, "Run `tutti logs` for details, then retry `tutti launch`.");
+    if (options.startupAttemptRef !== undefined) {
+        appendDetachedHostStartupEvent(options.tuttiHome, {
+            startup_attempt_ref: options.startupAttemptRef,
+            project_id: options.projectId,
+            stage: "wait",
+            disposition: "timed_out",
+            reason_code: lastReasonCode,
+            detail: formatCliErrorReason(lastReason),
+            latency_ms: Date.now() - startedAt,
+        });
+    }
+    throw new LaunchError("existing_server_unhealthy", `Tutti host did not become ready before timeout: ${lastReason}`, "Run `tutti logs` for details, then retry `tutti launch`.", options.startupAttemptRef === undefined
+        ? {}
+        : { startup_attempt_ref: options.startupAttemptRef });
 }
 //# sourceMappingURL=managed-host.js.map

package/dist/server-shell/cli/relay-registration.d.ts

@@ -1,5 +1,6 @@
 import { type ConnectRelayHostTunnelOptions, type RelayHostTunnelHandle, type RegisterRelayHostConnectionOptions, type RegisterRelayHostConnectionResponse } from "@tutti/relay-client";
 import { type HostConnectionRef, type RelayProjectRef } from "@tutti/shared/ids";
+import type { FeishuSetupProjection } from "@tutti/shared/schemas/internal";
 import { LaunchError } from "./errors.js";
 import type { LaunchPreparationResult } from "./launch.js";
 type FetchLike = (input: string | URL, init?: RequestInit) => Promise<Response>;
@@ -12,6 +13,8 @@ export type HostLaunchRelaySummary = {
     join_token_reusable: boolean;
     tunnel_url: string;
     connected_at: string;
+    surface_profile?: LaunchPreparationResult["machine_local"]["binding"]["surface_profile"];
+    feishu_setup?: FeishuSetupProjection;
 };
 export type RelayHostConnectionRegistrar = (options: RegisterRelayHostConnectionOptions) => Promise<RegisterRelayHostConnectionResponse>;
 export type RelayHostTunnelConnector = (options: ConnectRelayHostTunnelOptions) => RelayHostTunnelHandle;
@@ -20,7 +23,7 @@ export type RegisteredRelayHostConnection = {
     hostConnectionToken: string;
     heartbeatIntervalMs: number;
 };
-export type HostRelayRegistrationPreparation = Pick<LaunchPreparationResult, "tutti_home" | "project_id" | "workspace_root" | "relay_url">;
+export type HostRelayRegistrationPreparation = Pick<LaunchPreparationResult, "tutti_home" | "project_id" | "workspace_root" | "relay_url"> & Partial<Pick<LaunchPreparationResult, "machine_local">>;
 export declare function relayErrorToLaunchError(error: unknown, relayUrl: string): LaunchError;
 export declare function registerHostWithRelay(options: {
     preparation: HostRelayRegistrationPreparation;

package/dist/server-shell/cli/relay-registration.js

@@ -1,7 +1,7 @@
 import { basename } from "node:path";
 import { RelayHostControlClientError, } from "@tutti/relay-client";
 import { createIdempotencyKey, } from "@tutti/shared/ids";
-import { readHostRegistrationSecret, updateMachineProjectRelayBinding } from "./machine-local.js";
+import { deleteFeishuOwnerAccountHandoff, readFeishuOwnerAccountHandoff, readHostRegistrationSecret, updateMachineProjectRelayBinding, } from "./machine-local.js";
 import { LaunchError } from "./errors.js";
 import { readProjectDisplayName } from "./project-identity.js";
 export function relayErrorToLaunchError(error, relayUrl) {
@@ -12,6 +12,9 @@ export function relayErrorToLaunchError(error, relayUrl) {
         if (error.code === "relay_unavailable") {
             return new LaunchError("relay_unavailable", `Cannot register host connection because Relay is unavailable at ${relayUrl}`, "Keep the project host stopped, start or fix Relay, then run `tutti launch` again.");
         }
+        if (error.relayErrorCode === "project_surface_conflict") {
+            return new LaunchError("project_surface_conflict", "Relay rejected a different collaboration surface for this project", "Keep the Host stopped and inspect the machine project binding and Relay project metadata.");
+        }
         return new LaunchError("relay_registration_failed", `Relay rejected host registration${error.relayErrorCode === undefined ? "" : ` (${error.relayErrorCode})`}`, error.retryable
             ? "Retry after Relay recovers, or run `tutti launch` again with a new registration command."
             : "Check Relay host-control registration state and this machine's host registration credential.");
@@ -20,6 +23,8 @@ export function relayErrorToLaunchError(error, relayUrl) {
 }
 export async function registerHostWithRelay(options) {
     const hostSecret = readHostRegistrationSecret(options.preparation.tutti_home, options.preparation.project_id);
+    const surfaceProfile = options.preparation.machine_local?.binding.surface_profile ??
+        { kind: "standalone", version: 1 };
     const registrationOptions = {
         relayUrl: options.preparation.relay_url,
         projectId: options.preparation.project_id,
@@ -27,19 +32,34 @@ export async function registerHostWithRelay(options) {
         displayName: readProjectDisplayName(options.preparation.workspace_root) ??
             (basename(options.preparation.workspace_root) || options.preparation.project_id),
         serverVersion: options.serverVersion,
+        surfaceProfile,
         commandId: createIdempotencyKey(),
         joinToken: { mode: options.joinTokenMode ?? "rotate" },
+        capabilities: {
+            integration_source_ingestion_v1: true,
+            integration_outbound_v1: true,
+        },
         fetch: options.fetchImpl,
         ...(options.signal === undefined ? {} : { signal: options.signal }),
         ...(options.now === undefined ? {} : { issuedAt: options.now() }),
     };
+    const accountHandoff = surfaceProfile.kind === "feishu"
+        ? readFeishuOwnerAccountHandoff(options.preparation.tutti_home, options.preparation.project_id, options.now?.() ?? new Date())
+        : null;
+    if (accountHandoff !== null) {
+        registrationOptions.accountHandoffToken = accountHandoff.token;
+    }
     const response = await options.registerRelayHostConnection(registrationOptions);
     if (response.disposition.kind !== "registered" || response.result === undefined) {
         throw new LaunchError("relay_registration_failed", "Relay host registration did not complete", "Retry `tutti launch` with a new registration command.");
     }
     const result = response.result;
-    if ((options.joinTokenMode ?? "rotate") === "rotate" &&
-        (result.join_token.visibility !== "visible_once" || result.join_token.join_url === undefined)) {
+    if ((result.relay_project.surface_profile?.kind ?? "standalone") !== surfaceProfile.kind) {
+        throw new LaunchError("project_surface_conflict", "Relay returned a different project collaboration surface", "Keep the Host stopped and inspect the machine project binding and Relay project metadata.");
+    }
+    if (surfaceProfile.kind === "standalone" &&
+        (options.joinTokenMode ?? "rotate") === "rotate" &&
+        (result.join_token?.visibility !== "visible_once" || result.join_token.join_url === undefined)) {
         throw new LaunchError("relay_registration_failed", "Relay did not return a visible join URL for this launch", "Retry `tutti launch` so the host can rotate a fresh visible-once join URL.");
     }
     updateMachineProjectRelayBinding({
@@ -48,16 +68,25 @@ export async function registerHostWithRelay(options) {
         relayProjectRef: result.relay_project.relay_project_ref,
         ...(options.now === undefined ? {} : { now: options.now }),
     });
+    if (accountHandoff !== null && result.feishu_setup?.state !== "account_handoff_required") {
+        deleteFeishuOwnerAccountHandoff(options.preparation.tutti_home, options.preparation.project_id);
+    }
     return {
         summary: {
             relay_project_ref: result.relay_project.relay_project_ref,
             host_connection_ref: result.host_connection.host_connection_ref,
-            ...(result.join_token.join_url === undefined ? {} : { join_url: result.join_token.join_url }),
-            join_url_visibility: result.join_token.visibility,
-            join_token_expires_at: result.join_token.expires_at,
-            join_token_reusable: result.join_token.reusable,
+            ...(result.join_token?.join_url === undefined
+                ? {}
+                : { join_url: result.join_token.join_url }),
+            join_url_visibility: result.join_token?.visibility ?? "not_recoverable",
+            ...(result.join_token === undefined
+                ? {}
+                : { join_token_expires_at: result.join_token.expires_at }),
+            join_token_reusable: result.join_token?.reusable ?? false,
             tunnel_url: result.host_connection.tunnel_url,
             connected_at: result.host_connection.connected_at,
+            surface_profile: surfaceProfile,
+            ...(result.feishu_setup === undefined ? {} : { feishu_setup: result.feishu_setup }),
         },
         hostConnectionToken: result.host_connection_token,
         heartbeatIntervalMs: result.host_connection.heartbeat_interval_ms,

package/dist/server-shell/cli/runtime-commands.d.ts

@@ -56,7 +56,11 @@ export declare function runForgetCommand(target: string, options?: {
     fetchImpl?: LocalControlFetch;
     shutdownWaitMs?: number;
 }): Promise<string>;
-export declare function runInviteCommand(target?: string): Promise<string>;
+export declare function runInviteCommand(target?: string, options?: {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    fetchImpl?: LocalControlFetch;
+}): Promise<string>;
 export declare function runProviderStatusCommand(target?: string): string;
 export declare function runLogsCommand(target?: string, tailLines?: number): string;
 export declare function runDoctorCommand(target?: string, options?: {

package/dist/server-shell/cli/runtime-commands.js

@@ -442,15 +442,21 @@ export async function runForgetCommand(target, options = {}) {
     });
     return `Forgot ${project.display_name} (${project.project_id}) on this machine. The Relay project and memberships were not archived.`;
 }
-export async function runInviteCommand(target) {
-    const project = resolveProject(target);
+export async function runInviteCommand(target, options = {}) {
+    const project = resolveProject(target, options);
+    if (project.binding?.surface_profile.kind !== "standalone") {
+        throw new LaunchError("project_surface_mismatch", "Feishu collaboration projects do not use Standalone invite links.", "Manage the Feishu project binding from the Tutti Local Console.");
+    }
     const endpoint = project.runtime_endpoint;
     if (endpoint === null) {
         throw new LaunchError("host_not_running", "Tutti host is not running for this project.", "Run `tutti launch` first, then retry `tutti invite`.");
     }
     let status;
     try {
-        status = await rotateHostLocalInvite({ endpoint });
+        status = await rotateHostLocalInvite({
+            endpoint,
+            ...(options.fetchImpl === undefined ? {} : { fetchImpl: options.fetchImpl }),
+        });
     }
     catch (error) {
         throw new LaunchError("existing_server_unhealthy", `Could not refresh the invite: ${formatCliErrorReason(error)}`, "Run `tutti launch` to restart or reconnect the host, then retry `tutti invite`.");

package/dist/server-shell/http/host-tunnel.d.ts

@@ -1,12 +1,17 @@
 import type { FastifyInstance } from "fastify";
 import type { RelayHostTunnelRequestHandler, RelayHostTunnelStreamRequestHandler } from "@tutti/relay-client";
+import type { IntegrationDeliveryDisposition, TrustedConversationSourceIngestionCommand } from "@tutti/shared/schemas/internal";
+import type { ProjectSurface } from "@tutti/shared/domain";
 import { type TrustedRelaySessionMetadataStore } from "../session/relay-session-context.js";
 export type HostProjectApiTunnelDispatchOptions = {
     app: FastifyInstance;
+    projectSurface?: ProjectSurface;
     trustedMetadataStore: TrustedRelaySessionMetadataStore;
+    integrationDelivery?: (command: TrustedConversationSourceIngestionCommand) => IntegrationDeliveryDisposition;
 };
 export type HostProjectApiTunnelStreamDispatchOptions = {
     baseUrl: string;
+    projectSurface?: ProjectSurface;
     trustedMetadataStore: TrustedRelaySessionMetadataStore;
     fetch?: typeof fetch;
 };

package/dist/server-shell/http/host-tunnel.js

@@ -1,10 +1,97 @@
+import { isTrustedConversationSourceIngestionCommand } from "@tutti/shared/schemas/internal";
+import { TRUSTED_INTEGRATION_INGESTION_PATH } from "../../collaboration-ingestion/index.js";
 import { TRUSTED_RELAY_METADATA_REQUEST_HEADER, } from "../session/relay-session-context.js";
+function browserMetadataMatchesSurface(projectSurface, request) {
+    return projectSurface === "standalone"
+        ? "relay_session_context" in request.metadata
+        : "feishu_platform_session_context" in request.metadata;
+}
+function forbiddenBrowserResponse(requestId) {
+    return {
+        request_id: requestId,
+        status_code: 403,
+        headers: { "content-type": "application/json; charset=utf-8" },
+        body_base64: Buffer.from(JSON.stringify({
+            error: {
+                code: "forbidden",
+                message: "Project surface does not allow this session",
+                retryable: false,
+            },
+        }), "utf8").toString("base64"),
+    };
+}
 function decodeRequestBody(bodyBase64) {
     if (bodyBase64 === undefined) {
         return undefined;
     }
     return Buffer.from(bodyBase64, "base64");
 }
+function integrationResponse(requestId, disposition) {
+    const body = {
+        protocol_version: 1,
+        disposition,
+    };
+    return {
+        request_id: requestId,
+        status_code: 200,
+        headers: { "content-type": "application/json; charset=utf-8" },
+        body_base64: Buffer.from(JSON.stringify(body), "utf8").toString("base64"),
+    };
+}
+function sameInstallation(left, right) {
+    return left.platform === right.platform && left.installation_ref === right.installation_ref;
+}
+function dispatchIntegrationDelivery(options, request) {
+    if ((options.projectSurface ?? "standalone") !== "feishu") {
+        return Promise.resolve(integrationResponse(request.request_id, {
+            kind: "unsupported",
+            reason_code: "project_surface_mismatch",
+        }));
+    }
+    if (!("integration_delivery" in request.metadata)) {
+        throw new TypeError("Integration delivery metadata is required");
+    }
+    if (request.method.toUpperCase() !== "POST" ||
+        request.path !== TRUSTED_INTEGRATION_INGESTION_PATH) {
+        return Promise.resolve(integrationResponse(request.request_id, {
+            kind: "invalid",
+            reason_code: "internal_route_invalid",
+        }));
+    }
+    const payload = decodeRequestBody(request.body_base64);
+    let command;
+    try {
+        command = payload === undefined ? undefined : JSON.parse(payload.toString("utf8"));
+    }
+    catch {
+        command = undefined;
+    }
+    if (!isTrustedConversationSourceIngestionCommand(command)) {
+        return Promise.resolve(integrationResponse(request.request_id, {
+            kind: "invalid",
+            reason_code: "trusted_command_invalid",
+        }));
+    }
+    const metadata = request.metadata.integration_delivery;
+    if (command.relay_project_ref !== metadata.relay_project_ref ||
+        command.binding_ref !== metadata.binding_ref ||
+        command.receipt.receipt_key !== metadata.receipt_key ||
+        command.actor.verified_at !== metadata.verified_at ||
+        !sameInstallation(command.receipt.installation, metadata.installation)) {
+        return Promise.resolve(integrationResponse(request.request_id, {
+            kind: "invalid",
+            reason_code: "trusted_metadata_mismatch",
+        }));
+    }
+    if (options.integrationDelivery === undefined) {
+        return Promise.resolve(integrationResponse(request.request_id, {
+            kind: "host_incompatible",
+            retryable: true,
+            reason_code: "integration_source_ingestion_unsupported",
+        }));
+    }
+    return Promise.resolve(integrationResponse(request.request_id, options.integrationDelivery(command)));
+}
 function injectHeaders(request) {
     const headers = {};
     for (const [name, value] of Object.entries(request.headers)) {
@@ -69,6 +156,12 @@ function toInjectMethod(method) {
 }
 export function createHostProjectApiTunnelRequestHandler(options) {
     return async (request) => {
+        if ("integration_delivery" in request.metadata) {
+            return dispatchIntegrationDelivery(options, request);
+        }
+        if (!browserMetadataMatchesSurface(options.projectSurface ?? "standalone", request)) {
+            return forbiddenBrowserResponse(request.request_id);
+        }
         const headers = injectHeaders(request);
         headers[TRUSTED_RELAY_METADATA_REQUEST_HEADER] = options.trustedMetadataStore.stage(request.metadata);
         const payload = decodeRequestBody(request.body_base64);
@@ -132,6 +225,22 @@ async function writeFetchBodyToStreamSink(response, sink) {
 }
 export function createHostProjectApiTunnelStreamRequestHandler(options) {
     return async (request, sink) => {
+        if ("integration_delivery" in request.metadata) {
+            sink.error();
+            return;
+        }
+        if (!browserMetadataMatchesSurface(options.projectSurface ?? "standalone", request)) {
+            const response = forbiddenBrowserResponse(request.request_id);
+            sink.start({
+                status_code: response.status_code,
+                ...(response.headers === undefined ? {} : { headers: response.headers }),
+            });
+            if (response.body_base64 !== undefined) {
+                sink.write(Buffer.from(response.body_base64, "base64"));
+            }
+            sink.end();
+            return;
+        }
         const headers = injectHeaders(request);
         headers[TRUSTED_RELAY_METADATA_REQUEST_HEADER] = options.trustedMetadataStore.stage(request.metadata);
         const payload = decodeRequestBody(request.body_base64);

package/dist/server-shell/http/routes/local-control.d.ts

@@ -1,6 +1,7 @@
 import type { FastifyInstance } from "fastify";
 import type { ProviderConfigProjection } from "@tutti/shared/schemas/api";
 import type { ProjectId } from "@tutti/shared/ids";
+import { type FeishuSetupProjection } from "@tutti/shared/schemas/internal";
 export type HostLocalControlOptions = {
     token: string;
     getLaunchStatus?: () => HostLocalLaunchStatus;
@@ -38,6 +39,7 @@ export type HostLocalLaunchStatus = {
         join_token_reusable?: boolean;
         tunnel_url: string;
         connected_at: string;
+        feishu_setup?: FeishuSetupProjection;
     };
 };
 export type HostLocalProviderConfigBody = {

package/dist/server-shell/http/routes/local-control.js

@@ -1,4 +1,5 @@
 import { timingSafeEqual } from "node:crypto";
+import { FeishuSetupProjectionSchema, } from "@tutti/shared/schemas/internal";
 class HostLocalControlUnauthorizedError extends Error {
     statusCode = 401;
     code = "unauthorized";
@@ -174,6 +175,7 @@ const HostLocalLaunchStatusResponseSchema = {
                 join_token_reusable: { type: "boolean" },
                 tunnel_url: { type: "string" },
                 connected_at: { type: "string" },
+                feishu_setup: FeishuSetupProjectionSchema,
             },
         },
     },

package/dist/server-shell/http/routes/project-api/invalidations.d.ts

@@ -1,6 +1,5 @@
 import type { ClarificationRoundRef, TaskId } from "@tutti/shared/ids";
 import type { QueryInvalidationHint, RunSchedulerNowDisposition } from "@tutti/shared/schemas/api";
-export declare function mainChatMessageInvalidates(): QueryInvalidationHint[];
 export declare function worklistSubmitInvalidates(): QueryInvalidationHint[];
 export declare function schedulerRunNowInvalidates(disposition: RunSchedulerNowDisposition): QueryInvalidationHint[];
 export declare function taskRetryInvalidates(taskId: TaskId): QueryInvalidationHint[];

package/dist/server-shell/http/routes/project-api/invalidations.js

@@ -1,6 +1,3 @@
-export function mainChatMessageInvalidates() {
-    return [{ kind: "messages", scope: "main_chat" }, { kind: "read_state" }, { kind: "bootstrap" }];
-}
 export function worklistSubmitInvalidates() {
     return [
         { kind: "worklist" },