@xfey/tutti 0.1.119 → 0.1.121

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

@@ -1,5 +1,5 @@
 import { ApprovalRequestIdSchema, ClarificationRoundRefSchema, ClarificationThreadRefSchema, IdempotencyKeySchema, IsoDateTimeStringSchema, ProjectIdSchema, RelayAccountRefSchema, RelayClientSessionIdSchema, RelayPlatformSessionRefSchema, RelayProjectRefSchema, RecoverySummaryIdSchema, TaskIdSchema, } from "@tutti/shared/schemas/domain";
-import { ActiveClarificationProjectionSchema, ActiveApprovalProjectionSchema, ExecutionStatusProjectionSchema, MessageWindowSchema, ProjectTimelineResponseSchema, ReadStateSummaryProjectionSchema, ScratchpadProjectionSchema, WorklistProjectionSchema, } from "@tutti/shared/schemas/api";
+import { ActiveClarificationProjectionSchema, ActiveApprovalProjectionSchema, ExecutionStatusProjectionSchema, MessageWindowSchema, ProjectTimelineResponseSchema, ReadStateSummaryProjectionSchema, ScratchpadProjectionSchema, WorklistProjectionSchema, ProviderConfigProjectionSchema, } from "@tutti/shared/schemas/api";
 import { ACCOUNT_AVATAR_COLORS } from "@tutti/shared/domain";
 import { HOST_MAINLINE_BRANCH } from "./constants.js";
 export const AccountAvatarProjectionSchema = {
@@ -27,62 +27,8 @@ export const AccountAvatarProjectionSchema = {
         },
     ],
 };
