@xfey/tutti 0.1.5 → 0.1.7

package/dist/server-shell/cli/project-resolver.d.ts

@@ -0,0 +1,19 @@
+import { type ProjectId } from "@tutti/shared/ids";
+import { type OpenAiProviderConfigProjection } from "../../providers/openai/index.js";
+import { type MachineProjectBindingRecord, type MachineRuntimeEndpointRecord } from "./machine-local.js";
+export type ExistingProjectContext = {
+    workspace_root: string;
+    tutti_home: string;
+    project_id: ProjectId;
+    display_name: string;
+    binding: MachineProjectBindingRecord | null;
+    runtime_endpoint: MachineRuntimeEndpointRecord | null;
+    provider_config: OpenAiProviderConfigProjection;
+    provider_base_url?: string;
+};
+export declare function resolveExistingProjectContext(options: {
+    workspacePath?: string;
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+}): ExistingProjectContext;
+//# sourceMappingURL=project-resolver.d.ts.map

package/dist/server-shell/cli/project-resolver.js

@@ -0,0 +1,35 @@
+import { resolve } from "node:path";
+import { readOpenAiProviderConfigProjection, readProjectOpenAiProviderConfig, resolveTuttiHome, } from "../../providers/openai/index.js";
+import { LaunchError } from "./errors.js";
+import { assertSafeProjectRoot } from "./git-bootstrap.js";
+import { readMachineProjectBinding, readMachineRuntimeEndpoint, } from "./machine-local.js";
+import { readProjectDisplayName, readProjectIdentity } from "./project-identity.js";
+export function resolveExistingProjectContext(options) {
+    const cwd = options.cwd ?? process.cwd();
+    const env = options.env ?? process.env;
+    const workspaceRoot = resolve(cwd, options.workspacePath ?? ".");
+    assertSafeProjectRoot(workspaceRoot);
+    const identity = readProjectIdentity(workspaceRoot);
+    if (identity.kind !== "present") {
+        throw new LaunchError("project_identity_conflict", "Current directory is not a Tutti project", "Run `tutti launch` from a project root first.");
+    }
+    const tuttiHome = resolveTuttiHome(env.TUTTI_HOME, cwd);
+    const binding = readMachineProjectBinding(tuttiHome, identity.project_id);
+    const projectConfig = readProjectOpenAiProviderConfig(tuttiHome, identity.project_id);
+    return {
+        workspace_root: workspaceRoot,
+        tutti_home: tuttiHome,
+        project_id: identity.project_id,
+        display_name: readProjectDisplayName(workspaceRoot) ?? identity.project_id,
+        binding,
+        runtime_endpoint: readMachineRuntimeEndpoint(tuttiHome, identity.project_id),
+        provider_config: readOpenAiProviderConfigProjection({
+            tuttiHome,
+            projectId: identity.project_id,
+        }),
+        ...(projectConfig.kind === "ok" && projectConfig.config.api_base_url !== undefined
+            ? { provider_base_url: projectConfig.config.api_base_url }
+            : {}),
+    };
+}
+//# sourceMappingURL=project-resolver.js.map

package/dist/server-shell/cli/provider-tui.d.ts

@@ -0,0 +1,16 @@
+import type { ProjectId } from "@tutti/shared/ids";
+export type ProviderSetupResult = {
+    base_url: string;
+    redacted_key: string;
+    default_model: string;
+    validated_at: string;
+};
+export declare function runProviderSetupTui(options: {
+    projectName: string;
+    tuttiHome: string;
+    projectId: ProjectId;
+    initialBaseUrl?: string;
+    stdin?: NodeJS.ReadStream;
+    stdout?: NodeJS.WriteStream;
+}): Promise<ProviderSetupResult>;
+//# sourceMappingURL=provider-tui.d.ts.map

package/dist/server-shell/cli/provider-tui.js

