@xfey/tutti 0.1.32 → 0.1.34

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

@@ -0,0 +1,78 @@
+import { execFile } from "node:child_process";
+import { constants, accessSync, existsSync, statSync } from "node:fs";
+import { delimiter, 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" };
+    }
+}
+//# 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/invocation-context.d.ts

@@ -0,0 +1,21 @@
+export declare const LOCAL_CONSOLE_INVOCATION_ENV_KEYS: readonly ["DBUS_SESSION_BUS_ADDRESS", "DISPLAY", "LANG", "LC_ALL", "LC_CTYPE", "PATH", "TUTTI_HOST_ENDPOINT_HOST", "TUTTI_HOST_ENDPOINT_PORT", "TUTTI_RELAY_URL", "WAYLAND_DISPLAY", "XDG_CURRENT_DESKTOP"];
+export type LocalConsoleInvocationEnvironment = Partial<Record<(typeof LOCAL_CONSOLE_INVOCATION_ENV_KEYS)[number], string>>;
+export type LocalConsoleInvocationContext = {
+    currentDirectory: string;
+    environment: LocalConsoleInvocationEnvironment;
+};
+export declare function collectLocalConsoleInvocationEnvironment(env: NodeJS.ProcessEnv): LocalConsoleInvocationEnvironment;
+export declare function createLocalConsoleInvocationContext(options: {
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+}): LocalConsoleInvocationContext;
+export declare function createLocalConsoleServiceEnvironment(options: {
+    env: NodeJS.ProcessEnv;
+    tuttiHome: string;
+}): NodeJS.ProcessEnv;
+export declare function createLocalConsoleOperationEnvironment(options: {
+    serviceEnvironment: NodeJS.ProcessEnv;
+    invocationEnvironment: LocalConsoleInvocationEnvironment;
+    tuttiHome: string;
+}): NodeJS.ProcessEnv;
+//# sourceMappingURL=invocation-context.d.ts.map

package/dist/server-shell/local-console/invocation-context.js

@@ -0,0 +1,56 @@
+import { resolve } from "node:path";
+export const LOCAL_CONSOLE_INVOCATION_ENV_KEYS = [
+    "DBUS_SESSION_BUS_ADDRESS",
+    "DISPLAY",
+    "LANG",
+    "LC_ALL",
+    "LC_CTYPE",
+    "PATH",
+    "TUTTI_HOST_ENDPOINT_HOST",
+    "TUTTI_HOST_ENDPOINT_PORT",
+    "TUTTI_RELAY_URL",
+    "WAYLAND_DISPLAY",
+    "XDG_CURRENT_DESKTOP",
+];
+export function collectLocalConsoleInvocationEnvironment(env) {
+    const environment = {};
+    for (const key of LOCAL_CONSOLE_INVOCATION_ENV_KEYS) {
+        const value = env[key];
+        if (value !== undefined && value !== "") {
+            environment[key] = value;
+        }
+    }
+    return environment;
+}
+export function createLocalConsoleInvocationContext(options) {
+    return {
+        currentDirectory: resolve(options.cwd),
+        environment: collectLocalConsoleInvocationEnvironment(options.env),
+    };
+}
+export function createLocalConsoleServiceEnvironment(options) {
+    const environment = { TUTTI_HOME: options.tuttiHome };
+    for (const key of [
+        "HOME",
+        "LANG",
+        "LC_ALL",
+        "LC_CTYPE",
+        "LOGNAME",
+        "TMPDIR",
+        "USER",
+    ]) {
+        const value = options.env[key];
+        if (value !== undefined && value !== "") {
+            environment[key] = value;
+        }
+    }
+    return environment;
+}
+export function createLocalConsoleOperationEnvironment(options) {
+    return {
+        ...options.serviceEnvironment,
+        ...options.invocationEnvironment,
+        TUTTI_HOME: options.tuttiHome,
+    };
+}
+//# sourceMappingURL=invocation-context.js.map

package/dist/server-shell/local-console/lifecycle-lock.d.ts

@@ -0,0 +1,13 @@
+type LifecycleLockTiming = {
+    staleMs: number;
+    waitMs: number;
+    pollMs: number;
+};
+export declare function withLocalConsoleLifecycleLock<T>(options: {
+    tuttiHome: string;
+    run: () => Promise<T>;
+    now?: () => number;
+    timing?: Partial<LifecycleLockTiming>;
+}): Promise<T>;
+export {};
+//# sourceMappingURL=lifecycle-lock.d.ts.map

