@xfey/tutti 0.1.10 → 0.1.12

package/dist/server-shell/cli/launch-command.js

@@ -1,9 +1,9 @@
 import { createInterface } from "node:readline/promises";
-import { basename } from "node:path";
 import { formatLaunchLifecycleResult, startLaunchProject, waitForForegroundHostShutdown } from "./host-lifecycle.js";
 import { prepareLaunchProject } from "./launch.js";
 import { spawnDetachedHost, waitForManagedHostReady } from "./managed-host.js";
-import { renderTerminalQr } from "./terminal-qr.js";
+import { resolveLaunchWorkspacePath } from "./project-resolver.js";
+import { formatJoinLinkValidity, renderTerminalQr } from "./terminal-qr.js";
 import { renderTuttiTerminalLogo } from "./terminal-logo.js";
 import { runProviderSetupTui } from "./provider-tui.js";
 import { LaunchError } from "./errors.js";
@@ -24,9 +24,6 @@ export async function confirmFromTty(request) {
         readline.close();
     }
 }
-function projectName(preparation) {
-    return basename(preparation.workspace_root) || preparation.project_id;
-}
 async function waitForEnter() {
     if (!process.stdin.isTTY || !process.stdout.isTTY) {
         return;
@@ -48,13 +45,19 @@ function renderCompletionPage(options) {
         ...(isTty ? [CLEAR, renderTuttiTerminalLogo({ tty: true }), ""] : []),
         "Tutti is running in the background.",
         "",
-        `Project: ${options.projectName}`,
-        "",
         `Join URL: ${options.joinUrl}`,
+        formatJoinLinkValidity({
+            ...(options.joinTokenExpiresAt === undefined
+                ? {}
+                : { expiresAt: options.joinTokenExpiresAt }),
+            ...(options.joinTokenReusable === undefined
+                ? {}
+                : { reusable: options.joinTokenReusable }),
+        }),
         "",
         renderTerminalQr(options.joinUrl),
         "",
-        "Press Enter to close this page. The host will keep running in the background.",
+        "[Enter] to continue",
     ].join("\n");
 }
 async function ensureProviderConfigured(preparation) {
@@ -70,8 +73,11 @@ async function ensureProviderConfigured(preparation) {
     });
 }
 export async function runForegroundLaunchCommand(options) {
+    const workspacePath = resolveLaunchWorkspacePath({
+        ...(options.target === undefined ? {} : { target: options.target }),
+    });
     const result = await startLaunchProject({
-        workspacePath: options.workspacePath,
+        workspacePath,
         yes: options.yes,
         confirm: confirmFromTty,
     });
@@ -90,8 +96,11 @@ export async function runInternalHostRunCommand(options) {
     }
 }
 export async function runBackgroundLaunchCommand(options) {
+    const workspacePath = resolveLaunchWorkspacePath({
+        ...(options.target === undefined ? {} : { target: options.target }),
+    });
     const preparation = await prepareLaunchProject({
-        workspacePath: options.workspacePath,
+        workspacePath,
         yes: options.yes,
         confirm: confirmFromTty,
     });
@@ -108,8 +117,13 @@ export async function runBackgroundLaunchCommand(options) {
         throw new LaunchError("relay_registration_failed", "Host started but Relay did not return a visible join URL", "Run `tutti invite` to rotate a fresh invite link.");
     }
     process.stdout.write(`${renderCompletionPage({
-        projectName: projectName(preparation),
         joinUrl: ready.join_url,
+        ...(ready.join_token_expires_at === undefined
+            ? {}
+            : { joinTokenExpiresAt: ready.join_token_expires_at }),
+        ...(ready.join_token_reusable === undefined
+            ? {}
+            : { joinTokenReusable: ready.join_token_reusable }),
     })}\n`);
     await waitForEnter();
 }

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

@@ -1,6 +1,5 @@
 import { resolve } from "node:path";
 import { createProjectId } from "@tutti/shared/ids";
-import { redactText } from "@tutti/shared/utils";
 import { readOpenAiProviderConfigProjection, resolveTuttiHome, } from "../../providers/openai/index.js";
 import { LaunchError } from "./errors.js";
 import { assertSafeProjectRoot, ensureGitBootstrap, } from "./git-bootstrap.js";