@@ -0,0 +1,226 @@
+import { emitKeypressEvents } from "node:readline";
+import { redactError } from "@tutti/shared/utils";
+import { configureProjectOpenAiProvider, DEFAULT_OPENAI_MODEL, } from "../../providers/openai/index.js";
+const DEFAULT_BASE_URL = "https://api.openai.com/v1";
+const HIDE_CURSOR = "\u001B[?25l";
+const SHOW_CURSOR = "\u001B[?25h";
+const CLEAR = "\u001B[2J\u001B[H";
+function fieldLine(options) {
+    const active = options.index === options.selected;
+    const marker = active ? ">" : " ";
+    const value = options.secret && options.value.length > 0 ? "*".repeat(options.value.length) : options.value;
+    return `${marker} ${options.label.padEnd(10)} ${value}${active ? " _" : ""}`;
+}
+function renderProviderForm(options) {
+    const lines = [
+        CLEAR,
+        HIDE_CURSOR,
+        "Tutti Provider Setup",
+        "",
+        `Project: ${options.projectName}`,
+        "Use Up/Down to move, type to edit, Enter to validate, Ctrl-C to cancel.",
+        "",
+        fieldLine({
+            index: 0,
+            selected: options.state.selected,
+            label: "Base URL",
+            value: options.state.baseUrl,
+        }),
+        fieldLine({
+            index: 1,
+            selected: options.state.selected,
+            label: "API Key",
+            value: options.state.apiKey,
+            secret: true,
+        }),
+        "",
+    ];
+    if (options.state.error !== undefined) {
+        lines.push(`Error: ${options.state.error}`, "");
+    }
+    if (options.footer !== undefined) {
+        lines.push(options.footer);
+    }
+    return lines.join("\n");
+}
+function validationFailureMessage(result) {
+    if (result.kind === "configured") {
+        return "";
+    }
+    const retry = result.retryable ? " Retry after the provider recovers." : "";
+    return `${result.reason}.${retry}`;
+}
+function waitForKeypress(stdin) {
+    return new Promise((resolve, reject) => {
+        const onKeypress = (_character, key) => {
+            cleanup();
+            if (key.ctrl === true && key.name === "c") {
+                reject(new Error("Provider setup cancelled"));
+                return;
+            }
+            resolve();
+        };
+        const cleanup = () => {
+            stdin.off("keypress", onKeypress);
+            if (stdin.isTTY) {
+                stdin.setRawMode(false);
+            }
+        };
+        if (stdin.isTTY) {
+            stdin.setRawMode(true);
+        }
+        stdin.once("keypress", onKeypress);
+    });
+}
+async function readProviderForm(options) {
+    const state = {
+        selected: 0,
+        baseUrl: options.initialBaseUrl ?? DEFAULT_BASE_URL,
+        apiKey: "",
+        error: undefined,
+    };
+    return await new Promise((resolve, reject) => {
+        const render = () => {
+            options.stdout.write(renderProviderForm({ projectName: options.projectName, state }));
+        };
+        const cleanup = () => {
+            options.stdin.off("keypress", onKeypress);
+            if (options.stdin.isTTY) {
+                options.stdin.setRawMode(false);
+            }
+            options.stdout.write(SHOW_CURSOR);
+        };
+        const onKeypress = (character, key) => {
+            if (key.ctrl === true && key.name === "c") {
+                cleanup();
+                reject(new Error("Provider setup cancelled"));
+                return;
+            }
+            if (key.name === "escape") {
+                cleanup();
+                reject(new Error("Provider setup cancelled"));
+                return;
+            }
+            if (key.name === "up") {
+                state.selected = state.selected === 0 ? 1 : 0;
+                state.error = undefined;
+                render();
+                return;
+            }
+            if (key.name === "down" || key.name === "tab") {
+                state.selected = state.selected === 0 ? 1 : 0;
+                state.error = undefined;
+                render();
+                return;
+            }
+            if (key.name === "return") {
+                if (state.baseUrl.trim() === "" || state.apiKey.trim() === "") {
+                    state.error = "Base URL and API key are required.";
+                    render();
+                    return;
+                }
+                cleanup();
+                resolve({ baseUrl: state.baseUrl.trim(), apiKey: state.apiKey.trim() });
+                return;
+            }
+            if (key.name === "backspace") {
+                if (state.selected === 0) {
+                    state.baseUrl = state.baseUrl.slice(0, -1);
+                }
+                else {
+                    state.apiKey = state.apiKey.slice(0, -1);
+                }
+                state.error = undefined;
+                render();
+                return;
+            }
+            if (character !== undefined && character >= " " && character !== "\u007F") {
+                if (state.selected === 0) {
+                    state.baseUrl += character;
+                }
+                else {
+                    state.apiKey += character;
+                }
+                state.error = undefined;
+                render();
+            }
+        };
+        emitKeypressEvents(options.stdin);
+        if (options.stdin.isTTY) {
+            options.stdin.setRawMode(true);
+        }
+        options.stdin.on("keypress", onKeypress);
+        render();
+    });
+}
+function renderChecking(projectName, frame) {
+    const frames = ["|", "/", "-", "\\"];
+    const indicator = frames[frame % frames.length] ?? "|";
+    return [
+        CLEAR,
+        HIDE_CURSOR,
+        "Tutti Provider Setup",
+        "",
+        `Project: ${projectName}`,
+        "",
+        `${indicator} Checking provider connection with ${DEFAULT_OPENAI_MODEL}...`,
+    ].join("\n");
+}
+export async function runProviderSetupTui(options) {
+    const stdin = options.stdin ?? process.stdin;
+    const stdout = options.stdout ?? process.stdout;
+    if (!stdin.isTTY || !stdout.isTTY) {
+        throw new Error("Provider setup requires an interactive terminal.");
+    }
+    let initialBaseUrl = options.initialBaseUrl;
+    while (true) {
+        const input = await readProviderForm({
+            projectName: options.projectName,
+            ...(initialBaseUrl === undefined ? {} : { initialBaseUrl }),
+            stdin,
+            stdout,
+        });
+        initialBaseUrl = input.baseUrl;
+        let frame = 0;
+        const interval = setInterval(() => {
+            stdout.write(renderChecking(options.projectName, frame));
+            frame += 1;
+        }, 120);
+        try {
+            stdout.write(renderChecking(options.projectName, frame));
+            const result = await configureProjectOpenAiProvider({
+                tuttiHome: options.tuttiHome,
+                projectId: options.projectId,
+                apiBaseUrl: input.baseUrl,
+                apiKey: input.apiKey,
+            });
+            clearInterval(interval);
+            stdout.write(SHOW_CURSOR);
+            if (result.kind === "configured") {
+                return {
+                    base_url: input.baseUrl,
+                    redacted_key: result.projection.redacted_key,
+                    default_model: result.projection.default_model,
+                    validated_at: result.projection.validated_at,
+                };
+            }
+            stdout.write(renderProviderForm({
+                projectName: options.projectName,
+                state: {
+                    selected: 1,
+                    baseUrl: input.baseUrl,
+                    apiKey: input.apiKey,
+                    error: validationFailureMessage(result),
+                },
+                footer: "Press any key to edit and try again.",
+            }));
+            await waitForKeypress(stdin);
+        }
+        catch (error) {
+            clearInterval(interval);
+            stdout.write(SHOW_CURSOR);
+            throw new Error(`Provider setup failed: ${String(redactError(error))}`, { cause: error });
+        }
+    }
+}
+//# sourceMappingURL=provider-tui.js.map

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