package/dist/server-shell/local-console/lifecycle-lock.js

@@ -0,0 +1,135 @@
+import { randomBytes } from "node:crypto";
+import { chmodSync, closeSync, constants, mkdirSync, openSync, readFileSync, statSync, unlinkSync, writeFileSync, } from "node:fs";
+import { dirname, join } from "node:path";
+const LOCK_STALE_MS = 30_000;
+const LOCK_WAIT_MS = 35_000;
+const LOCK_POLL_MS = 100;
+function delay(milliseconds) {
+    return new Promise((resolveDelay) => setTimeout(resolveDelay, milliseconds));
+}
+function lockPath(tuttiHome) {
+    return join(tuttiHome, "runtime", "local-console.lock");
+}
+function ensurePrivateRuntimeDirectory(tuttiHome) {
+    const directory = dirname(lockPath(tuttiHome));
+    mkdirSync(directory, { recursive: true, mode: 0o700 });
+    chmodSync(directory, 0o700);
+}
+function lockOwnerAlive(path) {
+    try {
+        const value = JSON.parse(readFileSync(path, "utf8"));
+        if (!Number.isInteger(value.pid)) {
+            return false;
+        }
+        process.kill(value.pid, 0);
+        return true;
+    }
+    catch (error) {
+        return (typeof error === "object" &&
+            error !== null &&
+            "code" in error &&
+            error.code === "EPERM");
+    }
+}
+function removeStaleLock(path, now, staleMs) {
+    try {
+        const age = now() - statSync(path).mtimeMs;
+        if (age < staleMs || lockOwnerAlive(path)) {
+            return false;
+        }
+        unlinkSync(path);
+        return true;
+    }
+    catch (error) {
+        if (typeof error === "object" &&
+            error !== null &&
+            "code" in error &&
+            error.code === "ENOENT") {
+            return true;
+        }
+        return false;
+    }
+}
+async function acquireLock(options) {
+    const now = options.now ?? Date.now;
+    const timing = options.timing ?? {
+        staleMs: LOCK_STALE_MS,
+        waitMs: LOCK_WAIT_MS,
+        pollMs: LOCK_POLL_MS,
+    };
+    const path = lockPath(options.tuttiHome);
+    const deadline = now() + timing.waitMs;
+    const ownerId = randomBytes(16).toString("base64url");
+    ensurePrivateRuntimeDirectory(options.tuttiHome);
+    while (now() < deadline) {
+        try {
+            const descriptor = openSync(path, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY, 0o600);
+            try {
+                writeFileSync(descriptor, `${JSON.stringify({
+                    pid: process.pid,
+                    owner_id: ownerId,
+                    acquired_at: new Date(now()).toISOString(),
+                })}\n`, "utf8");
+            }
+            finally {
+                closeSync(descriptor);
+            }
+            chmodSync(path, 0o600);
+            return () => {
+                try {
+                    let record;
+                    try {
+                        record = JSON.parse(readFileSync(path, "utf8"));
+                    }
+                    catch {
+                        return;
+                    }
+                    if (record.owner_id !== ownerId) {
+                        return;
+                    }
+                    unlinkSync(path);
+                }
+                catch (error) {
+                    if (typeof error !== "object" ||
+                        error === null ||
+                        !("code" in error) ||
+                        error.code !== "ENOENT") {
+                        throw error;
+                    }
+                }
+            };
+        }
+        catch (error) {
+            if (typeof error !== "object" ||
+                error === null ||
+                !("code" in error) ||
+                error.code !== "EEXIST") {
+                throw error;
+            }
+            removeStaleLock(path, now, timing.staleMs);
+            await delay(timing.pollMs);
+        }
+    }
+    throw new Error("Timed out waiting for the Tutti service lifecycle lock.");
+}
+export async function withLocalConsoleLifecycleLock(options) {
+    const timing = options.timing === undefined
+        ? undefined
+        : {
+            staleMs: options.timing.staleMs ?? LOCK_STALE_MS,
+            waitMs: options.timing.waitMs ?? LOCK_WAIT_MS,
+            pollMs: options.timing.pollMs ?? LOCK_POLL_MS,
+        };
+    const release = await acquireLock({
+        tuttiHome: options.tuttiHome,
+        ...(options.now === undefined ? {} : { now: options.now }),
+        ...(timing === undefined ? {} : { timing }),
+    });
+    try {
+        return await options.run();
+    }
+    finally {
+        release();
+    }
+}
+//# sourceMappingURL=lifecycle-lock.js.map

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

