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

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,

package/cli/dist/utils/doctor-wiring.js

@@ -165,6 +165,94 @@ export function checkFrontendBackendUrls(projectRoot = findProjectRoot() ?? proc
         fix: `Backends are only reachable through Traefik: http://api.${project}.localhost/api/<name without -api>/... (for example catalog-api is /api/catalog). Use that URL, or the generated .autogenerated/env.ts`,
     };
 }
+/** The common ways to apply schema changes from a command line: Prisma, Drizzle, Knex, TypeORM, MikroORM, Sequelize, dbmate, Atlas, Alembic. */
+const MIGRATION_COMMAND = /\b(?:prisma\s+(?:migrate\s+(?:deploy|dev|resolve)|db\s+push)|drizzle-kit\s+(?:migrate|push)|knex\s+migrate:\w+|typeorm\s+migration:run|mikro-orm\s+migration:up|sequelize(?:-cli)?\s+db:migrate|dbmate\s+(?:up|migrate)|atlas\s+migrate\s+apply|alembic\s+upgrade)\b/;
+const START_SCRIPTS = new Set(["start", "dev", "serve", "prestart", "predev", "preserve"]);
+const SHELL_ENTRYPOINT = /\.(?:sh|bash)$/;
+const DOCKERFILE_START = /^\s*(?:CMD|ENTRYPOINT)\b/i;
+function readText(path) {
+    try {
+        return readFileSync(path, "utf-8");
+    }
+    catch {
+        return undefined;
+    }
+}
+function startScriptMigrations(resourceDir) {
+    const text = readText(join(resourceDir, "package.json"));
+    if (text === undefined)
+        return [];
+    let scripts = {};
+    try {
+        scripts = JSON.parse(text)?.scripts ?? {};
+    }
+    catch {
+        return [];
+    }
+    return Object.entries(scripts)
+        .filter(([name, command]) => START_SCRIPTS.has(name) && typeof command === "string" && MIGRATION_COMMAND.test(command))
+        .map(([name]) => `package.json "${name}" script`);
+}
+function fileMigrations(path, onlyStartLines) {
+    const text = readText(path);
+    if (text === undefined)
+        return false;
+    return text.split("\n").some((line) => 
+    // `["prisma", "migrate", "deploy"]` is the same command as `prisma migrate deploy`.
+    MIGRATION_COMMAND.test(line.replace(/["'`,[\]]+/g, " ")) &&
+        !COMMENT_LINE.test(line) &&
+        (!onlyStartLines || DOCKERFILE_START.test(line)));
+}
+/**
+ * A backend or worker that applies migrations from its own start-up (a `start` script, a Dockerfile CMD,
+ * an entrypoint script or its source) races its siblings and runs again on every restart. TDK has a
+ * `migrator` app type for this: it runs once, before the services that depend on it. This is a warning,
+ * not a failure: such services work, and the opt-in Infisical entrypoint is one of them.
+ */
+export function checkMigrationsInApi(projectRoot = findProjectRoot() ?? process.cwd()) {
+    const findings = [];
+    for (const resource of discoverResourcesFromRoot(projectRoot)) {
+        const appType = resource.config?.appType ?? resource.type;
+        if (appType !== "backend" && appType !== "worker")
+            continue;
+        const dir = resource.path;
+        for (const finding of startScriptMigrations(dir))
+            findings.push(`${resource.name}: ${finding}`);
+        const dockerfile = join(dir, resource.config?.dockerfile ?? "Dockerfile");
+        if (fileMigrations(dockerfile, true)) {
+            findings.push(`${resource.name}: ${relative(projectRoot, dockerfile)} CMD or ENTRYPOINT`);
+        }
+        let entries = [];
+        try {
+            entries = readdirSync(dir, { withFileTypes: true });
+        }
+        catch { }
+        for (const entry of entries) {
+            const path = join(dir, entry.name);
+            if (entry.isFile() && SHELL_ENTRYPOINT.test(entry.name) && fileMigrations(path, false)) {
+                findings.push(`${resource.name}: ${relative(projectRoot, path)}`);
+            }
+        }
+        for (const path of listSourceFiles(join(dir, "src"))) {
+            if (fileMigrations(path, false))
+                findings.push(`${resource.name}: ${relative(projectRoot, path)}`);
+        }
+    }
+    if (findings.length === 0) {
+        return {
+            name: "Migrations outside the API",
+            didPass: true,
+            message: "No backend or worker runs a migration command from its own start-up",
+        };
+    }
+    return {
+        name: "Migrations outside the API",
+        didPass: false,
+        isWarning: true,
+        message: `${formatCount(findings.length, "migration command")} run from a backend or worker's own start-up:\n    ${findings.join("\n    ")}`,
+        fix: "Move the migration into a `migrator` resource (appType migrator) that the service depends on, so it runs once before the service starts instead of on every start and restart",
+    };
+}
 export function checkNatsBroker(projectRoot = findProjectRoot() ?? process.cwd()) {
     const users = discoverResourcesFromRoot(projectRoot)
         .filter((resource) => resource.config?.featuresEnabled?.includes("nats"))

package/cli/dist/utils/services.js

@@ -48,11 +48,34 @@ const printedWarnings = new Set();
 export function resetPrintedServiceWarnings() {
     printedWarnings.clear();
 }
+class InvalidServiceJsonError extends Error {
+    reason;
+    constructor(reason) {
+        super(reason);
+        this.reason = reason;
+        this.name = "InvalidServiceJsonError";
+    }
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
 function parseResource(serviceJsonPath) {
-    const content = readFileSync(serviceJsonPath, "utf-8");
-    const parsed = JSON.parse(content);
+    let content;
+    try {
+        content = readFileSync(serviceJsonPath, "utf-8");
+    }
+    catch (error) {
+        throw new InvalidServiceJsonError(`could not read file: ${errorMessage(error)}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(content);
+    }
+    catch (error) {
+        throw new InvalidServiceJsonError(`invalid JSON: ${errorMessage(error)}`);
+    }
     if (!isValidResourceConfig(parsed)) {
-        throw new Error(`Invalid service.json at ${serviceJsonPath}: missing required fields (appName, runtime or appType)`);
+        throw new InvalidServiceJsonError("missing required fields (appName, runtime or appType)");
     }
     const parsedConfig = parsed;
     for (const warning of validateServiceManifest(parsed, serviceJsonPath).warnings) {
@@ -76,12 +99,35 @@ function parseResource(serviceJsonPath) {
         stack: config.stack,
     };
 }
-export function discoverResourcesFromRoot(projectRoot) {
+export function discoverResourcesWithProblems(projectRoot) {
     const serviceJsonPaths = findServiceJsonFiles(projectRoot);
     const resources = [];
+    const problems = [];
     for (const path of serviceJsonPaths) {
-        resources.push(parseResource(path));
+        try {
+            resources.push(parseResource(path));
+        }
+        catch (error) {
+            problems.push({
+                path,
+                reason: error instanceof InvalidServiceJsonError ? error.reason : errorMessage(error),
+            });
+        }
+    }
+    return { resources, problems };
+}
+export function warnAboutSkippedFiles(problems) {
+    for (const problem of problems) {
+        const warning = `skipped ${problem.path}: ${problem.reason}`;
+        if (printedWarnings.has(warning))
+            continue;
+        printedWarnings.add(warning);
+        console.warn(`⚠️  ${warning}`);
     }
+}
+export function discoverResourcesFromRoot(projectRoot) {
+    const { resources, problems } = discoverResourcesWithProblems(projectRoot);
+    warnAboutSkippedFiles(problems);
     return resources;
 }
 export function discoverResources() {
@@ -91,6 +137,19 @@ export function discoverResources() {
     }
     return discoverResourcesFromRoot(projectRoot);
 }
+export function discoverResourcesStrict() {
+    const projectRoot = findProjectRoot();
+    if (!projectRoot) {
+        throw new Error("Could not find project root (no .tdk/project.json found). Run `tdk project --yes` first.");
+    }
+    const { resources, problems } = discoverResourcesWithProblems(projectRoot);
+    if (problems.length > 0) {
+        throw new Error(problems
+            .map((problem) => `Invalid service.json at ${problem.path}: ${problem.reason}`)
+            .join("\n"));
+    }
+    return resources;
+}
 /**
  * Unique, sorted `stack` values across discovered service.json files under `projectRoot`.
  * Tilt's discovery groups services by this same field (see tdk-cli-extensions
@@ -117,8 +176,7 @@ export function getAllStacks(resources) {
     }
     return Array.from(stacks).sort();
 }
-export function discoverStacks() {
-    const resources = discoverResources();
+export function discoverStacks(resources = discoverResources()) {
     const stackMap = new Map();
     for (const resource of resources) {
         if (resource.stack) {

package/cli/dist/utils/tilt-logs.js

@@ -0,0 +1,62 @@
+export const DEFAULT_LOG_TAIL = 200;
+/** Upper bound for --tail so a snapshot stays small enough for an agent to read. */
+export const MAX_LOG_TAIL = 10_000;
+const NANOSECONDS = {
+    ns: 1,
+    us: 1e3,
+    µs: 1e3,
+    ms: 1e6,
+    s: 1e9,
+    m: 6e10,
+    h: 3.6e12,
+};
+// Go's time.Duration is an int64 of nanoseconds, so anything beyond this is rejected by `tilt logs`.
+const MAX_DURATION_NANOSECONDS = 2 ** 63 - 1;
+/**
+ * Go-style duration such as 30s, 5m, 1h or 1h30m, within roughly the range Go's ParseDuration accepts.
+ * The sum is a JS number, so values within a few nanoseconds of the int64 limit can disagree with Go; this only needs to
+ * reject absurd input, and Tilt remains the final judge (its rejection is reported as TILT_LOGS_FAILED).
+ */
+export function isValidSince(value) {
+    if (!/^(\d+(\.\d+)?(ns|us|µs|ms|s|m|h))+$/.test(value))
+        return false;
+    let total = 0;
+    for (const [, amount, unit] of value.matchAll(/(\d+(?:\.\d+)?)(ns|us|µs|ms|s|m|h)/g)) {
+        total += Number(amount) * (NANOSECONDS[unit] ?? 0);
+    }
+    return total <= MAX_DURATION_NANOSECONDS;
+}
+export function isValidPort(value) {
+    return /^[1-9]\d{0,4}$/.test(value) && Number(value) <= 65535;
+}
+export function isValidTail(value) {
+    return /^[1-9]\d*$/.test(value) && Number(value) <= MAX_LOG_TAIL;
+}
+/** Parse `tilt logs --json` (JSON Lines) into normalized lines, keeping at most the last `limit`. Unparseable lines are skipped. */
+export function parseTiltLogLines(output, limit) {
+    const lines = [];
+    for (const raw of output.split("\n")) {
+        if (!raw.trim())
+            continue;
+        try {
+            const entry = JSON.parse(raw);
+            const str = (value) => typeof value === "string" && value !== "" ? value : null;
+            lines.push({
+                time: str(entry.time),
+                resource: str(entry.resource),
+                level: str(entry.level),
+                source: str(entry.source),
+                text: typeof entry.message === "string" ? entry.message : "",
+            });
+        }
+        catch {
+            // Tilt can print a non-JSON notice before the stream; it is not a log line.
+        }
+    }
+    return lines.slice(-limit);
+}
+/** True when `tilt logs` failed because no Tilt server answered, as opposed to rejecting its arguments. */
+export function isTiltConnectionFailure(stderr) {
+    return /connection refused|connecting to Tilt|no such host|dial tcp|websocket_token/i.test(stderr);
+}
+//# sourceMappingURL=tilt-logs.js.map

package/cli/dist/utils/up-only.js

@@ -0,0 +1,29 @@
+/** Requested names that match no discovered service (the Tiltfile silently enables everything for an unknown focus name). */
+export function findUnknownServices(requested, candidates) {
+    const known = new Set(candidates.map((resource) => resource.name));
+    return requested.filter((name) => !known.has(name));
+}
+/**
+ * The requested services plus their `dependsOn` closure. This mirrors what the generated Tiltfile enables for
+ * `--focus=<service>` (see get_all_needed_services in engine/topologies/tilt/config/profiles.star) so the CLI can report
+ * the same set. Shared infrastructure (Postgres, Traefik, the golden images) is always enabled by the Tiltfile and is not listed here.
+ * A dependsOn entry that is not a discovered service is ignored.
+ */
+export function resolveOnlySelection(requested, all) {
+    const byName = new Map(all.map((resource) => [resource.name, resource]));
+    const wanted = new Set();
+    const visit = (name) => {
+        if (wanted.has(name) || !byName.has(name))
+            return;
+        wanted.add(name);
+        for (const dep of byName.get(name)?.config?.dependsOn ?? [])
+            visit(dep);
+    };
+    for (const name of requested)
+        visit(name);
+    return {
+        selected: all.filter((resource) => wanted.has(resource.name)),
+        dependencies: all.map((r) => r.name).filter((n) => wanted.has(n) && !requested.includes(n)),
+    };
+}
+//# sourceMappingURL=up-only.js.map