@@ -0,0 +1,32 @@
+import { type ProjectId } from "@tutti/shared/ids";
+import { type FetchLike } from "./host-runtime-endpoint.js";
+import { type MachineRuntimeEndpointRecord } from "./machine-local.js";
+export type RuntimeProjectRow = {
+    project_id: ProjectId;
+    status: "online" | "stale";
+    display_name: string;
+    workspace_root: string;
+    endpoint?: string;
+    provider_status?: string;
+    relay_project_ref?: string;
+    join_url?: string;
+};
+export declare function listRuntimeProjects(options?: {
+    env?: NodeJS.ProcessEnv;
+    cwd?: string;
+    fetchImpl?: FetchLike;
+}): Promise<RuntimeProjectRow[]>;
+export declare function runPsCommand(): Promise<string>;
+export declare function runPsManageCommand(options?: {
+    stdin?: NodeJS.ReadStream;
+    stdout?: NodeJS.WriteStream;
+}): Promise<void>;
+export declare function runStopCommand(workspacePath?: string): Promise<string>;
+export declare function runInviteCommand(workspacePath?: string): Promise<string>;
+export declare function runProviderStatusCommand(workspacePath?: string): string;
+export declare function runLogsCommand(workspacePath?: string, tailLines?: number): string;
+export declare function readRuntimeEndpointForProject(tuttiHome: string, projectId: ProjectId): MachineRuntimeEndpointRecord | null;
+export declare function runtimeEndpointPathForProject(tuttiHome: string, projectId: ProjectId): string;
+export declare function projectLocalStoreRoot(tuttiHome: string, projectId: ProjectId): string;
+export declare function resolveWorkspacePath(value: string | undefined): string;
+//# sourceMappingURL=runtime-commands.d.ts.map

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

