@xfey/tutti 0.1.0

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

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+import { createInterface } from "node:readline/promises";
+import { formatLaunchError } from "./errors.js";
+import { formatLaunchLifecycleResult, startLaunchProject, waitForForegroundHostShutdown, } from "./host-lifecycle.js";
+import { parseLaunchCliArgs } from "./args.js";
+const HELP_TEXT = `Usage:
+  tutti launch [workspace_path] [--yes]
+
+Options:
+  --yes        Accept non-interactive launch confirmations.
+  -h, --help   Show this help message.
+`;
+function isHelpRequest(argv) {
+    return (argv.length === 0 ||
+        argv.includes("--help") ||
+        argv.includes("-h") ||
+        (argv[0] === "launch" && (argv[1] === "--help" || argv[1] === "-h")));
+}
+async function confirmFromTty(request) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        return false;
+    }
+    const readline = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    try {
+        const answer = await readline.question(`${request.message}\n\nContinue? [y/N] `);
+        return /^(y|yes)$/iu.test(answer.trim());
+    }
+    finally {
+        readline.close();
+    }
+}
+try {
+    const argv = process.argv.slice(2);
+    if (isHelpRequest(argv)) {
+        process.stdout.write(HELP_TEXT);
+    }
+    else {
+        const args = parseLaunchCliArgs(argv);
+        const result = await startLaunchProject({
+            workspacePath: args.workspacePath,
+            yes: args.yes,
+            confirm: confirmFromTty,
+        });
+        process.stdout.write(`${formatLaunchLifecycleResult(result)}\n`);
+        if (result.kind === "hosting") {
+            await waitForForegroundHostShutdown(result.host);
+        }
+    }
+}
+catch (error) {
+    console.error(formatLaunchError(error));
+    process.exitCode = 1;
+}
+//# sourceMappingURL=cli.js.map

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

@@ -0,0 +1,9 @@
+export type LaunchErrorCode = "unsafe_project_root" | "unsupported_tutti_schema" | "project_identity_conflict" | "git_bootstrap_failed" | "sensitive_file_detected" | "relay_unavailable" | "relay_registration_failed" | "provider_configuration_required" | "provider_validation_failed" | "store_migration_failed" | "existing_server_unhealthy" | "takeover_rejected" | "takeover_failed" | "port_unavailable";
+export declare class LaunchError extends Error {
+    readonly code: LaunchErrorCode;
+    readonly next: string;
+    readonly details: Record<string, unknown>;
+    constructor(code: LaunchErrorCode, message: string, next: string, details?: Record<string, unknown>);
+}
+export declare function formatLaunchError(error: unknown): string;
+//# sourceMappingURL=errors.d.ts.map

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

@@ -0,0 +1,53 @@
+import { redactError, redactText } from "@tutti/shared/utils";
+export class LaunchError extends Error {
+    code;
+    next;
+    details;
+    constructor(code, message, next, details = {}) {
+        super(message);
+        this.code = code;
+        this.next = next;
+        this.details = details;
+        this.name = "LaunchError";
+    }
+}
+export function formatLaunchError(error) {
+    if (error instanceof LaunchError) {
+        const lines = [
+            "Tutti launch failed",
+            "",
+            `Code: ${error.code}`,
+            `Reason: ${redactText(error.message)}`,
+        ];
+        const detailLines = Object.entries(error.details)
+            .filter(([, value]) => value !== undefined)
+            .map(([key, value]) => `Detail ${key}: ${redactText(formatDetailValue(value))}`);
+        if (detailLines.length > 0) {
+            lines.push(...detailLines);
+        }
+        lines.push(`Next: ${redactText(error.next)}`);
+        return lines.join("\n");
+    }
+    const redactedError = redactError(error);
+    const reason = typeof redactedError === "string" ? redactedError : JSON.stringify(redactedError);
+    return [
+        "Tutti launch failed",
+        "",
+        "Code: internal_error",
+        `Reason: ${reason ?? "Unknown error"}`,
+        "Next: Retry after checking the local debug logs.",
+    ].join("\n");
+}
+function formatDetailValue(value) {
+    if (Array.isArray(value)) {
+        return value.map((entry) => formatDetailValue(entry)).join(", ");
+    }
+    if (value === null) {
+        return "null";
+    }
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        return String(value);
+    }
+    return JSON.stringify(value) ?? "undefined";
+}
+//# sourceMappingURL=errors.js.map

package/dist/server-shell/cli/git-bootstrap.d.ts

