@xfey/tutti 0.1.32 → 0.1.34

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

@@ -0,0 +1,61 @@
+import type { ProjectId } from "@tutti/shared/ids";
+import { type RuntimeProjectRow } from "../cli/runtime-commands.js";
+import { type LocalConsoleInvocationContext } from "./invocation-context.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;
+    activity_at?: string;
+    host_version?: string;
+    update_required?: boolean;
+};
+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: {
+        tuttiHome: string;
+        serviceEnvironment?: NodeJS.ProcessEnv;
+    });
+    listProjects(context: LocalConsoleInvocationContext): Promise<LocalConsoleProject[]>;
+    discoverModels(input: {
+        baseUrl: string;
+        apiKey: string;
+    }): Promise<{
+        kind: "ok";
+        models: string[];
+    } | {
+        kind: "unavailable";
+        reason: string;
+    }>;
+    launchProject(input: {
+        workspacePath: string;
+        provider?: LocalConsoleProviderInput;
+    }, context: LocalConsoleInvocationContext): Promise<LocalConsoleLaunchResult>;
+    refreshInvite(projectId: string, context: LocalConsoleInvocationContext): Promise<{
+        join_url: string;
+        expires_at?: string;
+    }>;
+    stopProject(projectId: string, context: LocalConsoleInvocationContext): Promise<{
+        message: string;
+    }>;
+}
+//# sourceMappingURL=project-service.d.ts.map

package/dist/server-shell/local-console/project-service.js