@@ -0,0 +1,308 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { emitKeypressEvents } from "node:readline";
+import { ID_PREFIXES, isPrefixedId } from "@tutti/shared/ids";
+import { redactText } from "@tutti/shared/utils";
+import { createRuntimeEndpointProbe } from "./host-runtime-endpoint.js";
+import { getHostLogFilePath, getMachineRuntimeEndpointPath, getProjectLocalStoreRoot, readMachineProjectBinding, readMachineRuntimeEndpoint, } from "./machine-local.js";
+import { readHostLocalLaunchStatus, readHostLocalProject, readHostLocalProviderConfig, requestHostLocalShutdown, rotateHostLocalInvite, } from "./local-control-client.js";
+import { resolveExistingProjectContext } from "./project-resolver.js";
+import { renderTerminalQr } from "./terminal-qr.js";
+import { resolveTuttiHome } from "../../providers/openai/index.js";
+function resolveProject(workspacePath) {
+    return resolveExistingProjectContext({
+        ...(workspacePath === undefined ? {} : { workspacePath }),
+    });
+}
+function projectIdsFromTuttiHome(tuttiHome) {
+    const projectsRoot = join(tuttiHome, "projects");
+    if (!existsSync(projectsRoot)) {
+        return [];
+    }
+    return readdirSync(projectsRoot, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory() && isPrefixedId(entry.name, ID_PREFIXES.project))
+        .map((entry) => entry.name)
+        .sort();
+}
+function readEndpointFile(tuttiHome, projectId) {
+    try {
+        return readMachineRuntimeEndpoint(tuttiHome, projectId);
+    }
+    catch {
+        return null;
+    }
+}
+export async function listRuntimeProjects(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const tuttiHome = resolveTuttiHome(options.env?.TUTTI_HOME, cwd);
+    const probe = createRuntimeEndpointProbe(options.fetchImpl ?? fetch);
+    const rows = [];
+    for (const projectId of projectIdsFromTuttiHome(tuttiHome)) {
+        const endpoint = readEndpointFile(tuttiHome, projectId);
+        if (endpoint === null) {
+            continue;
+        }
+        const binding = readMachineProjectBinding(tuttiHome, projectId);
+        const health = await probe(endpoint);
+        if (health.kind === "stale") {
+            rows.push({
+                project_id: projectId,
+                status: "stale",
+                display_name: binding?.workspace_root === undefined ? projectId : binding.workspace_root.split(/[\\/]/u).pop() ?? projectId,
+                workspace_root: binding?.workspace_root ?? endpoint.workspace_root,
+                endpoint: endpoint.base_url,
+            });
+            continue;
+        }
+        const fetchOption = options.fetchImpl === undefined ? {} : { fetchImpl: options.fetchImpl };
+        const [project, provider, launchStatus] = await Promise.allSettled([
+            readHostLocalProject({ endpoint, ...fetchOption }),
+            readHostLocalProviderConfig({ endpoint, ...fetchOption }),
+            readHostLocalLaunchStatus({ endpoint, ...fetchOption }),
+        ]);
+        const row = {
+            project_id: projectId,
+            status: "online",
+            display_name: project.status === "fulfilled" ? project.value.display_name : binding?.workspace_root.split(/[\\/]/u).pop() ?? projectId,
+            workspace_root: binding?.workspace_root ?? endpoint.workspace_root,
+            endpoint: endpoint.base_url,
+        };
+        if (provider.status === "fulfilled") {
+            row.provider_status = provider.value.status;
+        }
+        if (launchStatus.status === "fulfilled" && launchStatus.value.relay?.relay_project_ref !== undefined) {
+            row.relay_project_ref = launchStatus.value.relay.relay_project_ref;
+        }
+        if (launchStatus.status === "fulfilled" && launchStatus.value.relay?.join_url !== undefined) {
+            row.join_url = launchStatus.value.relay.join_url;
+        }
+        rows.push(row);
+    }
+    return rows;
+}
+function formatTable(rows) {
+    if (rows.length === 0) {
+        return "No Tutti host processes found.";
+    }
+    const header = ["STATUS", "PROJECT", "PROVIDER", "WORKSPACE"];
+    const data = rows.map((row) => [
+        row.status,
+        row.display_name,
+        row.provider_status ?? "-",
+        redactText(row.workspace_root),
+    ]);
+    const widths = header.map((label, index) => Math.max(label.length, ...data.map((row) => row[index]?.length ?? 0)));
+    const line = (columns) => columns.map((column, index) => column.padEnd(widths[index] ?? column.length)).join("  ");
+    return [line(header), line(widths.map((width) => "-".repeat(width))), ...data.map(line)].join("\n");
+}
+const CLEAR = "\u001B[2J\u001B[H";
+const HIDE_CURSOR = "\u001B[?25l";
+const SHOW_CURSOR = "\u001B[?25h";
+function keypress(stdin) {
+    return new Promise((resolveKeypress) => {
+        stdin.once("keypress", (character, key) => {
+            resolveKeypress({
+                ...(character === undefined ? {} : { character }),
+                key,
+            });
+        });
+    });
+}
+function selectedProject(rows, selectedIndex) {
+    return rows[selectedIndex];
+}
+function renderManager(options) {
+    const lines = [
+        CLEAR,
+        HIDE_CURSOR,
+        "Tutti Projects",
+        "",
+        options.rows.length === 0
+            ? "No Tutti host processes found."
+            : "Up/Down select, Enter/i invite, l logs, s stop, r refresh, q quit.",
+        "",
+    ];
+    if (options.rows.length > 0) {
+        const header = ["", "STATUS", "PROJECT", "PROVIDER", "WORKSPACE"];
+        const data = options.rows.map((row, index) => [
+            index === options.selectedIndex ? ">" : " ",
+            row.status,
+            row.display_name,
+            row.provider_status ?? "-",
+            redactText(row.workspace_root),
+        ]);
+        const widths = header.map((label, index) => Math.max(label.length, ...data.map((row) => row[index]?.length ?? 0)));
+        const line = (columns) => columns.map((column, index) => column.padEnd(widths[index] ?? column.length)).join("  ");
+        lines.push(line(header), line(widths.map((width) => "-".repeat(width))), ...data.map(line), "");
+    }
+    if (options.message !== undefined) {
+        lines.push(options.message, "");
+    }
+    if (options.detail !== undefined) {
+        lines.push(options.detail, "");
+    }
+    return lines.join("\n");
+}
+export async function runPsCommand() {
+    return formatTable(await listRuntimeProjects());
+}
+export async function runPsManageCommand(options = {}) {
+    const stdin = options.stdin ?? process.stdin;
+    const stdout = options.stdout ?? process.stdout;
+    if (!stdin.isTTY || !stdout.isTTY) {
+        stdout.write(`${await runPsCommand()}\n`);
+        return;
+    }
+    emitKeypressEvents(stdin);
+    stdin.setRawMode(true);
+    let rows = await listRuntimeProjects();
+    let selectedIndex = 0;
+    let message;
+    let detail;
+    const render = () => {
+        stdout.write(renderManager({
+            rows,
+            selectedIndex,
+            ...(message === undefined ? {} : { message }),
+            ...(detail === undefined ? {} : { detail }),
+        }));
+    };
+    try {
+        render();
+        while (true) {
+            const input = await keypress(stdin);
+            if (input.key.ctrl === true && input.key.name === "c") {
+                return;
+            }
+            if (input.key.name === "escape" || input.character === "q") {
+                return;
+            }
+            if (input.key.name === "up" && rows.length > 0) {
+                selectedIndex = selectedIndex === 0 ? rows.length - 1 : selectedIndex - 1;
+                message = undefined;
+                detail = undefined;
+                render();
+                continue;
+            }
+            if (input.key.name === "down" && rows.length > 0) {
+                selectedIndex = selectedIndex === rows.length - 1 ? 0 : selectedIndex + 1;
+                message = undefined;
+                detail = undefined;
+                render();
+                continue;
+            }
+            if (input.character === "r") {
+                rows = await listRuntimeProjects();
+                selectedIndex = Math.min(selectedIndex, Math.max(rows.length - 1, 0));
+                message = "Refreshed.";
+                detail = undefined;
+                render();
+                continue;
+            }
+            const project = selectedProject(rows, selectedIndex);
+            if (project === undefined) {
+                message = "No project selected.";
+                detail = undefined;
+                render();
+                continue;
+            }
+            if (input.key.name === "return" || input.character === "i") {
+                try {
+                    detail = await runInviteCommand(project.workspace_root);
+                    message = `Invite refreshed for ${project.display_name}.`;
+                }
+                catch (error) {
+                    message = error instanceof Error ? error.message : "Invite refresh failed.";
+                    detail = undefined;
+                }
+                render();
+                continue;
+            }
+            if (input.character === "l") {
+                detail = runLogsCommand(project.workspace_root, 40);
+                message = `Showing last 40 host log lines for ${project.display_name}.`;
+                render();
+                continue;
+            }
+            if (input.character === "s") {
+                try {
+                    message = await runStopCommand(project.workspace_root);
+                    rows = await listRuntimeProjects();
+                    selectedIndex = Math.min(selectedIndex, Math.max(rows.length - 1, 0));
+                    detail = undefined;
+                }
+                catch (error) {
+                    message = error instanceof Error ? error.message : "Stop failed.";
+                    detail = undefined;
+                }
+                render();
+                continue;
+            }
+            message = "Unsupported key.";
+            detail = undefined;
+            render();
+        }
+    }
+    finally {
+        stdin.setRawMode(false);
+        stdout.write(SHOW_CURSOR);
+    }
+}
+export async function runStopCommand(workspacePath) {
+    const project = resolveProject(workspacePath);
+    const endpoint = project.runtime_endpoint;
+    if (endpoint === null) {
+        return "Tutti host is not running for this project.";
+    }
+    await requestHostLocalShutdown({ endpoint });
+    return `Stopped ${project.display_name}.`;
+}
+export async function runInviteCommand(workspacePath) {
+    const project = resolveProject(workspacePath);
+    const endpoint = project.runtime_endpoint;
+    if (endpoint === null) {
+        throw new Error("Tutti host is not running for this project.");
+    }
+    const status = await rotateHostLocalInvite({ endpoint });
+    const joinUrl = status.relay?.join_url;
+    if (joinUrl === undefined) {
+        throw new Error("Relay did not return a visible join URL.");
+    }
+    return [`Join URL: ${joinUrl}`, "", renderTerminalQr(joinUrl)].join("\n");
+}
+export function runProviderStatusCommand(workspacePath) {
+    const project = resolveProject(workspacePath);
+    return [
+        `Project: ${project.display_name}`,
+        `Provider: ${project.provider_config.status}`,
+        ...(project.provider_config.status === "configured"
+            ? [
+                `Model: ${project.provider_config.default_model}`,
+                `Key: ${project.provider_config.redacted_key}`,
+                `Validated: ${project.provider_config.validated_at}`,
+            ]
+            : []),
+    ].join("\n");
+}
+export function runLogsCommand(workspacePath, tailLines = 120) {
+    const project = resolveProject(workspacePath);
+    const logPath = getHostLogFilePath(project.tutti_home);
+    if (!existsSync(logPath)) {
+        return `No host log exists yet at ${redactText(logPath)}.`;
+    }
+    const lines = readFileSync(logPath, "utf8").split(/\r?\n/u).filter(Boolean).slice(-tailLines);
+    return lines.length === 0 ? "Host log is empty." : lines.join("\n");
+}
+export function readRuntimeEndpointForProject(tuttiHome, projectId) {
+    return readEndpointFile(tuttiHome, projectId);
+}
+export function runtimeEndpointPathForProject(tuttiHome, projectId) {
+    return getMachineRuntimeEndpointPath(tuttiHome, projectId);
+}
+export function projectLocalStoreRoot(tuttiHome, projectId) {
+    return getProjectLocalStoreRoot(tuttiHome, projectId);
+}
+export function resolveWorkspacePath(value) {
+    return resolve(process.cwd(), value ?? ".");
+}
+//# sourceMappingURL=runtime-commands.js.map

