@tdk-landscape/tdk-cli-core 1.3.104 → 1.3.106

package/cli/dist/commands/up.js

@@ -3,20 +3,25 @@ import { join } from "node:path";
 import chalk from "chalk";
 import { Command } from "commander";
 import { ensureProjectRuntimeAssets } from "../generator/template-engine.js";
+import { DEVCONTAINER_DOCKER_FIX, detectHost, isContainerHost, WEBCONTAINER_UP_MESSAGE, } from "../utils/agent-host.js";
 import { handleDryRun } from "../utils/command-helpers.js";
+import { getDeferredResourceNames } from "../utils/doctor-runtime.js";
 import { completeEnvFile } from "../utils/env-validator.js";
 import { errorFactories, handleTiltFailure, requireProjectRoot, runCommand, showErrorAndExit, withTiltCheck, } from "../utils/errors.js";
 import { formatCount } from "../utils/formatting.js";
 import { exportHostPortPlan, getHostPortPlan, writeSavedHostPortPlan, } from "../utils/host-port-config.js";
 import { formatHostPortPlan } from "../utils/host-port-plan.js";
+import { createJsonEmitter } from "../utils/json-output.js";
 import { findProjectRoot } from "../utils/paths.js";
 import { findAvailablePort } from "../utils/port-assignment.js";
 import { isApiServiceType } from "../utils/resource-kind.js";
 import { appendHealthPath, resolveSubdomainBases } from "../utils/service-urls.js";
-import { discoverResources, discoverStacks, getResourcesForStack, stackExists, } from "../utils/services.js";
+import { discoverResources, discoverResourcesStrict, discoverStacks, stackExists, } from "../utils/services.js";
 import { buildSmokePlans, formatSmokeFailure, runSmokePlans } from "../utils/smoke.js";
 import { buildTiltUpArgs, runTilt } from "../utils/tilt.js";
 import { stopTiltOnPort } from "../utils/tilt-process.js";
