@xfey/tutti 0.1.23 → 0.1.25

package/README.md

@@ -43,7 +43,7 @@
 - packaged / production `tutti launch` 默认连接 `https://tutti.now`；`TUTTI_RELAY_URL` 可覆盖 Relay URL，本地开发 dev runner 默认使用 `http://127.0.0.1:4370`。
 - host 注册使用 machine-local `host_registration_secret`；该 secret 明文只可写入受限权限的 machine-local secret store，不写入目标项目 repo、Git local config 项目身份、SQLite 协作真相或日志，`binding.json` 只保存引用。
 - Relay registration 成功后只把 `relay_project_ref` 写回 machine-local binding；join URL 只在 host 本机终端或当前 host-local control 内存状态中展示，不写入 binding、runtime endpoint、SQLite 协作真相或日志。
-- 普通 `tutti launch` 默认后台运行 host，CLI 完成页展示 join URL 和二维码；`tutti launch --foreground` 保留前台诊断模式。Host HTTP request log 与 Control Plane / Run Pipeline runtime log 写入 `TUTTI_HOME/logs/host.log`，不写入目标项目 repo 或常规 CLI stdout。
+- 普通 `tutti launch` 默认后台运行 host，CLI 完成页展示 join URL 后直接退出；`tutti launch --foreground` 保留前台诊断模式。Host HTTP request log 与 Control Plane / Run Pipeline runtime log 写入 `TUTTI_HOME/logs/host.log`，不写入目标项目 repo 或常规 CLI stdout。
 - Reference 和 Skills 上传的最终写入由 Host Project API 完成；Host 只通过 Relay host-control resolve 获取短期 R2 URL 下载 staged object，不接收浏览器 base64 文件正文，也不持久化 presigned URL。
 - Host Project API command 的 browser session context 只信任 Relay tunnel metadata 中的 `relay_session_context`；route handler 不读取浏览器身份 header，也不接受 payload 内身份字段。
 - Fastify request log、debug log、SSE payload、activity event 和 run result 都必须经过 redaction，不得泄露 provider secret、host registration secret、host connection token、join token、cookie、host 绝对路径或 run workspace path。

package/dist/providers/openai/credential-validation.d.ts

@@ -34,6 +34,27 @@ export type OpenAiCredentialValidationClient = {
         }) => Promise<unknown>;
     };
 };
