@xfey/tenso 0.1.130

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

@@ -0,0 +1,716 @@
+import { existsSync, statSync } from "node:fs";
+import { resolve } from "node:path";
+import { readRelayProjectMembershipState } from "@tutti/relay-client";
+import { createProjectSurfaceProfile, } from "@tutti/shared/domain";
+import { relayProjectRouteSegment } from "@tutti/shared/ids";
+import { hasProjectModelConfiguration, readProjectModelAccess, } from "../managed-access/project-provider.js";
+import { materializeManagedWorkspace } from "../managed-access/workspace.js";
+import { configureProjectOpenAiProvider, discoverOpenAiModels, isOpenAiApiKey, validateOpenAiCredential, } from "../../providers/openai/index.js";
+import { formatCliErrorReason, LaunchError } from "../cli/errors.js";
+import { createRuntimeEndpointProbe, waitForHostShutdown, } from "../cli/host-runtime-endpoint.js";
+import { prepareLaunchProject, resolveLaunchLocalContext, resolveRelayUrl } from "../cli/launch.js";
+import { readHostLocalLaunchStatus, requestHostLocalIdleShutdown, rotateHostLocalInvite, } from "../cli/local-control-client.js";
+import { readFreshVisibleJoinUrl } from "../cli/join-url.js";
+import { readHostRegistrationSecret, readMachineProjectBinding, readMachineRuntimeEndpoint, writeFeishuOwnerAccountHandoff, } from "../cli/machine-local.js";
+import { spawnDetachedHost, waitForManagedHostReady } from "../cli/managed-host.js";
+import { relayStatusFromLocalStatus } from "../cli/host-relay-status.js";
+import { resolveManagedProjectContext } from "../cli/project-resolver.js";
+import { listRuntimeProjects, runStopCommand, } from "../cli/runtime-commands.js";
+import { readCliVersion } from "../cli/version.js";
+import { createLocalConsoleOperationEnvironment, } from "./invocation-context.js";
+import { LocalConsoleOperationConflictError, LocalConsoleOperationCoordinator, } from "./operation-coordinator.js";
+const OPEN_UPDATE_SHUTDOWN_WAIT_MS = 5_000;
+const STOP_SHUTDOWN_WAIT_MS = 5_000;
+export class LocalConsoleProjectError extends Error {
+    code;
+    statusCode;
+    constructor(code, message, statusCode = 422) {
+        super(message);
+        this.code = code;
+        this.statusCode = statusCode;
+        this.name = "LocalConsoleProjectError";
+    }
+}
+export function localConsoleProviderValidationMessage(result) {
+    switch (result.reason) {
+        case "provider_auth_invalid":
+            return "The API key was rejected. Enter the raw bearer token and try again.";
+        case "provider_model_unavailable":
+            return "The selected model is not available through this Responses API endpoint.";
+        case "provider_quota_or_billing_required":
+            return "This Provider account does not have available quota or billing access.";
+        case "provider_rate_limited":
+            return "The Provider is rate limited. Wait a moment, then try again.";
+        case "provider_network_error":
+            if (result.diagnostic?.http_status === 404 || result.diagnostic?.http_status === 405) {
+                return "This Base URL does not expose an OpenAI-compatible POST /responses endpoint.";
+            }
+            return "Could not validate the OpenAI Responses API endpoint. Check the Base URL and try again.";
+    }
+}
+function validateWorkspacePath(value) {
+    const path = resolve(value.trim());
+    if (value.trim() === "" || !existsSync(path) || !statSync(path).isDirectory()) {
+        throw new LocalConsoleProjectError("project_folder_invalid", "Choose an existing project folder before launching.");
+    }
+    return path;
+}
+function validateProvider(input) {
+    const provider = {
+        base_url: input.base_url.trim(),
+        api_key: input.api_key.trim(),
+        model: input.model.trim(),
+    };
+    if (provider.base_url === "" || provider.api_key === "" || provider.model === "") {
+        throw new LocalConsoleProjectError("provider_configuration_required", "Base URL, API key, and model are required for a new Provider configuration.");
+    }
+    try {
+        const url = new URL(provider.base_url);
+        if (url.protocol !== "http:" && url.protocol !== "https:") {
+            throw new Error("unsupported protocol");
+        }
+    }
+    catch {
+        throw new LocalConsoleProjectError("provider_base_url_invalid", "Enter a valid HTTP or HTTPS Provider Base URL.");
+    }
+    return provider;
+}
+function validateProjectMetadata(input) {
+    const displayName = input.display_name.trim();
+    const description = input.description?.trim();
+    if (displayName === "" || displayName.length > 80) {
+        throw new LocalConsoleProjectError("project_display_name_invalid", "Project name must be between 1 and 80 characters.");
+    }
+    if (description !== undefined && description.length > 160) {
+        throw new LocalConsoleProjectError("project_description_invalid", "Project description cannot exceed 160 characters.");
+    }
+    return {
+        display_name: displayName,
+        ...(description === undefined || description === "" ? {} : { description }),
+    };
+}
+function projectFromRuntimeRow(row, providerStatus, providerModel, metadata) {
+    const currentVersion = readCliVersion();
+    const relayOrigin = safeRelayOrigin(metadata.relayUrl);
+    const openUrl = metadata.surfaceProfile.kind === "standalone"
+        ? projectOpenUrl(metadata.relayUrl, row.relay_project_ref)
+        : undefined;
+    return {
+        project_id: row.project_id,
+        surface_profile: metadata.surfaceProfile,
+        display_name: row.display_name,
+        workspace_path: row.workspace_root,
+        status: row.status,
+        provider_status: providerStatus,
+        ...(providerModel === undefined ? {} : { provider_model: providerModel }),
+        ...(row.relay_project_ref === undefined ? {} : { relay_project_ref: row.relay_project_ref }),
+        ...(relayOrigin === undefined ? {} : { relay_origin: relayOrigin }),
+        ...(openUrl === undefined ? {} : { open_url: openUrl }),
+        ...(row.relay_connection_status === undefined
+            ? {}
+            : { relay_connection_status: row.relay_connection_status }),
+        ...(metadata.activityAt === undefined ? {} : { activity_at: metadata.activityAt }),
+        ...(metadata.createdAt === undefined ? {} : { created_at: metadata.createdAt }),
+        ...(row.host_version === undefined ? {} : { host_version: row.host_version }),
+        ...(row.host_version === undefined || row.host_version === currentVersion
+            ? {}
+            : { update_required: true }),
+    };
+}
+function safeRelayOrigin(value) {
+    try {
+        const url = new URL(value ?? "");
+        return !url.username && !url.password && (url.protocol === "https:" || url.protocol === "http:")
+            ? url.origin
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function projectOpenUrl(relayUrl, relayProjectRef) {
+    if (relayUrl === undefined || relayProjectRef === undefined) {
+        return undefined;
+    }
+    try {
+        const url = new URL(`/projects?open=${encodeURIComponent(relayProjectRouteSegment(relayProjectRef))}`, relayUrl);
+        return url.protocol === "http:" || url.protocol === "https:" ? url.toString() : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function readProjectActivityAt(tuttiHome, row, binding) {
+    if (row.last_connected_at !== undefined) {
+        return row.last_connected_at;
+    }
+    try {
+        const endpoint = readMachineRuntimeEndpoint(tuttiHome, row.project_id);
+        if (endpoint !== null) {
+            return endpoint.updated_at;
+        }
+    }
+    catch {
+        // Invalid endpoint state is already represented by the project status.
+    }
+    try {
+        return binding?.updated_at;
+    }
+    catch {
+        return undefined;
+    }
+}
+function relayUrlFromJoinUrl(joinUrl) {
+    if (joinUrl === undefined) {
+        return undefined;
+    }
+    try {
+        return new URL(joinUrl).origin;
+    }
+    catch {
+        return undefined;
+    }
+}
+export class LocalConsoleProjectService {
+    #tuttiHome;
+    #serviceEnvironment;
+    #fetchImpl;
+    #validateProviderCredential;
+    #operations;
+    #now;
+    #launches = new Map();
+    constructor(options) {
+        this.#tuttiHome = resolve(options.tuttiHome);
+        this.#serviceEnvironment = options.serviceEnvironment ?? process.env;
+        this.#fetchImpl = options.fetchImpl ?? fetch;
+        this.#operations = options.operations ?? new LocalConsoleOperationCoordinator();
+        this.#now = options.now ?? (() => new Date());
+        this.#validateProviderCredential =
+            options.validateProviderCredential ?? validateOpenAiCredential;
+    }
+    #operationOptions(context) {
+        return {
+            cwd: context.source === "terminal" ? context.currentDirectory : this.#tuttiHome,
+            env: createLocalConsoleOperationEnvironment({
+                serviceEnvironment: this.#serviceEnvironment,
+                invocationEnvironment: context.environment,
+                tuttiHome: this.#tuttiHome,
+            }),
+        };
+    }
+    async listProjects(context) {
+        const operation = this.#operationOptions(context);
+        const rows = await listRuntimeProjects({
+            all: true,
+            fetchImpl: this.#fetchImpl,
+            ...operation,
+        });
+        return rows.map((row) => {
+            let binding = null;
+            try {
+                binding = readMachineProjectBinding(this.#tuttiHome, row.project_id);
+            }
+            catch {
+                // Invalid binding state is already represented by the project status.
+            }
+            let createdAt = binding?.created_at;
+            if (createdAt === undefined) {
+                try {
+                    createdAt = readHostRegistrationSecret(this.#tuttiHome, row.project_id).created_at;
+                }
+                catch {
+                    // Damaged legacy metadata remains visible without an invented creation date.
+                }
+            }
+            const provider = readProjectModelAccess({
+                tuttiHome: this.#tuttiHome,
+                projectId: row.project_id,
+                relayUrl: binding?.relay_url ?? resolveRelayUrl(operation.env),
+            });
+            const providerModel = provider.status === "not_configured"
+                ? undefined
+                : provider.status === "managed"
+                    ? "Tenso"
+                    : provider.default_model;
+            const activityAt = readProjectActivityAt(this.#tuttiHome, row, binding);
+            return {
+                ...projectFromRuntimeRow(row, provider.status, providerModel, {
+                    ...(activityAt === undefined ? {} : { activityAt }),
+                    ...(createdAt === undefined ? {} : { createdAt }),
+                    relayUrl: binding?.relay_url ??
+                        relayUrlFromJoinUrl(row.join_url) ??
+                        resolveRelayUrl(operation.env),
+                    surfaceProfile: binding?.surface_profile ?? createProjectSurfaceProfile(),
+                }),
+            };
+        });
+    }
+    async #readProject(projectId, context) {
+        const project = (await this.listProjects(context)).find((candidate) => candidate.project_id === projectId);
+        if (project === undefined) {
+            throw new LocalConsoleProjectError("project_not_found", "The project could not be read from the machine project list.", 404);
+        }
+        return project;
+    }
+    async readFeishuSetup(projectId, context) {
+        const project = await this.#readProject(projectId, context);
+        if (project.surface_profile.kind !== "feishu") {
+            throw new LocalConsoleProjectError("project_surface_mismatch", "Tenso Workspace projects do not use a Feishu connection.");
+        }
+        let endpoint;
+        try {
+            endpoint = resolveManagedProjectContext({
+                target: projectId,
+                ...this.#operationOptions(context),
+            }).runtime_endpoint;
+        }
+        catch {
+            throw new LocalConsoleProjectError("feishu_setup_unavailable", "The Feishu connection state is temporarily unavailable.", 503);
+        }
+        if (endpoint === null) {
+            throw new LocalConsoleProjectError("host_not_running", "Resume this project before viewing its Feishu connection.", 409);
+        }
+        let status;
+        try {
+            status = await readHostLocalLaunchStatus({ endpoint, fetchImpl: this.#fetchImpl });
+        }
+        catch {
+            throw new LocalConsoleProjectError("feishu_setup_unavailable", "The running Host did not return its Feishu connection state.", 503);
+        }
+        if (status.project_id !== project.project_id || status.relay?.feishu_setup === undefined) {
+            throw new LocalConsoleProjectError("feishu_setup_unavailable", "The running Host did not return its Feishu connection state.", 503);
+        }
+        const setup = status.relay.feishu_setup;
+        if (setup.state === "pairing_required" && setup.visibility === "visible_once") {
+            const expiresAt = Date.parse(setup.expires_at);
+            if (!Number.isFinite(expiresAt) || expiresAt <= this.#now().getTime()) {
+                return { state: "pairing_required", visibility: "not_recoverable" };
+            }
+        }
+        return setup;
+    }
+    async #startManagedHost(options) {
+        const startup = spawnDetachedHost({
+            tuttiHome: options.tuttiHome,
+            projectId: options.projectId,
+            workspaceRoot: options.workspaceRoot,
+            env: options.env,
+            inheritProcessEnv: false,
+        });
+        return await waitForManagedHostReady({
+            tuttiHome: options.tuttiHome,
+            projectId: options.projectId,
+            workspaceRoot: options.workspaceRoot,
+            fetchImpl: this.#fetchImpl,
+            startupAttemptRef: startup.startup_attempt_ref,
+            ...(options.inviteMode === undefined ? {} : { inviteMode: options.inviteMode }),
+        });
+    }
+    async discoverModels(input) {
+        const provider = validateProvider({
+            base_url: input.baseUrl,
+            api_key: input.apiKey,
+            model: "model-discovery",
+        });
+        return await discoverOpenAiModels({
+            apiBaseUrl: provider.base_url,
+            apiKey: provider.api_key,
+        });
+    }
+    async #validateLaunchProvider(input) {
+        let validation;
+        try {
+            validation = isOpenAiApiKey(input.api_key)
+                ? await this.#validateProviderCredential({
+                    apiKey: input.api_key,
+                    apiBaseUrl: input.base_url,
+                    defaultModel: input.model,
+                })
+                : {
+                    kind: "failed",
+                    reason: "provider_auth_invalid",
+                    retryable: false,
+                };
+        }
+        catch (error) {
+            throw this.#normalizeError(error);
+        }
+        if (validation.kind === "failed") {
+            const failure = {
+                kind: "validation_failed",
+                reason: validation.reason,
+                retryable: validation.retryable,
+                ...(validation.diagnostic === undefined ? {} : { diagnostic: validation.diagnostic }),
+            };
+            throw new LocalConsoleProjectError(failure.reason, localConsoleProviderValidationMessage(failure));
+        }
+        return { input, validation };
+    }
+    #requireStoredLaunchProvider(workspacePath, operation) {
+        const context = resolveLaunchLocalContext({ workspacePath, ...operation });
+        const provider = context.existing_identity.kind === "present"
+            ? readProjectModelAccess({
+                tuttiHome: context.tutti_home,
+                projectId: context.existing_identity.project_id,
+                relayUrl: readMachineProjectBinding(context.tutti_home, context.existing_identity.project_id)
+                    ?.relay_url ?? resolveRelayUrl(operation.env),
+            })
+            : { status: "not_configured" };
+        if (!hasProjectModelConfiguration(provider)) {
+            throw new LocalConsoleProjectError("provider_configuration_required", "This project does not have a valid saved Provider. Configure it in the launch form.");
+        }
+    }
+    async launchProject(input, context, accountHandoff) {
+        const workspacePath = validateWorkspacePath(input.workspacePath);
+        const active = this.#launches.get(workspacePath);
+        if (active !== undefined) {
+            return await active;
+        }
+        const launch = this.#operations
+            .runProjectOperation(async () => await this.#launchProject({
+            workspacePath,
+            ...(input.project === undefined
+                ? {}
+                : { project: validateProjectMetadata(input.project) }),
+            ...(input.provider === undefined
+                ? {}
+                : { provider: validateProvider(input.provider) }),
+            ...(input.surface === undefined ? {} : { surface: input.surface }),
+        }, context, accountHandoff))
+            .finally(() => {
+            this.#launches.delete(workspacePath);
+        });
+        this.#launches.set(workspacePath, launch);
+        return await launch;
+    }
+    async #launchProject(input, context, accountHandoff) {
+        const operation = this.#operationOptions(context);
+        if (input.provider !== undefined) {
+            const local = resolveLaunchLocalContext({ workspacePath: input.workspacePath, ...operation });
+            if (local.existing_identity.kind === "present" &&
+                readProjectModelAccess({
+                    tuttiHome: local.tutti_home,
+                    projectId: local.existing_identity.project_id,
+                    relayUrl: readMachineProjectBinding(local.tutti_home, local.existing_identity.project_id)
+                        ?.relay_url ?? resolveRelayUrl(operation.env),
+                }).status === "managed") {
+                throw new LocalConsoleProjectError("managed_model_fixed", "Managed projects cannot be changed through BYOK setup.", 409);
+            }
+        }
+        if (input.provider === undefined) {
+            try {
+                this.#requireStoredLaunchProvider(input.workspacePath, operation);
+            }
+            catch (error) {
+                throw this.#normalizeError(error);
+            }
+        }
+        const provider = input.provider === undefined ? undefined : await this.#validateLaunchProvider(input.provider);
+        let preparation;
+        try {
+            preparation = await prepareLaunchProject({
+                workspacePath: input.workspacePath,
+                yes: true,
+                ...(input.project === undefined
+                    ? {}
+                    : {
+                        projectDisplayName: input.project.display_name,
+                        ...(input.project.description === undefined
+                            ? {}
+                            : { projectDescription: input.project.description }),
+                    }),
+                ...(input.surface === undefined ? {} : { projectSurface: input.surface }),
+                ...operation,
+            });
+        }
+        catch (error) {
+            throw this.#normalizeError(error);
+        }
+        if (provider !== undefined && preparation.provider_status === "managed") {
+            throw new LocalConsoleProjectError("managed_model_fixed", "Managed projects cannot be changed through BYOK setup.", 409);
+        }
+        if (provider !== undefined) {
+            const configured = await configureProjectOpenAiProvider({
+                tuttiHome: preparation.tutti_home,
+                projectId: preparation.project_id,
+                apiBaseUrl: provider.input.base_url,
+                apiKey: provider.input.api_key,
+                defaultModel: provider.input.model,
+                validateCredential: () => Promise.resolve(provider.validation),
+            });
+            if (configured.kind === "validation_failed") {
+                throw new LocalConsoleProjectError(configured.reason, localConsoleProviderValidationMessage(configured));
+            }
+        }
+        else if (!hasProjectModelConfiguration(preparation.provider_config)) {
+            throw new LocalConsoleProjectError("provider_configuration_required", "This project does not have a valid saved Provider. Configure it in the launch form.");
+        }
+        if (preparation.machine_local.binding.surface_profile.kind === "feishu" &&
+            preparation.provider_status !== "managed" &&
+            accountHandoff !== undefined) {
+            writeFeishuOwnerAccountHandoff({
+                tuttiHome: preparation.tutti_home,
+                projectId: preparation.project_id,
+                token: accountHandoff.token,
+                expiresAt: accountHandoff.expires_at,
+                now: this.#now(),
+            });
+        }
+        return this.#finishLaunch(preparation, context, operation.env);
+    }
+    // Called only by the native authority service while holding the Console operation
+    // guard. It accepts a private, verified journal, never a browser-provided receipt.
+    async launchAuthorizedProject(state, requestRef, context) {
+        const operation = this.#operationOptions(context);
+        const preparation = await materializeManagedWorkspace({
+            state,
+            requestRef,
+            tuttiHome: this.#tuttiHome,
+            environment: operation.env,
+            now: this.#now,
+        });
+        return this.#finishLaunch(preparation, context, {
+            ...operation.env,
+            TUTTI_RELAY_URL: state.origin,
+        });
+    }
+    async #finishLaunch(preparation, context, environment) {
+        try {
+            const ready = await this.#startManagedHost({
+                workspaceRoot: preparation.workspace_root,
+                tuttiHome: preparation.tutti_home,
+                projectId: preparation.project_id,
+                env: environment,
+            });
+            if (preparation.machine_local.binding.surface_profile.kind === "standalone" &&
+                ready.join_url === undefined) {
+                throw new LocalConsoleProjectError("relay_registration_failed", "The host started, but Relay did not return a visible join link.");
+            }
+            const projects = await this.listProjects(context);
+            const project = projects.find((item) => item.project_id === preparation.project_id);
+            if (project === undefined) {
+                throw new LocalConsoleProjectError("project_not_found", "The launched project could not be read from the machine project list.");
+            }
+            return {
+                project,
+                project_created: preparation.project_identity_created,
+                ...(ready.join_url === undefined ? {} : { join_url: ready.join_url }),
+                ...(ready.join_token_expires_at === undefined
+                    ? {}
+                    : { join_token_expires_at: ready.join_token_expires_at }),
+                ...(ready.feishu_setup === undefined ? {} : { feishu_setup: ready.feishu_setup }),
+            };
+        }
+        catch (error) {
+            throw this.#normalizeError(error);
+        }
+    }
+    async openProject(projectId, context) {
+        return await this.#operations.runProjectOperation(async () => {
+            const current = await this.#readProject(projectId, context);
+            if (current.surface_profile.kind !== "standalone") {
+                throw new LocalConsoleProjectError("project_surface_mismatch", "Feishu collaboration projects do not use the Standalone workspace entry.");
+            }
+            if (current.open_url === undefined) {
+                throw new LocalConsoleProjectError("project_open_unavailable", "This project does not have a Relay destination yet.");
+            }
+            const updated = await this.#updateHostForOpen(current, projectId, context);
+            if (updated.project.open_url === undefined) {
+                throw new LocalConsoleProjectError("project_open_unavailable", "This project does not have a Relay destination yet.");
+            }
+            return {
+                project: updated.project,
+                handoff: await this.#resolveOpenHandoff(updated.project, updated.project.open_url, projectId, context),
+                host_update: updated.hostUpdate,
+            };
+        });
+    }
+    async #updateHostForOpen(current, projectId, context) {
+        if (current.update_required !== true) {
+            return { project: current, hostUpdate: "not_needed" };
+        }
+        let managed;
+        try {
+            managed = resolveManagedProjectContext({
+                target: projectId,
+                ...this.#operationOptions(context),
+            });
+        }
+        catch (error) {
+            throw this.#normalizeError(error);
+        }
+        if (!managed.workspace_exists ||
+            managed.runtime_endpoint === null ||
+            !hasProjectModelConfiguration(managed.provider_config)) {
+            return { project: current, hostUpdate: "deferred_unavailable" };
+        }
+        let shutdownDisposition;
+        try {
+            shutdownDisposition = await requestHostLocalIdleShutdown({
+                endpoint: managed.runtime_endpoint,
+                fetchImpl: this.#fetchImpl,
+            });
+        }
+        catch {
+            return { project: current, hostUpdate: "deferred_unavailable" };
+        }
+        if (shutdownDisposition !== "accepted") {
+            return {
+                project: current,
+                hostUpdate: shutdownDisposition === "busy" ? "deferred_busy" : "deferred_unsupported",
+            };
+        }
+        try {
+            await waitForHostShutdown({
+                endpoint: managed.runtime_endpoint,
+                probeRuntimeEndpoint: createRuntimeEndpointProbe(this.#fetchImpl),
+                shutdownWaitMs: OPEN_UPDATE_SHUTDOWN_WAIT_MS,
+            });
+            await this.#startManagedHost({
+                workspaceRoot: managed.workspace_root,
+                tuttiHome: managed.tutti_home,
+                projectId: managed.project_id,
+                env: this.#operationOptions(context).env,
+                inviteMode: "preserve",
+            });
+            const project = await this.#readProject(projectId, context);
+            if (project.open_url === undefined) {
+                throw new LocalConsoleProjectError("project_open_unavailable", "The updated project does not have a Relay destination.");
+            }
+            return { project, hostUpdate: "updated" };
+        }
+        catch (error) {
+            throw this.#normalizeError(error);
+        }
+    }
+    async #resolveOpenHandoff(project, openUrl, projectId, context) {
+        const projectOpen = () => ({
+            kind: "project_open",
+            url: openUrl,
+        });
+        let runtimeEndpoint;
+        let relay;
+        try {
+            const managed = resolveManagedProjectContext({
+                target: projectId,
+                ...this.#operationOptions(context),
+            });
+            if (managed.runtime_endpoint === null || project.relay_project_ref === undefined) {
+                return projectOpen();
+            }
+            const status = await readHostLocalLaunchStatus({
+                endpoint: managed.runtime_endpoint,
+                fetchImpl: this.#fetchImpl,
+            });
+            const resolvedRelay = relayStatusFromLocalStatus(status);
+            if (resolvedRelay === undefined ||
+                resolvedRelay.relay_project_ref !== project.relay_project_ref) {
+                return projectOpen();
+            }
+            const relayUrl = managed.binding?.relay_url ?? relayUrlFromJoinUrl(openUrl);
+            if (relayUrl === undefined) {
+                return projectOpen();
+            }
+            const credential = readHostRegistrationSecret(managed.tutti_home, managed.project_id);
+            const membership = await readRelayProjectMembershipState({
+                relayUrl,
+                projectId: managed.project_id,
+                relayProjectRef: resolvedRelay.relay_project_ref,
+                hostConnectionRef: resolvedRelay.host_connection_ref,
+                hostRegistrationSecret: credential.secret,
+                fetch: this.#fetchImpl,
+            });
+            if (membership.membership_state === "established") {
+                return projectOpen();
+            }
+            runtimeEndpoint = managed.runtime_endpoint;
+            relay = resolvedRelay;
+        }
+        catch {
+            return projectOpen();
+        }
+        try {
+            const currentJoinUrl = readFreshVisibleJoinUrl(relay, this.#now());
+            if (currentJoinUrl !== undefined) {
+                return { kind: "project_join", url: currentJoinUrl };
+            }
+            const refreshed = await rotateHostLocalInvite({
+                endpoint: runtimeEndpoint,
+                fetchImpl: this.#fetchImpl,
+            });
+            const refreshedRelay = relayStatusFromLocalStatus(refreshed);
+            const refreshedJoinUrl = refreshedRelay === undefined
+                ? undefined
+                : readFreshVisibleJoinUrl(refreshedRelay, this.#now());
+            if (refreshedJoinUrl === undefined) {
+                throw new LocalConsoleProjectError("project_join_unavailable", "This project still needs its first member, but a fresh invitation could not be created.");
+            }
+            return { kind: "project_join", url: refreshedJoinUrl };
+        }
+        catch (error) {
+            throw this.#normalizeError(error);
+        }
+    }
+    async refreshInvite(projectId, context) {
+        return await this.#operations.runProjectOperation(async () => {
+            const project = resolveManagedProjectContext({
+                target: projectId,
+                ...this.#operationOptions(context),
+            });
+            if (project.binding?.surface_profile.kind !== "standalone") {
+                throw new LocalConsoleProjectError("project_surface_mismatch", "Feishu collaboration projects do not use Standalone invite links.");
+            }
+            if (project.runtime_endpoint === null) {
+                throw new LocalConsoleProjectError("host_not_running", "Launch this project before creating an invite link.");
+            }
+            try {
+                const status = await rotateHostLocalInvite({
+                    endpoint: project.runtime_endpoint,
+                    fetchImpl: this.#fetchImpl,
+                });
+                const joinUrl = status.relay?.join_url;
+                if (joinUrl === undefined) {
+                    throw new LocalConsoleProjectError("relay_registration_failed", "Relay did not return a visible invite link.");
+                }
+                return {
+                    join_url: joinUrl,
+                    ...(status.relay?.join_token_expires_at === undefined
+                        ? {}
+                        : { expires_at: status.relay.join_token_expires_at }),
+                };
+            }
+            catch (error) {
+                throw this.#normalizeError(error);
+            }
+        });
+    }
+    async stopProject(projectId, context) {
+        return await this.#operations.runProjectOperation(async () => {
+            try {
+                return {
+                    message: await runStopCommand(projectId, {
+                        ...this.#operationOptions(context),
+                        fetchImpl: this.#fetchImpl,
+                        shutdownWaitMs: STOP_SHUTDOWN_WAIT_MS,
+                    }),
+                };
+            }
+            catch (error) {
+                throw this.#normalizeError(error);
+            }
+        });
+    }
+    #normalizeError(error) {
+        if (error instanceof LocalConsoleProjectError) {
+            return error;
+        }
+        if (error instanceof LocalConsoleOperationConflictError) {
+            return new LocalConsoleProjectError(error.code, error.message, error.statusCode);
+        }
+        if (error instanceof LaunchError) {
+            return new LocalConsoleProjectError(error.code, error.message);
+        }
+        return new LocalConsoleProjectError("local_console_failed", formatCliErrorReason(error), 500);
+    }
+}
+//# sourceMappingURL=project-service.js.map