@@ -0,0 +1,47 @@
+import { type LocalConsoleRuntimeEndpoint } from "./runtime-endpoint.js";
+type FetchLike = (input: string | URL, init?: RequestInit) => Promise<Response>;
+export type LocalConsoleServiceStatus = {
+    status: "stopped";
+    log_path: string;
+} | {
+    status: "stale";
+    pid: number;
+    base_url: string;
+    started_at: string;
+    log_path: string;
+} | {
+    status: "running";
+    pid: number;
+    base_url: string;
+    started_at: string;
+    version: string;
+    current_version: string;
+    update_required: boolean;
+    log_path: string;
+};
+export declare function getLocalConsoleLogPath(tuttiHome: string): string;
+export declare function ensureLocalConsole(options?: {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    fetchImpl?: FetchLike;
+}): Promise<{
+    url: string;
+    endpoint: LocalConsoleRuntimeEndpoint;
+}>;
+export declare function readLocalConsoleServiceStatus(options?: {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    fetchImpl?: FetchLike;
+}): Promise<LocalConsoleServiceStatus>;
+export declare function stopLocalConsoleService(options?: {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    fetchImpl?: FetchLike;
+}): Promise<"stopped" | "already_stopped">;
+export declare function restartLocalConsoleService(options?: {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    fetchImpl?: FetchLike;
+}): Promise<LocalConsoleRuntimeEndpoint>;
+export {};
+//# sourceMappingURL=managed-console.d.ts.map

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