-export const ProviderConfigProjectionSchema = {
-    oneOf: [
-        {
-            type: "object",
-            required: ["status"],
-            additionalProperties: false,
-            properties: {
-                status: { type: "string", enum: ["not_configured"] },
-            },
-        },
-        {
-            type: "object",
-            required: [
-                "status",
-                "provider",
-                "auth_kind",
-                "redacted_key",
-                "default_model",
-                "validated_at",
-            ],
-            additionalProperties: false,
-            properties: {
-                status: { type: "string", enum: ["configured"] },
-                provider: { type: "string", enum: ["openai"] },
-                auth_kind: { type: "string", enum: ["api_key"] },
-                redacted_key: { type: "string" },
-                default_model: { type: "string" },
-                validated_at: IsoDateTimeStringSchema,
-            },
-        },
-        {
-            type: "object",
-            required: ["status"],
-            additionalProperties: false,
-            properties: {
-                status: { type: "string", enum: ["invalid"] },
-                provider: { type: "string", enum: ["openai"] },
-                auth_kind: { type: "string", enum: ["api_key"] },
-                redacted_key: { type: "string" },
-                default_model: { type: "string" },
-                validated_at: IsoDateTimeStringSchema,
-                invalid_reason_code: {
-                    type: "string",
-                    enum: [
-                        "provider_auth_invalid",
-                        "provider_quota_or_billing_required",
-                        "provider_rate_limited",
-                        "provider_model_unavailable",
-                        "provider_network_error",
-                        "unknown",
-                    ],
-                },
-            },
-        },
-    ],
-};
+// Keep Fastify serialization and OpenAPI on the shared provider contract.
+export { ProviderConfigProjectionSchema } from "@tutti/shared/schemas/api";
 const ProviderUsageBreakdownProjectionSchema = {
     type: "object",
     required: [
@@ -305,7 +251,7 @@ export const WorkspaceResponseSchema = {
             required: ["status"],
             additionalProperties: false,
             properties: {
-                status: { type: "string", enum: ["not_configured", "configured", "invalid"] },
+                status: { type: "string", enum: ["not_configured", "configured", "managed", "invalid"] },
                 provider: { type: "string", enum: ["openai"] },
             },
         },

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

@@ -23,6 +23,9 @@ export type ResolvedStagedUpload = {
     complete: (status: "completed" | "aborted") => Promise<void>;
 };
 export type HostProviderConfigProjection = {
+    status: "managed";
+    funding_kind: "trial";
+} | {
     status: "not_configured";
 } | {
     status: "configured";

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

@@ -0,0 +1,9 @@
+import type { FastifyInstance, FastifyRequest } from "fastify";
+import { type LocalConsoleManagedProjectService } from "./managed-project-service.js";
+import type { ReadLocalConsoleSession } from "./session.js";
+export declare function registerLocalConsoleManagedProjectRoutes(app: FastifyInstance, options: {
+    service: LocalConsoleManagedProjectService;
+    tuttiHome: string;
+    requireSession: (request: FastifyRequest, csrf: boolean) => ReadLocalConsoleSession;
+}): void;
+//# sourceMappingURL=managed-project-routes.d.ts.map

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

@@ -0,0 +1,120 @@
+import { Type } from "@sinclair/typebox";
+import { Value } from "@sinclair/typebox/value";
+import { IdempotencyKeySchema } from "@tutti/shared/schemas/domain";
+import { serializeRuntimeLogLine } from "@tutti/shared/utils";
+import { NativeAuthorityTransportError } from "@tutti/relay-client";
+import { appendHostLogLine, getHostLogFilePath } from "../cli/machine-local.js";
+import { ManagedLocalStateError } from "../managed-access/private-store.js";
+import { LocalConsoleProjectError } from "./project-service.js";
+import { LocalConsoleOperationConflictError } from "./operation-coordinator.js";
+import { LaunchError } from "../cli/errors.js";
+import { ManagedDraftInputSchema, } from "./managed-project-service.js";
+const ReadSchema = Type.Object({ request_ref: IdempotencyKeySchema }, { additionalProperties: false });
+export function registerLocalConsoleManagedProjectRoutes(app, options) {
+    for (const operation of ["prepare", "read", "reconcile", "validate", "launch"]) {
+        app.post(`/local-console/v1/managed-projects/${operation}`, {
+            bodyLimit: 8192,
+            errorHandler: (error, request, reply) => {
+                if (error.code !== "FST_ERR_CTP_INVALID_JSON_BODY" &&
+                    error.code !== "FST_ERR_CTP_BODY_TOO_LARGE")
+                    throw error;
+                const status = error.code === "FST_ERR_CTP_BODY_TOO_LARGE" ? 413 : 400;
+                void reply
+                    .code(status)
+                    .header("cache-control", "no-store")
+                    .header("x-tutti-request-id", request.id)
+                    .send({
+                    error: {
+                        code: status === 413 ? "payload_too_large" : "managed_creation_input_invalid",
+                        request_id: request.id,
+                        retryable: false,
+                    },
+                });
+            },
+            onError: (request, _reply, error, done) => {
+                // Parser, loopback, cookie and CSRF rejection precede the operation handler.
+                // Never record error.message: JSON parser errors may include request content.
+                observeManagedCreation(options.tuttiHome, request.id, operation, "rejected", error.statusCode === 401
+                    ? "session_required"
+                    : error.statusCode === 403
+                        ? "request_origin_or_csrf_rejected"
+                        : error.statusCode === 413
+                            ? "payload_too_large"
+                            : "managed_http_rejected");
+                done();
+            },
+        }, async (request, reply) => {
+            const diagnostic = request.id;
+            reply.header("x-tutti-request-id", diagnostic);
+            const session = options.requireSession(request, true);
+            if (!session.accountReady) {
+                observeManagedCreation(options.tuttiHome, diagnostic, operation, "rejected", "account_required");
+                return reply.code(401).send({
+                    error: { code: "account_required", request_id: diagnostic, retryable: false },
+                });
+            }
+            const observe = (status, reason, upstreamRequestId) => {
+                observeManagedCreation(options.tuttiHome, diagnostic, operation, status, reason, upstreamRequestId);
+            };
+            try {
+                if (Object.keys(request.query).length)
+                    throw new ManagedLocalStateError("managed_creation_input_invalid");
+                let result;
+                if (operation === "prepare") {
+                    if (!Value.Check(ManagedDraftInputSchema, request.body))
+                        throw new ManagedLocalStateError("managed_creation_input_invalid");
+                    result = await options.service.prepare(request.body, session.context);
+                }
+                else {
+                    if (!Value.Check(ReadSchema, request.body))
+                        throw new ManagedLocalStateError("managed_creation_input_invalid");
+                    result = await options.service[operation](request.body.request_ref, session.context);
+                }
+                observe("succeeded");
+                return result;
+            }
+            catch (error) {
+                const code = error instanceof ManagedLocalStateError ||
+                    error instanceof LocalConsoleProjectError ||
+                    error instanceof LocalConsoleOperationConflictError ||
+                    error instanceof LaunchError ||
+                    error instanceof NativeAuthorityTransportError
+                    ? error.code
+                    : "managed_creation_unavailable";
+                const status = error instanceof NativeAuthorityTransportError
+                    ? (error.status ?? 503)
+                    : error instanceof LocalConsoleProjectError
+                        ? error.statusCode
+                        : code === "managed_creation_input_invalid"
+                            ? 400
+                            : 409;
+                observe("rejected", code, error instanceof NativeAuthorityTransportError ? error.requestId : undefined);
+                return reply
+                    .code(status)
+                    .send({ error: { code, request_id: diagnostic, retryable: false } });
+            }
+        });
+    }
+}
+function observeManagedCreation(tuttiHome, diagnostic, stage, status, reason, upstreamRequestId) {
+    try {
+        appendHostLogLine(getHostLogFilePath(tuttiHome), serializeRuntimeLogLine({
+            service: "host",
+            component: "managed-creation",
+            level: status === "succeeded" ? "info" : "warn",
+            message: "Native managed creation operation",
+            fields: {
+                request_id: diagnostic,
+                stage,
+                status,
+                ...(reason === undefined ? {} : { reason_code: reason }),
+                ...(upstreamRequestId === undefined ? {} : { relay_request_id: upstreamRequestId }),
+            },
+            now: () => new Date(),
+        }));
+    }
+    catch {
+        /* Diagnostics cannot alter authorization or disclose private failures. */
+    }
+}
+//# sourceMappingURL=managed-project-routes.js.map

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

@@ -0,0 +1,141 @@
+import { type Static } from "@sinclair/typebox";
+import { type LocalConsoleInvocationContext } from "./invocation-context.js";
+import type { LocalConsoleOperationCoordinator } from "./operation-coordinator.js";
+import type { LocalConsoleProjectService } from "./project-service.js";
+export declare const ManagedDraftInputSchema: import("@sinclair/typebox").TObject<{
+    request_ref: import("@sinclair/typebox").TString;
+    workspace_path: 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_project_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+export type ManagedDraftInput = Static<typeof ManagedDraftInputSchema>;
+export declare class LocalConsoleManagedProjectService {
+    private readonly options;
+    constructor(options: {
+        tuttiHome: string;
+        operations: LocalConsoleOperationCoordinator;
+        serviceEnvironment?: NodeJS.ProcessEnv;
+        fetchImpl?: typeof fetch;
+        now?: () => Date;
+        projects?: Pick<LocalConsoleProjectService, "launchAuthorizedProject">;
+    });
+    private environment;
+    private state;
+    prepare(input: ManagedDraftInput, context: LocalConsoleInvocationContext): Promise<{
+        draft: {
+            state: "validation_failed" | "prepared" | "registered" | "validated" | "awaiting_authorization" | "validation_unknown";
+            expires_at: string;
+            existing_project_id?: `prj_${string}`;
+            surface: "standalone" | "feishu";
+            description?: string;
+            request_ref: string;
+            project_id: `prj_${string}`;
+            display_name: string;
+            workspace_path: string;
+        };
+        relay_origin: string;
+        preparation: {
+            existing_relay_project_ref?: string;
+            expires_before?: string;
+            installation_ref: string;
+            surface: "standalone" | "feishu";
+            request_ref: string;
+            project_id: string;
+            installation_secret_hash: string;
+            handoff_token_hash: string;
+            host_registration_secret_hash: string;
+            trial_consent: "trial-project-v1";
+        };
+    }>;
+    read(requestRef: string, context: LocalConsoleInvocationContext): {
+        draft: {
+            state: "validation_failed" | "prepared" | "registered" | "validated" | "awaiting_authorization" | "validation_unknown";
+            expires_at: string;
+            existing_project_id?: `prj_${string}`;
+            surface: "standalone" | "feishu";
+            description?: string;
+            request_ref: string;
+            project_id: `prj_${string}`;
+            display_name: string;
+            workspace_path: string;
+        };
+        relay_origin: string;
+        preparation: {
+            existing_relay_project_ref?: string;
+            expires_before?: string;
+            installation_ref: string;
+            surface: "standalone" | "feishu";
+            request_ref: string;
+            project_id: string;
+            installation_secret_hash: string;
+            handoff_token_hash: string;
+            host_registration_secret_hash: string;
+            trial_consent: "trial-project-v1";
+        };
+    };
+    reconcile(requestRef: string, context: LocalConsoleInvocationContext): Promise<{
+        draft: {
+            state: "validation_failed" | "prepared" | "registered" | "validated" | "awaiting_authorization" | "validation_unknown";
+            expires_at: string;
+            existing_project_id?: `prj_${string}`;
+            surface: "standalone" | "feishu";
+            description?: string;
+            request_ref: string;
+            project_id: `prj_${string}`;
+            display_name: string;
+            workspace_path: string;
+        };
+        relay_origin: string;
+        preparation: {
+            existing_relay_project_ref?: string;
+            expires_before?: string;
+            installation_ref: string;
+            surface: "standalone" | "feishu";
+            request_ref: string;
+            project_id: string;
+            installation_secret_hash: string;
+            handoff_token_hash: string;
+            host_registration_secret_hash: string;
+            trial_consent: "trial-project-v1";
+        };
+    }>;
+    validate(requestRef: string, context: LocalConsoleInvocationContext): Promise<{
+        validation: {
+            state: "failed" | "unknown" | "started" | "succeeded";
+            installation_ref: string;
+            reason_code: "validation_started" | "validation_succeeded" | "validation_route_unavailable" | "validation_http_rejected" | "validation_response_invalid" | "validation_transport_unknown" | "validation_interrupted";
+            project_id: string;
+            creation_ref: string;
+            route_ref: string;
+            http_status: number | null;
+        };
+        draft: {
+            state: "validation_failed" | "prepared" | "registered" | "validated" | "awaiting_authorization" | "validation_unknown";
+            expires_at: string;
+            existing_project_id?: `prj_${string}`;
+            surface: "standalone" | "feishu";
+            description?: string;
+            request_ref: string;
+            project_id: `prj_${string}`;
+            display_name: string;
+            workspace_path: string;
+        };
+        relay_origin: string;
+        preparation: {
+            existing_relay_project_ref?: string;
+            expires_before?: string;
+            installation_ref: string;
+            surface: "standalone" | "feishu";
+            request_ref: string;
+            project_id: string;
+            installation_secret_hash: string;
+            handoff_token_hash: string;
+            host_registration_secret_hash: string;
+            trial_consent: "trial-project-v1";
+        };
+    }>;
+    launch(requestRef: string, context: LocalConsoleInvocationContext): Promise<import("./project-service.js").LocalConsoleLaunchResult>;
+}
+//# sourceMappingURL=managed-project-service.d.ts.map

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

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

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

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

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

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

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

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