@@ -0,0 +1,262 @@
+import { existsSync, statSync } from "node:fs";
+import { resolve } from "node:path";
+import { configureProjectOpenAiProvider, discoverOpenAiModels, readOpenAiProviderConfigProjection, } from "../../providers/openai/index.js";
+import { formatCliErrorReason, LaunchError } from "../cli/errors.js";
+import { prepareLaunchProject } from "../cli/launch.js";
+import { rotateHostLocalInvite } from "../cli/local-control-client.js";
+import { readMachineProjectBinding, readMachineRuntimeEndpoint } from "../cli/machine-local.js";
+import { spawnDetachedHost, waitForManagedHostReady } from "../cli/managed-host.js";
+import { resolveManagedProjectContext } from "../cli/project-resolver.js";
+import { listRuntimeProjects, runStopCommand, } from "../cli/runtime-commands.js";
+import { readCliVersion } from "../cli/version.js";
+import { createLocalConsoleOperationEnvironment, } from "./invocation-context.js";
+export class LocalConsoleProjectError extends Error {
+    code;
+    statusCode;
+    constructor(code, message, statusCode = 422) {
+        super(message);
+        this.code = code;
+        this.statusCode = statusCode;
+        this.name = "LocalConsoleProjectError";
+    }
+}
+function validateWorkspacePath(value) {
+    const path = resolve(value.trim());
+    if (value.trim() === "" || !existsSync(path) || !statSync(path).isDirectory()) {
+        throw new LocalConsoleProjectError("project_folder_invalid", "Choose an existing project folder before launching.");
+    }
+    return path;
+}
+function validateProvider(input) {
+    const provider = {
+        base_url: input.base_url.trim(),
+        api_key: input.api_key.trim(),
+        model: input.model.trim(),
+    };
+    if (provider.base_url === "" || provider.api_key === "" || provider.model === "") {
+        throw new LocalConsoleProjectError("provider_configuration_required", "Base URL, API key, and model are required for a new Provider configuration.");
+    }
+    try {
+        const url = new URL(provider.base_url);
+        if (url.protocol !== "http:" && url.protocol !== "https:") {
+            throw new Error("unsupported protocol");
+        }
+    }
+    catch {
+        throw new LocalConsoleProjectError("provider_base_url_invalid", "Enter a valid HTTP or HTTPS Provider Base URL.");
+    }
+    return provider;
+}
+function projectFromRuntimeRow(row, providerStatus, activityAt) {
+    const currentVersion = readCliVersion();
+    return {
+        project_id: row.project_id,
+        display_name: row.display_name,
+        workspace_path: row.workspace_root,
+        status: row.status,
+        provider_status: providerStatus,
+        ...(row.relay_project_ref === undefined ? {} : { relay_project_ref: row.relay_project_ref }),
+        ...(row.join_url === undefined ? {} : { join_url: row.join_url }),
+        ...(row.relay_connection_status === undefined
+            ? {}
+            : { relay_connection_status: row.relay_connection_status }),
+        ...(activityAt === undefined ? {} : { activity_at: activityAt }),
+        ...(row.host_version === undefined ? {} : { host_version: row.host_version }),
+        ...(row.host_version === undefined || row.host_version === currentVersion
+            ? {}
+            : { update_required: true }),
+    };
+}
+function readProjectActivityAt(tuttiHome, row) {
+    if (row.last_connected_at !== undefined) {
+        return row.last_connected_at;
+    }
+    try {
+        const endpoint = readMachineRuntimeEndpoint(tuttiHome, row.project_id);
+        if (endpoint !== null) {
+            return endpoint.updated_at;
+        }
+    }
+    catch {
+        // Invalid endpoint state is already represented by the project status.
+    }
+    try {
+        return readMachineProjectBinding(tuttiHome, row.project_id)?.updated_at;
+    }
+    catch {
+        return undefined;
+    }
+}
+export class LocalConsoleProjectService {
+    #tuttiHome;
+    #serviceEnvironment;
+    #launches = new Map();
+    #mutationTail = Promise.resolve();
+    constructor(options) {
+        this.#tuttiHome = resolve(options.tuttiHome);
+        this.#serviceEnvironment = options.serviceEnvironment ?? process.env;
+    }
+    #operationOptions(context) {
+        return {
+            cwd: context.currentDirectory,
+            env: createLocalConsoleOperationEnvironment({
+                serviceEnvironment: this.#serviceEnvironment,
+                invocationEnvironment: context.environment,
+                tuttiHome: this.#tuttiHome,
+            }),
+        };
+    }
+    #runMutation(operation) {
+        const result = this.#mutationTail.then(operation, operation);
+        this.#mutationTail = result.then(() => undefined, () => undefined);
+        return result;
+    }
+    async listProjects(context) {
+        const operation = this.#operationOptions(context);
+        const rows = await listRuntimeProjects({
+            all: true,
+            ...operation,
+        });
+        return rows.map((row) => {
+            const provider = readOpenAiProviderConfigProjection({
+                tuttiHome: this.#tuttiHome,
+                projectId: row.project_id,
+            });
+            return projectFromRuntimeRow(row, provider.status, readProjectActivityAt(this.#tuttiHome, row));
+        });
+    }
+    async discoverModels(input) {
+        const provider = validateProvider({
+            base_url: input.baseUrl,
+            api_key: input.apiKey,
+            model: "model-discovery",
+        });
+        return await discoverOpenAiModels({
+            apiBaseUrl: provider.base_url,
+            apiKey: provider.api_key,
+        });
+    }
+    async launchProject(input, context) {
+        const workspacePath = validateWorkspacePath(input.workspacePath);
+        const active = this.#launches.get(workspacePath);
+        if (active !== undefined) {
+            return await active;
+        }
+        const launch = this.#runMutation(async () => await this.#launchProject({
+            workspacePath,
+            ...(input.provider === undefined ? {} : { provider: validateProvider(input.provider) }),
+        }, context)).finally(() => {
+            this.#launches.delete(workspacePath);
+        });
+        this.#launches.set(workspacePath, launch);
+        return await launch;
+    }
+    async #launchProject(input, context) {
+        const operation = this.#operationOptions(context);
+        let preparation;
+        try {
+            preparation = await prepareLaunchProject({
+                workspacePath: input.workspacePath,
+                yes: true,
+                ...operation,
+            });
+        }
+        catch (error) {
+            throw this.#normalizeError(error);
+        }
+        if (input.provider !== undefined) {
+            const configured = await configureProjectOpenAiProvider({
+                tuttiHome: preparation.tutti_home,
+                projectId: preparation.project_id,
+                apiBaseUrl: input.provider.base_url,
+                apiKey: input.provider.api_key,
+                defaultModel: input.provider.model,
+            });
+            if (configured.kind === "validation_failed") {
+                throw new LocalConsoleProjectError(configured.reason, "Provider validation failed. Check the Base URL, API key, and selected model.");
+            }
+        }
+        else if (preparation.provider_status !== "configured") {
+            throw new LocalConsoleProjectError("provider_configuration_required", "This project does not have a valid saved Provider. Configure it in the launch form.");
+        }
+        try {
+            spawnDetachedHost({
+                workspaceRoot: preparation.workspace_root,
+                env: operation.env,
+                inheritProcessEnv: false,
+            });
+            const ready = await waitForManagedHostReady({
+                tuttiHome: preparation.tutti_home,
+                projectId: preparation.project_id,
+                workspaceRoot: preparation.workspace_root,
+            });
+            if (ready.join_url === undefined) {
+                throw new LocalConsoleProjectError("relay_registration_failed", "The host started, but Relay did not return a visible join link.");
+            }
+            const projects = await this.listProjects(context);
+            const project = projects.find((item) => item.project_id === preparation.project_id);
+            if (project === undefined) {
+                throw new LocalConsoleProjectError("project_not_found", "The launched project could not be read from the machine project list.");
+            }
+            return {
+                project,
+                join_url: ready.join_url,
+                ...(ready.join_token_expires_at === undefined
+                    ? {}
+                    : { join_token_expires_at: ready.join_token_expires_at }),
+            };
+        }
+        catch (error) {
+            throw this.#normalizeError(error);
+        }
+    }
+    async refreshInvite(projectId, context) {
+        return await this.#runMutation(async () => {
+            const project = resolveManagedProjectContext({
+                target: projectId,
+                ...this.#operationOptions(context),
+            });
+            if (project.runtime_endpoint === null) {
+                throw new LocalConsoleProjectError("host_not_running", "Launch this project before creating an invite link.");
+            }
+            try {
+                const status = await rotateHostLocalInvite({ endpoint: project.runtime_endpoint });
+                const joinUrl = status.relay?.join_url;
+                if (joinUrl === undefined) {
+                    throw new LocalConsoleProjectError("relay_registration_failed", "Relay did not return a visible invite link.");
+                }
+                return {
+                    join_url: joinUrl,
+                    ...(status.relay?.join_token_expires_at === undefined
+                        ? {}
+                        : { expires_at: status.relay.join_token_expires_at }),
+                };
+            }
+            catch (error) {
+                throw this.#normalizeError(error);
+            }
+        });
+    }
+    async stopProject(projectId, context) {
+        return await this.#runMutation(async () => {
+            try {
+                return {
+                    message: await runStopCommand(projectId, this.#operationOptions(context)),
+                };
+            }
+            catch (error) {
+                throw this.#normalizeError(error);
+            }
+        });
+    }
+    #normalizeError(error) {
+        if (error instanceof LocalConsoleProjectError) {
+            return error;
+        }
+        if (error instanceof LaunchError) {
+            return new LocalConsoleProjectError(error.code, error.message);
+        }
+        return new LocalConsoleProjectError("local_console_failed", formatCliErrorReason(error), 500);
+    }
+}
+//# sourceMappingURL=project-service.js.map