@@ -0,0 +1,24 @@
+import type { ProjectId } from "@tutti/shared/ids";
+export declare const TUTTI_MAINLINE_BRANCH: "tutti/mainline";
+export type LaunchConfirmationKind = "non_git_non_empty" | "nested_git_repository" | "uncommitted_changes" | "takeover_existing_server";
+export type LaunchConfirmationRequest = {
+    kind: LaunchConfirmationKind;
+    message: string;
+};
+export type LaunchConfirmationHandler = (request: LaunchConfirmationRequest) => boolean | Promise<boolean>;
+export type GitBootstrapOptions = {
+    workspaceRoot: string;
+    projectId: ProjectId;
+    assumeYes?: boolean;
+    confirm?: LaunchConfirmationHandler;
+    prepareBootstrapFiles?: () => void;
+};
+export type GitBootstrapResult = {
+    branch: typeof TUTTI_MAINLINE_BRANCH;
+    initialized_git: boolean;
+    bootstrap_commit_created: boolean;
+};
+export declare function assertSafeProjectRoot(workspaceRoot: string): void;
+export declare function listSensitiveBootstrapCandidates(workspaceRoot: string): string[];
+export declare function ensureGitBootstrap(options: GitBootstrapOptions): Promise<GitBootstrapResult>;
+//# sourceMappingURL=git-bootstrap.d.ts.map

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