+import { findUnknownServices, resolveOnlySelection } from "../utils/up-only.js";
+import { tiltGetUiResources, waitForTiltResourcesReady } from "../utils/up-readiness.js";
 import { enableDiscoveredStacks } from "./project.js";
 export function formatUpSuccess(port, appUrls = []) {
     return [
@@ -34,6 +39,20 @@ export function nativeWindowsUpRefusal(platform, allowNativeWindows) {
         return null;
     return "Landscape startup needs Ubuntu on WSL2. Native Windows is inspect-only.";
 }
+/** Why `tdk up` cannot work on this host, or null when it may proceed. Docker reachability is only probed in container hosts. */
+export async function hostUpRefusal(host = detectHost(), dockerReachable = defaultDockerReachable) {
+    if (host.kind === "webcontainer")
+        return WEBCONTAINER_UP_MESSAGE;
+    if (isContainerHost(host.kind) && !(await dockerReachable()))
+        return DEVCONTAINER_DOCKER_FIX;
+    return null;
+}
+async function defaultDockerReachable() {
+    const { execFile } = await import("node:child_process");
+    return new Promise((resolve) => {
+        execFile("docker", ["ps"], { timeout: 10_000 }, (error) => resolve(!error));
+    });
+}
 function waitForTiltUi(port, timeoutMs = 30_000) {
     return new Promise((resolve) => {
         const deadline = Date.now() + timeoutMs;
@@ -64,7 +83,17 @@ export const upCommand = new Command("up")
     .option("-q, --quiet", "Suppress non-essential output", false)
     .option("--dry-run", "Show what would be started without starting", false)
     .option("-f, --force", "Kill existing Tilt process before starting", false)
+    .option("--only <services...>", "Start only these services plus what the Tiltfile enables for them (their dependsOn services and shared infrastructure). With a stack, names must belong to that stack; dependencies may cross stacks")
+    .option("--json", "Print one JSON object on stdout when the stack is ready or the command fails; implies --quiet", false)
     .action(async (stackName, options) => {
+    const emit = options.json ? createJsonEmitter("UP_FAILED", "tdk up") : undefined;
+    if (options.json)
+        options.quiet = true;
+    const hostRefusal = options.dryRun ? null : await hostUpRefusal();
+    if (hostRefusal) {
+        emit?.({ ok: false }, [{ code: "HOST_UNSUPPORTED", message: hostRefusal }]);
+        showErrorAndExit(hostRefusal);
+    }
     const platformRefusal = nativeWindowsUpRefusal(process.platform, process.env.TDK_ALLOW_NATIVE_WINDOWS);
     if (platformRefusal)
         showErrorAndExit(platformRefusal);
@@ -76,6 +105,21 @@ export const upCommand = new Command("up")
         const projectRoot = options.dryRun
             ? requireProjectRoot()
             : (findProjectRoot() ?? process.cwd());
+        const discoveredResources = discoverResourcesStrict();
+        // Reject a bad request before anything below can write to the project (.env, runtime assets, .tdk/project.json).
+        if (options.only) {
+            if (stackName && !stackExists(stackName))
+                errorFactories.stackNotFound(stackName).exit();
+            const candidates = stackName
+                ? discoveredResources.filter((resource) => resource.stack === stackName)
+                : discoveredResources;
+            const unknown = findUnknownServices(options.only, candidates);
+            if (unknown.length > 0) {
+                const message = `Unknown service ${unknown.join(", ")}. Valid names: ${candidates.map((s) => s.name).join(", ")}`;
+                emit?.({ ok: false }, [{ code: "UNKNOWN_SERVICE", message }]);
+                showErrorAndExit(message, 2);
+            }
+        }
         const hostPortPlan = await getHostPortPlan(projectRoot, {
             inspectDocker: !options.dryRun,
         });
@@ -101,18 +145,27 @@ export const upCommand = new Command("up")
         let stackDescription;
         let focusServiceNames = [];
         if (stackName) {
-            if (!stackExists(stackName)) {
+            servicesToStart = discoveredResources.filter((resource) => resource.stack === stackName);
+            if (servicesToStart.length === 0) {
                 errorFactories.stackNotFound(stackName).exit();
             }
-            servicesToStart = getResourcesForStack(stackName);
             focusServiceNames = servicesToStart.map((s) => s.name);
             stackDescription = `stack "${stackName}"`;
         }
         else {
-            servicesToStart = discoverResources();
-            const allStacks = discoverStacks();
+            servicesToStart = discoveredResources;
+            const allStacks = discoverStacks(discoveredResources);
             stackDescription = `all stacks (${formatCount(allStacks.length, "stack")}, ${formatCount(servicesToStart.length, "service")})`;
         }
+        let dependencyNames = [];
+        if (options.only) {
+            // Dependencies come from the whole project, not just the named stack: dependsOn may cross stacks.
+            const selection = resolveOnlySelection(options.only, discoverResources());
+            servicesToStart = selection.selected;
+            dependencyNames = selection.dependencies;
+            focusServiceNames = servicesToStart.map((s) => s.name);
+            stackDescription = `${formatCount(options.only.length, "requested service")}${dependencyNames.length > 0 ? ` plus ${dependencyNames.join(", ")}` : ""}`;
+        }
         if (options.verbose && !options.quiet) {
             console.log(chalk.gray(`Found ${formatCount(servicesToStart.length, "service")} in ${stackDescription}`));
         }
@@ -145,13 +198,31 @@ export const upCommand = new Command("up")
                 });
             }
         }
-        const dryRunCommand = stackName
-            ? `tilt up -- --focus=${stackName} ${focusServiceNames.join(" ")}`
-            : "tilt up";
+        const focusTargets = options.only ?? (stackName ? [stackName] : undefined);
+        const tiltArgs = buildTiltUpArgs(focusServiceNames, {
+            verbose: options.verbose,
+            quiet: options.quiet,
+            force: options.force,
+            focusTargets,
+        });
+        const dryRunCommand = focusTargets ? `tilt up ${tiltArgs.join(" ")}` : "tilt up";
         if (!options.quiet) {
             console.log(chalk.blue(formatHostPortPlan(hostPortPlan)));
             console.log(chalk.gray("Override with TDK_HTTP_PORT, TDK_HTTPS_PORT, or TDK_POSTGRES_PORT."));
         }
+        if (emit && options.dryRun) {
+            emit({
+                ok: true,
+                dryRun: true,
+                stack: stackName ?? null,
+                services: serviceNames,
+                ...(options.only
+                    ? { requested: options.only, declaredDependencies: dependencyNames }
+                    : {}),
+                command: dryRunCommand,
+            });
+            return;
+        }
         if (handleDryRun(options, "not starting services", dryRunCommand)) {
             return;
         }
@@ -159,6 +230,27 @@ export const upCommand = new Command("up")
         writeSavedHostPortPlan(projectRoot, hostPortPlan);
         const basePort = 10350;
         let port = basePort;
+        // A second Tilt would apply a different selection to the same containers, whatever port it listens on, so `--only`
+        // looks for a Tilt that answers on the default port and on TILT_PORT before it chooses one. A listener that is not
+        // Tilt does not count: the port is then picked below as usual.
+        if (options.only) {
+            const envPort = process.env.TILT_PORT ? Number.parseInt(process.env.TILT_PORT, 10) : NaN;
+            const candidatePorts = [
+                ...new Set([basePort, ...(Number.isInteger(envPort) ? [envPort] : [])]),
+            ];
+            const running = [];
+            for (const candidate of candidatePorts) {
+                if ((await tiltGetUiResources(candidate)) !== null)
+                    running.push(candidate);
+            }
+            if (running.length > 0 && !options.force) {
+                const message = `A Tilt is already running on port ${running.join(", ")}. --only cannot change a running stack's services: run \`tdk down\` first, or pass --force to replace it.`;
+                emit?.({ ok: false }, [{ code: "TILT_ALREADY_RUNNING", message }]);
+                showErrorAndExit(message);
+            }
+            for (const runningPort of running)
+                stopTiltOnPort(runningPort);
+        }
         if (process.env.TILT_PORT) {
             port = parseInt(process.env.TILT_PORT, 10);
         }
@@ -180,18 +272,12 @@ export const upCommand = new Command("up")
             stopTiltOnPort(port);
             await new Promise((resolve) => setTimeout(resolve, 2000));
         }
-        const tiltArgs = buildTiltUpArgs(focusServiceNames, {
-            verbose: options.verbose,
-            quiet: options.quiet,
-            force: options.force,
-            focusTargets: stackName ? [stackName] : undefined,
-        });
         if (!options.quiet) {
             console.log(chalk.gray("\nRunning tilt up..."));
             console.log(chalk.gray(`Using Tiltfile: .tdk/.tdk-out/Tiltfile`));
         }
         const tiltRun = runTilt("up", tiltArgs, {
-            verbose: options.verbose,
+            verbose: options.verbose && !options.json,
             quiet: options.quiet,
             inheritStdio: !options.quiet, // Suppress tilt output in quiet mode
         });
@@ -202,12 +288,45 @@ export const upCommand = new Command("up")
         let printedSuccess = false;
         const successOutput = (async () => {
             const uiReady = await waitForTiltUi(port);
+            // JSON consumers get success only after every non-deferred resource is built and running, not when the UI port opens.
+            let jsonReady = false;
+            let startedServices = serviceNames;
+            let startedDependencies = dependencyNames;
+            if (uiReady && emit) {
+                const deferred = getDeferredResourceNames();
+                const readiness = await waitForTiltResourcesReady(port, {
+                    deferred,
+                    // Only what the caller named must be enabled. Dependencies are the Tiltfile's call (it skips some on purpose).
+                    expected: options.only
+                        ? options.only.filter((name) => !deferred.has(name))
+                        : undefined,
+                });
+                if (readiness.ready) {
+                    jsonReady = true;
+                    if (options.only) {
+                        // Report what Tilt actually enabled, not the service.json closure, which can differ from the Tiltfile's expansion.
+                        const enabled = new Set(readiness.enabled);
+                        const allNames = discoverResources().map((r) => r.name);
+                        startedServices = allNames.filter((name) => enabled.has(name));
+                        startedDependencies = startedServices.filter((name) => !options.only.includes(name));
+                    }
+                }
+                else {
+                    const detail = readiness.failures.map((f) => `${f.name}: ${f.message}`).join("; ");
+                    emit({ ok: false, tiltUrl: `http://localhost:${port}`, failures: readiness.failures }, [
+                        {
+                            code: readiness.timedOut ? "UP_TIMEOUT" : "UP_RESOURCE_FAILED",
+                            message: `${readiness.timedOut ? "Timed out waiting for resources" : "Resources failed"}${detail ? ` (${detail})` : ""}. Tilt is still running; inspect it or run: tdk down`,
+                        },
+                    ]);
+                }
+            }
             if (uiReady && !options.quiet) {
                 for (const line of formatUpSuccess(port))
                     console.log(chalk.blue(line));
                 printedSuccess = true;
             }
-            if (uiReady && smokePlans.length > 0) {
+            if (uiReady && smokePlans.length > 0 && (!emit || jsonReady)) {
                 if (!options.quiet) {
                     console.log(chalk.gray(`Smoke check: ${smokePlans.map((p) => p.name).join(", ")}`));
                 }
@@ -224,8 +343,21 @@ export const upCommand = new Command("up")
                         console.error(chalk.red(formatSmokeFailure(smokeResult)));
                     }
                 }
-                if (smokeFailed)
+                if (smokeFailed) {
                     stopTiltOnPort(port);
+                    emit?.({ ok: false }, [
+                        { code: "UP_SMOKE_FAILED", message: "A smoke check failed; Tilt was stopped" },
+                    ]);
+                }
+            }
+            if (uiReady && jsonReady && !smokeFailed) {
+                emit?.({
+                    ok: true,
+                    stack: stackName ?? null,
+                    services: startedServices,
+                    ...(options.only ? { requested: options.only, dependencies: startedDependencies } : {}),
+                    tiltUrl: `http://localhost:${port}`,
+                });
             }
         })();
         const result = await tiltRun;

package/cli/dist/mcp/server.js

@@ -0,0 +1,100 @@
+/**
+ * A minimal Model Context Protocol server over newline-delimited JSON-RPC 2.0 (the stdio transport). It implements only
+ * what a tools-only server needs: initialize, ping, tools/list and tools/call. Keeping it dependency-free keeps the
+ * published CLI small; the protocol surface used here is stable across the listed protocol versions.
+ */
+export const SUPPORTED_PROTOCOL_VERSIONS = ["2025-06-18", "2025-03-26", "2024-11-05"];
+const ERROR = {
+    parse: -32700,
+    invalidRequest: -32600,
+    methodNotFound: -32601,
+    invalidParams: -32602,
+};
+function reply(id, result) {
+    return JSON.stringify({ jsonrpc: "2.0", id, result });
+}
+function fail(id, code, message) {
+    return JSON.stringify({ jsonrpc: "2.0", id: id ?? null, error: { code, message } });
+}
+export function createMcpServer(tools, info) {
+    const byName = new Map(tools.map((tool) => [tool.name, tool]));
+    async function handle(message) {
+        const isNotification = message.id === undefined;
+        if (message.jsonrpc !== "2.0" || typeof message.method !== "string") {
+            return isNotification ? null : fail(message.id, ERROR.invalidRequest, "Invalid request");
+        }
+        switch (message.method) {
+            case "initialize": {
+                const requested = String(message.params?.protocolVersion ?? "");
+                const protocolVersion = SUPPORTED_PROTOCOL_VERSIONS.includes(requested)
+                    ? requested
+                    : SUPPORTED_PROTOCOL_VERSIONS[0];
+                return reply(message.id, {
+                    protocolVersion,
+                    capabilities: { tools: { listChanged: false } },
+                    serverInfo: info,
+                });
+            }
+            case "ping":
+                return reply(message.id, {});
+            case "tools/list":
+                return reply(message.id, {
+                    tools: tools.map(({ name, description, inputSchema }) => ({
+                        name,
+                        description,
+                        inputSchema,
+                    })),
+                });
+            case "tools/call": {
+                const name = message.params?.name;
+                const tool = typeof name === "string" ? byName.get(name) : undefined;
+                if (!tool)
+                    return fail(message.id, ERROR.invalidParams, `Unknown tool: ${String(name)}`);
+                const args = message.params?.arguments;
+                if (args !== undefined &&
+                    (typeof args !== "object" || args === null || Array.isArray(args))) {
+                    return fail(message.id, ERROR.invalidParams, "arguments must be an object");
+                }
+                try {
+                    const result = await tool.handler((args ?? {}));
+                    return reply(message.id, {
+                        content: [{ type: "text", text: JSON.stringify(result.data) }],
+                        structuredContent: result.data,
+                        isError: result.isError,
+                    });
+                }
+                catch (error) {
+                    // A tool failure is a tool result, not a protocol error, so the model can read and react to it.
+                    const text = error instanceof Error ? error.message : String(error);
+                    return reply(message.id, {
+                        content: [{ type: "text", text }],
+                        isError: true,
+                    });
+                }
+            }
+            default:
+                // Notifications such as notifications/initialized need no reply; unknown requests do.
+                return isNotification
+                    ? null
+                    : fail(message.id, ERROR.methodNotFound, `Method not found: ${message.method}`);
+        }
+    }
+    return {
+        async handleLine(line) {
+            if (!line.trim())
+                return null;
+            let parsed;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch {
+                return fail(null, ERROR.parse, "Parse error");
+            }
+            if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+                return fail(null, ERROR.invalidRequest, "Invalid request");
+            }
+            return handle(parsed);
+        },
+    };
+}
+//# sourceMappingURL=server.js.map

package/cli/dist/mcp/tools.js

@@ -0,0 +1,273 @@
+import { spawn } from "node:child_process";
+import { closeSync, existsSync, openSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+/** A service or stack name. A leading "-" is rejected so a value can never be read as a flag. */
+const NAME = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+const SINCE = /^(\d+(\.\d+)?(ns|us|µs|ms|s|m|h))+$/;
+/**
+ * How to run this CLI again: `node <script>` / `bun <script>` when started from a script, or the executable alone when it is
+ * a `bun build --compile` binary, whose argv[1] is a virtual path that exists only inside the binary.
+ */
+export function cliInvocation(execPath = process.execPath, script = process.argv[1], fileExists = existsSync) {
+    if (!script || script.startsWith("/$bunfs/") || script.includes("~BUN") || !fileExists(script)) {
+        return [execPath];
+    }
+    return [execPath, script];
+}
+/** Runs this same CLI (`tdk <args>`) so every tool behaves exactly like its command. */
+export const runTdkCli = (args, options = {}) => new Promise((resolve, reject) => {
+    const [command, ...prefix] = cliInvocation();
+    const child = spawn(command, [...prefix, ...args], {
+        stdio: ["ignore", "pipe", "pipe"],
+        env: { ...process.env, NO_COLOR: "1" },
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (chunk) => {
+        stdout += chunk.toString();
+    });
+    child.stderr?.on("data", (chunk) => {
+        stderr += chunk.toString();
+    });
+    const timer = setTimeout(() => child.kill("SIGTERM"), options.timeoutMs ?? 120_000);
+    child.once("error", (error) => {
+        clearTimeout(timer);
+        reject(error);
+    });
+    child.once("close", (exitCode) => {
+        clearTimeout(timer);
+        resolve({ exitCode, stdout, stderr });
+    });
+});
+function names(value, field) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value) || value.some((item) => typeof item !== "string" || !NAME.test(item))) {
+        throw new Error(`${field} must be an array of service names (letters, digits, ".", "_", "-")`);
+    }
+    return value;
+}
+function optionalName(value, field) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string" || !NAME.test(value)) {
+        throw new Error(`${field} must be a name (letters, digits, ".", "_", "-")`);
+    }
+    return value;
+}
+function flag(value, field) {
+    if (value === undefined)
+        return false;
+    if (typeof value !== "boolean")
+        throw new Error(`${field} must be a boolean`);
+    return value;
+}
+/** Turn a command's `--json` stdout into a tool result. A parseable envelope with errors, or `ok: false`, is an error result. */
+export function toToolResult(run) {
+    const text = run.stdout.trim();
+    // The envelope is the last JSON line; anything before it is incidental output.
+    const lastLine = text
+        .split("\n")
+        .filter((line) => line.trim().startsWith("{"))
+        .pop();
+    if (!lastLine) {
+        return {
+            data: {
+                errors: [
+                    { code: "NO_JSON", message: run.stderr.trim() || `tdk exited with code ${run.exitCode}` },
+                ],
+            },
+            isError: true,
+        };
+    }
+    try {
+        const envelope = JSON.parse(lastLine);
+        const failed = (envelope.errors?.length ?? 0) > 0 || envelope.data?.ok === false;
+        return { data: envelope, isError: failed };
+    }
+    catch {
+        return {
+            data: { errors: [{ code: "BAD_JSON", message: lastLine.slice(0, 200) }] },
+            isError: true,
+        };
+    }
+}
+export const defaultUpDeps = {
+    spawnUp(args, logFile) {
+        const fd = openSync(logFile, "a");
+        const [command, ...prefix] = cliInvocation();
+        const child = spawn(command, [...prefix, ...args], {
+            detached: true,
+            stdio: ["ignore", fd, fd],
+            env: { ...process.env, NO_COLOR: "1" },
+        });
+        closeSync(fd);
+        return child;
+    },
+    readLog(logFile) {
+        try {
+            return readFileSync(logFile, "utf-8");
+        }
+        catch {
+            return "";
+        }
+    },
+    sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+    now: () => Date.now(),
+    logFile: () => join(tmpdir(), `tdk-mcp-up-${Date.now()}.log`),
+};
+export function buildUpArgs(args) {
+    const stack = optionalName(args.stack, "stack");
+    const only = names(args.only, "only");
+    const out = ["up"];
+    if (stack)
+        out.push(stack);
+    if (only.length > 0)
+        out.push(...only.map((name) => `--only=${name}`));
+    if (flag(args.force, "force"))
+        out.push("--force");
+    out.push("--json");
+    return out;
+}
+/**
+ * Starts the stack detached and returns without waiting for it to be ready (a build can take minutes, longer than a tool
+ * call may last). It watches only for an early result, which is how a refusal such as UNKNOWN_SERVICE, TILT_ALREADY_RUNNING
+ * or an unsupported host arrives; otherwise the caller polls the `status` tool for `data.tilt.readiness`.
+ */
+export async function startUp(args, deps = defaultUpDeps) {
+    const argv = buildUpArgs(args);
+    const logFile = deps.logFile();
+    const child = deps.spawnUp(argv, logFile);
+    let exited;
+    child.once("exit", (code) => {
+        exited = code;
+    });
+    const waitMs = typeof args.waitSeconds === "number"
+        ? Math.min(Math.max(args.waitSeconds, 0), 60) * 1000
+        : 15_000;
+    const deadline = deps.now() + waitMs;
+    for (;;) {
+        const log = deps.readLog(logFile);
+        const line = log
+            .split("\n")
+            .filter((l) => l.startsWith('{"schemaVersion"'))
+            .pop();
+        if (line)
+            return { ...toToolResult({ exitCode: exited ?? null, stdout: line, stderr: "" }) };
+        if (exited !== undefined) {
+            return toToolResult({ exitCode: exited, stdout: "", stderr: log.slice(-2000) });
+        }
+        if (deps.now() >= deadline)
+            break;
+        await deps.sleep(250);
+    }
+    child.unref();
+    return {
+        data: {
+            schemaVersion: 1,
+            data: {
+                ok: true,
+                started: true,
+                pid: child.pid ?? null,
+                logFile,
+                next: "Poll the status tool until data.tilt.readiness.ready is true. Call down to stop it.",
+            },
+            errors: [],
+        },
+        isError: false,
+    };
+}
+export function buildLogsArgs(args) {
+    const out = ["logs", "--json"];
+    for (const name of names(args.services, "services"))
+        out.push(`--service=${name}`);
+    if (args.tail !== undefined) {
+        if (!Number.isInteger(args.tail) || args.tail < 1) {
+            throw new Error("tail must be a positive integer");
+        }
+        out.push(`--tail=${args.tail}`);
+    }
+    if (args.since !== undefined) {
+        if (typeof args.since !== "string" || !SINCE.test(args.since)) {
+            throw new Error("since must be a duration such as 30s, 5m or 1h");
+        }
+        out.push(`--since=${args.since}`);
+    }
+    return out;
+}
+const OBJECT = (properties) => ({
+    type: "object",
+    properties,
+    additionalProperties: false,
+});
+export function createTdkTools(run = runTdkCli, up = defaultUpDeps) {
+    const viaCli = (build) => async (args) => toToolResult(await run(build(args)));
+    return [
+        {
+            name: "doctor",
+            description: "Check whether this machine can run the TDK stack. Returns data.ready and data.host.canUp; run it before `up`.",
+            inputSchema: OBJECT({
+                noPing: { type: "boolean", description: "Skip pinging running services' health endpoints" },
+            }),
+            handler: viaCli((args) => [
+                "doctor",
+                "--json",
+                ...(flag(args.noPing, "noPing") ? ["--no-ping"] : []),
+            ]),
+        },
+        {
+            name: "up",
+            description: "Start the stack (or part of it) detached and return without waiting for it to be ready. Poll `status` for data.tilt.readiness.ready. Fails fast on an unknown service, an unsupported host, or a Tilt already running.",
+            inputSchema: OBJECT({
+                stack: { type: "string", description: "Only this stack" },
+                only: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Start only these services plus what they depend on and shared infrastructure",
+                },
+                force: { type: "boolean", description: "Replace a Tilt that is already running" },
+                waitSeconds: {
+                    type: "number",
+                    description: "How long to watch for an early failure before returning (default 15, max 60)",
+                },
+            }),
+            handler: (args) => startUp(args, up),
+        },
+        {
+            name: "down",
+            description: "Stop the running stack.",
+            inputSchema: OBJECT({}),
+            handler: viaCli(() => ["down", "--json"]),
+        },
+        {
+            name: "status",
+            description: "Stacks, resources, their ingress URLs and container ports, the stack-level ports, and Tilt readiness (data.tilt.readiness: ready, pending, failures, enabled; null when no Tilt answers).",
+            inputSchema: OBJECT({}),
+            handler: viaCli(() => ["status", "--json"]),
+        },
+        {
+            name: "logs",
+            description: "A bounded snapshot of recent logs from the running stack (default the last 200 lines, at most 10000). Not a stream.",
+            inputSchema: OBJECT({
+                services: { type: "array", items: { type: "string" }, description: "Only these services" },
+                tail: { type: "integer", minimum: 1, maximum: 10000 },
+                since: {
+                    type: "string",
+                    description: "Only logs newer than this, for example 30s, 5m, 1h",
+                },
+            }),
+            handler: viaCli(buildLogsArgs),
+        },
+        {
+            name: "resource_list",
+            description: "List the project's services (resources) with their stack, type and port.",
+            inputSchema: OBJECT({ stack: { type: "string", description: "Only this stack" } }),
+            handler: viaCli((args) => {
+                const stack = optionalName(args.stack, "stack");
+                return ["resources", "--json", ...(stack ? [`--stack=${stack}`] : [])];
+            }),
+        },
+    ];
+}
+//# sourceMappingURL=tools.js.map