@@ -0,0 +1,312 @@
+import { spawn } from "node:child_process";
+import { chmodSync, closeSync, existsSync, mkdirSync, openSync, renameSync, statSync, unlinkSync, } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { resolveTuttiHome } from "../../providers/openai/index.js";
+import { readCliVersion } from "../cli/version.js";
+import { createLocalConsoleInvocationContext, createLocalConsoleServiceEnvironment, } from "./invocation-context.js";
+import { withLocalConsoleLifecycleLock } from "./lifecycle-lock.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;
+const STOP_TIMEOUT_MS = 5_000;
+const CONSOLE_LOG_MAX_BYTES = 2 * 1024 * 1024;
+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 resolve(entrypoint);
+}
+export function getLocalConsoleLogPath(tuttiHome) {
+    return join(tuttiHome, "logs", "console.log");
+}
+function prepareConsoleLog(tuttiHome) {
+    const path = getLocalConsoleLogPath(tuttiHome);
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    chmodSync(dirname(path), 0o700);
+    if (existsSync(path) && statSync(path).size >= CONSOLE_LOG_MAX_BYTES) {
+        const previousPath = `${path}.1`;
+        if (existsSync(previousPath)) {
+            unlinkSync(previousPath);
+        }
+        renameSync(path, previousPath);
+    }
+    const descriptor = openSync(path, "a", 0o600);
+    chmodSync(path, 0o600);
+    return descriptor;
+}
+async function endpointHealth(endpoint, fetchImpl) {
+    try {
+        const response = await fetchImpl(`${endpoint.base_url}${LOCAL_CONSOLE_API_BASE}/health`, {
+            signal: AbortSignal.timeout(1_000),
+        });
+        if (!response.ok) {
+            return { kind: "stale" };
+        }
+        const value = (await response.json());
+        if (value.status !== "ready") {
+            return { kind: "stale" };
+        }
+        if (endpoint.schema_version === 1) {
+            return { kind: "ready", identityVerified: false };
+        }
+        return {
+            kind: "ready",
+            identityVerified: value.instance_id === endpoint.instance_id && value.pid === endpoint.pid,
+        };
+    }
+    catch {
+        return { kind: "stale" };
+    }
+}
+function endpointMatchesCurrentRuntime(endpoint) {
+    return (endpoint.schema_version === 2 &&
+        endpoint.version === readCliVersion() &&
+        resolve(endpoint.entrypoint) === cliEntrypoint());
+}
+function spawnDetachedConsole(options) {
+    const logDescriptor = prepareConsoleLog(options.tuttiHome);
+    try {
+        const child = spawn(process.execPath, [...process.execArgv, cliEntrypoint(), "internal", "console-run"], {
+            cwd: options.cwd,
+            detached: true,
+            env: createLocalConsoleServiceEnvironment({
+                env: options.env,
+                tuttiHome: options.tuttiHome,
+            }),
+            stdio: ["ignore", logDescriptor, logDescriptor],
+        });
+        child.on("error", () => undefined);
+        child.unref();
+        return child;
+    }
+    finally {
+        closeSync(logDescriptor);
+    }
+}
+async function waitForConsoleEndpoint(options) {
+    const deadline = Date.now() + READY_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+        const endpoint = readLocalConsoleRuntimeEndpoint(options.tuttiHome);
+        if (endpoint?.schema_version === 2 && endpointMatchesCurrentRuntime(endpoint)) {
+            const health = await endpointHealth(endpoint, options.fetchImpl);
+            if (health.kind === "ready" && health.identityVerified) {
+                return endpoint;
+            }
+        }
+        await delay(READY_POLL_MS);
+    }
+    throw new Error(`Tutti service did not become ready. Inspect ${getLocalConsoleLogPath(options.tuttiHome)}.`);
+}
+async function waitForEndpointToStop(options) {
+    const deadline = Date.now() + STOP_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+        const current = readLocalConsoleRuntimeEndpoint(options.tuttiHome);
+        if (current === null || current.control_token !== options.endpoint.control_token) {
+            return true;
+        }
+        if ((await endpointHealth(options.endpoint, options.fetchImpl)).kind === "stale") {
+            deleteLocalConsoleRuntimeEndpoint({
+                tuttiHome: options.tuttiHome,
+                expectedControlToken: options.endpoint.control_token,
+            });
+            return true;
+        }
+        await delay(100);
+    }
+    return false;
+}
+async function authenticateLegacyEndpoint(options) {
+    try {
+        const response = await options.fetchImpl(`${options.endpoint.base_url}${LOCAL_CONSOLE_API_BASE}/access-tokens`, {
+            method: "POST",
+            headers: {
+                authorization: `Bearer ${options.endpoint.control_token}`,
+                "content-type": "application/json",
+            },
+            body: JSON.stringify({ current_directory: options.cwd }),
+            signal: AbortSignal.timeout(2_000),
+        });
+        return response.ok;
+    }
+    catch {
+        return false;
+    }
+}
+async function stopEndpoint(options) {
+    const health = await endpointHealth(options.endpoint, options.fetchImpl);
+    if (health.kind === "stale") {
+        deleteLocalConsoleRuntimeEndpoint({
+            tuttiHome: options.tuttiHome,
+            expectedControlToken: options.endpoint.control_token,
+        });
+        return;
+    }
+    if (options.endpoint.schema_version === 2 && !health.identityVerified) {
+        throw new Error("The running Tutti service identity does not match its endpoint record.");
+    }
+    let shutdownAccepted = false;
+    try {
+        const response = await options.fetchImpl(`${options.endpoint.base_url}${LOCAL_CONSOLE_API_BASE}/control/shutdown`, {
+            method: "POST",
+            headers: { authorization: `Bearer ${options.endpoint.control_token}` },
+            signal: AbortSignal.timeout(2_000),
+        });
+        shutdownAccepted = response.ok;
+    }
+    catch {
+        // A legacy service is handled by the authenticated SIGTERM fallback below.
+    }
+    if (!shutdownAccepted) {
+        const authenticated = await authenticateLegacyEndpoint(options);
+        if (!authenticated) {
+            throw new Error("The running Tutti service identity could not be verified.");
+        }
+        process.kill(options.endpoint.pid, "SIGTERM");
+    }
+    if (!(await waitForEndpointToStop(options))) {
+        throw new Error("The Tutti service did not stop before the shutdown timeout.");
+    }
+}
+async function ensureConsoleEndpointUnlocked(options) {
+    const existing = readLocalConsoleRuntimeEndpoint(options.tuttiHome);
+    if (existing !== null) {
+        const health = await endpointHealth(existing, options.fetchImpl);
+        if (health.kind === "ready" &&
+            (existing.schema_version === 1 || health.identityVerified) &&
+            endpointMatchesCurrentRuntime(existing)) {
+            return existing;
+        }
+        if (health.kind === "ready") {
+            await stopEndpoint({ ...options, endpoint: existing });
+        }
+        else {
+            deleteLocalConsoleRuntimeEndpoint({
+                tuttiHome: options.tuttiHome,
+                expectedControlToken: existing.control_token,
+            });
+        }
+    }
+    const child = spawnDetachedConsole(options);
+    try {
+        return await waitForConsoleEndpoint(options);
+    }
+    catch (error) {
+        if (child.pid !== undefined) {
+            try {
+                process.kill(child.pid, "SIGTERM");
+            }
+            catch {
+                // The process already exited.
+            }
+        }
+        throw error;
+    }
+}
+async function issueBrowserAccess(options) {
+    const context = createLocalConsoleInvocationContext({ cwd: options.cwd, env: options.env });
+    const response = await options.fetchImpl(`${options.endpoint.base_url}${LOCAL_CONSOLE_API_BASE}/access-tokens`, {
+        method: "POST",
+        headers: {
+            authorization: `Bearer ${options.endpoint.control_token}`,
+            accept: "application/json",
+            "content-type": "application/json",
+        },
+        body: JSON.stringify({
+            current_directory: context.currentDirectory,
+            environment: context.environment,
+        }),
+        signal: AbortSignal.timeout(3_000),
+    });
+    if (!response.ok) {
+        throw new Error("Tutti 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 returned an invalid browser access link.");
+    }
+    return `${options.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 fetchImpl = options.fetchImpl ?? fetch;
+    const tuttiHome = resolveTuttiHome(env.TUTTI_HOME, cwd);
+    const endpoint = await withLocalConsoleLifecycleLock({
+        tuttiHome,
+        run: async () => await ensureConsoleEndpointUnlocked({ cwd, env, tuttiHome, fetchImpl }),
+    });
+    return {
+        endpoint,
+        url: await issueBrowserAccess({ endpoint, cwd, env, fetchImpl }),
+    };
+}
+export async function readLocalConsoleServiceStatus(options = {}) {
+    const cwd = resolve(options.cwd ?? process.cwd());
+    const env = options.env ?? process.env;
+    const tuttiHome = resolveTuttiHome(env.TUTTI_HOME, cwd);
+    const logPath = getLocalConsoleLogPath(tuttiHome);
+    const endpoint = readLocalConsoleRuntimeEndpoint(tuttiHome);
+    if (endpoint === null) {
+        return { status: "stopped", log_path: logPath };
+    }
+    const health = await endpointHealth(endpoint, options.fetchImpl ?? fetch);
+    if (health.kind === "stale" || (endpoint.schema_version === 2 && !health.identityVerified)) {
+        return {
+            status: "stale",
+            pid: endpoint.pid,
+            base_url: endpoint.base_url,
+            started_at: endpoint.started_at,
+            log_path: logPath,
+        };
+    }
+    const currentVersion = readCliVersion();
+    return {
+        status: "running",
+        pid: endpoint.pid,
+        base_url: endpoint.base_url,
+        started_at: endpoint.started_at,
+        version: endpoint.schema_version === 2 ? endpoint.version : "unknown",
+        current_version: currentVersion,
+        update_required: !endpointMatchesCurrentRuntime(endpoint),
+        log_path: logPath,
+    };
+}
+export async function stopLocalConsoleService(options = {}) {
+    const cwd = resolve(options.cwd ?? process.cwd());
+    const env = options.env ?? process.env;
+    const fetchImpl = options.fetchImpl ?? fetch;
+    const tuttiHome = resolveTuttiHome(env.TUTTI_HOME, cwd);
+    return await withLocalConsoleLifecycleLock({
+        tuttiHome,
+        run: async () => {
+            const endpoint = readLocalConsoleRuntimeEndpoint(tuttiHome);
+            if (endpoint === null) {
+                return "already_stopped";
+            }
+            await stopEndpoint({ endpoint, tuttiHome, cwd, fetchImpl });
+            return "stopped";
+        },
+    });
+}
+export async function restartLocalConsoleService(options = {}) {
+    const cwd = resolve(options.cwd ?? process.cwd());
+    const env = options.env ?? process.env;
+    const fetchImpl = options.fetchImpl ?? fetch;
+    const tuttiHome = resolveTuttiHome(env.TUTTI_HOME, cwd);
+    return await withLocalConsoleLifecycleLock({
+        tuttiHome,
+        run: async () => {
+            const endpoint = readLocalConsoleRuntimeEndpoint(tuttiHome);
+            if (endpoint !== null) {
+                await stopEndpoint({ endpoint, tuttiHome, cwd, fetchImpl });
+            }
+            return await ensureConsoleEndpointUnlocked({ cwd, env, tuttiHome, fetchImpl });
+        },
+    });
+}
+//# sourceMappingURL=managed-console.js.map