@xfey/tutti 0.1.6 → 0.1.8

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-logo.d.ts

@@ -0,0 +1,5 @@
+export declare function renderTuttiTerminalLogo(options?: {
+    tty?: boolean;
+    color?: boolean;
+}): string;
+//# sourceMappingURL=terminal-logo.d.ts.map

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

@@ -0,0 +1,27 @@
+const RESET = "\u001B[0m";
+const ACTION_STRONG = "\u001B[38;2;8;121;95m";
+// Static Braille rendering of docs/design/Tutti.png, generated from the alpha mask.
+const TUTTI_BRAILLE_LOGO = [
+    "    ⣀⣤⣶⣶⣾⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣶⡄      ⣠⣶⣶⣦  ⢀⣤⣶⣶⣄",
+    "  ⢀⣾⣿⣿⠿⠛⠛⠛⢉⣿⣿⣿⠏⠉⠉⠛⠛⠛⠛⠛⠁    ⢀⣾⣿⠏⣿⣿⡇⣠⣿⡿⠙⣿⣿",
+    "  ⢸⣿⣿⡇    ⢸⣿⣿⣿             ⣾⣿⡏⢀⣿⣿⢡⣿⣿⠃⣸⣿⡟ ⢀⣴⣶⣤",
+    "  ⠈⠿⣿⠟    ⣿⣿⣿⡇            ⢸⣿⣿⣡⣾⡿⠃⣾⣿⣟⣰⣿⠟⠁ ⠘⠿⠿⠛",
+    "         ⢰⣿⣿⣿⠁  ⣤⣶⡦  ⣴⣶⡆⣾⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠆⣤⣶⣦",
+    "         ⣸⣿⣿⡿  ⢰⣿⣿⠇ ⢰⣿⣿⠇⠈⠉⣿⣿⡏⠉⠉⠉⢹⣿⣿⡏⠉⠉⠁ ⢠⣿⣿⡟",
+    "         ⣿⣿⣿⡇  ⣾⣿⣿ ⢠⣿⣿⡿  ⢀⣿⣿⣇   ⢸⣿⣿⡇    ⣸⣿⣿⠇",
+    "        ⢰⣿⣿⣿⠃  ⣿⣿⣿⣴⣿⣿⣿⣇⣀⣴⣿⣿⣿⣿⣄⣀⣠⣾⣿⣿⣧⣀⣀⣀⣴⣿⣿⣿",
+    "        ⠸⣿⣿⡿   ⠹⣿⣿⡿⠃⠻⣿⣿⣿⠟⠋⠈⠻⣿⣿⣿⡿⠛⠙⠿⣿⣿⣿⣿⠟⣿⣿⡿",
+].join("\n");
+function supportsColor(options) {
+    return options.color !== false && process.env.NO_COLOR === undefined;
+}
+export function renderTuttiTerminalLogo(options = {}) {
+    if (options.tty !== true) {
+        return "Tutti";
+    }
+    if (!supportsColor(options)) {
+        return TUTTI_BRAILLE_LOGO;
+    }
+    return `${ACTION_STRONG}${TUTTI_BRAILLE_LOGO}${RESET}`;
+}
+//# sourceMappingURL=terminal-logo.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;

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

@@ -190,6 +190,19 @@ export function registerHostLocalControlRoutes(app, options) {
         requireLocalToken(request.headers.authorization);
         return options.getLaunchStatus?.() ?? {};
     });
+    app.post("/host-local/v1/invite/rotate", {
+        schema: {
+            response: {
+                200: HostLocalLaunchStatusResponseSchema,
+            },
+        },
+    }, async (request) => {
+        requireLocalToken(request.headers.authorization);
+        if (options.refreshInvite === undefined) {
+            return options.getLaunchStatus?.() ?? {};
+        }
+        return await options.refreshInvite();
+    });
     app.get("/host-local/v1/provider/config", {
         schema: {
             response: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xfey/tutti",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -35,6 +35,7 @@
     "better-sqlite3": "^12.9.0",
     "fastify": "^5.8.5",
     "openai": "^6.34.0",
+    "qrcode-terminal": "^0.12.0",
     "sharp": "^0.35.3",
     "ulid": "^3.0.2",
     "ws": "^8.20.0",