package/cli/dist/utils/agent-host.js

@@ -0,0 +1,35 @@
+import { existsSync } from "node:fs";
+export const WEBCONTAINER_DOCS = "docs/agent-hosts.md";
+export const WEBCONTAINER_UP_MESSAGE = `WebContainers cannot run TDK: there is no Docker daemon or Tilt. Run \`tdk up\` on a machine with Docker. See ${WEBCONTAINER_DOCS}.`;
+export const DEVCONTAINER_DOCKER_FIX = `Docker is not reachable from this Dev Container. Mount the host Docker socket (-v /var/run/docker.sock:/var/run/docker.sock) or add the docker-outside-of-docker feature to devcontainer.json, then retry. Docker-in-docker is not supported. See ${WEBCONTAINER_DOCS}.`;
+function defaultInputs() {
+    return {
+        env: process.env,
+        versions: process.versions,
+        platform: process.platform,
+        fileExists: existsSync,
+    };
+}
+/** Classify where the CLI is running. Informational: Docker reachability is still decided by the runtime checks. */
+export function detectHost(inputs = defaultInputs()) {
+    const { env, versions, platform, fileExists } = inputs;
+    if (versions.webcontainer) {
+        return { kind: "webcontainer", canUp: false };
+    }
+    if (env.CODESPACES === "true")
+        return { kind: "codespaces", canUp: true };
+    if (env.REMOTE_CONTAINERS || (fileExists("/.dockerenv") && env.DEVCONTAINER)) {
+        return { kind: "devcontainer", canUp: true };
+    }
+    // Mirrors nativeWindowsUpRefusal in commands/up.ts: native Windows is inspect-only unless explicitly overridden.
+    if (platform === "win32") {
+        return { kind: "native-windows", canUp: env.TDK_ALLOW_NATIVE_WINDOWS === "1" };
+    }
+    if (platform === "linux" && env.WSL_DISTRO_NAME)
+        return { kind: "wsl2", canUp: true };
+    return { kind: "local", canUp: true };
+}
+export function isContainerHost(kind) {
+    return kind === "devcontainer" || kind === "codespaces";
+}
+//# sourceMappingURL=agent-host.js.map