package/dist/server-shell/cli/terminal-qr.d.ts

@@ -0,0 +1,2 @@
+export declare function renderTerminalQr(input: string): string;
+//# sourceMappingURL=terminal-qr.d.ts.map

package/dist/server-shell/cli/terminal-qr.js

@@ -0,0 +1,11 @@
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+export function renderTerminalQr(input) {
+    const qrcode = require("qrcode-terminal");
+    let output = "";
+    qrcode.generate(input, { small: true }, (rendered) => {
+        output = rendered;
+    });
+    return output.trimEnd();
+}
+//# sourceMappingURL=terminal-qr.js.map

package/dist/server-shell/cli/version.d.ts

@@ -0,0 +1,2 @@
+export declare function readCliVersion(): string;
+//# sourceMappingURL=version.d.ts.map

package/dist/server-shell/cli/version.js

@@ -0,0 +1,7 @@
+import { readFileSync } from "node:fs";
+export function readCliVersion() {
+    const packageUrl = new URL("../../../package.json", import.meta.url);
+    const parsed = JSON.parse(readFileSync(packageUrl, "utf8"));
+    return typeof parsed.version === "string" ? parsed.version : "0.0.0";
+}
+//# sourceMappingURL=version.js.map

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

@@ -3,6 +3,7 @@ import type { ProviderConfigProjection } from "@tutti/shared/schemas/api";
 export type HostLocalControlOptions = {
     token: string;
     getLaunchStatus?: () => HostLocalLaunchStatus;
+    refreshInvite?: () => Promise<HostLocalLaunchStatus>;
     project?: {
         get: () => HostLocalProjectProjection;
         update: (input: HostLocalProjectBody) => HostLocalProjectProjection;