@@ -101,8 +100,6 @@ export function formatLaunchPreparation(result) {
         "Tutti launch prerequisites are ready",
         "",
         "Status: prepared",
-        `Workspace: ${redactText(result.workspace_root)}`,
-        `Project: ${result.project_id}`,
         `Branch: ${result.branch}`,
         `Relay: ${result.relay_url}`,
         `Provider: ${result.provider_status}`,

package/dist/server-shell/cli/managed-host.d.ts

@@ -4,6 +4,8 @@ import type { ProjectId } from "@tutti/shared/ids";
 export type ManagedHostReadyResult = {
     endpoint: MachineRuntimeEndpointRecord;
     join_url?: string;
+    join_token_expires_at?: string;
+    join_token_reusable?: boolean;
 };
 export declare function spawnDetachedHost(options: {
     workspaceRoot: string;

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

@@ -1,8 +1,8 @@
 import { spawn } from "node:child_process";
-import { readFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { createRuntimeEndpointProbe } from "./host-runtime-endpoint.js";
-import { getHostLogFilePath, readMachineRuntimeEndpoint, } from "./machine-local.js";
+import { LaunchError } from "./errors.js";
+import { readMachineRuntimeEndpoint } from "./machine-local.js";
 import { readHostLocalLaunchStatus, rotateHostLocalInvite } from "./local-control-client.js";
 const DEFAULT_READY_TIMEOUT_MS = 60_000;
 const READY_POLL_INTERVAL_MS = 250;
@@ -38,15 +38,6 @@ export function spawnDetachedHost(options) {
     });
     child.unref();
 }
-function readHostLogTail(tuttiHome, maxLines = 80) {
-    try {
-        const text = readFileSync(getHostLogFilePath(tuttiHome), "utf8");
-        return text.split(/\r?\n/u).filter(Boolean).slice(-maxLines).join("\n");
-    }
-    catch {
-        return "";
-    }
-}
 export async function waitForManagedHostReady(options) {
     const deadline = Date.now() + (options.timeoutMs ?? DEFAULT_READY_TIMEOUT_MS);
     const probe = createRuntimeEndpointProbe(options.fetchImpl ?? fetch);
@@ -83,6 +74,12 @@ export async function waitForManagedHostReady(options) {
                 return {
                     endpoint,
                     join_url: status.relay.join_url,
+                    ...(status.relay.join_token_expires_at === undefined
+                        ? {}
+                        : { join_token_expires_at: status.relay.join_token_expires_at }),
+                    ...(status.relay.join_token_reusable === undefined
+                        ? {}
+                        : { join_token_reusable: status.relay.join_token_reusable }),
                 };
             }
             lastReason = "host is running but Relay invite is not visible yet";
@@ -92,12 +89,6 @@ export async function waitForManagedHostReady(options) {
         }
         await delay(READY_POLL_INTERVAL_MS);
     }
-    const tail = readHostLogTail(options.tuttiHome);
-    throw new Error([
-        `Tutti host did not become ready before timeout: ${lastReason}`,
-        tail.length === 0 ? "" : `Recent host log:\n${tail}`,
-    ]
-        .filter(Boolean)
-        .join("\n"));
+    throw new LaunchError("existing_server_unhealthy", `Tutti host did not become ready before timeout: ${lastReason}`, "Run `tutti logs` for details, then retry `tutti launch`.");
 }
 //# sourceMappingURL=managed-host.js.map

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

@@ -11,7 +11,13 @@ export type ExistingProjectContext = {
     provider_config: OpenAiProviderConfigProjection;
     provider_base_url?: string;
 };
+export declare function resolveLaunchWorkspacePath(options: {
+    target?: string;
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+}): string;
 export declare function resolveExistingProjectContext(options: {
+    target?: string;
     workspacePath?: string;
     cwd?: string;
     env?: NodeJS.ProcessEnv;

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

@@ -1,19 +1,141 @@
-import { resolve } from "node:path";
+import { existsSync, readdirSync } from "node:fs";
+import { basename, join, resolve } from "node:path";
+import { ID_PREFIXES, isPrefixedId } from "@tutti/shared/ids";
 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";
+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 readRuntimeEndpoint(tuttiHome, projectId) {
+    try {
+        return readMachineRuntimeEndpoint(tuttiHome, projectId);
+    }
+    catch {
+        return null;
+    }
+}
+function readBinding(tuttiHome, projectId) {
+    try {
+        return readMachineProjectBinding(tuttiHome, projectId);
+    }
+    catch {
+        return null;
+    }
+}
+function readProjectTargetEntry(tuttiHome, projectId) {
+    const binding = readBinding(tuttiHome, projectId);
+    const endpoint = readRuntimeEndpoint(tuttiHome, projectId);
+    const workspaceRoot = binding?.workspace_root ?? endpoint?.workspace_root;
+    if (workspaceRoot === undefined) {
+        return null;
+    }
+    const workspaceName = basename(workspaceRoot) || projectId;
+    const displayName = readProjectDisplayName(workspaceRoot) ?? workspaceName;
+    const aliases = Array.from(new Set([displayName, workspaceName].filter((alias) => alias.trim() !== "")));
+    return {
+        project_id: projectId,
+        workspace_root: workspaceRoot,
+        display_name: displayName,
+        aliases,
+    };
+}
+function listProjectTargetEntries(tuttiHome) {
+    return projectIdsFromTuttiHome(tuttiHome)
+        .map((projectId) => readProjectTargetEntry(tuttiHome, projectId))
+        .filter((entry) => entry !== null);
+}
+function normalizeTargetName(value) {
+    return value.trim().toLowerCase();
+}
+function formatTargetMatch(entry) {
+    return `${entry.project_id}  ${entry.display_name}  ${entry.workspace_root}`;
+}
+function resolveSingleTargetMatch(target, matches) {
+    if (matches.length === 1) {
+        return matches[0];
+    }
+    if (matches.length > 1) {
+        throw new LaunchError("project_target_ambiguous", `Project target is ambiguous: ${target}`, "Use the unique project ID prefix shown by `tutti ps`, or the full project ID from this error.", { matches: matches.map(formatTargetMatch) });
+    }
+    throw new LaunchError("project_target_not_found", `Project target was not found: ${target}`, "Run `tutti ps` to list known projects, or pass a project workspace path.");
+}
+function resolveProjectTargetWorkspaceRoot(options) {
+    const target = options.target.trim();
+    if (target === "") {
+        return resolve(options.cwd, ".");
+    }
+    const pathCandidate = resolve(options.cwd, target);
+    if (existsSync(pathCandidate)) {
+        return pathCandidate;
+    }
+    const entries = listProjectTargetEntries(options.tuttiHome);
+    const exactId = entries.filter((entry) => entry.project_id === target);
+    if (exactId.length > 0) {
+        return resolveSingleTargetMatch(target, exactId).workspace_root;
+    }
+    if (target.startsWith(ID_PREFIXES.project)) {
+        const idPrefix = entries.filter((entry) => entry.project_id.startsWith(target));
+        if (idPrefix.length > 0) {
+            return resolveSingleTargetMatch(target, idPrefix).workspace_root;
+        }
+    }
+    const normalizedTarget = normalizeTargetName(target);
+    const nameMatches = entries.filter((entry) => entry.aliases.some((alias) => normalizeTargetName(alias) === normalizedTarget));
+    return resolveSingleTargetMatch(target, nameMatches).workspace_root;
+}
+export function resolveLaunchWorkspacePath(options) {
+    const cwd = options.cwd ?? process.cwd();
+    const env = options.env ?? process.env;
+    const target = options.target;
+    if (target === undefined) {
+        return resolve(cwd, ".");
+    }
+    const pathCandidate = resolve(cwd, target);
+    if (existsSync(pathCandidate)) {
+        return pathCandidate;
+    }
+    try {
+        return resolveProjectTargetWorkspaceRoot({
+            target,
+            cwd,
+            tuttiHome: resolveTuttiHome(env.TUTTI_HOME, cwd),
+        });
+    }
+    catch (error) {
+        if (error instanceof LaunchError &&
+            error.code === "project_target_not_found" &&
+            !target.startsWith(ID_PREFIXES.project)) {
+            return pathCandidate;
+        }
+        throw error;
+    }
+}
 export function resolveExistingProjectContext(options) {
     const cwd = options.cwd ?? process.cwd();
     const env = options.env ?? process.env;
-    const workspaceRoot = resolve(cwd, options.workspacePath ?? ".");
+    const tuttiHome = resolveTuttiHome(env.TUTTI_HOME, cwd);
+    const workspaceRoot = options.workspacePath === undefined
+        ? resolveProjectTargetWorkspaceRoot({
+            target: options.target ?? ".",
+            cwd,
+            tuttiHome,
+        })
+        : 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 {

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

@@ -1,14 +1,33 @@
+import { type ConfigureProjectOpenAiProviderResult } from "../../providers/openai/index.js";
 import type { ProjectId } from "@tutti/shared/ids";
+type ProviderSetupLogEvent = {
+    ts: string;
+    level: "error";
+    scope: "provider_setup";
+    event: "provider_validation_failed" | "provider_validation_exception";
+    project_id: ProjectId;
+    reason?: string;
+    retryable?: boolean;
+    diagnostic?: unknown;
+    error?: unknown;
+};
 export type ProviderSetupResult = {
     base_url: string;
     redacted_key: string;
     default_model: string;
     validated_at: string;
 };
+export declare function providerValidationFailureMessage(result: ConfigureProjectOpenAiProviderResult): string;
+export declare function writeProviderSetupValidationLog(options: {
+    tuttiHome: string;
+    event: Omit<ProviderSetupLogEvent, "ts" | "level" | "scope">;
+    now?: () => Date;
+}): boolean;
 export declare function runProviderSetupTui(options: {
     tuttiHome: string;
     projectId: ProjectId;
     stdin?: NodeJS.ReadStream;
     stdout?: NodeJS.WriteStream;
 }): Promise<ProviderSetupResult>;
+export {};
 //# sourceMappingURL=provider-tui.d.ts.map

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

@@ -2,6 +2,7 @@ import { emitKeypressEvents } from "node:readline";
 import { redactError } from "@tutti/shared/utils";
 import { configureProjectOpenAiProvider, DEFAULT_OPENAI_MODEL, } from "../../providers/openai/index.js";
 import { LaunchError } from "./errors.js";
+import { appendHostLogLine, getHostLogFilePath } from "./machine-local.js";
 import { renderTuttiTerminalLogo } from "./terminal-logo.js";
 const HIDE_CURSOR = "\u001B[?25l";
 const SHOW_CURSOR = "\u001B[?25h";
@@ -40,7 +41,9 @@ function renderProviderField(state) {
             secret: true,
         }),
         "",
-        "[Enter] to validate    [Esc] to edit Base URL",
+        state.error === undefined
+            ? "[Enter] to validate    [Esc] to edit Base URL"
+            : "[Enter] to retry    [Esc] to edit Base URL",
     ];
 }
 function renderProviderForm(options) {
@@ -66,41 +69,54 @@ function renderProviderForm(options) {
     }
     return lines.join("\n");
 }
-function validationFailureMessage(result) {
+export function providerValidationFailureMessage(result) {
     if (result.kind === "configured") {
         return "";
     }
-    const retry = result.retryable ? " Retry after the provider recovers." : "";
-    return `${result.reason}.${retry}`;
+    switch (result.reason) {
+        case "provider_auth_invalid":
+            return "API key was rejected.";
+        case "provider_model_unavailable":
+            return "Default model is unavailable for this provider.";
+        case "provider_quota_or_billing_required":
+            return "Provider quota or billing is not available.";
+        case "provider_rate_limited":
+            return "Provider is rate limited. Try again later.";
+        case "provider_network_error":
+            return "Could not reach a Responses API-compatible endpoint.";
+    }
 }
-function waitForKeypress(stdin) {
-    return new Promise((resolve, reject) => {
-        const onKeypress = (_character, key) => {
-            cleanup();
-            if (key.ctrl === true && key.name === "c") {
-                reject(providerSetupCancelled());
-                return;
-            }
-            resolve();
-        };
-        const cleanup = () => {
-            stdin.off("keypress", onKeypress);
-            if (stdin.isTTY) {
-                stdin.setRawMode(false);
-            }
-        };
-        if (stdin.isTTY) {
-            stdin.setRawMode(true);
-        }
-        stdin.once("keypress", onKeypress);
-    });
+function providerValidationExceptionMessage(logged) {
+    if (logged) {
+        return "Could not validate the provider connection. Details were written to the host log.";
+    }
+    return "Could not validate the provider connection. Host log could not be written.";
+}
+export function writeProviderSetupValidationLog(options) {
+    const logEvent = {
+        ts: (options.now ?? (() => new Date()))().toISOString(),
+        level: "error",
+        scope: "provider_setup",
+        ...options.event,
+    };
+    const redactedLogEvent = {
+        ...logEvent,
+        ...(logEvent.error === undefined ? {} : { error: redactError(logEvent.error) }),
+    };
+    try {
+        appendHostLogLine(getHostLogFilePath(options.tuttiHome), JSON.stringify(redactError(redactedLogEvent)));
+        return true;
+    }
+    catch {
+        return false;
+    }
 }
 async function readProviderForm(options) {
     const state = {
         step: options.initialStep ?? "base-url",
         baseUrl: options.initialBaseUrl ?? "",
         apiKey: options.initialApiKey ?? "",
-        error: undefined,
+        error: options.initialError,
     };
     return await new Promise((resolve, reject) => {
         const render = () => {
@@ -204,16 +220,18 @@ 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.");
+        throw new LaunchError("provider_configuration_required", "Provider setup requires an interactive terminal.", "Run `tutti provider setup` from an interactive terminal.");
     }
     let initialBaseUrl;
     let initialApiKey = "";
     let initialStep = "base-url";
+    let initialError;
     while (true) {
         const input = await readProviderForm({
             ...(initialBaseUrl === undefined ? {} : { initialBaseUrl }),
             ...(initialApiKey === "" ? {} : { initialApiKey }),
             initialStep,
+            ...(initialError === undefined ? {} : { initialError }),
             stdin,
             stdout,
         });
@@ -243,17 +261,17 @@ export async function runProviderSetupTui(options) {
                     validated_at: result.projection.validated_at,
                 };
             }
-            stdout.write(renderProviderForm({
-                state: {
-                    step: "api-key",
-                    baseUrl: input.baseUrl,
-                    apiKey: input.apiKey,
-                    error: validationFailureMessage(result),
+            writeProviderSetupValidationLog({
+                tuttiHome: options.tuttiHome,
+                event: {
+                    event: "provider_validation_failed",
+                    project_id: options.projectId,
+                    reason: result.reason,
+                    retryable: result.retryable,
+                    ...(result.diagnostic === undefined ? {} : { diagnostic: result.diagnostic }),
                 },
-                footer: "Press any key to edit and try again.",
-                tty: stdout.isTTY === true,
-            }));
-            await waitForKeypress(stdin);
+            });
+            initialError = providerValidationFailureMessage(result);
         }
         catch (error) {
             clearInterval(interval);
@@ -261,7 +279,15 @@ export async function runProviderSetupTui(options) {
             if (error instanceof LaunchError) {
                 throw error;
             }
-            throw new Error(`Provider setup failed: ${String(redactError(error))}`, { cause: error });
+            const logged = writeProviderSetupValidationLog({
+                tuttiHome: options.tuttiHome,
+                event: {
+                    event: "provider_validation_exception",
+                    project_id: options.projectId,
+                    error,
+                },
+            });
+            initialError = providerValidationExceptionMessage(logged);
         }
     }
 }

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

@@ -11,6 +11,7 @@ export type RuntimeProjectRow = {
     relay_project_ref?: string;
     join_url?: string;
 };
+export declare function formatProjectIdForDisplay(projectId: ProjectId, projectIds: readonly ProjectId[]): string;
 export declare function listRuntimeProjects(options?: {
     env?: NodeJS.ProcessEnv;
     cwd?: string;
@@ -21,12 +22,11 @@ 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 runStopCommand(target?: string): Promise<string>;
+export declare function runInviteCommand(target?: string): Promise<string>;
+export declare function runProviderStatusCommand(target?: string): string;
+export declare function runLogsCommand(target?: 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