@xfey/tutti 0.1.0

package/dist/server-shell/dev-runner/config.js

@@ -0,0 +1,277 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { isAbsolute, join, relative, resolve } from "node:path";
+import { resolveTuttiHome } from "../../providers/openai/index.js";
+const DEFAULT_RELAY_HOST = "127.0.0.1";
+const DEFAULT_RELAY_PORT = 4370;
+const DEFAULT_HOST_ENDPOINT_HOST = "127.0.0.1";
+const DEFAULT_HOST_ENDPOINT_PORT = 4371;
+const DEFAULT_WEB_HOST = "127.0.0.1";
+const DEFAULT_WEB_PORT = 4372;
+const DEFAULT_DEV_R2_CONFIG_PATH = ".tutti-dev/secrets/r2.json";
+const DEV_PROCESS_SECRET_ENV_NAMES = new Set([
+    "OPENAI_API_KEY",
+    "TUTTI_API_KEY",
+    "TUTTI_BASE_URL",
+    "TUTTI_MODEL",
+]);
+const DEV_R2_ENV_NAMES = new Set([
+    "TUTTI_R2_ENDPOINT",
+    "TUTTI_R2_BUCKET",
+    "TUTTI_R2_ACCESS_KEY_ID",
+    "TUTTI_R2_SECRET_ACCESS_KEY",
+    "TUTTI_R2_REGION",
+    "TUTTI_R2_UPLOAD_TTL_SECONDS",
+    "TUTTI_R2_HOST_READ_TTL_SECONDS",
+    "TUTTI_DEV_R2_CONFIG_PATH",
+]);
+const DUMMY_PROJECT_README = "# Tutti Dev Target\n\nThis is the default target project for local Tutti development.\n";
+export class DevRunnerConfigError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "DevRunnerConfigError";
+    }
+}
+function readPort(name, value, fallback) {
+    if (value === undefined || value.trim() === "") {
+        return fallback;
+    }
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed <= 0 || parsed > 65535) {
+        throw new DevRunnerConfigError("invalid_port", `${name} must be an integer port`);
+    }
+    return parsed;
+}
+function resolvePath(input, cwd, userHome) {
+    const trimmed = input.trim();
+    if (trimmed === "~") {
+        return userHome;
+    }
+    if (trimmed.startsWith("~/")) {
+        return join(userHome, trimmed.slice(2));
+    }
+    return isAbsolute(trimmed) ? resolve(trimmed) : resolve(cwd, trimmed);
+}
+function isInsideOrEqual(parent, child) {
+    const parentPath = resolve(parent);
+    const childPath = resolve(child);
+    const pathRelativeToParent = relative(parentPath, childPath);
+    return (pathRelativeToParent === "" ||
+        (!pathRelativeToParent.startsWith("..") && !isAbsolute(pathRelativeToParent)));
+}
+function readOptionalString(value) {
+    return typeof value === "string" && value.trim() !== "" ? value.trim() : undefined;
+}
+function readRecordString(record, keys) {
+    for (const key of keys) {
+        const value = readOptionalString(record[key]);
+        if (value !== undefined) {
+            return value;
+        }
+    }
+    return undefined;
+}
+function readOptionalPositiveInteger(value, label) {
+    const raw = typeof value === "number"
+        ? value
+        : typeof value === "string" && value.trim() !== ""
+            ? Number(value)
+            : undefined;
+    if (raw === undefined) {
+        return undefined;
+    }
+    if (!Number.isInteger(raw) || raw <= 0) {
+        throw new DevRunnerConfigError("invalid_r2_config", `${label} must be a positive integer`);
+    }
+    return raw;
+}
+function normalizeR2Endpoint(endpoint, bucket) {
+    const url = new URL(endpoint);
+    url.search = "";
+    url.hash = "";
+    const segments = url.pathname.split("/").filter((segment) => segment.length > 0);
+    if (segments.length === 1 && segments[0] === bucket) {
+        url.pathname = "/";
+    }
+    else {
+        url.pathname = url.pathname.replace(/\/+$/u, "");
+    }
+    return url.toString().replace(/\/$/u, "");
+}
+function completeR2Config(input) {
+    if (input.endpoint === undefined ||
+        input.bucket === undefined ||
+        input.accessKeyId === undefined ||
+        input.secretAccessKey === undefined) {
+        throw new DevRunnerConfigError("invalid_r2_config", `${input.sourceLabel} must provide endpoint, bucket, access key id, and secret access key`);
+    }
+    return {
+        endpoint: normalizeR2Endpoint(input.endpoint, input.bucket),
+        bucket: input.bucket,
+        accessKeyId: input.accessKeyId,
+        secretAccessKey: input.secretAccessKey,
+        ...(input.region === undefined ? {} : { region: input.region }),
+        ...(input.uploadTtlSeconds === undefined ? {} : { uploadTtlSeconds: input.uploadTtlSeconds }),
+        ...(input.hostReadTtlSeconds === undefined
+            ? {}
+            : { hostReadTtlSeconds: input.hostReadTtlSeconds }),
+    };
+}
+function resolveR2ConfigFromEnv(env) {
+    const endpoint = readOptionalString(env.TUTTI_R2_ENDPOINT);
+    const bucket = readOptionalString(env.TUTTI_R2_BUCKET);
+    const accessKeyId = readOptionalString(env.TUTTI_R2_ACCESS_KEY_ID);
+    const secretAccessKey = readOptionalString(env.TUTTI_R2_SECRET_ACCESS_KEY);
+    const hasAnyR2Env = endpoint !== undefined ||
+        bucket !== undefined ||
+        accessKeyId !== undefined ||
+        secretAccessKey !== undefined;
+    if (!hasAnyR2Env) {
+        return undefined;
+    }
+    return completeR2Config({
+        endpoint,
+        bucket,
+        accessKeyId,
+        secretAccessKey,
+        region: readOptionalString(env.TUTTI_R2_REGION),
+        uploadTtlSeconds: readOptionalPositiveInteger(env.TUTTI_R2_UPLOAD_TTL_SECONDS, "TUTTI_R2_UPLOAD_TTL_SECONDS"),
+        hostReadTtlSeconds: readOptionalPositiveInteger(env.TUTTI_R2_HOST_READ_TTL_SECONDS, "TUTTI_R2_HOST_READ_TTL_SECONDS"),
+        sourceLabel: "TUTTI_R2_*",
+    });
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function resolveR2ConfigFromFile(configPath) {
+    if (!existsSync(configPath)) {
+        return undefined;
+    }
+    const parsed = JSON.parse(readFileSync(configPath, "utf8"));
+    if (!isRecord(parsed)) {
+        throw new DevRunnerConfigError("invalid_r2_config", "R2 config file must contain a JSON object");
+    }
+    return completeR2Config({
+        endpoint: readRecordString(parsed, ["endpoint", "TUTTI_R2_ENDPOINT", "S3 API"]),
+        bucket: readRecordString(parsed, ["bucket", "bucketName", "TUTTI_R2_BUCKET", "bucket name"]),
+        accessKeyId: readRecordString(parsed, [
+            "accessKeyId",
+            "access_key_id",
+            "TUTTI_R2_ACCESS_KEY_ID",
+            "S3 credential AK ID",
+        ]),
+        secretAccessKey: readRecordString(parsed, [
+            "secretAccessKey",
+            "secret_access_key",
+            "TUTTI_R2_SECRET_ACCESS_KEY",
+            "S3 credential SK",
+        ]),
+        region: readRecordString(parsed, ["region", "TUTTI_R2_REGION"]),
+        uploadTtlSeconds: readOptionalPositiveInteger(parsed.uploadTtlSeconds ?? parsed.TUTTI_R2_UPLOAD_TTL_SECONDS, "R2 upload TTL"),
+        hostReadTtlSeconds: readOptionalPositiveInteger(parsed.hostReadTtlSeconds ?? parsed.TUTTI_R2_HOST_READ_TTL_SECONDS, "R2 host read TTL"),
+        sourceLabel: configPath,
+    });
+}
+function resolveDevR2Config(env, repoRoot, userHome) {
+    const envConfig = resolveR2ConfigFromEnv(env);
+    if (envConfig !== undefined) {
+        return envConfig;
+    }
+    const configPath = resolvePath(env.TUTTI_DEV_R2_CONFIG_PATH ?? DEFAULT_DEV_R2_CONFIG_PATH, repoRoot, userHome);
+    return resolveR2ConfigFromFile(configPath);
+}
+export function resolveDevRunnerConfig(options = {}) {
+    const env = options.env ?? process.env;
+    const repoRoot = resolve(options.repoRoot ?? process.cwd());
+    const userHome = options.userHome ?? homedir();
+    const relayHost = env.TUTTI_RELAY_HOST ?? DEFAULT_RELAY_HOST;
+    const relayPort = readPort("TUTTI_RELAY_PORT", env.TUTTI_RELAY_PORT, DEFAULT_RELAY_PORT);
+    const hostEndpointHost = env.TUTTI_HOST_ENDPOINT_HOST ?? DEFAULT_HOST_ENDPOINT_HOST;
+    const hostEndpointPort = readPort("TUTTI_HOST_ENDPOINT_PORT", env.TUTTI_HOST_ENDPOINT_PORT, DEFAULT_HOST_ENDPOINT_PORT);
+    const webHost = env.TUTTI_WEB_HOST ?? DEFAULT_WEB_HOST;
+    const webPort = readPort("TUTTI_WEB_PORT", env.TUTTI_WEB_PORT, DEFAULT_WEB_PORT);
+    const tuttiHome = resolveTuttiHome(env.TUTTI_HOME ?? ".tutti-dev/home", repoRoot);
+    const overrideTarget = env.TUTTI_DEV_WORKSPACE_ROOT;
+    const targetWorkspaceRoot = overrideTarget === undefined || overrideTarget.trim() === ""
+        ? resolvePath("~/.tutti-dev/workspaces/tutti-default", repoRoot, userHome)
+        : resolvePath(overrideTarget, repoRoot, userHome);
+    const r2 = resolveDevR2Config(env, repoRoot, userHome);
+    if (isInsideOrEqual(repoRoot, targetWorkspaceRoot)) {
+        throw new DevRunnerConfigError("target_inside_repo", "TUTTI_DEV_WORKSPACE_ROOT must point outside the Tutti source repository");
+    }
+    return {
+        repoRoot,
+        tuttiHome,
+        targetWorkspaceRoot,
+        targetSource: overrideTarget === undefined || overrideTarget.trim() === ""
+            ? "default_dummy"
+            : "env_override",
+        ...(r2 === undefined ? {} : { r2 }),
+        relayUrl: env.TUTTI_RELAY_URL ?? `http://${relayHost}:${relayPort}`,
+        relayHost,
+        relayPort,
+        hostEndpointHost,
+        hostEndpointPort,
+        webHost,
+        webPort,
+        webUrl: `http://${webHost}:${webPort}`,
+    };
+}
+export function ensureDevRunnerState(config) {
+    mkdirSync(config.tuttiHome, { recursive: true, mode: 0o700 });
+    mkdirSync(join(config.tuttiHome, "projects"), { recursive: true, mode: 0o700 });
+    if (config.targetSource !== "default_dummy") {
+        return;
+    }
+    mkdirSync(config.targetWorkspaceRoot, { recursive: true });
+    if (readdirSync(config.targetWorkspaceRoot).length === 0) {
+        writeFileSync(join(config.targetWorkspaceRoot, "README.md"), DUMMY_PROJECT_README, "utf8");
+    }
+}
+export function createDevProcessEnv(config, sourceEnv = process.env) {
+    const inheritedEnv = { ...sourceEnv };
+    for (const name of DEV_PROCESS_SECRET_ENV_NAMES) {
+        delete inheritedEnv[name];
+    }
+    for (const name of DEV_R2_ENV_NAMES) {
+        delete inheritedEnv[name];
+    }
+    return {
+        ...inheritedEnv,
+        TUTTI_HOME: config.tuttiHome,
+        TUTTI_RELAY_METADATA_DB_PATH: join(config.tuttiHome, "relay", "relay.sqlite"),
+        TUTTI_RELAY_URL: config.relayUrl,
+        TUTTI_RELAY_HOST: config.relayHost,
+        TUTTI_RELAY_PORT: String(config.relayPort),
+        TUTTI_HOST_ENDPOINT_HOST: config.hostEndpointHost,
+        TUTTI_HOST_ENDPOINT_PORT: String(config.hostEndpointPort),
+        TUTTI_WEB_HOST: config.webHost,
+        TUTTI_WEB_PORT: String(config.webPort),
+        TUTTI_WEB_URL: config.webUrl,
+        VITE_TUTTI_RELAY_URL: config.relayUrl,
+        TUTTI_DEV_WORKSPACE_ROOT: config.targetWorkspaceRoot,
+    };
+}
+export function createDevRelayProcessEnv(config, sourceEnv = process.env) {
+    const env = createDevProcessEnv(config, sourceEnv);
+    if (config.r2 === undefined) {
+        return env;
+    }
+    return {
+        ...env,
+        TUTTI_R2_ENDPOINT: config.r2.endpoint,
+        TUTTI_R2_BUCKET: config.r2.bucket,
+        TUTTI_R2_ACCESS_KEY_ID: config.r2.accessKeyId,
+        TUTTI_R2_SECRET_ACCESS_KEY: config.r2.secretAccessKey,
+        ...(config.r2.region === undefined ? {} : { TUTTI_R2_REGION: config.r2.region }),
+        ...(config.r2.uploadTtlSeconds === undefined
+            ? {}
+            : { TUTTI_R2_UPLOAD_TTL_SECONDS: String(config.r2.uploadTtlSeconds) }),
+        ...(config.r2.hostReadTtlSeconds === undefined
+            ? {}
+            : { TUTTI_R2_HOST_READ_TTL_SECONDS: String(config.r2.hostReadTtlSeconds) }),
+    };
+}
+//# sourceMappingURL=config.js.map

package/dist/server-shell/dev-runner/host-cli.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=host-cli.d.ts.map

package/dist/server-shell/dev-runner/host-cli.js

@@ -0,0 +1,22 @@
+import { redactError } from "@tutti/shared/utils";
+import { formatLaunchError, LaunchError } from "../cli/errors.js";
+import { formatLaunchLifecycleResult, startLaunchProject, waitForForegroundHostShutdown, } from "../cli/host-lifecycle.js";
+import { createDevProcessEnv, ensureDevRunnerState, resolveDevRunnerConfig, } from "./config.js";
+try {
+    const config = resolveDevRunnerConfig();
+    ensureDevRunnerState(config);
+    const result = await startLaunchProject({
+        workspacePath: config.targetWorkspaceRoot,
+        yes: true,
+        env: createDevProcessEnv(config),
+    });
+    process.stdout.write(`${formatLaunchLifecycleResult(result)}\n`);
+    if (result.kind === "hosting") {
+        await waitForForegroundHostShutdown(result.host);
+    }
+}
+catch (error) {
+    console.error(error instanceof LaunchError ? formatLaunchError(error) : redactError(error));
+    process.exitCode = 1;
+}
+//# sourceMappingURL=host-cli.js.map

package/dist/server-shell/dev-runner/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./config.js";
+export * from "./runner.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/server-shell/dev-runner/index.js

@@ -0,0 +1,3 @@
+export * from "./config.js";
+export * from "./runner.js";
+//# sourceMappingURL=index.js.map

package/dist/server-shell/dev-runner/runner.d.ts

@@ -0,0 +1,30 @@
+export type DevProcessName = "relay" | "host" | "web";
+export type DevProcessSpec = {
+    name: DevProcessName;
+    args: string[];
+};
+export type DevRunnerOptions = {
+    fetch?: typeof fetch;
+    relayHealthTimeoutMs?: number;
+    hostJoinUrlTimeoutMs?: number;
+};
+export declare function createDevProcessSpecs(): {
+    relay: DevProcessSpec;
+    host: DevProcessSpec;
+    web: DevProcessSpec;
+};
+export declare function extractLaunchSetupUrl(line: string): string | null;
+export declare function formatLaunchSetupUrlLine(line: string, setupUrlBase: string): string | null;
+export declare function formatDevProcessOutputLine(name: DevProcessName, line: string, options?: {
+    setupUrlBase?: string;
+}): string | undefined;
+export declare function waitForRelayHealth(options: {
+    relayUrl: string;
+    fetchImpl?: typeof fetch;
+    timeoutMs?: number;
+    intervalMs?: number;
+}): Promise<void>;
+export declare function extractLaunchJoinUrl(line: string): string | null;
+export declare function isLaunchJoinUrlLine(line: string): boolean;
+export declare function runDevRunner(options?: DevRunnerOptions): Promise<void>;
+//# sourceMappingURL=runner.d.ts.map

package/dist/server-shell/dev-runner/runner.js

@@ -0,0 +1,236 @@
+import { spawn } from "node:child_process";
+import { once } from "node:events";
+import { redactText } from "@tutti/shared/utils";
+import { createDevProcessEnv, createDevRelayProcessEnv, ensureDevRunnerState, resolveDevRunnerConfig, } from "./config.js";
+const DEFAULT_RELAY_HEALTH_TIMEOUT_MS = 15_000;
+const DEFAULT_HOST_JOIN_URL_TIMEOUT_MS = 60_000;
+const PROCESS_KILLED_EXIT_CODE = 143;
+export function createDevProcessSpecs() {
+    return {
+        relay: { name: "relay", args: ["run", "dev:relay"] },
+        host: { name: "host", args: ["run", "dev", "--workspace", "@tutti/server"] },
+        web: { name: "web", args: ["run", "dev:web"] },
+    };
+}
+function linesFromChunk(buffer, chunk) {
+    const combined = `${buffer}${chunk.toString("utf8")}`;
+    const parts = combined.split(/\r?\n/u);
+    const remainder = parts.pop() ?? "";
+    return { lines: parts, remainder };
+}
+export function extractLaunchSetupUrl(line) {
+    return /^Setup URL:\s+(https?:\/\/\S+)/u.exec(line.trim())?.[1] ?? null;
+}
+function rewriteUrlOrigin(url, baseUrl) {
+    const rewritten = new URL(url);
+    const base = new URL(baseUrl);
+    rewritten.protocol = base.protocol;
+    rewritten.host = base.host;
+    return rewritten.toString();
+}
+export function formatLaunchSetupUrlLine(line, setupUrlBase) {
+    const setupUrl = extractLaunchSetupUrl(line);
+    if (setupUrl === null) {
+        return null;
+    }
+    return `Setup URL: ${rewriteUrlOrigin(setupUrl, setupUrlBase)}`;
+}
+export function formatDevProcessOutputLine(name, line, options = {}) {
+    if (line.length === 0) {
+        return undefined;
+    }
+    const setupLine = name === "host" && options.setupUrlBase !== undefined
+        ? formatLaunchSetupUrlLine(line, options.setupUrlBase)
+        : null;
+    const outputLine = setupLine ?? (name === "host" && isLaunchJoinUrlLine(line) ? line : redactText(line));
+    return `[${name}] ${outputLine}`;
+}
+function prefixLine(name, line, config) {
+    const formatted = formatDevProcessOutputLine(name, line, { setupUrlBase: config.webUrl });
+    if (formatted === undefined) {
+        return;
+    }
+    process.stdout.write(`${formatted}\n`);
+}
+function pipePrefixedOutput(child, name, config, onLine) {
+    for (const stream of [child.stdout, child.stderr]) {
+        let buffer = "";
+        stream.on("data", (chunk) => {
+            const parsed = linesFromChunk(buffer, chunk);
+            buffer = parsed.remainder;
+            for (const line of parsed.lines) {
+                prefixLine(name, line, config);
+                onLine?.(line);
+            }
+        });
+        stream.on("end", () => {
+            if (buffer.length > 0) {
+                prefixLine(name, buffer, config);
+                onLine?.(buffer);
+                buffer = "";
+            }
+        });
+    }
+}
+function spawnDevProcess(spec, config, env, onLine) {
+    const child = spawn("npm", spec.args, {
+        cwd: config.repoRoot,
+        env,
+        stdio: ["pipe", "pipe", "pipe"],
+    });
+    child.stdin.end();
+    pipePrefixedOutput(child, spec.name, config, onLine);
+    return { spec, child };
+}
+function stopChildren(children) {
+    for (const child of children) {
+        if (child.exitCode === null && child.signalCode === null) {
+            child.kill("SIGTERM");
+        }
+    }
+}
+async function waitForExit(processInfo) {
+    if (processInfo.child.exitCode !== null || processInfo.child.signalCode !== null) {
+        return {
+            spec: processInfo.spec,
+            code: processInfo.child.exitCode,
+            signal: processInfo.child.signalCode,
+        };
+    }
+    const [code, signal] = (await once(processInfo.child, "exit"));
+    return { spec: processInfo.spec, code, signal };
+}
+async function waitForReadyOrExit(processInfo, ready) {
+    let isReady = false;
+    const exit = waitForExit(processInfo).then((result) => {
+        if (isReady) {
+            return new Promise(() => { });
+        }
+        throw new Error(`${result.spec.name} dev process exited before it was ready with ${result.code ?? result.signal}`);
+    });
+    const readyTracked = ready.then((result) => {
+        isReady = true;
+        return result;
+    });
+    try {
+        return await Promise.race([readyTracked, exit]);
+    }
+    finally {
+        isReady = true;
+    }
+}
+function delay(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+export async function waitForRelayHealth(options) {
+    const fetchImpl = options.fetchImpl ?? fetch;
+    const timeoutMs = options.timeoutMs ?? DEFAULT_RELAY_HEALTH_TIMEOUT_MS;
+    const intervalMs = options.intervalMs ?? 100;
+    const deadline = Date.now() + timeoutMs;
+    const healthUrl = new URL("/health", options.relayUrl);
+    let lastReason = "Relay health endpoint did not respond";
+    while (Date.now() < deadline) {
+        try {
+            const response = await fetchImpl(healthUrl, {
+                headers: { accept: "application/json" },
+            });
+            if (response.ok) {
+                return;
+            }
+            lastReason = `Relay health returned HTTP ${response.status}`;
+        }
+        catch (error) {
+            lastReason = error instanceof Error ? error.message : "Relay health check failed";
+        }
+        await delay(intervalMs);
+    }
+    throw new Error(`Relay did not become ready before timeout: ${lastReason}`);
+}
+export function extractLaunchJoinUrl(line) {
+    return /^Join URL:\s+(https?:\/\/\S+)/u.exec(line.trim())?.[1] ?? null;
+}
+export function isLaunchJoinUrlLine(line) {
+    return extractLaunchJoinUrl(line) !== null;
+}
+function waitForLaunchJoinUrl(timeoutMs) {
+    let timeout;
+    let resolveLine;
+    const promise = new Promise((resolve, reject) => {
+        resolveLine = resolve;
+        timeout = setTimeout(() => {
+            reject(new Error("Host launch did not print a join URL before timeout"));
+        }, timeoutMs);
+    });
+    return {
+        onLine: (line) => {
+            if (!isLaunchJoinUrlLine(line)) {
+                return;
+            }
+            clearTimeout(timeout);
+            resolveLine(line);
+        },
+        promise: promise.catch((error) => {
+            clearTimeout(timeout);
+            throw error;
+        }),
+    };
+}
+function printDevRunnerHeader(config) {
+    process.stdout.write(`Tutti dev runner\n`);
+    process.stdout.write(`Relay: ${config.relayUrl}\n`);
+    process.stdout.write(`Host: http://${config.hostEndpointHost}:${config.hostEndpointPort}\n`);
+    process.stdout.write(`Web: http://${config.webHost}:${config.webPort}\n`);
+    process.stdout.write(`Upload staging: ${config.r2 === undefined ? "not configured" : "configured"}\n`);
+    process.stdout.write(`Target: ${redactText(config.targetWorkspaceRoot)}\n`);
+}
+export async function runDevRunner(options = {}) {
+    const config = resolveDevRunnerConfig();
+    ensureDevRunnerState(config);
+    const env = createDevProcessEnv(config);
+    const relayEnv = createDevRelayProcessEnv(config);
+    const specs = createDevProcessSpecs();
+    const processes = [];
+    let stopping = false;
+    printDevRunnerHeader(config);
+    const stop = () => {
+        stopping = true;
+        stopChildren(processes.map((processInfo) => processInfo.child));
+    };
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+    try {
+        const relay = spawnDevProcess(specs.relay, config, relayEnv);
+        processes.push(relay);
+        const relayHealthOptions = {
+            relayUrl: config.relayUrl,
+        };
+        if (options.fetch !== undefined) {
+            relayHealthOptions.fetchImpl = options.fetch;
+        }
+        if (options.relayHealthTimeoutMs !== undefined) {
+            relayHealthOptions.timeoutMs = options.relayHealthTimeoutMs;
+        }
+        await waitForReadyOrExit(relay, waitForRelayHealth(relayHealthOptions));
+        const joinUrlWaiter = waitForLaunchJoinUrl(options.hostJoinUrlTimeoutMs ?? DEFAULT_HOST_JOIN_URL_TIMEOUT_MS);
+        const host = spawnDevProcess(specs.host, config, env, joinUrlWaiter.onLine);
+        processes.push(host);
+        await waitForReadyOrExit(host, joinUrlWaiter.promise);
+        const web = spawnDevProcess(specs.web, config, env);
+        processes.push(web);
+        const firstExit = await Promise.race(processes.map(waitForExit));
+        stopChildren(processes.map((processInfo) => processInfo.child));
+        if (stopping || firstExit.code === PROCESS_KILLED_EXIT_CODE || firstExit.signal === "SIGTERM") {
+            return;
+        }
+        if (firstExit.code !== 0) {
+            throw new Error(`${firstExit.spec.name} dev process exited with ${firstExit.code ?? firstExit.signal}`);
+        }
+    }
+    finally {
+        process.off("SIGINT", stop);
+        process.off("SIGTERM", stop);
+    }
+}
+//# sourceMappingURL=runner.js.map

package/dist/server-shell/http/create-server.d.ts

@@ -0,0 +1,18 @@
+import type { FastifyInstance } from "fastify";
+import { type HostLocalControlOptions } from "./routes/local-control.js";
+import { type HostProjectApiRouteOptions } from "./routes/project-api.js";
+import { AgentContextTokenRegistry } from "./routes/agent-context.js";
+import { type HostWebStaticOptions } from "./static-web.js";
+export type HostServerOptions = {
+    agentContext?: false | {
+        tokenRegistry?: AgentContextTokenRegistry;
+    };
+    logger?: false;
+    localControl?: HostLocalControlOptions;
+    now?: () => Date;
+    projectApi?: false | HostProjectApiRouteOptions;
+    serviceVersion?: string;
+    webStatic?: false | HostWebStaticOptions;
+};
+export declare function createHostServer(options?: HostServerOptions): FastifyInstance;
+//# sourceMappingURL=create-server.d.ts.map

package/dist/server-shell/http/create-server.js

@@ -0,0 +1,51 @@
+import fastify from "fastify";
+import { createRedactedLoggerOptions } from "./logger.js";
+import { registerHostHealthRoute } from "./routes/health.js";
+import { registerHostLocalControlRoutes, } from "./routes/local-control.js";
+import { registerHostProjectApiRoutes, } from "./routes/project-api.js";
+import { AgentContextTokenRegistry, registerAgentContextRoutes, } from "./routes/agent-context.js";
+import { registerHostWebStaticRoutes } from "./static-web.js";
+import { registerApiErrorHandler } from "./validation.js";
+export function createHostServer(options = {}) {
+    const app = options.logger === false
+        ? fastify({ logger: false })
+        : fastify({ logger: createRedactedLoggerOptions("tutti-host") });
+    registerApiErrorHandler(app);
+    registerHostHealthRoute(app, {
+        now: options.now ?? (() => new Date()),
+        serviceVersion: options.serviceVersion ?? "0.0.0",
+    });
+    if (options.localControl !== undefined) {
+        registerHostLocalControlRoutes(app, options.localControl);
+    }
+    if (options.projectApi !== undefined && options.projectApi !== false) {
+        const projectApiOptions = options.projectApi;
+        registerHostProjectApiRoutes(app, projectApiOptions);
+        app.addHook("onClose", (_instance, done) => {
+            projectApiOptions.controlPlane?.dispose();
+            done();
+        });
+        if (options.agentContext !== false) {
+            registerAgentContextRoutes(app, {
+                project: projectApiOptions.project,
+                ...(projectApiOptions.store === undefined ? {} : { store: projectApiOptions.store }),
+                ...(projectApiOptions.workspaceOps === undefined
+                    ? {}
+                    : { workspaceOps: projectApiOptions.workspaceOps }),
+                ...(projectApiOptions.tuttiHome === undefined
+                    ? {}
+                    : { tuttiHome: projectApiOptions.tuttiHome }),
+                ...(options.now === undefined ? {} : { now: options.now }),
+                tokenRegistry: options.agentContext?.tokenRegistry ??
+                    new AgentContextTokenRegistry({
+                        ...(options.now === undefined ? {} : { now: options.now }),
+                    }),
+            });
+        }
+    }
+    if (options.webStatic !== undefined && options.webStatic !== false) {
+        registerHostWebStaticRoutes(app, options.webStatic);
+    }
+    return app;
+}
+//# sourceMappingURL=create-server.js.map

package/dist/server-shell/http/host-tunnel.d.ts

@@ -0,0 +1,15 @@
+import type { FastifyInstance } from "fastify";
+import type { RelayHostTunnelRequestHandler, RelayHostTunnelStreamRequestHandler } from "@tutti/relay-client";
+import { type TrustedRelaySessionMetadataStore } from "../session/relay-session-context.js";
+export type HostProjectApiTunnelDispatchOptions = {
+    app: FastifyInstance;
+    trustedMetadataStore: TrustedRelaySessionMetadataStore;
+};
+export type HostProjectApiTunnelStreamDispatchOptions = {
+    baseUrl: string;
+    trustedMetadataStore: TrustedRelaySessionMetadataStore;
+    fetch?: typeof fetch;
+};
+export declare function createHostProjectApiTunnelRequestHandler(options: HostProjectApiTunnelDispatchOptions): RelayHostTunnelRequestHandler;
+export declare function createHostProjectApiTunnelStreamRequestHandler(options: HostProjectApiTunnelStreamDispatchOptions): RelayHostTunnelStreamRequestHandler;
+//# sourceMappingURL=host-tunnel.d.ts.map