@xfey/tutti 0.1.32 → 0.1.33

package/README.md

@@ -2,11 +2,12 @@
 
 ## 作用
 
-`apps/server` 是 Tutti 的项目 host service。
+`apps/server` 是 Tutti 的项目 host service，也是机器级 Local Console 的进程入口。
 
 它负责：
 
 - `tutti launch` 后的项目绑定、恢复和接管入口
+- 裸 `tutti` 启动 / 复用的 loopback Local Console 与既有项目 Host 编排
 - Fastify API、SSE、packaged static Web 产物服务和 server 生命周期
 - SQLite store、migrations、repository 与协作真相读写
 - `control-plane`、scheduler、`procedure-engine`、`run-engine`、`workspace-ops` 与 OpenAI provider 接入
@@ -24,8 +25,8 @@
 
 ## 当前状态
 
-- 已具备 Fastify host shell、后台 host manager CLI 套件、Dev Runner、Host Project API、SSE、SQLite store、collaboration-state、workspace read-state、project timeline observability helper、Control Plane、Procedure / Run、workspace-ops、checks、Relay staged upload finalize、user skills 文件服务、artifacts 可视化产物查看层和 OpenAI / Codex provider 接入。
-- Host server 支持在显式 `webStatic.root` 或 packaged `web/` 存在时服务 Web 静态产物；`/api/*`、SSE、health 和 host-local control 不被 SPA fallback 吞掉。
+- 已具备 Fastify host shell、后台 host manager CLI 套件、机器级 Local Console、Dev Runner、Host Project API、SSE、SQLite store、collaboration-state、workspace read-state、project timeline observability helper、Control Plane、Procedure / Run、workspace-ops、checks、Relay staged upload finalize、user skills 文件服务、artifacts 可视化产物查看层和 OpenAI / Codex provider 接入。
+- Host server 与 Local Console 支持在显式 `webStatic.root` 或 packaged `web/` 存在时服务 Web 静态产物；`/api/*`、SSE、health、host-local control 和 `/local-console/*` API 不被 SPA fallback 吞掉。
 - Root `pack:dry-run` 会先清理 build output、重新构建，再复制 `apps/web/dist` 到 package-local `web/`，生成临时 staging `@xfey/tutti` artifact，并校验 npm pack 文件列表包含 CLI、migrations、prompts、Web index、bundled `@tutti/shared` / `@tutti/relay-client` 以及它们的外部 runtime dependencies，同时排除源码、source map、日志、SQLite、`.env`、`.tutti-dev` 与测试产物。
 - Root `smoke:packed-cli` 同样从干净 build output 生成 staging `@xfey/tutti` tarball、在临时目录安装，并验证 SQLite native binding、`tutti --help` / `tutti launch --help` / `tutti archive --help` / `tutti --version`、migrations、prompts、Web static index、bundled internal dependencies、bundled external runtime dependencies、CLI QR dependency、仓库锁定的 `@openai/codex` binary 可执行性和临时全局安装路径；该 smoke 不需要 Tutti source repo 存在。
 - `prompts/` 是所有模型-facing prompt、指令模板和 Codex 执行模板的统一落点；长 prompt 不内联在 TypeScript 中。

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

