@flisk-sh/flisk 0.0.0-stage → 1.3.190

package/cli/dist/commands/down.js

@@ -0,0 +1,114 @@
+// Copyright (c) 2026 Flisk Landscape contributors
+// SPDX-License-Identifier: MIT
+import chalk from "chalk";
+import { Command } from "commander";
+import { readProjectConfig } from "../generator/template-engine.js";
+import { addYesOption, handleDryRun } from "../utils/command-helpers.js";
+import { pruneProjectNetworks, stopProjectTiltUp, waitForTiltUpExit, } from "../utils/down-cleanup.js";
+import { errorFactories, handleTiltFailure, withTiltCheck } from "../utils/errors.js";
+import { createJsonEmitter } from "../utils/json-output.js";
+import { writeMachineError } from "../utils/machine-output.js";
+import { findProjectRoot } from "../utils/paths.js";
+import { discoverResources, discoverStacks } from "../utils/services.js";
+import { buildTiltDownArgs, getTiltfilePath, runTilt } from "../utils/tilt.js";
+function allStackNames() {
+    try {
+        const names = discoverStacks(discoverResources()).map((stack) => stack.name);
+        return names.length > 0 ? names : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function pruneNetworksOrWarn(json) {
+    const root = findProjectRoot();
+    if (!root)
+        return undefined;
+    try {
+        const result = pruneProjectNetworks(readProjectConfig(root).project.name);
+        if (!json) {
+            if (result.removed.length > 0) {
+                console.log(chalk.gray(`Removed networks: ${result.removed.join(", ")}`));
+            }
+            for (const kept of result.kept) {
+                console.log(chalk.yellow(`Kept network ${kept.name}: ${kept.reason}`));
+            }
+        }
+        return result;
+    }
+    catch (err) {
+        if (!json) {
+            console.log(chalk.yellow(`Could not remove networks: ${err.message}`));
+        }
+        return undefined;
+    }
+}
+export const downCommand = addYesOption(new Command("down"))
+    .description("Stop all tilt resources")
+    .option("-v, --verbose", "Enable verbose output", false)
+    .option("-f, --force", "Deprecated alias for --yes; accepted for script compatibility", false)
+    .option("--prune-networks", "Also remove this project's Docker networks (only those no container is attached to)", false)
+    .option("--dry-run", "Show what would be stopped without stopping", false)
+    .option("--json", "Print one JSON object on stdout; implies quiet human output", false)
+    .action(async (options) => {
+    if (!findProjectRoot()) {
+        const projectRootError = errorFactories.notInProject();
+        if (options.json)
+            writeMachineError(projectRootError);
+        projectRootError.exit();
+    }
+    if (options.force) {
+        options.yes = true;
+        if (!options.json) {
+            console.warn(chalk.yellow("Note: --force (-f) on flisk down is deprecated; use --yes (-y) instead."));
+        }
+    }
+    const emit = options.json ? createJsonEmitter("DOWN_FAILED", "flisk down") : undefined;
+    await withTiltCheck(async () => {
+        if (emit && options.dryRun) {
+            emit({ ok: true, dryRun: true });
+            return;
+        }
+        if (handleDryRun(options, "not stopping resources", "tilt down")) {
+            return;
+        }
+        const tiltArgs = buildTiltDownArgs({
+            focusTargets: allStackNames(),
+        });
+        // Stop `tilt up` first: `tilt down` does not end it, and a live Tilt re-creates the containers `tilt down` just removed.
+        let stoppedTilt = [];
+        try {
+            const tiltfile = getTiltfilePath();
+            stoppedTilt = stopProjectTiltUp(tiltfile);
+            if (stoppedTilt.length > 0)
+                await waitForTiltUpExit(tiltfile);
+        }
+        catch {
+            // Not fatal: the containers are already down.
+        }
+        if (stoppedTilt.length > 0 && !options.json) {
+            console.log(chalk.gray(`Stopped tilt up (pid ${stoppedTilt.join(", ")}).`));
+        }
+        if (!options.json)
+            console.log(chalk.blue("Stopping all tilt resources..."));
+        if (options.verbose && !options.json) {
+            console.log(chalk.gray("Running: tilt down -f .tdk/.tdk-out/Tiltfile"));
+        }
+        const result = await runTilt("down", tiltArgs, {
+            verbose: options.verbose && !options.json,
+            inheritStdio: !options.json,
+        });
+        if (result.exitCode !== 0) {
+            handleTiltFailure("down", result.exitCode);
+        }
+        let networks;
+        if (options.pruneNetworks) {
+            networks = pruneNetworksOrWarn(options.json);
+        }
+        emit?.({
+            ok: true,
+            stoppedTilt,
+            ...(networks ? { removedNetworks: networks.removed, keptNetworks: networks.kept } : {}),
+        });
+    });
+});

package/cli/dist/commands/eject.js

@@ -0,0 +1,108 @@
+// Copyright (c) 2026 Flisk Landscape contributors
+// SPDX-License-Identifier: MIT
+import { existsSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import chalk from "chalk";
+import { Command } from "commander";
+import { addYesOption, confirmOrCancel, handleDryRun } from "../utils/command-helpers.js";
+import { errorFactories, runCommand } from "../utils/errors.js";
+import { findProjectRoot } from "../utils/paths.js";
+// Same location `flisk up` hands to Tilt (see getTiltfilePath in utils/tilt.ts), relative to the project root.
+export const TILTFILE_RELATIVE_PATH = ".tdk/.tdk-out/Tiltfile";
+export const TILT_UP_COMMAND = `tilt up -f ${TILTFILE_RELATIVE_PATH} -- --focus=<stack>`;
+export const EJECTED_CONTENT = `# Ejected from Flisk
+
+\`flisk eject\` wrote this file and nothing else. It did not copy, move or generate anything, and it did
+not remove Flisk. What exists is what Flisk had already generated, and that is still Flisk-owned output.
+
+## Where the generated files are
+
+- \`.tdk/.tdk-out/\` holds the Tiltfile and the engine it loads (\`tdk-cli-ext/\`). It is git-ignored.
+  \`flisk config regenerate\` rewrites the master files in it.
+- The per-service Compose files (\`services/<stack>/<name>/.autogenerated/\`), the golden-layer
+  Dockerfile and the Traefik file (\`.tdk/.tdk-out/\`) are written by Tilt when it runs, not by
+  \`flisk eject\`. Until Tilt has run they do not exist. They are git-ignored too.
+- Your own Dockerfiles, \`service.json\` files and source code are untouched.
+
+## Running the stack without the flisk CLI
+
+There is no Tiltfile at the project root, so a plain \`tilt up\` does not find one. Flisk runs:
+
+    ${TILT_UP_COMMAND}
+
+from the project root (\`<stack>\` is a stack name under \`services/\`; without \`--focus\` the Tiltfile
+falls back to its default phase). The Tiltfile still reads \`.tdk/project.json\` and the
+\`service.json\` files, so those must stay. \`flisk up\` also does steps before Tilt starts (it chooses
+host ports and exports them to Tilt); running Tilt by hand skips them.
+
+## Cleaning up
+
+Optional to delete later: this file, and \`.tdk/\` plus the \`service.json\` files if you stop using Flisk.
+Deleting them also removes what the Tiltfile needs.
+
+To go back to Flisk: install it and run \`flisk config regenerate\`.
+`;
+export const ejectCommand = addYesOption(new Command("eject"))
+    .description("Write EJECTED.md describing the generated Tilt files (copies and generates nothing; they stay in .tdk/.tdk-out/)")
+    .option("--dry-run", "List the generated files and what would be written, without changing the project", false)
+    .action(async (options) => {
+    await runCommand(async () => {
+        const projectRoot = findProjectRoot();
+        if (!projectRoot) {
+            throw errorFactories.notInProject();
+        }
+        const generatedPaths = [".tdk/.tdk-out"];
+        const presentPaths = generatedPaths.filter((path) => existsSync(join(projectRoot, path)));
+        const files = presentPaths.flatMap((path) => {
+            const absolutePath = join(projectRoot, path);
+            if (statSync(absolutePath).isFile())
+                return [path];
+            try {
+                return readdirSync(absolutePath, { recursive: true }).map((entry) => join(path, entry.toString()));
+            }
+            catch {
+                return [path];
+            }
+        });
+        if (!existsSync(join(projectRoot, ".tdk", ".tdk-out", "Tiltfile"))) {
+            throw new Error("Generated Tilt files are missing. Run `flisk project --yes` before ejecting.");
+        }
+        const rootTiltfile = join(projectRoot, "Tiltfile");
+        const userTiltfile = existsSync(rootTiltfile) ? ["Tiltfile"] : [];
+        const ejectedPath = join(projectRoot, "EJECTED.md");
+        const willCreate = existsSync(ejectedPath) ? [] : ["EJECTED.md"];
+        // eject's plan is a file list, not the standard "Dry run - ..." pair, so it supplies its own printer.
+        if (handleDryRun(options, "", "", () => {
+            console.log("Generated files, left where they are (git-ignored):");
+            for (const path of files)
+                console.log(`  ${path}`);
+            if (userTiltfile.length > 0) {
+                console.log("Root Tiltfile, left where it is (not generated, not git-ignored):");
+                for (const path of userTiltfile)
+                    console.log(`  ${path}`);
+            }
+            console.log("Files written:");
+            for (const path of willCreate)
+                console.log(`  ${path}`);
+            if (willCreate.length === 0)
+                console.log("  (none)");
+        })) {
+            return;
+        }
+        if (!options.yes &&
+            !(await confirmOrCancel("Write EJECTED.md? (Generated files stay in .tdk/.tdk-out/; nothing is copied or moved.)"))) {
+            return;
+        }
+        if (existsSync(ejectedPath)) {
+            console.log(chalk.green("EJECTED.md already exists and was left unchanged. Nothing was copied, moved or generated."));
+        }
+        else {
+            writeFileSync(ejectedPath, EJECTED_CONTENT, { flag: "wx" });
+            console.log(chalk.green("Wrote EJECTED.md. Nothing was copied, moved or generated."));
+        }
+        console.log("Generated files stay in .tdk/.tdk-out/ (git-ignored) and still need Flisk inputs.");
+        console.log(`Run from the project root: ${TILT_UP_COMMAND}`);
+        console.log("Replace <stack> with a stack name under services/, or omit --focus to use the Tiltfile's default phase.");
+        console.log("Read EJECTED.md");
+    });
+});

package/cli/dist/commands/help.js

@@ -0,0 +1,152 @@
+// Copyright (c) 2026 Flisk Landscape contributors
+// SPDX-License-Identifier: MIT
+import chalk from "chalk";
+import pkg from "../../package.json" with { type: "json" };
+const TDK_BANNER = `
+  ${chalk.bold.cyan("flisk")} ${chalk.gray(`v${pkg.version}`)}  ${chalk.white("Flisk CLI — start services on your machine.")}
+`;
+const COMMAND_GROUPS = [
+    {
+        title: "Project Level",
+        color: chalk.blue,
+        commands: [
+            {
+                name: "project",
+                desc: "Initialize master configs (TILT_RESOURCE_DEFAULTS.star)",
+                alias: "",
+            },
+            { name: "projects, info", desc: "Show project information and config status", alias: "" },
+            {
+                name: "import",
+                desc: "Import the services a directory describes",
+                alias: "[dir] --dry-run --yes",
+            },
+            {
+                name: "eject",
+                desc: "Write EJECTED.md describing the generated Tilt files",
+                alias: "--dry-run --yes",
+            },
+        ],
+    },
+    {
+        title: "Stack Level",
+        color: chalk.magenta,
+        commands: [
+            { name: "stack", desc: "Organize resources into stacks (interactive)", alias: "" },
+            { name: "stacks, ls", desc: "List all stacks and their resources", alias: "" },
+        ],
+    },
+    {
+        title: "Resource Level",
+        color: chalk.yellow,
+        commands: [
+            { name: "resource", desc: "Create new resource with templates", alias: "" },
+            { name: "resources", desc: "List all resources with filtering", alias: "--stack, --ports" },
+            {
+                name: "agent",
+                desc: "Inspect and operate AI agent resources",
+                alias: "sessions <resource>",
+            },
+        ],
+    },
+    {
+        title: "Lifecycle",
+        color: chalk.green,
+        commands: [
+            { name: "up, deploy", desc: "Start services (optionally by stack)", alias: "[stack-name]" },
+            { name: "down", desc: "Stop all tilt resources", alias: "" },
+            { name: "restart", desc: "Restart a running resource in the stack", alias: "<resource>" },
+            { name: "status", desc: "Show status of services and stacks", alias: "" },
+            { name: "logs", desc: "Print recent logs from the running stack", alias: "--json" },
+        ],
+    },
+    {
+        title: "Networking",
+        color: chalk.blueBright,
+        commands: [
+            {
+                name: "networks, traefik",
+                desc: "Show Traefik-routed URLs for all services",
+                alias: "--stack, --json",
+            },
+        ],
+    },
+    {
+        title: "Utilities",
+        color: chalk.cyan,
+        commands: [
+            { name: "ui, interactive", desc: "Interactive TUI for managing services", alias: "" },
+            {
+                name: "config",
+                desc: "Manage project configuration and regenerate master files",
+                alias: "regenerate, verify, edit",
+            },
+            { name: "doctor", desc: "Check environment readiness", alias: "" },
+            { name: "mcp", desc: "Run an MCP server over stdio for coding agents", alias: "" },
+            {
+                name: "runtime",
+                desc: "Inspect packaged engine and template assets",
+                alias: "--check-assets",
+            },
+            { name: "completion", desc: "Generate shell completions", alias: "--install --shell zsh" },
+            { name: "upgrade, update", desc: "Self-update to latest version", alias: "--force --all" },
+            { name: "version, -v", desc: "Display version number", alias: "" },
+            { name: "help", desc: "Show help", alias: "[command]" },
+        ],
+    },
+];
+/** Every command name and alias that the help table lists. */
+export function listedCommandNames() {
+    return COMMAND_GROUPS.flatMap((group) => group.commands.flatMap((command) => command.name.split(",").map((name) => name.trim())));
+}
+function formatCommand(name, desc, alias, color) {
+    const nameFormatted = color(name.padEnd(20));
+    const descFormatted = chalk.white(desc);
+    const aliasFormatted = alias ? chalk.gray(` ${alias}`) : "";
+    return `  ${nameFormatted} ${descFormatted}${aliasFormatted}`;
+}
+export function showHelp() {
+    console.log(TDK_BANNER);
+    console.log(chalk.gray("\n  Local development inner loop; Flisk does not replace Helm for cluster deployments.\n"));
+    console.log(chalk.bold.white("  Project → Phase → Stack → Resource\n"));
+    console.log(chalk.gray("  Usage: flisk [command] [options]\n"));
+    console.log(chalk.bold.yellow("  Global Options:"));
+    console.log(`  ${chalk.cyan("-v, --version".padEnd(20))} ${chalk.white("Display version number")}`);
+    console.log(`  ${chalk.cyan("--verbose".padEnd(20))} ${chalk.white("Enable verbose output")}`);
+    console.log(`  ${chalk.cyan("-h, --help".padEnd(20))} ${chalk.white("Show help")}`);
+    console.log();
+    for (const group of COMMAND_GROUPS) {
+        console.log(group.color.bold(`  ${group.title}`));
+        console.log(group.color(`  ${"─".repeat(50)}`));
+        for (const cmd of group.commands) {
+            console.log(formatCommand(cmd.name, cmd.desc, cmd.alias, group.color));
+        }
+        console.log();
+    }
+    console.log(chalk.bold.yellow("  Quick start:"));
+    console.log(chalk.gray(`  ${"─".repeat(50)}`));
+    console.log(chalk.white(`
+  ${chalk.cyan("1.")} Initialize project:        ${chalk.green("flisk project")}
+  ${chalk.cyan("2.")} Create a resource:         ${chalk.green("flisk resource my-api --type backend")}
+  ${chalk.cyan("3.")} Assign to stack:           ${chalk.green("flisk stack my-stack")}
+  ${chalk.cyan("4.")} Start development:         ${chalk.green("flisk up my-stack")}
+  `));
+    console.log(chalk.bold.yellow("  Examples:"));
+    console.log(chalk.gray(`  ${"─".repeat(50)}`));
+    console.log(chalk.white(`
+  ${chalk.cyan("$")} flisk project                       # Create master configs
+  ${chalk.cyan("$")} flisk resource api --type backend   # Create a backend service
+  ${chalk.cyan("$")} flisk resource app --type frontend  # Create a frontend app
+  ${chalk.cyan("$")} flisk resource bot --type agent     # Create an AI agent (sessions survive flisk down)
+  ${chalk.cyan("$")} flisk stacks --services             # List stacks with their resources
+  ${chalk.cyan("$")} flisk up my-stack                   # Start a stack
+  ${chalk.cyan("$")} flisk networks                      # Show Traefik-routed URLs
+  ${chalk.cyan("$")} flisk doctor                        # Check your environment
+  ${chalk.cyan("$")} flisk upgrade                       # Self-update
+  ${chalk.cyan("$")} flisk upgrade --all                 # Update all Flisk installs on PATH
+  `));
+    console.log(chalk.gray(`  ${"═".repeat(50)}`));
+    console.log(chalk.gray(`  For more help: ${chalk.cyan("flisk help [command]")}`));
+    console.log(chalk.gray(`  GitHub: ${chalk.cyan("https://github.com/flisk-sh/flisk")}`));
+    console.log();
+}

package/cli/dist/commands/import.js

@@ -0,0 +1,164 @@
+// Copyright (c) 2026 Flisk Landscape contributors
+// SPDX-License-Identifier: MIT
+import { spawn } from "node:child_process";
+import { Command } from "commander";
+import { addYesOption } from "../utils/command-helpers.js";
+import { getPackageVersion } from "../utils/paths.js";
+/**
+ * The importer lives in its own repo so it can ship without a CLI release, and is run from npm at a
+ * pinned version so a push to its main branch cannot change what `flisk import` does. Move the pin
+ * when a new importer is published. `TDK_IMPORT_PACKAGE` overrides the package spec.
+ */
+export const IMPORT_PACKAGE = "@tdk-landscape/tdk-import@0.2.1";
+/** Minimum Flisk core release supporting buildContext required by flisk import (#634). */
+export const MIN_CORE_VERSION = "1.3.104";
+/** Recommended core version with automatic Tiltfile bootstrapping for imported stacks (#1018). */
+export const RECOMMENDED_CORE_VERSION = "1.3.145";
+/** Parses a semver version string, extracting major, minor, patch, and prerelease identifiers. */
+export function parseSemver(raw) {
+    const cleaned = raw.trim().replace(/^v/, "").split("+")[0];
+    const match = cleaned.match(/^(\d+)\.(\d+)(?:\.(\d+))?(?:-([0-9A-Za-z.-]+))?$/);
+    if (!match)
+        return null;
+    const major = Number(match[1]);
+    const minor = Number(match[2]);
+    const patch = Number(match[3] ?? 0);
+    const prereleaseRaw = match[4];
+    const prerelease = prereleaseRaw
+        ? prereleaseRaw.split(".").map((part) => (/^\d+$/.test(part) ? Number(part) : part))
+        : [];
+    return { major, minor, patch, prerelease };
+}
+/**
+ * Compares two semver version strings per the SemVer 2.0.0 specification:
+ * Returns 1 if a > b, -1 if a < b, 0 if a === b, or null if either is unparseable.
+ */
+export function compareSemver(aStr, bStr) {
+    const a = parseSemver(aStr);
+    const b = parseSemver(bStr);
+    if (!a || !b)
+        return null;
+    if (a.major !== b.major)
+        return a.major > b.major ? 1 : -1;
+    if (a.minor !== b.minor)
+        return a.minor > b.minor ? 1 : -1;
+    if (a.patch !== b.patch)
+        return a.patch > b.patch ? 1 : -1;
+    const aHasPre = a.prerelease.length > 0;
+    const bHasPre = b.prerelease.length > 0;
+    // A normal version has greater precedence than a prerelease of the same major.minor.patch
+    if (aHasPre && !bHasPre)
+        return -1;
+    if (!aHasPre && bHasPre)
+        return 1;
+    if (!aHasPre && !bHasPre)
+        return 0;
+    const len = Math.max(a.prerelease.length, b.prerelease.length);
+    for (let i = 0; i < len; i++) {
+        const pA = a.prerelease[i];
+        const pB = b.prerelease[i];
+        if (pA === undefined)
+            return -1;
+        if (pB === undefined)
+            return 1;
+        if (pA === pB)
+            continue;
+        const numA = typeof pA === "number";
+        const numB = typeof pB === "number";
+        if (numA && !numB)
+            return -1;
+        if (!numA && numB)
+            return 1;
+        if (numA && numB) {
+            return pA > pB ? 1 : -1;
+        }
+        return pA.localeCompare(pB) > 0 ? 1 : -1;
+    }
+    return 0;
+}
+/** Compares two semver version strings. Returns true if current >= minimum. */
+export function isVersionAtLeast(current, minimum) {
+    const cmp = compareSemver(current, minimum);
+    if (cmp === null)
+        return false;
+    return cmp >= 0;
+}
+/**
+ * Checks whether the running Flisk CLI meets the minimum version required to adopt Compose repos.
+ * If the installed core is older than the buildContext release (1.3.104), exit before writing
+ * and print the upgrade command.
+ */
+export function checkCoreVersion(currentVersion = getPackageVersion(), args = []) {
+    const isWriting = !args.includes("--dry-run") && !args.includes("--help") && !args.includes("-h");
+    if (!isWriting) {
+        return { ok: true };
+    }
+    if (!isVersionAtLeast(currentVersion, MIN_CORE_VERSION)) {
+        return {
+            ok: false,
+            message: `flisk import: installed Flisk core (${currentVersion}) is older than the required ${MIN_CORE_VERSION} (buildContext release). Upgrade with: flisk upgrade`,
+        };
+    }
+    return { ok: true };
+}
+export function importInvocation(args, env = process.env, platform = process.platform) {
+    const pkg = env.TDK_IMPORT_PACKAGE || IMPORT_PACKAGE;
+    return {
+        command: platform === "win32" ? "npx.cmd" : "npx",
+        args: ["--yes", pkg, ...args],
+        shell: platform === "win32",
+    };
+}
+/** Runs tdk-import with the caller's terminal and resolves to its exit code. */
+export function runImport(args, spawnFn = spawn, getVersionFn = getPackageVersion) {
+    const check = checkCoreVersion(getVersionFn(), args);
+    if (!check.ok) {
+        console.error(check.message);
+        return Promise.resolve(1);
+    }
+    const invocation = importInvocation(args);
+    return new Promise((resolve) => {
+        const child = spawnFn(invocation.command, invocation.args, {
+            stdio: "inherit",
+            shell: invocation.shell,
+        });
+        child.on("error", (err) => {
+            console.error(`flisk import: could not run npx (${err.message}). Install Node.js/npm and retry.`);
+            resolve(127);
+        });
+        child.on("close", (code) => resolve(code ?? 1));
+    });
+}
+export function buildForwardedImportArgs(args, options = {}) {
+    let yes = Boolean(options.yes);
+    let force = Boolean(options.force);
+    const filtered = [];
+    for (const arg of args) {
+        if (arg === "--yes" || arg === "-y") {
+            yes = true;
+        }
+        else if (arg === "--force" || arg === "-f") {
+            force = true;
+        }
+        else {
+            filtered.push(arg);
+        }
+    }
+    if (yes) {
+        filtered.push("--yes");
+    }
+    if (force) {
+        filtered.push("--force");
+    }
+    return filtered;
+}
+export const importCommand = addYesOption(new Command("import"))
+    .description("Import the services in a directory's root docker-compose.yml (runs tdk-import)")
+    .argument("[args...]", "Passed to tdk-import: [dir] --dry-run --yes --force")
+    .option("-f, --force", "Overwrite an existing service.json", false)
+    .allowUnknownOption()
+    .helpOption(false)
+    .action(async (args, options) => {
+    const forwardedArgs = buildForwardedImportArgs(args, options);
+    process.exitCode = await runImport(forwardedArgs);
+});

package/cli/dist/commands/logs.js

@@ -0,0 +1,119 @@
+// Copyright (c) 2026 Flisk Landscape contributors
+// SPDX-License-Identifier: MIT
+import { Command } from "commander";
+import { STANDARD_PORTS } from "../utils/constants.js";
+import { errorFactories, runCommand, showErrorAndExit, TdkError } from "../utils/errors.js";
+import { createMachineEnvelope } from "../utils/machine-output.js";
+import { findProjectRoot } from "../utils/paths.js";
+import { EnvUnreadableError, envSecretValues, redactSecrets, redactValue, } from "../utils/secret-redaction.js";
+import { isTiltAvailable, runTilt } from "../utils/tilt.js";
+import { DEFAULT_LOG_TAIL, isTiltConnectionFailure, isValidPort, isValidSince, isValidTail, MAX_LOG_TAIL, parseTiltLogLines, } from "../utils/tilt-logs.js";
+import { tiltUnreachableMessage } from "../utils/tilt-unreachable-message.js";
+/** Resource names Tilt knows about, or null when they cannot be listed (the logs call then reports the real error). */
+async function tiltResourceNames(port) {
+    try {
+        const result = await runTilt("get", ["uiresources", "-o", "json", "--port", port], {
+            inheritStdio: false,
+        });
+        if (result.exitCode !== 0)
+            return null;
+        const items = JSON.parse(result.stdout)
+            .items;
+        return (items ?? []).flatMap((item) => (item.metadata?.name ? [item.metadata.name] : []));
+    }
+    catch {
+        return null;
+    }
+}
+export const logsCommand = new Command("logs")
+    .description("Print a bounded snapshot of recent logs from the running stack")
+    .option("-s, --service <names...>", "Only these services (Tilt resource names)")
+    .option("--tail <n>", "Number of most recent lines to return", String(DEFAULT_LOG_TAIL))
+    .option("--since <duration>", "Only logs newer than this duration, for example 30s, 5m, 1h")
+    .option("--port <n>", "Tilt UI port (default: TILT_PORT or 10350)")
+    .option("--json", "Output one JSON object and exit", false)
+    .action(async (options) => {
+    let secrets = [];
+    const fail = (code, rawMessage, exitCode = 1, suggestions = []) => {
+        const message = redactSecrets(rawMessage, secrets);
+        const redactedSuggestions = redactValue(suggestions, secrets);
+        if (options.json) {
+            console.log(JSON.stringify(createMachineEnvelope(null, [
+                {
+                    code,
+                    message,
+                    ...(redactedSuggestions.length > 0 ? { suggestions: redactedSuggestions } : {}),
+                },
+            ])));
+            console.error(message);
+            process.exit(exitCode);
+        }
+        if (redactedSuggestions.length > 0) {
+            return new TdkError(message, redactedSuggestions, exitCode).exit();
+        }
+        return showErrorAndExit(message, exitCode);
+    };
+    if (!isValidTail(options.tail))
+        fail("USAGE", `--tail must be an integer from 1 to ${MAX_LOG_TAIL}`, 2);
+    if (options.since !== undefined && !isValidSince(options.since)) {
+        fail("USAGE", "--since must be a duration such as 30s, 5m or 1h", 2);
+    }
+    const portText = options.port ?? process.env.TILT_PORT ?? String(STANDARD_PORTS.tiltUi);
+    if (!isValidPort(portText))
+        fail("USAGE", "--port must be a valid port number", 2);
+    const tail = Number(options.tail);
+    const services = options.service ?? [];
+    const action = async () => {
+        const projectRoot = findProjectRoot();
+        if (!projectRoot) {
+            // Same code `writeMachineError` gives this error in `down`, `stacks` and `resources`.
+            const error = errorFactories.notInProject();
+            return fail("COMMAND_FAILED", error.message, error.exitCode, error.suggestions);
+        }
+        try {
+            secrets = envSecretValues(projectRoot);
+        }
+        catch (error) {
+            if (!(error instanceof EnvUnreadableError))
+                throw error;
+            fail("ENV_UNREADABLE", error.message, 1, [
+                "Fix the read permission on .env, or move it out of the project",
+            ]);
+        }
+        if (!(await isTiltAvailable())) {
+            fail("TILT_MISSING", "Tilt is not installed. Run: flisk doctor");
+        }
+        if (services.length > 0) {
+            const known = await tiltResourceNames(portText);
+            const unknown = services.filter((name) => known && !known.includes(name));
+            if (unknown.length > 0) {
+                const error = errorFactories.unknownServices(unknown, known ?? []);
+                const suggestions = error.suggestions;
+                fail("UNKNOWN_SERVICE", error.message, error.exitCode, suggestions);
+            }
+        }
+        const args = ["--port", portText, "--tail", String(tail)];
+        if (options.since !== undefined)
+            args.push("--since", options.since);
+        if (options.json)
+            args.push("--json");
+        // `--` so a service name that starts with "-" is never read as a Tilt flag.
+        if (services.length > 0)
+            args.push("--", ...services);
+        const result = await runTilt("logs", args, { inheritStdio: false });
+        if (result.exitCode !== 0) {
+            const detail = result.stderr.trim();
+            if (!detail || isTiltConnectionFailure(detail)) {
+                fail("TILT_NOT_RUNNING", tiltUnreachableMessage(portText));
+            }
+            fail("TILT_LOGS_FAILED", `tilt logs failed: ${detail}`);
+        }
+        if (!options.json) {
+            process.stdout.write(redactSecrets(result.stdout, secrets));
+            return;
+        }
+        const lines = parseTiltLogLines(result.stdout, tail);
+        console.log(JSON.stringify(redactValue(createMachineEnvelope({ services, tail, since: options.since ?? null, lines }), secrets)));
+    };
+    await runCommand(action);
+});