+export type OpenAiModelDiscoveryInput = {
+    apiKey: string;
+    apiBaseUrl?: string;
+    organizationId?: string;
+    openAiProjectId?: string;
+};
+export type OpenAiModelDiscoveryClient = {
+    models: {
+        list: (options?: {
+            timeout?: number;
+            maxRetries?: number;
+        }) => Promise<unknown>;
+    };
+};
+export type OpenAiModelDiscoveryResult = {
+    kind: "ok";
+    models: string[];
+} | {
+    kind: "unavailable";
+    reason: "model_list_unavailable" | "model_list_empty";
+};
 export type ValidateOpenAiCredentialOptions = {
     client?: OpenAiCredentialValidationClient;
     now?: () => Date;
@@ -42,4 +63,7 @@ export declare function summarizeOpenAiCredentialValidationError(error: unknown,
 export declare function classifyOpenAiCredentialValidationError(error: unknown): OpenAiCredentialValidationFailureReason;
 export declare function isOpenAiCredentialValidationFailureRetryable(reason: OpenAiCredentialValidationFailureReason): boolean;
 export declare function validateOpenAiCredential(input: OpenAiCredentialValidationInput, options?: ValidateOpenAiCredentialOptions): Promise<OpenAiCredentialValidationResult>;
+export declare function discoverOpenAiModels(input: OpenAiModelDiscoveryInput, options?: {
+    client?: OpenAiModelDiscoveryClient;
+}): Promise<OpenAiModelDiscoveryResult>;
 //# sourceMappingURL=credential-validation.d.ts.map

package/dist/providers/openai/credential-validation.js

@@ -2,6 +2,7 @@ import OpenAI, { APIConnectionError, APIConnectionTimeoutError, APIError, Authen
 import { DEFAULT_OPENAI_MODEL } from "./model-config.js";
 const VALIDATION_INPUT = "Tutti provider validation. Reply with the single word ok.";
 const VALIDATION_TIMEOUT_MS = 20_000;
+const MODEL_DISCOVERY_TIMEOUT_MS = 12_000;
 function createOpenAiValidationClient(input) {
     const clientOptions = {
         apiKey: input.apiKey,
@@ -19,6 +20,47 @@ function createOpenAiValidationClient(input) {
     }
     return new OpenAI(clientOptions);
 }
+function createOpenAiModelDiscoveryClient(input) {
+    const clientOptions = {
+        apiKey: input.apiKey,
+        maxRetries: 0,
+        timeout: MODEL_DISCOVERY_TIMEOUT_MS,
+    };
+    if (input.apiBaseUrl !== undefined) {
+        clientOptions.baseURL = input.apiBaseUrl;
+    }
+    if (input.organizationId !== undefined) {
+        clientOptions.organization = input.organizationId;
+    }
+    if (input.openAiProjectId !== undefined) {
+        clientOptions.project = input.openAiProjectId;
+    }
+    return new OpenAI(clientOptions);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function modelIdFromItem(item) {
+    if (!isRecord(item)) {
+        return undefined;
+    }
+    const id = item.id;
+    if (typeof id === "string" && id.trim() !== "") {
+        return id.trim();
+    }
+    const name = item.name;
+    if (typeof name === "string" && name.trim() !== "") {
+        return name.trim();
+    }
+    return undefined;
+}
+function modelIdsFromResponse(response) {
+    if (!isRecord(response) || !Array.isArray(response.data)) {
+        return [];
+    }
+    return [...new Set(response.data.map(modelIdFromItem).filter((model) => model !== undefined))]
+        .sort((left, right) => left.localeCompare(right));
+}
 function lowerErrorText(error) {
     if (error instanceof Error) {
         return error.message.toLowerCase();
@@ -187,4 +229,30 @@ export async function validateOpenAiCredential(input, options = {}) {
         };
     }
 }
+export async function discoverOpenAiModels(input, options = {}) {
+    const client = options.client ?? createOpenAiModelDiscoveryClient(input);
+    try {
+        const response = await client.models.list({
+            timeout: MODEL_DISCOVERY_TIMEOUT_MS,
+            maxRetries: 0,
+        });
+        const models = modelIdsFromResponse(response);
+        if (models.length === 0) {
+            return {
+                kind: "unavailable",
+                reason: "model_list_empty",
+            };
+        }
+        return {
+            kind: "ok",
+            models,
+        };
+    }
+    catch {
+        return {
+            kind: "unavailable",
+            reason: "model_list_unavailable",
+        };
+    }
+}
 //# sourceMappingURL=credential-validation.js.map

package/dist/server-shell/cli/launch-command.d.ts

@@ -6,8 +6,6 @@ export declare function renderCompletionPage(options: {
     joinTokenReusable?: boolean;
     projectId: string;
     workspaceRoot: string;
-    relayUrl: string;
-    branch?: string;
     tty?: boolean;
     hyperlinks?: boolean;
 }): string;

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

@@ -4,7 +4,7 @@ import { formatLaunchLifecycleResult, startLaunchProject, waitForForegroundHostS
 import { prepareLaunchProject } from "./launch.js";
 import { spawnDetachedHost, waitForManagedHostReady } from "./managed-host.js";
 import { resolveLaunchWorkspacePath } from "./project-resolver.js";
-import { formatJoinLinkValidity, formatTerminalLink, renderTerminalQr } from "./terminal-qr.js";
+import { formatJoinLinkValidity, formatTerminalLink } from "./terminal-qr.js";
 import { renderTuttiTerminalLogo } from "./terminal-logo.js";
 import { runProviderSetupTui } from "./provider-tui.js";
 import { LaunchError } from "./errors.js";
@@ -25,69 +25,69 @@ export async function confirmFromTty(request) {
         readline.close();
     }
 }
-async function waitForEnter() {
-    if (!process.stdin.isTTY || !process.stdout.isTTY) {
-        return;
-    }
-    const readline = createInterface({
-        input: process.stdin,
-        output: process.stdout,
-    });
-    try {
-        await readline.question("");
-    }
-    finally {
-        readline.close();
-    }
-}
 function formatProjectLabel(workspaceRoot, projectId) {
     return basename(workspaceRoot) || projectId;
 }
+function visibleTerminalLength(line) {
+    let stripped = line;
+    while (true) {
+        const start = stripped.indexOf("\u001B]8;;");
+        if (start < 0) {
+            break;
+        }
+        const end = stripped.indexOf("\u001B\\", start);
+        if (end < 0) {
+            break;
+        }
+        stripped = `${stripped.slice(0, start)}${stripped.slice(end + 2)}`;
+    }
+    while (true) {
+        const start = stripped.indexOf("\u001B[");
+        if (start < 0) {
+            break;
+        }
+        const end = Array.from(stripped.slice(start + 2)).findIndex((character) => {
+            const codePoint = character.codePointAt(0);
+            return (codePoint !== undefined &&
+                ((codePoint >= 0x41 && codePoint <= 0x5a) ||
+                    (codePoint >= 0x61 && codePoint <= 0x7a)));
+        });
+        if (end < 0) {
+            break;
+        }
+        stripped = `${stripped.slice(0, start)}${stripped.slice(start + 3 + end)}`;
+    }
+    return stripped.length;
+}
 function borderedBlock(lines) {
-    const width = Math.max(...lines.map((line) => line.length));
+    const width = Math.max(...lines.map(visibleTerminalLength));
     const top = `╭${"─".repeat(width + 2)}╮`;
     const bottom = `╰${"─".repeat(width + 2)}╯`;
-    const body = lines.map((line) => `│ ${line.padEnd(width, " ")} │`);
+    const body = lines.map((line) => `│ ${line}${" ".repeat(width - visibleTerminalLength(line))} │`);
     return [top, ...body, bottom].join("\n");
 }
 export function renderCompletionPage(options) {
     const isTty = options.tty ?? process.stdout.isTTY === true;
     const projectLabel = formatProjectLabel(options.workspaceRoot, options.projectId);
     const joinUrl = formatTerminalLink(options.joinUrl, { hyperlinks: options.hyperlinks === true });
+    const joinValidity = formatJoinLinkValidity({
+        ...(options.joinTokenExpiresAt === undefined
+            ? {}
+            : { expiresAt: options.joinTokenExpiresAt }),
+        ...(options.joinTokenReusable === undefined
+            ? {}
+            : { reusable: options.joinTokenReusable }),
+        includeRemaining: false,
+    });
     const summaryLines = [
         "Tutti is hosting this project.",
         `Project: ${projectLabel}`,
-        "Status: background host ready",
-        `Branch: ${options.branch ?? "tutti/mainline"}`,
-        `Relay: ${options.relayUrl}`,
-    ];
-    const nextSteps = [
-        "Next:",
-        "  Open the join URL or scan the QR code.",
-        "  `tutti invite` rotates a fresh link.",
-        "  `tutti ps` shows running hosts.",
-        "  `tutti stop` stops this host.",
+        `Join URL: ${joinUrl}`,
+        joinValidity,
     ];
     return [
         ...(isTty ? [CLEAR, renderTuttiTerminalLogo({ tty: true }), ""] : []),
         isTty ? borderedBlock(summaryLines) : summaryLines.join("\n"),
-        "",
-        `Join URL: ${joinUrl}`,
-        formatJoinLinkValidity({
-            ...(options.joinTokenExpiresAt === undefined
-                ? {}
-                : { expiresAt: options.joinTokenExpiresAt }),
-            ...(options.joinTokenReusable === undefined
-                ? {}
-                : { reusable: options.joinTokenReusable }),
-        }),
-        "",
-        "QR code:",
-        renderTerminalQr(options.joinUrl),
-        "",
-        ...nextSteps,
-        "",
-        isTty ? "[Enter] close this view. The host keeps running." : "The host keeps running.",
     ].join("\n");
 }
 async function ensureProviderConfigured(preparation) {
@@ -150,8 +150,6 @@ export async function runBackgroundLaunchCommand(options) {
         joinUrl: ready.join_url,
         projectId: preparation.project_id,
         workspaceRoot: preparation.workspace_root,
-        relayUrl: preparation.relay_url,
-        branch: preparation.branch,
         tty: process.stdout.isTTY === true,
         hyperlinks: process.stdout.isTTY === true,
         ...(ready.join_token_expires_at === undefined
@@ -161,6 +159,5 @@ export async function runBackgroundLaunchCommand(options) {
             ? {}
             : { joinTokenReusable: ready.join_token_reusable }),
     })}\n`);
-    await waitForEnter();
 }
 //# sourceMappingURL=launch-command.js.map

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

@@ -1,10 +1,14 @@
 import { type ConfigureProjectOpenAiProviderResult } from "../../providers/openai/index.js";
 import type { ProjectId } from "@tutti/shared/ids";
-type ProviderSetupStep = "base-url" | "api-key";
+type ProviderSetupStep = "base-url" | "api-key" | "model";
 type ProviderFormState = {
     step: ProviderSetupStep;
     baseUrl: string;
     apiKey: string;
+    modelOptions?: string[];
+    modelListStatus?: "loaded" | "unavailable";
+    selectedModelIndex?: number;
+    customModel?: string;
     error: string | undefined;
 };
 type ProviderSetupLogEvent = {

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

@@ -1,6 +1,6 @@
 import { emitKeypressEvents } from "node:readline";
 import { redactError } from "@tutti/shared/utils";
-import { configureProjectOpenAiProvider, DEFAULT_OPENAI_MODEL, } from "../../providers/openai/index.js";
+import { configureProjectOpenAiProvider, DEFAULT_OPENAI_MODEL, discoverOpenAiModels, } from "../../providers/openai/index.js";
 import { LaunchError } from "./errors.js";
 import { appendHostLogLine, getHostLogFilePath } from "./machine-local.js";
 import { renderTuttiTerminalLogo } from "./terminal-logo.js";
@@ -9,41 +9,100 @@ const SHOW_CURSOR = "\u001B[?25h";
 const BLINK_ON = "\u001B[5m";
 const BLINK_OFF = "\u001B[25m";
 const CLEAR = "\u001B[2J\u001B[H";
-const FIELD_UNDERLINE = "------------------------------------------------------------";
+const FIELD_BOX_WIDTH = 60;
+const MODEL_LIST_WINDOW = 8;
 function providerSetupCancelled() {
     return new LaunchError("provider_setup_cancelled", "Provider setup cancelled.", "Run the command again when you are ready.");
 }
 function renderFieldInput(options) {
     const value = options.secret && options.value.length > 0 ? "*".repeat(options.value.length) : options.value;
-    return [options.label, `${value}${BLINK_ON}_${BLINK_OFF}`, FIELD_UNDERLINE];
+    const visibleValue = value.length >= FIELD_BOX_WIDTH ? `<${value.slice(-(FIELD_BOX_WIDTH - 2))}` : value;
+    const cursor = `${BLINK_ON}_${BLINK_OFF}`;
+    const plainLength = visibleValue.length + 1;
+    const padding = Math.max(0, FIELD_BOX_WIDTH - plainLength);
+    return [
+        `+${"-".repeat(FIELD_BOX_WIDTH + 2)}+`,
+        `| ${visibleValue}${cursor}${" ".repeat(padding)} |`,
+        `+${"-".repeat(FIELD_BOX_WIDTH + 2)}+`,
+    ];
+}
+function modelOptionsWithCustom(state) {
+    return [...(state.modelOptions ?? []), ""];
+}
+function selectedModelIndex(state) {
+    const options = modelOptionsWithCustom(state);
+    const selected = state.selectedModelIndex ?? 0;
+    return Math.min(Math.max(0, selected), Math.max(0, options.length - 1));
+}
+function selectedModelValue(state) {
+    const options = modelOptionsWithCustom(state);
+    const selected = selectedModelIndex(state);
+    if (selected < (state.modelOptions ?? []).length) {
+        return options[selected] ?? "";
+    }
+    return state.customModel?.trim() ?? "";
+}
+function renderModelOptions(state) {
+    const options = modelOptionsWithCustom(state);
+    const selected = selectedModelIndex(state);
+    const modelCount = state.modelOptions?.length ?? 0;
+    const windowStart = Math.max(0, Math.min(selected - Math.floor(MODEL_LIST_WINDOW / 2), options.length - MODEL_LIST_WINDOW));
+    const windowEnd = Math.min(options.length, windowStart + MODEL_LIST_WINDOW);
+    const lines = [];
+    if (windowStart > 0) {
+        lines.push("  ...");
+    }
+    for (let index = windowStart; index < windowEnd; index += 1) {
+        const marker = index === selected ? ">" : " ";
+        const label = index < modelCount ? options[index] : "Custom model";
+        const suffix = index < modelCount ? "" : " (type your own)";
+        lines.push(`${marker} ${label}${suffix}`);
+    }
+    if (windowEnd < options.length) {
+        lines.push("  ...");
+    }
+    if (selected === modelCount) {
+        lines.push("", ...renderFieldInput({ value: state.customModel ?? "" }));
+    }
+    return lines;
 }
 function renderProviderField(state) {
     if (state.step === "base-url") {
         return [
-            "Step 1/2  Base URL",
+            "Step 1/3  Base URL",
             "OpenAI-compatible Responses API base URL; must expose POST /responses.",
             "",
             ...renderFieldInput({
-                label: "Base URL",
                 value: state.baseUrl,
             }),
             "",
             "[Enter] Continue    [Esc] Cancel",
         ];
     }
+    if (state.step === "api-key") {
+        return [
+            "Step 2/3  API Key",
+            "Stored only in the machine-local Tutti credential store.",
+            "",
+            ...renderFieldInput({
+                value: state.apiKey,
+                secret: true,
+            }),
+            "",
+            "[Enter] Continue    [Esc] Back to Base URL",
+        ];
+    }
     return [
-        "Step 2/2  API Key",
-        "Stored only in the machine-local Tutti credential store.",
+        "Step 3/3  Model",
+        state.modelListStatus === "loaded"
+            ? "Choose a model with Up/Down, or move to Custom model and type one."
+            : "Could not read the model list. Type a model name in Custom model.",
         "",
-        ...renderFieldInput({
-            label: "API Key",
-            value: state.apiKey,
-            secret: true,
-        }),
+        ...renderModelOptions(state),
         "",
         state.error === undefined
-            ? "[Enter] Validate    [Esc] Back to Base URL"
-            : "[Enter] Retry    [Esc] Back to Base URL",
+            ? "[Enter] Validate    [Esc] Back to API Key"
+            : "[Enter] Retry    [Esc] Back to API Key",
     ];
 }
 export function renderProviderForm(options) {
@@ -116,6 +175,7 @@ async function readProviderForm(options) {
         error: options.initialError,
     };
     return await new Promise((resolve, reject) => {
+        let busy = false;
         const render = () => {
             options.stdout.write(renderProviderForm({
                 state,
@@ -129,7 +189,38 @@ async function readProviderForm(options) {
             }
             options.stdout.write(SHOW_CURSOR);
         };
+        const openModelStep = async () => {
+            busy = true;
+            state.error = undefined;
+            options.stdout.write(renderModelDiscovery(options.stdout.isTTY === true));
+            const discoverModels = options.discoverModels ?? discoverOpenAiModels;
+            const result = await discoverModels({
+                apiKey: state.apiKey.trim(),
+                apiBaseUrl: state.baseUrl.trim(),
+            }).catch(() => ({
+                kind: "unavailable",
+                reason: "model_list_unavailable",
+            }));
+            if (result.kind === "ok") {
+                state.modelOptions = result.models;
+                state.modelListStatus = "loaded";
+                const defaultIndex = result.models.indexOf(DEFAULT_OPENAI_MODEL);
+                state.selectedModelIndex = defaultIndex >= 0 ? defaultIndex : 0;
+            }
+            else {
+                state.modelOptions = [];
+                state.modelListStatus = "unavailable";
+                state.selectedModelIndex = 0;
+            }
+            state.customModel = "";
+            state.step = "model";
+            busy = false;
+            render();
+        };
         const onKeypress = (character, key) => {
+            if (busy) {
+                return;
+            }
             if (key.ctrl === true && key.name === "c") {
                 cleanup();
                 reject(providerSetupCancelled());
@@ -142,6 +233,12 @@ async function readProviderForm(options) {
                     render();
                     return;
                 }
+                if (state.step === "model") {
+                    state.step = "api-key";
+                    state.error = undefined;
+                    render();
+                    return;
+                }
                 cleanup();
                 reject(providerSetupCancelled());
                 return;
@@ -158,22 +255,48 @@ async function readProviderForm(options) {
                     render();
                     return;
                 }
-                if (state.apiKey.trim() === "") {
-                    state.error = "API key is required.";
+                if (state.step === "api-key") {
+                    if (state.apiKey.trim() === "") {
+                        state.error = "API key is required.";
+                        render();
+                        return;
+                    }
+                    void openModelStep();
+                    return;
+                }
+                const model = selectedModelValue(state);
+                if (model === "") {
+                    state.error = "Model name is required.";
                     render();
                     return;
                 }
                 cleanup();
-                resolve({ baseUrl: state.baseUrl.trim(), apiKey: state.apiKey.trim() });
+                resolve({
+                    baseUrl: state.baseUrl.trim(),
+                    apiKey: state.apiKey.trim(),
+                    defaultModel: model,
+                });
+                return;
+            }
+            if (state.step === "model" && (key.name === "up" || key.name === "down")) {
+                const optionsWithCustom = modelOptionsWithCustom(state);
+                const delta = key.name === "up" ? -1 : 1;
+                state.selectedModelIndex =
+                    (selectedModelIndex(state) + delta + optionsWithCustom.length) % optionsWithCustom.length;
+                state.error = undefined;
+                render();
                 return;
             }
             if (key.name === "backspace") {
                 if (state.step === "base-url") {
                     state.baseUrl = state.baseUrl.slice(0, -1);
                 }
-                else {
+                else if (state.step === "api-key") {
                     state.apiKey = state.apiKey.slice(0, -1);
                 }
+                else if (selectedModelIndex(state) === (state.modelOptions?.length ?? 0)) {
+                    state.customModel = (state.customModel ?? "").slice(0, -1);
+                }
                 state.error = undefined;
                 render();
                 return;
@@ -182,9 +305,13 @@ async function readProviderForm(options) {
                 if (state.step === "base-url") {
                     state.baseUrl += character;
                 }
-                else {
+                else if (state.step === "api-key") {
                     state.apiKey += character;
                 }
+                else {
+                    state.selectedModelIndex = state.modelOptions?.length ?? 0;
+                    state.customModel = `${state.customModel ?? ""}${character}`;
+                }
                 state.error = undefined;
                 render();
             }
@@ -197,7 +324,19 @@ async function readProviderForm(options) {
         render();
     });
 }
-function renderChecking(frame, tty) {
+function renderModelDiscovery(tty) {
+    return [
+        CLEAR,
+        HIDE_CURSOR,
+        renderTuttiTerminalLogo({ tty }),
+        "",
+        "Provider setup",
+        "Looking up available models for this provider.",
+        "",
+        "Checking model list...",
+    ].join("\n");
+}
+function renderChecking(frame, tty, model) {
     const frames = ["|", "/", "-", "\\"];
     const indicator = frames[frame % frames.length] ?? "|";
     return [
@@ -208,7 +347,7 @@ function renderChecking(frame, tty) {
         "Provider setup",
         "Validating the configured Responses API endpoint.",
         "",
-        `${indicator} Checking provider connection with ${DEFAULT_OPENAI_MODEL}...`,
+        `${indicator} Checking provider connection with ${model}...`,
     ].join("\n");
 }
 export async function runProviderSetupTui(options) {
@@ -235,16 +374,17 @@ export async function runProviderSetupTui(options) {
         initialStep = "api-key";
         let frame = 0;
         const interval = setInterval(() => {
-            stdout.write(renderChecking(frame, stdout.isTTY === true));
+            stdout.write(renderChecking(frame, stdout.isTTY === true, input.defaultModel));
             frame += 1;
         }, 120);
         try {
-            stdout.write(renderChecking(frame, stdout.isTTY === true));
+            stdout.write(renderChecking(frame, stdout.isTTY === true, input.defaultModel));
             const result = await configureProjectOpenAiProvider({
                 tuttiHome: options.tuttiHome,
                 projectId: options.projectId,
                 apiBaseUrl: input.baseUrl,
                 apiKey: input.apiKey,
+                defaultModel: input.defaultModel,
             });
             clearInterval(interval);
             stdout.write(SHOW_CURSOR);

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

@@ -6,5 +6,6 @@ export declare function formatJoinLinkValidity(options: {
     expiresAt?: string;
     reusable?: boolean;
     now?: Date;
+    includeRemaining?: boolean;
 }): string;
 //# sourceMappingURL=terminal-qr.d.ts.map

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

@@ -29,6 +29,9 @@ export function formatJoinLinkValidity(options) {
     if (options.expiresAt !== undefined) {
         const expiresAt = new Date(options.expiresAt);
         if (!Number.isNaN(expiresAt.getTime())) {
+            if (options.includeRemaining === false) {
+                return `Join link valid until: ${options.expiresAt}`;
+            }
             const now = options.now ?? new Date();
             const remainingMs = expiresAt.getTime() - now.getTime();
             const suffix = remainingMs <= 0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xfey/tutti",
-  "version": "0.1.23",
+  "version": "0.1.25",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",