package/dist/server-shell/local-console/runtime-endpoint.d.ts

@@ -0,0 +1,35 @@
+export type LocalConsoleRuntimeEndpoint = {
+    schema_version: 2;
+    instance_id: string;
+    pid: number;
+    base_url: string;
+    control_token: string;
+    version: string;
+    entrypoint: string;
+    started_at: string;
+};
+export type LegacyLocalConsoleRuntimeEndpoint = {
+    schema_version: 1;
+    pid: number;
+    base_url: string;
+    control_token: string;
+    started_at: string;
+};
+export type ReadableLocalConsoleRuntimeEndpoint = LocalConsoleRuntimeEndpoint | LegacyLocalConsoleRuntimeEndpoint;
+export declare function createLocalConsoleSecret(): string;
+export declare function readLocalConsoleRuntimeEndpoint(tuttiHome: string): ReadableLocalConsoleRuntimeEndpoint | null;
+export declare function writeLocalConsoleRuntimeEndpoint(options: {
+    tuttiHome: string;
+    instanceId: string;
+    pid: number;
+    baseUrl: string;
+    controlToken: string;
+    version: string;
+    entrypoint: string;
+    now?: () => Date;
+}): LocalConsoleRuntimeEndpoint;
+export declare function deleteLocalConsoleRuntimeEndpoint(options: {
+    tuttiHome: string;
+    expectedControlToken?: string;
+}): void;
+//# sourceMappingURL=runtime-endpoint.d.ts.map

