@tdk-landscape/tdk-cli-core 1.3.105 → 1.3.107

package/cli/dist/commands/up.js

@@ -5,6 +5,7 @@ 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";
@@ -15,11 +16,13 @@ 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 { waitForTiltResourcesReady } from "../utils/up-readiness.js";
+import { parseTiltPort, resolveTiltPort, stopTiltForUp } from "../utils/tilt-startup.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 [
@@ -81,11 +84,18 @@ 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 portSetting = parseTiltPort(process.env.TILT_PORT);
+    if (!portSetting.ok) {
+        emit?.({ ok: false }, [{ code: "INVALID_TILT_PORT", message: portSetting.message }]);
+        showErrorAndExit(portSetting.message);
+    }
+    const configuredTiltPort = portSetting.port;
     const hostRefusal = options.dryRun ? null : await hostUpRefusal();
     if (hostRefusal) {
         emit?.({ ok: false }, [{ code: "HOST_UNSUPPORTED", message: hostRefusal }]);
@@ -102,6 +112,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,
         });
@@ -127,18 +152,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}`));
         }
@@ -171,9 +205,14 @@ 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."));
@@ -184,6 +223,9 @@ export const upCommand = new Command("up")
                 dryRun: true,
                 stack: stackName ?? null,
                 services: serviceNames,
+                ...(options.only
+                    ? { requested: options.only, declaredDependencies: dependencyNames }
+                    : {}),
                 command: dryRunCommand,
             });
             return;
@@ -194,33 +236,42 @@ export const upCommand = new Command("up")
         exportHostPortPlan(hostPortPlan);
         writeSavedHostPortPlan(projectRoot, hostPortPlan);
         const basePort = 10350;
-        let port = basePort;
-        if (process.env.TILT_PORT) {
-            port = parseInt(process.env.TILT_PORT, 10);
-        }
-        else if (!options.force) {
-            const availablePort = await findAvailablePort(basePort, 10);
-            if (availablePort && availablePort !== basePort) {
-                port = availablePort;
-                if (!options.quiet) {
-                    console.log(chalk.yellow(`⚠️  Port ${basePort} is already in use`));
-                    console.log(chalk.blue(`🔄 Auto-switching to port ${port}\n`));
-                }
+        // 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 candidatePorts = [
+                ...new Set([basePort, ...(configuredTiltPort === undefined ? [] : [configuredTiltPort])]),
+            ];
+            const running = [];
+            for (const candidate of candidatePorts) {
+                if ((await tiltGetUiResources(candidate)) !== null)
+                    running.push(candidate);
             }
-        }
-        process.env.TILT_PORT = port.toString();
-        if (options.force) {
-            if (!options.quiet) {
-                console.log(chalk.yellow(`Force flag set - stopping Tilt on port ${port} if running...`));
+            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);
             }
-            stopTiltOnPort(port);
-            await new Promise((resolve) => setTimeout(resolve, 2000));
+            for (const runningPort of running)
+                stopTiltOnPort(runningPort);
         }
-        const tiltArgs = buildTiltUpArgs(focusServiceNames, {
-            verbose: options.verbose,
-            quiet: options.quiet,
+        const resolution = await resolveTiltPort({
+            configuredPort: configuredTiltPort,
             force: options.force,
-            focusTargets: stackName ? [stackName] : undefined,
+            basePort,
+            findAvailablePort,
+        });
+        const port = resolution.port;
+        if (resolution.autoSwitched && !options.quiet) {
+            console.log(chalk.yellow(`⚠️  Port ${basePort} is already in use`));
+            console.log(chalk.blue(`🔄 Auto-switching to port ${port}\n`));
+        }
+        process.env.TILT_PORT = port.toString();
+        await stopTiltForUp({ force: options.force, quiet: options.quiet, port }, {
+            stop: stopTiltOnPort,
+            log: (message) => console.log(chalk.yellow(message)),
+            wait: (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)),
         });
         if (!options.quiet) {
             console.log(chalk.gray("\nRunning tilt up..."));
@@ -240,10 +291,26 @@ export const upCommand = new Command("up")
             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 readiness = await waitForTiltResourcesReady(port);
+                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("; ");
@@ -288,7 +355,8 @@ export const upCommand = new Command("up")
                 emit?.({
                     ok: true,
                     stack: stackName ?? null,
-                    services: serviceNames,
+                    services: startedServices,
+                    ...(options.only ? { requested: options.only, dependencies: startedDependencies } : {}),
                     tiltUrl: `http://localhost:${port}`,
                 });
             }

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/discovery-context.js

@@ -1,5 +1,6 @@
 import { createCacheValidator } from "./cache.js";
-import { discoverResources, discoverStacks, getAllStacks } from "./services.js";
+import { findProjectRoot } from "./paths.js";
+import { discoverResources, discoverResourcesWithProblems, discoverStacks, getAllStacks, warnAboutSkippedFiles, } from "./services.js";
 let cachedContext = null;
 const cacheValidator = createCacheValidator(1000);
 export function clearDiscoveryCache() {
@@ -13,9 +14,13 @@ export function createDiscoveryContext(forceRefresh = false) {
     if (!forceRefresh && isCacheValid() && cachedContext) {
         return cachedContext;
     }
-    const resources = discoverResources();
-    const stacks = discoverStacks();
+    const projectRoot = findProjectRoot();
+    const { resources, problems } = projectRoot
+        ? discoverResourcesWithProblems(projectRoot)
+        : { resources: discoverResources(), problems: [] };
+    const stacks = discoverStacks(resources);
     const stackNames = getAllStacks(resources);
+    warnAboutSkippedFiles(problems);
     const unassignedResources = resources.filter((r) => !r.stack);
     const resourcesByStack = new Map();
     for (const resource of resources) {
@@ -27,6 +32,7 @@ export function createDiscoveryContext(forceRefresh = false) {
     }
     const context = {
         resources,
+        problems,
         stacks,
         stackNames,
         unassignedResources,