@@ -0,0 +1,246 @@
+import { spawnSync } from "node:child_process";
+import { accessSync, constants, existsSync, readdirSync, statSync, writeFileSync, } from "node:fs";
+import { homedir } from "node:os";
+import { basename, join, parse, relative, resolve } from "node:path";
+import { LaunchError } from "./errors.js";
+export const TUTTI_MAINLINE_BRANCH = "tutti/mainline";
+const MINIMAL_GITIGNORE = [
+    ".env",
+    ".env.*",
+    "*.pem",
+    "*.key",
+    ".DS_Store",
+    "node_modules/",
+    "dist/",
+    "build/",
+    "coverage/",
+    ".next/",
+    ".turbo/",
+    ".tutti-dev/",
+    "",
+].join("\n");
+const SENSITIVE_FILE_PATTERNS = [
+    /^\.env(?:\.|$)/u,
+    /^id_rsa$/u,
+    /^id_dsa$/u,
+    /^id_ecdsa$/u,
+    /^id_ed25519$/u,
+    /\.pem$/iu,
+    /\.key$/iu,
+];
+const WALK_SKIP_DIRECTORY_NAMES = new Set([
+    ".git",
+    "node_modules",
+    "dist",
+    "build",
+    "coverage",
+    ".next",
+    ".turbo",
+]);
+const BOOTSTRAP_INFRASTRUCTURE_FILENAMES = new Set([".gitignore"]);
+function runGitRaw(args, cwd) {
+    const result = spawnSync("git", [...args], {
+        cwd,
+        encoding: "utf8",
+        shell: false,
+    });
+    return {
+        status: result.status,
+        stdout: result.stdout ?? "",
+        stderr: result.stderr ?? "",
+        ...(result.error === undefined ? {} : { error: result.error }),
+    };
+}
+function summarizeGitFailure(args, result) {
+    const stderr = result.stderr.trim();
+    if (stderr.length > 0) {
+        return stderr;
+    }
+    if (result.error !== undefined) {
+        return result.error.message;
+    }
+    return `git ${args.join(" ")} failed`;
+}
+function runGit(args, cwd) {
+    const result = runGitRaw(args, cwd);
+    if (result.status !== 0) {
+        throw new LaunchError("git_bootstrap_failed", summarizeGitFailure(args, result), "Resolve the Git error and run `tutti launch` again.");
+    }
+    return result.stdout.trim();
+}
+function tryGit(args, cwd) {
+    return runGitRaw(args, cwd);
+}
+function directoryEntries(workspaceRoot) {
+    return readdirSync(workspaceRoot, { withFileTypes: true }).filter((entry) => entry.name !== ".");
+}
+function isDirectoryEmpty(workspaceRoot) {
+    return directoryEntries(workspaceRoot).every((entry) => BOOTSTRAP_INFRASTRUCTURE_FILENAMES.has(entry.name));
+}
+function hasRootGitDirectory(workspaceRoot) {
+    return existsSync(join(workspaceRoot, ".git"));
+}
+function readGitTopLevel(workspaceRoot) {
+    const result = tryGit(["rev-parse", "--show-toplevel"], workspaceRoot);
+    if (result.status !== 0) {
+        return null;
+    }
+    return resolve(result.stdout.trim());
+}
+function hasHead(workspaceRoot) {
+    return tryGit(["rev-parse", "--verify", "HEAD"], workspaceRoot).status === 0;
+}
+function hasBranch(workspaceRoot, branch) {
+    return (tryGit(["show-ref", "--verify", "--quiet", `refs/heads/${branch}`], workspaceRoot).status === 0);
+}
+function hasUncommittedChanges(workspaceRoot) {
+    return runGit(["status", "--porcelain"], workspaceRoot).length > 0;
+}
+export function assertSafeProjectRoot(workspaceRoot) {
+    const resolvedRoot = resolve(workspaceRoot);
+    if (!existsSync(resolvedRoot) || !statSync(resolvedRoot).isDirectory()) {
+        throw new LaunchError("unsafe_project_root", "Workspace path must be an existing writable directory", "Create or choose a project directory before running `tutti launch`.");
+    }
+    try {
+        accessSync(resolvedRoot, constants.W_OK);
+    }
+    catch {
+        throw new LaunchError("unsafe_project_root", "Workspace path must be an existing writable directory", "Choose a writable project directory before running `tutti launch`.");
+    }
+    const filesystemRoot = parse(resolvedRoot).root;
+    const userHome = homedir();
+    const blockedExactRoots = new Set([
+        filesystemRoot,
+        userHome,
+        join(userHome, "Desktop"),
+        "/System",
+        "/Library",
+        "/Applications",
+        "/bin",
+        "/sbin",
+        "/usr",
+        "/etc",
+    ]);
+    if (blockedExactRoots.has(resolvedRoot)) {
+        throw new LaunchError("unsafe_project_root", "Workspace path is too broad to be treated as a Tutti project root", "Choose a dedicated project directory.");
+    }
+}
+async function requireConfirmation(request, options) {
+    if (options.assumeYes === true) {
+        return;
+    }
+    const accepted = (await options.confirm?.(request)) ?? false;
+    if (!accepted) {
+        throw new LaunchError("git_bootstrap_failed", "Git bootstrap requires confirmation", "Re-run with `--yes` or confirm the bootstrap prompt in an interactive terminal.");
+    }
+}
+function switchToTuttiMainline(workspaceRoot) {
+    if (hasBranch(workspaceRoot, TUTTI_MAINLINE_BRANCH)) {
+        runGit(["switch", TUTTI_MAINLINE_BRANCH], workspaceRoot);
+        return;
+    }
+    if (hasHead(workspaceRoot)) {
+        runGit(["switch", "-c", TUTTI_MAINLINE_BRANCH], workspaceRoot);
+        return;
+    }
+    runGit(["switch", "-c", TUTTI_MAINLINE_BRANCH], workspaceRoot);
+}
+function ensureMinimalGitignore(workspaceRoot) {
+    const gitignorePath = join(workspaceRoot, ".gitignore");
+    if (existsSync(gitignorePath)) {
+        return;
+    }
+    writeFileSync(gitignorePath, MINIMAL_GITIGNORE, { encoding: "utf8", mode: 0o644 });
+}
+function isSensitiveFilename(filename) {
+    return SENSITIVE_FILE_PATTERNS.some((pattern) => pattern.test(filename));
+}
+function walkFiles(root, current, output) {
+    for (const entry of readdirSync(current, { withFileTypes: true })) {
+        const fullPath = join(current, entry.name);
+        if (entry.isDirectory()) {
+            if (!WALK_SKIP_DIRECTORY_NAMES.has(entry.name)) {
+                walkFiles(root, fullPath, output);
+            }
+            continue;
+        }
+        if (entry.isFile()) {
+            output.push(relative(root, fullPath));
+        }
+    }
+}
+function isGitIgnored(workspaceRoot, relativePath) {
+    return tryGit(["check-ignore", "-q", "--", relativePath], workspaceRoot).status === 0;
+}
+export function listSensitiveBootstrapCandidates(workspaceRoot) {
+    const files = [];
+    walkFiles(workspaceRoot, workspaceRoot, files);
+    return files
+        .filter((file) => isSensitiveFilename(basename(file)))
+        .filter((file) => !isGitIgnored(workspaceRoot, file))
+        .sort();
+}
+function commitBootstrapIfNeeded(workspaceRoot, projectId) {
+    if (!hasUncommittedChanges(workspaceRoot)) {
+        return false;
+    }
+    runGit(["add", "--all"], workspaceRoot);
+    runGit([
+        "-c",
+        "user.name=Tutti",
+        "-c",
+        "user.email=tutti@example.invalid",
+        "commit",
+        "-m",
+        `Tutti: initialize project\n\nProject: ${projectId}\nBranch: ${TUTTI_MAINLINE_BRANCH}`,
+    ], workspaceRoot);
+    return true;
+}
+async function ensureGitRepository(options) {
+    const workspaceRoot = resolve(options.workspaceRoot);
+    const gitTopLevel = readGitTopLevel(workspaceRoot);
+    const rootHasGitDirectory = hasRootGitDirectory(workspaceRoot);
+    if (gitTopLevel === null) {
+        if (!isDirectoryEmpty(workspaceRoot)) {
+            await requireConfirmation({
+                kind: "non_git_non_empty",
+                message: "This directory is not a Git repo. Tutti will initialize Git here and create an initial baseline commit.",
+            }, options);
+        }
+        runGit(["init", "-b", TUTTI_MAINLINE_BRANCH], workspaceRoot);
+        return true;
+    }
+    if (!rootHasGitDirectory && gitTopLevel !== workspaceRoot) {
+        await requireConfirmation({
+            kind: "nested_git_repository",
+            message: "This directory appears to be inside another Git repository. Tutti will initialize a nested Git repository here.",
+        }, options);
+        runGit(["init", "-b", TUTTI_MAINLINE_BRANCH], workspaceRoot);
+        return true;
+    }
+    if (hasUncommittedChanges(workspaceRoot)) {
+        await requireConfirmation({
+            kind: "uncommitted_changes",
+            message: "Current repository has uncommitted changes. Tutti can commit the current working tree as the initial Tutti baseline.",
+        }, options);
+    }
+    switchToTuttiMainline(workspaceRoot);
+    return false;
+}
+export async function ensureGitBootstrap(options) {
+    const workspaceRoot = resolve(options.workspaceRoot);
+    assertSafeProjectRoot(workspaceRoot);
+    const initializedGit = await ensureGitRepository({ ...options, workspaceRoot });
+    ensureMinimalGitignore(workspaceRoot);
+    const sensitiveCandidates = listSensitiveBootstrapCandidates(workspaceRoot);
+    if (sensitiveCandidates.length > 0) {
+        throw new LaunchError("sensitive_file_detected", `Sensitive-like file would enter bootstrap commit: ${sensitiveCandidates[0]}`, "Move or ignore sensitive files before launching. `--yes` cannot bypass this check.");
+    }
+    options.prepareBootstrapFiles?.();
+    return {
+        branch: TUTTI_MAINLINE_BRANCH,
+        initialized_git: initializedGit,
+        bootstrap_commit_created: commitBootstrapIfNeeded(workspaceRoot, options.projectId),
+    };
+}
+//# sourceMappingURL=git-bootstrap.js.map