@@ -1,4 +1,6 @@
 export type CliCommand = {
+    kind: "console";
+} | {
     kind: "help";
     topic?: string;
 } | {
@@ -12,6 +14,8 @@ export type CliCommand = {
     kind: "internal-host-run";
     workspacePath: string;
     yes: boolean;
+} | {
+    kind: "internal-console-run";
 } | {
     kind: "ps";
     manage: boolean;

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

@@ -49,7 +49,10 @@ function readOptionalTarget(args) {
 export function parseCliArgs(argv, cwd = process.cwd()) {
     const args = [...argv];
     const command = args.shift();
-    if (command === undefined || command === "--help" || command === "-h" || command === "help") {
+    if (command === undefined) {
+        return { kind: "console" };
+    }
+    if (command === "--help" || command === "-h" || command === "help") {
         return { kind: "help", ...(args[0] === undefined ? {} : { topic: args[0] }) };
     }
     if (command === "--version" || command === "-v" || command === "version") {
@@ -83,6 +86,12 @@ export function parseCliArgs(argv, cwd = process.cwd()) {
     }
     if (command === "internal") {
         const internalCommand = args.shift();
+        if (internalCommand === "console-run") {
+            if (args.length > 0) {
+                throw new LaunchError("git_bootstrap_failed", "Internal console-run does not accept options", "Internal commands are managed by Tutti.");
+            }
+            return { kind: "internal-console-run" };
+        }
         if (internalCommand !== "host-run") {
             throw new LaunchError("git_bootstrap_failed", "Unsupported internal command", "Internal commands are managed by Tutti.");
         }

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

@@ -6,23 +6,28 @@ import { resolveExistingProjectContext } from "./project-resolver.js";
 import { runProviderSetupTui } from "./provider-tui.js";
 import { runArchiveCommand, runDoctorCommand, runForgetCommand, runInviteCommand, runLogsCommand, runProviderStatusCommand, runPsManageCommand, runPsCommand, runStopCommand, } from "./runtime-commands.js";
 import { readCliVersion } from "./version.js";
+import { ensureLocalConsole, openLocalConsoleBrowser, runLocalConsoleProcess, } from "../local-console/index.js";
 const HELP_TEXT = `Usage:
+  tutti
   tutti launch [target] [--yes] [--foreground]
   tutti ps [--manage] [--all]
   tutti invite [target]
   tutti stop [target]
-  tutti archive <target> [--yes]
-  tutti forget <target> [--yes]
-  tutti logs [target] [--tail 120]
   tutti provider setup [target]
   tutti provider status [target]
+
+Advanced and diagnostic commands:
+  tutti logs [target] [--tail 120]
   tutti doctor [target]
+  tutti archive <target> [--yes]
+  tutti forget <target> [--yes]
 
 Options:
   -h, --help      Show help.
   -v, --version   Show version.
 
 Notes:
+  tutti opens the machine-local project console in your browser.
   launch starts the host in the background by default.
   provider setup stores credentials in the machine-local Tutti provider store.
 `;
@@ -151,9 +156,20 @@ async function runProviderSetupCommand(target) {
     ].join("\n"));
     process.stdout.write("\n");
 }
+async function runLocalConsoleCommand() {
+    const console = await ensureLocalConsole();
+    if (openLocalConsoleBrowser(console.url)) {
+        process.stdout.write(`Tutti Local Console is ready at ${console.endpoint.base_url}/console\n`);
+        return;
+    }
+    process.stdout.write(["Open Tutti Local Console in a browser:", console.url, ""].join("\n"));
+}
 try {
     const command = parseCliArgs(process.argv.slice(2));
     switch (command.kind) {
+        case "console":
+            await runLocalConsoleCommand();
+            break;
         case "help":
             process.stdout.write(helpForTopic(command.topic));
             break;
@@ -172,6 +188,9 @@ try {
         case "internal-host-run":
             await runInternalHostRunCommand(command);
             break;
+        case "internal-console-run":
+            await runLocalConsoleProcess();
+            break;
         case "ps":
             if (command.manage) {
                 await runPsManageCommand({ all: command.all });

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

@@ -1,6 +1,4 @@
-import { existsSync } from "node:fs";
-import { basename, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
+import { basename, join } from "node:path";
 import { serializeRuntimeLogLine } from "@tutti/shared/utils";
 import { completeRelayUpload, resolveRelayUpload } from "@tutti/relay-client";
 import { ApprovalRequestManager } from "../../approvals/index.js";
@@ -14,6 +12,7 @@ import { readProviderUsageProjection, recordProviderUsageEvent, } from "../../pr
 import { resolveProjectOpenAiRunPipelineRunner } from "../../run-pipeline/openai.js";
 import { openHostProjectStore } from "../../store/index.js";
 import { cleanupStaleRunWorkspaces } from "../../workspace-ops/index.js";
+import { resolvePackagedWebStaticRoot } from "../http/static-web.js";
 import { AGENT_CONTEXT_BASE_PATH, AgentContextTokenRegistry, } from "../http/routes/agent-context.js";
 import { readHostRepoProjection } from "../http/routes/project-api.js";
 import { WorkspaceEventBus } from "../http/workspace-events.js";
@@ -38,13 +37,6 @@ function createHostRuntimeLogger(options) {
         },
     };
 }
-function resolvePackagedWebStaticRoot(env = process.env) {
-    if (env.TUTTI_WEB_STATIC_ROOT !== undefined && env.TUTTI_WEB_STATIC_ROOT.trim() !== "") {
-        return resolve(env.TUTTI_WEB_STATIC_ROOT);
-    }
-    const packagedRoot = fileURLToPath(new URL("../../../web", import.meta.url));
-    return existsSync(join(packagedRoot, "index.html")) ? packagedRoot : undefined;
-}
 function createAgentContextRuntime(options) {
     return {
         baseUrl: new URL(AGENT_CONTEXT_BASE_PATH, options.baseUrl).toString(),

package/dist/server-shell/http/routes/project-api/project-timeline-projection.js

@@ -12,10 +12,10 @@ const RUN_USAGE_SOURCES = [
 const TASK_ACCEPTED_USAGE_SOURCES = ["task_compile"];
 const TRACE_CONSENSUS_LIMIT = 3;
 const TRACE_TASK_CHANGE_LIMIT = 2;
-const TRACE_CONTRACT_SCOPE_LIMIT = 5;
-const TRACE_CHANGED_PATH_LIMIT = 6;
-const TRACE_CHECKPOINT_ITEM_LIMIT = 5;
-const TRACE_GENERATED_FILE_LIMIT = 5;
+const TRACE_CONTRACT_SCOPE_LIMIT = 40;
+const TRACE_CHANGED_PATH_LIMIT = 100;
+const TRACE_CHECKPOINT_ITEM_LIMIT = 50;
+const TRACE_GENERATED_FILE_LIMIT = 50;
 const TRACE_SOURCE_SNIPPET_LIMIT = 3;
 const TRACE_SOURCE_SNIPPET_BODY_LIMIT = 280;
 const TRACE_CHANGE_LINK_LIMIT = 3;

package/dist/server-shell/http/static-web.d.ts

@@ -3,4 +3,5 @@ export type HostWebStaticOptions = {
     root: string;
 };
 export declare function registerHostWebStaticRoutes(app: FastifyInstance, options: HostWebStaticOptions): void;
+export declare function resolvePackagedWebStaticRoot(env?: NodeJS.ProcessEnv): string | undefined;
 //# sourceMappingURL=static-web.d.ts.map

package/dist/server-shell/http/static-web.js

@@ -1,10 +1,12 @@
 import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
+import { join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
 import fastifyStatic from "@fastify/static";
 const BLOCKED_SPA_FALLBACK_PREFIXES = [
     "/api/",
     "/health",
     "/host-local/",
+    "/local-console/",
     "/assets/",
 ];
 function requestPath(request) {
@@ -49,4 +51,15 @@ export function registerHostWebStaticRoutes(app, options) {
         sendIndex(reply, indexHtml);
     });
 }
+export function resolvePackagedWebStaticRoot(env = process.env) {
+    if (env.TUTTI_WEB_STATIC_ROOT !== undefined && env.TUTTI_WEB_STATIC_ROOT.trim() !== "") {
+        return resolve(env.TUTTI_WEB_STATIC_ROOT);
+    }
+    const packagedRoot = fileURLToPath(new URL("../../../web", import.meta.url));
+    if (existsSync(join(packagedRoot, "index.html"))) {
+        return packagedRoot;
+    }
+    const workspaceWebDist = fileURLToPath(new URL("../../../../web/dist", import.meta.url));
+    return existsSync(join(workspaceWebDist, "index.html")) ? workspaceWebDist : undefined;
+}
 //# sourceMappingURL=static-web.js.map

package/dist/server-shell/local-console/browser-open.d.ts

@@ -0,0 +1,5 @@
+export declare function openLocalConsoleBrowser(url: string, options?: {
+    platform?: NodeJS.Platform;
+    env?: NodeJS.ProcessEnv;
+}): boolean;
+//# sourceMappingURL=browser-open.d.ts.map

package/dist/server-shell/local-console/browser-open.js

@@ -0,0 +1,40 @@
+import { spawn } from "node:child_process";
+import { constants, accessSync } from "node:fs";
+import { delimiter, join } from "node:path";
+function executableInPath(command, env) {
+    for (const directory of (env.PATH ?? "").split(delimiter)) {
+        if (directory.trim() === "") {
+            continue;
+        }
+        const candidate = join(directory, command);
+        try {
+            accessSync(candidate, constants.X_OK);
+            return candidate;
+        }
+        catch {
+            // Keep searching PATH.
+        }
+    }
+    return null;
+}
+export function openLocalConsoleBrowser(url, options = {}) {
+    const platform = options.platform ?? process.platform;
+    const env = options.env ?? process.env;
+    const command = platform === "darwin"
+        ? "/usr/bin/open"
+        : platform === "linux" && (env.DISPLAY !== undefined || env.WAYLAND_DISPLAY !== undefined)
+            ? executableInPath("xdg-open", env)
+            : null;
+    if (command === null) {
+        return false;
+    }
+    const child = spawn(command, [url], {
+        detached: true,
+        env,
+        stdio: "ignore",
+    });
+    child.on("error", () => undefined);
+    child.unref();
+    return true;
+}
+//# sourceMappingURL=browser-open.js.map

package/dist/server-shell/local-console/folder-picker.d.ts

@@ -0,0 +1,21 @@
+export type LocalFolderPickerKind = "macos" | "zenity" | "kdialog" | "unavailable";
+export type LocalFolderPickResult = {
+    kind: "selected";
+    path: string;
+} | {
+    kind: "cancelled";
+} | {
+    kind: "unavailable";
+    message: string;
+};
+export declare function detectLocalFolderPicker(platform?: NodeJS.Platform, env?: NodeJS.ProcessEnv): {
+    kind: LocalFolderPickerKind;
+    executable?: string;
+};
+export declare function pickLocalFolder(options?: {
+    prompt?: string;
+    platform?: NodeJS.Platform;
+    env?: NodeJS.ProcessEnv;
+}): Promise<LocalFolderPickResult>;
+export declare function createLocalProjectFolder(parentPath: string, childName: string): string;
+//# sourceMappingURL=folder-picker.d.ts.map

package/dist/server-shell/local-console/folder-picker.js

@@ -0,0 +1,109 @@
+import { execFile } from "node:child_process";
+import { constants, accessSync, existsSync, mkdirSync, statSync } from "node:fs";
+import { basename, delimiter, dirname, join, resolve } from "node:path";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+function executableInPath(command, env) {
+    for (const directory of (env.PATH ?? "").split(delimiter)) {
+        if (directory.trim() === "") {
+            continue;
+        }
+        const candidate = join(directory, command);
+        try {
+            accessSync(candidate, constants.X_OK);
+            return candidate;
+        }
+        catch {
+            // Keep searching PATH.
+        }
+    }
+    return null;
+}
+export function detectLocalFolderPicker(platform = process.platform, env = process.env) {
+    if (platform === "darwin") {
+        return { kind: "macos", executable: "/usr/bin/osascript" };
+    }
+    if (platform !== "linux" || (env.DISPLAY === undefined && env.WAYLAND_DISPLAY === undefined)) {
+        return { kind: "unavailable" };
+    }
+    const zenity = executableInPath("zenity", env);
+    if (zenity !== null) {
+        return { kind: "zenity", executable: zenity };
+    }
+    const kdialog = executableInPath("kdialog", env);
+    if (kdialog !== null) {
+        return { kind: "kdialog", executable: kdialog };
+    }
+    return { kind: "unavailable" };
+}
+function normalizeSelectedPath(stdout) {
+    const value = stdout.trim();
+    if (value === "") {
+        return null;
+    }
+    const selected = resolve(value);
+    if (!existsSync(selected) || !statSync(selected).isDirectory()) {
+        return null;
+    }
+    return selected;
+}
+export async function pickLocalFolder(options = {}) {
+    const prompt = options.prompt ?? "Choose a Tutti project folder";
+    const picker = detectLocalFolderPicker(options.platform, options.env);
+    if (picker.kind === "unavailable" || picker.executable === undefined) {
+        return {
+            kind: "unavailable",
+            message: "No desktop folder picker is available. Enter an absolute folder path instead.",
+        };
+    }
+    const args = picker.kind === "macos"
+        ? ["-e", `POSIX path of (choose folder with prompt ${JSON.stringify(prompt)})`]
+        : picker.kind === "zenity"
+            ? ["--file-selection", "--directory", `--title=${prompt}`]
+            : ["--getexistingdirectory", resolve(process.cwd()), "--title", prompt];
+    try {
+        const result = await execFileAsync(picker.executable, args, {
+            encoding: "utf8",
+            env: options.env ?? process.env,
+            maxBuffer: 16 * 1024,
+            timeout: 120_000,
+        });
+        const selected = normalizeSelectedPath(result.stdout);
+        return selected === null ? { kind: "cancelled" } : { kind: "selected", path: selected };
+    }
+    catch {
+        return { kind: "cancelled" };
+    }
+}
+function validateChildName(value) {
+    const name = value.trim();
+    const hasControlCharacter = [...name].some((character) => {
+        const codePoint = character.codePointAt(0) ?? 0;
+        return codePoint <= 0x1f || codePoint === 0x7f;
+    });
+    if (name === "" ||
+        name === "." ||
+        name === ".." ||
+        name !== basename(name) ||
+        hasControlCharacter) {
+        throw new Error("Project folder name must be a single valid directory name.");
+    }
+    return name;
+}
+export function createLocalProjectFolder(parentPath, childName) {
+    const parent = resolve(parentPath.trim());
+    if (!existsSync(parent) || !statSync(parent).isDirectory()) {
+        throw new Error("Parent folder does not exist or is not a directory.");
+    }
+    accessSync(parent, constants.W_OK);
+    const child = resolve(parent, validateChildName(childName));
+    if (dirname(child) !== parent) {
+        throw new Error("Project folder must be created directly inside the selected parent.");
+    }
+    if (existsSync(child)) {
+        throw new Error("A file or folder with that name already exists.");
+    }
+    mkdirSync(child, { mode: 0o755 });
+    return child;
+}
+//# sourceMappingURL=folder-picker.js.map

package/dist/server-shell/local-console/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./browser-open.js";
+export * from "./managed-console.js";
+export * from "./server.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/server-shell/local-console/index.js

@@ -0,0 +1,4 @@
+export * from "./browser-open.js";
+export * from "./managed-console.js";
+export * from "./server.js";
+//# sourceMappingURL=index.js.map

package/dist/server-shell/local-console/managed-console.d.ts

@@ -0,0 +1,9 @@
+import { type LocalConsoleRuntimeEndpoint } from "./runtime-endpoint.js";
+export declare function ensureLocalConsole(options?: {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+}): Promise<{
+    url: string;
+    endpoint: LocalConsoleRuntimeEndpoint;
+}>;
+//# sourceMappingURL=managed-console.d.ts.map

package/dist/server-shell/local-console/managed-console.js

@@ -0,0 +1,94 @@
+import { spawn } from "node:child_process";
+import { resolve } from "node:path";
+import { resolveTuttiHome } from "../../providers/openai/index.js";
+import { deleteLocalConsoleRuntimeEndpoint, readLocalConsoleRuntimeEndpoint, } from "./runtime-endpoint.js";
+import { LOCAL_CONSOLE_API_BASE } from "./server.js";
+const READY_TIMEOUT_MS = 15_000;
+const READY_POLL_MS = 150;
+function delay(milliseconds) {
+    return new Promise((resolveDelay) => setTimeout(resolveDelay, milliseconds));
+}
+function cliEntrypoint() {
+    const entrypoint = process.argv[1];
+    if (entrypoint === undefined || entrypoint.trim() === "") {
+        throw new Error("Cannot locate the Tutti CLI entrypoint.");
+    }
+    return entrypoint;
+}
+async function endpointReady(endpoint) {
+    try {
+        const response = await fetch(`${endpoint.base_url}${LOCAL_CONSOLE_API_BASE}/health`, {
+            signal: AbortSignal.timeout(1_000),
+        });
+        if (!response.ok) {
+            return false;
+        }
+        const value = (await response.json());
+        return value.status === "ready";
+    }
+    catch {
+        return false;
+    }
+}
+function spawnDetachedConsole(options) {
+    const child = spawn(process.execPath, [...process.execArgv, cliEntrypoint(), "internal", "console-run"], {
+        cwd: options.cwd,
+        detached: true,
+        env: options.env,
+        stdio: "ignore",
+    });
+    child.unref();
+}
+async function waitForConsoleEndpoint(tuttiHome) {
+    const deadline = Date.now() + READY_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+        const endpoint = readLocalConsoleRuntimeEndpoint(tuttiHome);
+        if (endpoint !== null && (await endpointReady(endpoint))) {
+            return endpoint;
+        }
+        await delay(READY_POLL_MS);
+    }
+    throw new Error("Tutti Local Console did not become ready. Run `tutti doctor` for diagnostics.");
+}
+async function ensureConsoleEndpoint(options) {
+    const existing = readLocalConsoleRuntimeEndpoint(options.tuttiHome);
+    if (existing !== null && (await endpointReady(existing))) {
+        return existing;
+    }
+    if (existing !== null) {
+        deleteLocalConsoleRuntimeEndpoint({
+            tuttiHome: options.tuttiHome,
+            expectedControlToken: existing.control_token,
+        });
+    }
+    spawnDetachedConsole({ cwd: options.cwd, env: options.env });
+    return await waitForConsoleEndpoint(options.tuttiHome);
+}
+async function issueBrowserAccess(endpoint, currentDirectory) {
+    const response = await fetch(`${endpoint.base_url}${LOCAL_CONSOLE_API_BASE}/access-tokens`, {
+        method: "POST",
+        headers: {
+            authorization: `Bearer ${endpoint.control_token}`,
+            accept: "application/json",
+            "content-type": "application/json",
+        },
+        body: JSON.stringify({ current_directory: currentDirectory }),
+        signal: AbortSignal.timeout(3_000),
+    });
+    if (!response.ok) {
+        throw new Error("Tutti Local Console could not create a browser access link.");
+    }
+    const value = (await response.json());
+    if (typeof value.access_token !== "string" || value.access_token.trim() === "") {
+        throw new Error("Tutti Local Console returned an invalid browser access link.");
+    }
+    return `${endpoint.base_url}/console#access_token=${encodeURIComponent(value.access_token)}`;
+}
+export async function ensureLocalConsole(options = {}) {
+    const cwd = resolve(options.cwd ?? process.cwd());
+    const env = options.env ?? process.env;
+    const tuttiHome = resolveTuttiHome(env.TUTTI_HOME, cwd);
+    const endpoint = await ensureConsoleEndpoint({ cwd, env, tuttiHome });
+    return { endpoint, url: await issueBrowserAccess(endpoint, cwd) };
+}
+//# sourceMappingURL=managed-console.js.map

package/dist/server-shell/local-console/project-service.d.ts

@@ -0,0 +1,57 @@
+import type { ProjectId } from "@tutti/shared/ids";
+import { type RuntimeProjectRow } from "../cli/runtime-commands.js";
+export type LocalConsoleProject = {
+    project_id: ProjectId;
+    display_name: string;
+    workspace_path: string;
+    status: RuntimeProjectRow["status"];
+    provider_status: "configured" | "not_configured" | "invalid";
+    relay_project_ref?: string;
+    join_url?: string;
+    relay_connection_status?: string;
+};
+export type LocalConsoleProviderInput = {
+    base_url: string;
+    api_key: string;
+    model: string;
+};
+export type LocalConsoleLaunchResult = {
+    project: LocalConsoleProject;
+    join_url: string;
+    join_token_expires_at?: string;
+};
+export declare class LocalConsoleProjectError extends Error {
+    readonly code: string;
+    readonly statusCode: number;
+    constructor(code: string, message: string, statusCode?: number);
+}
+export declare class LocalConsoleProjectService {
+    #private;
+    constructor(options?: {
+        cwd?: string;
+        env?: NodeJS.ProcessEnv;
+    });
+    listProjects(): Promise<LocalConsoleProject[]>;
+    discoverModels(input: {
+        baseUrl: string;
+        apiKey: string;
+    }): Promise<{
+        kind: "ok";
+        models: string[];
+    } | {
+        kind: "unavailable";
+        reason: string;
+    }>;
+    launchProject(input: {
+        workspacePath: string;
+        provider?: LocalConsoleProviderInput;
+    }): Promise<LocalConsoleLaunchResult>;
+    refreshInvite(projectId: string): Promise<{
+        join_url: string;
+        expires_at?: string;
+    }>;
+    stopProject(projectId: string): Promise<{
+        message: string;
+    }>;
+}
+//# sourceMappingURL=project-service.d.ts.map