package/dist/server-shell/local-console/runtime-endpoint.js

@@ -0,0 +1,90 @@
+import { randomBytes } from "node:crypto";
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync, } from "node:fs";
+import { dirname, join } from "node:path";
+function endpointPath(tuttiHome) {
+    return join(tuttiHome, "runtime", "local-console.json");
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasSharedEndpointFields(value) {
+    return (typeof value.pid === "number" &&
+        Number.isInteger(value.pid) &&
+        typeof value.base_url === "string" &&
+        /^http:\/\/127\.0\.0\.1:\d+$/u.test(value.base_url) &&
+        typeof value.control_token === "string" &&
+        value.control_token.length >= 32 &&
+        typeof value.started_at === "string");
+}
+function isEndpoint(value) {
+    if (!isRecord(value) || !hasSharedEndpointFields(value)) {
+        return false;
+    }
+    if (value.schema_version === 1) {
+        return true;
+    }
+    return (value.schema_version === 2 &&
+        typeof value.instance_id === "string" &&
+        value.instance_id.length >= 16 &&
+        typeof value.version === "string" &&
+        value.version.trim() !== "" &&
+        typeof value.entrypoint === "string" &&
+        value.entrypoint.trim() !== "");
+}
+export function createLocalConsoleSecret() {
+    return randomBytes(32).toString("base64url");
+}
+export function readLocalConsoleRuntimeEndpoint(tuttiHome) {
+    const path = endpointPath(tuttiHome);
+    if (!existsSync(path)) {
+        return null;
+    }
+    try {
+        const value = JSON.parse(readFileSync(path, "utf8"));
+        return isEndpoint(value) ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function writeLocalConsoleRuntimeEndpoint(options) {
+    const record = {
+        schema_version: 2,
+        instance_id: options.instanceId,
+        pid: options.pid,
+        base_url: options.baseUrl,
+        control_token: options.controlToken,
+        version: options.version,
+        entrypoint: options.entrypoint,
+        started_at: (options.now ?? (() => new Date()))().toISOString(),
+    };
+    if (!isEndpoint(record)) {
+        throw new Error("Local Console runtime endpoint is invalid.");
+    }
+    const path = endpointPath(options.tuttiHome);
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    chmodSync(dirname(path), 0o700);
+    const temporaryPath = `${path}.${process.pid}.tmp`;
+    writeFileSync(temporaryPath, `${JSON.stringify(record, null, 2)}\n`, {
+        encoding: "utf8",
+        mode: 0o600,
+    });
+    chmodSync(temporaryPath, 0o600);
+    renameSync(temporaryPath, path);
+    chmodSync(path, 0o600);
+    return record;
+}
+export function deleteLocalConsoleRuntimeEndpoint(options) {
+    const path = endpointPath(options.tuttiHome);
+    if (!existsSync(path)) {
+        return;
+    }
+    if (options.expectedControlToken !== undefined) {
+        const current = readLocalConsoleRuntimeEndpoint(options.tuttiHome);
+        if (current === null || current.control_token !== options.expectedControlToken) {
+            return;
+        }
+    }
+    unlinkSync(path);
+}
+//# sourceMappingURL=runtime-endpoint.js.map

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

@@ -0,0 +1,29 @@
+import { type FastifyInstance } from "fastify";
+export declare const LOCAL_CONSOLE_API_BASE = "/local-console/v1";
+type LocalConsoleRuntimeMetadata = {
+    instanceId: string;
+    version: string;
+    entrypoint: string;
+    startedAt: string;
+    pid: number;
+};
+type LocalConsoleServerOptions = {
+    controlToken: string;
+    cwd: string;
+    tuttiHome?: string;
+    env?: NodeJS.ProcessEnv;
+    now?: () => Date;
+    webStaticRoot?: string | false;
+    runtime?: LocalConsoleRuntimeMetadata;
+    onActivity?: () => void;
+    onShutdown?: () => void;
+};
+export declare function createLocalConsoleServer(options: LocalConsoleServerOptions): FastifyInstance;
+export declare function runLocalConsoleProcess(options?: {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    now?: () => Date;
+    idleTimeoutMs?: number;
+}): Promise<void>;
+export {};
+//# sourceMappingURL=server.d.ts.map