package/dist/server-shell/cli/host-lifecycle.d.ts

@@ -0,0 +1,45 @@
+import type { ProjectId } from "@tutti/shared/ids";
+import { TUTTI_MAINLINE_BRANCH } from "./git-bootstrap.js";
+import { type FetchLike, type HostRuntimeEndpointProbe } from "./host-runtime-endpoint.js";
+import { type HostServerFactory, type HostServerHandle } from "./host-server-runtime.js";
+import { type MachineRuntimeEndpointRecord } from "./machine-local.js";
+import { type LaunchPreparationOptions, type LaunchPreparationResult, type LaunchProviderStatus } from "./launch.js";
+import { type HostLaunchRelaySummary, type RelayHostConnectionRegistrar, type RelayHostTunnelConnector } from "./relay-registration.js";
+export type { HostLaunchRelaySummary, RelayHostConnectionRegistrar, RelayHostTunnelConnector, } from "./relay-registration.js";
+export { createRuntimeEndpointProbe } from "./host-runtime-endpoint.js";
+export type { HostRuntimeEndpointProbe, HostRuntimeEndpointProbeResult, } from "./host-runtime-endpoint.js";
+export type { HostServerHandle } from "./host-server-runtime.js";
+export type HostRuntimeStatus = "created" | "connected" | "recovered" | "taken_over";
+export type HostRuntimeSummary = {
+    status: HostRuntimeStatus;
+    workspace_root: string;
+    project_id: ProjectId;
+    branch: typeof TUTTI_MAINLINE_BRANCH;
+    relay_url: string;
+    local_diagnostic_endpoint: string;
+    provider_status?: LaunchProviderStatus;
+    setup_url?: string;
+    runtime_endpoint?: Omit<MachineRuntimeEndpointRecord, "token">;
+    relay?: HostLaunchRelaySummary;
+};
+export type StartLaunchProjectResult = {
+    kind: "connected";
+    summary: HostRuntimeSummary;
+} | {
+    kind: "hosting";
+    preparation: LaunchPreparationResult;
+    host: HostServerHandle;
+    summary: HostRuntimeSummary;
+};
+export type StartLaunchProjectOptions = LaunchPreparationOptions & {
+    createServer?: HostServerFactory;
+    fetch?: FetchLike;
+    connectRelayHostTunnel?: RelayHostTunnelConnector;
+    probeRuntimeEndpoint?: HostRuntimeEndpointProbe;
+    registerRelayHostConnection?: RelayHostConnectionRegistrar;
+    shutdownWaitMs?: number;
+};
+export declare function startLaunchProject(options: StartLaunchProjectOptions): Promise<StartLaunchProjectResult>;
+export declare function formatLaunchLifecycleResult(result: StartLaunchProjectResult): string;
+export declare function waitForForegroundHostShutdown(handle: HostServerHandle, processLike?: NodeJS.Process): Promise<void>;
+//# sourceMappingURL=host-lifecycle.d.ts.map