@flisk-sh/flisk 0.0.0-stage → 1.3.190

package/cli/dist/commands/resources.js

@@ -0,0 +1,127 @@
+// Copyright (c) 2026 Flisk Landscape contributors
+// SPDX-License-Identifier: MIT
+import chalk from "chalk";
+import { Command } from "commander";
+import { VALID_RESOURCE_TYPES } from "../utils/constants.js";
+import { createDiscoveryContext } from "../utils/discovery-context.js";
+import { errorFactories, requireProjectRoot, runCommand, TdkError } from "../utils/errors.js";
+import { formatCount, showAllSatisfyCondition, showDetail, showEmptyState, showStep, } from "../utils/formatting.js";
+import { createMachineEnvelope, writeMachineError } from "../utils/machine-output.js";
+import { findProjectRoot } from "../utils/paths.js";
+import { stackExists } from "../utils/services.js";
+import { includes } from "../utils/validation.js";
+export const resourcesCommand = new Command("resources")
+    .description("List all resources (services) in the project")
+    .option("-v, --verbose", "Show detailed information about each resource", false)
+    .option("-s, --stack <stack>", "Filter resources by stack name")
+    .option("-t, --type <type>", "Filter resources by type")
+    .option("--no-stack", "Show only resources without a stack")
+    .option("--ports", "Show port assignments", false)
+    .option("--json", "Output a versioned JSON resource report", false)
+    .action(async (options) => {
+    const action = async () => {
+        if (options.json) {
+            if (!findProjectRoot()) {
+                writeMachineError(errorFactories.notInProject());
+            }
+        }
+        else {
+            requireProjectRoot();
+        }
+        if (options.type !== undefined && !includes(VALID_RESOURCE_TYPES, options.type)) {
+            throw new TdkError(`Invalid resource type "${options.type}"`, [
+                `Valid types: ${VALID_RESOURCE_TYPES.join(", ")}`,
+            ]);
+        }
+        const discovery = createDiscoveryContext();
+        if (options.stack && !stackExists(options.stack, discovery.resources)) {
+            const error = errorFactories.stackNotFound(options.stack, discovery.stackNames);
+            if (options.json)
+                writeMachineError(error);
+            error.exit();
+        }
+        const withoutStackFilter = options.noStack || options.stack === false;
+        let resources = discovery.resources;
+        if (options.stack) {
+            resources = discovery.resourcesByStack.get(options.stack) || [];
+            if (resources.length === 0 && !options.json && options.type === undefined) {
+                showEmptyState("stack-services", ` in stack "${options.stack}"`);
+                return;
+            }
+        }
+        if (withoutStackFilter) {
+            resources = discovery.unassignedResources;
+            if (resources.length === 0 && !options.json && options.type === undefined) {
+                showAllSatisfyCondition("resources", "assigned to a stack");
+                return;
+            }
+        }
+        if (options.type !== undefined) {
+            resources = resources.filter((resource) => (resource.config?.appType ?? resource.type) === options.type);
+        }
+        if (options.json) {
+            const data = resources.map((resource) => ({
+                name: resource.name,
+                stack: resource.stack ?? null,
+                type: resource.config?.appType ?? resource.type ?? "unknown",
+                port: resource.port ?? null,
+                path: resource.configPath,
+            }));
+            console.log(JSON.stringify(createMachineEnvelope({ resources: data })));
+            return;
+        }
+        if (resources.length === 0) {
+            const stackContext = options.stack ? ` in stack "${options.stack}"` : "";
+            const noStackContext = withoutStackFilter && !options.stack ? " without a stack" : "";
+            const typeContext = options.type !== undefined ? ` with type "${options.type}"` : "";
+            showEmptyState(options.stack ? "stack-services" : "resources", stackContext + noStackContext + typeContext);
+            return;
+        }
+        showStep(`Found ${formatCount(resources.length, "resource")}:\n`);
+        if (options.verbose || options.ports) {
+            for (const resource of resources) {
+                console.log(chalk.bold(`${resource.name}`));
+                if (resource.stack) {
+                    console.log(chalk.gray(`  Stack: ${resource.stack}`));
+                }
+                else {
+                    console.log(chalk.yellow(`  Stack: (not assigned)`));
+                }
+                if (options.ports && resource.port) {
+                    console.log(chalk.gray(`  Port: ${resource.port}`));
+                }
+                if (options.verbose) {
+                    console.log(chalk.gray(`  Type: ${resource.type || "unknown"}`));
+                    console.log(chalk.gray(`  Path: ${resource.configPath}`));
+                }
+                console.log();
+            }
+        }
+        else {
+            for (const resource of resources) {
+                const stackInfo = resource.stack
+                    ? chalk.gray(` [${resource.stack}]`)
+                    : chalk.yellow(" [no stack]");
+                console.log(`  ${resource.name}${stackInfo}`);
+            }
+            showDetail("\nRun with --verbose for more details or --ports to see port assignments.", 0);
+        }
+        const withoutStackCount = options.stack || options.type !== undefined
+            ? resources.filter((r) => !r.stack).length
+            : discovery.unassignedResources.length;
+        if (withoutStackCount > 0 && !withoutStackFilter && !options.stack) {
+            console.log(chalk.yellow(`\n${formatCount(withoutStackCount, "resource")} not assigned to any stack.`));
+            showDetail('Run "flisk resources --no-stack" to see them, or "flisk stack" to assign them.');
+        }
+    };
+    if (options.json) {
+        try {
+            await action();
+        }
+        catch (error) {
+            writeMachineError(error);
+        }
+        return;
+    }
+    await runCommand(action);
+});

package/cli/dist/commands/restart.js

@@ -0,0 +1,89 @@
+// Copyright (c) 2026 Flisk Landscape contributors
+// SPDX-License-Identifier: MIT
+import chalk from "chalk";
+import { Command } from "commander";
+import { STANDARD_PORTS } from "../utils/constants.js";
+import { errorFactories, runCommand, showErrorAndExit, TdkError } from "../utils/errors.js";
+import { createMachineEnvelope, writeMachineError } from "../utils/machine-output.js";
+import { findProjectRoot } from "../utils/paths.js";
+import { isTiltAvailable, runTilt } from "../utils/tilt.js";
+import { isTiltConnectionFailure, isValidPort } from "../utils/tilt-logs.js";
+import { tiltUnreachableMessage } from "../utils/tilt-unreachable-message.js";
+export const restartCommand = new Command("restart")
+    .description("Restart a running resource in the stack")
+    .argument("<resource>", "Name of the resource (service) to restart")
+    .option("--port <n>", "Tilt UI port (default: TILT_PORT or 10350)")
+    .option("--json", "Output one JSON object and exit", false)
+    .action(async (resourceName, options) => {
+    const portText = options.port ?? process.env.TILT_PORT ?? String(STANDARD_PORTS.tiltUi);
+    if (!isValidPort(portText)) {
+        const portSource = options.port !== undefined ? "--port" : "TILT_PORT";
+        const message = `${portSource} must be a valid port number`;
+        if (options.json) {
+            console.log(JSON.stringify(createMachineEnvelope(null, [{ code: "USAGE", message }])));
+            console.error(message);
+            process.exit(2);
+        }
+        showErrorAndExit(message, 2);
+    }
+    const action = async () => {
+        const root = findProjectRoot();
+        if (!root) {
+            const error = errorFactories.notInProject();
+            if (options.json)
+                writeMachineError(error);
+            error.exit();
+        }
+        let tiltAvailable = false;
+        try {
+            tiltAvailable = await isTiltAvailable();
+        }
+        catch {
+            tiltAvailable = false;
+        }
+        if (!tiltAvailable) {
+            // isTiltAvailable collapses missing binary and nonzero version into false.
+            // Report TILT_NOT_RUNNING for both; a missing binary is rare and still surfaces via doctor.
+            const msg = tiltUnreachableMessage(portText);
+            if (options.json) {
+                console.log(JSON.stringify(createMachineEnvelope(null, [{ code: "TILT_NOT_RUNNING", message: msg }])));
+                process.exit(1);
+            }
+            throw new TdkError(msg, ["Start the stack first with: flisk up"]);
+        }
+        const result = await runTilt("trigger", [resourceName, "--port", portText], {
+            inheritStdio: false,
+        });
+        if (result.exitCode !== 0) {
+            const detail = result.stderr.trim();
+            if (!detail || isTiltConnectionFailure(detail)) {
+                const msg = tiltUnreachableMessage(portText);
+                if (options.json) {
+                    console.log(JSON.stringify(createMachineEnvelope(null, [{ code: "TILT_NOT_RUNNING", message: msg }])));
+                    process.exit(1);
+                }
+                throw new TdkError(msg, ["Start the stack first with: flisk up"]);
+            }
+            if (options.json) {
+                console.log(JSON.stringify(createMachineEnvelope(null, [{ code: "TILT_TRIGGER_FAILED", message: detail }])));
+                process.exit(1);
+            }
+            throw new TdkError(`Failed to restart ${resourceName}: ${detail}`);
+        }
+        if (options.json) {
+            console.log(JSON.stringify(createMachineEnvelope({ resource: resourceName, restarted: true })));
+            return;
+        }
+        console.log(chalk.green(`✓ Triggered restart for ${resourceName}`));
+    };
+    if (options.json) {
+        try {
+            await action();
+        }
+        catch (err) {
+            writeMachineError(err);
+        }
+        return;
+    }
+    await runCommand(action);
+});

package/cli/dist/commands/runtime.js

@@ -0,0 +1,75 @@
+// Copyright (c) 2026 Flisk Landscape contributors
+// SPDX-License-Identifier: MIT
+import { statSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { Command } from "commander";
+import { findCliAssetRoot, loadTemplate } from "../generator/template-engine.js";
+const REQUIRED_ASSET_PATHS = [
+    { path: "Tiltfile", directory: false },
+    { path: "engine", directory: true },
+    { path: "discovery", directory: true },
+    { path: "specs", directory: true },
+    { path: "ext", directory: true },
+    { path: "cli/templates", directory: true },
+    { path: "shared-platform-engineering/docker-templates", directory: true },
+];
+const REQUIRED_TEMPLATES = [
+    ".tiltignore.hbs",
+    "TILT_RESOURCE_DEFAULTS.star.hbs",
+    "TILT_TECH_STACK.star.hbs",
+    "Tiltfile.hbs",
+    "spec.master.hbs",
+];
+export const runtimeCommand = new Command("runtime")
+    .description("Inspect the packaged Flisk runtime assets")
+    .option("--check-assets", "Check bundled engine and template assets")
+    .option("--json", "Print the check result as JSON")
+    .action((options) => {
+    if (!options.checkAssets) {
+        runtimeCommand.outputHelp();
+        process.exitCode = 2;
+        return;
+    }
+    const candidate = findCliAssetRoot();
+    const assetRoot = candidate ? resolve(candidate) : null;
+    const missing = assetRoot
+        ? REQUIRED_ASSET_PATHS.filter(({ path, directory }) => {
+            try {
+                const stats = statSync(join(assetRoot, path));
+                return directory ? !stats.isDirectory() : !stats.isFile();
+            }
+            catch {
+                return true;
+            }
+        }).map(({ path }) => path)
+        : REQUIRED_ASSET_PATHS.map(({ path }) => path);
+    const templateErrors = [];
+    if (assetRoot && missing.length === 0) {
+        for (const template of REQUIRED_TEMPLATES) {
+            try {
+                loadTemplate(template);
+            }
+            catch (error) {
+                templateErrors.push(error instanceof Error ? error.message : `Failed to load template ${template}`);
+            }
+        }
+    }
+    const ok = Boolean(assetRoot) && missing.length === 0 && templateErrors.length === 0;
+    if (options.json) {
+        console.log(JSON.stringify({ ok, assetRoot, missing, templateErrors }));
+    }
+    else if (ok) {
+        console.log(`Flisk runtime assets found at ${assetRoot}`);
+    }
+    else {
+        console.error([
+            assetRoot
+                ? `Incomplete Flisk runtime assets at ${assetRoot}`
+                : "Flisk runtime assets not found",
+            ...missing.map((path) => `Missing: ${path}`),
+            ...templateErrors,
+        ].join("\n"));
+    }
+    if (!ok)
+        process.exitCode = 1;
+});

package/cli/dist/commands/stack.js

@@ -0,0 +1,171 @@
+// Copyright (c) 2026 Flisk Landscape contributors
+// SPDX-License-Identifier: MIT
+import { readFileSync } from "node:fs";
+import chalk from "chalk";
+import { Command } from "commander";
+import { addYesOption, assertValid, confirmOrCancel } from "../utils/command-helpers.js";
+import { clearDiscoveryCache, createDiscoveryContext } from "../utils/discovery-context.js";
+import { errorFactories, requireProjectRoot, runCommand, TdkError } from "../utils/errors.js";
+import { writeJsonFile } from "../utils/file-helpers.js";
+import { formatCount, showAllSatisfyCondition, showCommandHeader, showDetail, showSuccess, } from "../utils/formatting.js";
+import { promptMultiSelect, promptText } from "../utils/prompt.js";
+import { createKebabCaseValidator, validateStackName } from "../utils/validation.js";
+export function parseStackResourceConfig(content, configPath) {
+    try {
+        return JSON.parse(content);
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new TdkError(`Could not parse service.json at ${configPath}: ${reason}`);
+    }
+}
+function normalizeResourceNames(names) {
+    const normalizedNames = names.flatMap((name) => name
+        .split(",")
+        .map((part) => part.trim())
+        .filter(Boolean));
+    return [...new Set(normalizedNames)];
+}
+export const stackCommand = addYesOption(new Command("stack"))
+    .description("Organize resources into stacks (groups)")
+    .argument("[stack-name]", "Stack name to assign to resources")
+    .option("--list", "List resources without a stack", false)
+    .option("--resources <names...>", "Resource names to add (comma- or space-separated)")
+    .action(async (stackName, options) => {
+    await runCommand(async () => {
+        requireProjectRoot();
+        showCommandHeader("Stack Management");
+        const discovery = createDiscoveryContext();
+        if (discovery.resources.length === 0 && options.resources === undefined) {
+            console.log(chalk.yellow("No resources discovered. Make sure you're in a project with service.json files."));
+            return;
+        }
+        showDetail(`Found ${formatCount(discovery.resources.length, "resource")}\n`, 0);
+        if (discovery.stackNames.length > 0) {
+            console.log(chalk.bold("Existing stacks:"));
+            for (const name of discovery.stackNames) {
+                const count = discovery.resourcesByStack.get(name)?.length || 0;
+                showDetail(`${name} (${formatCount(count, "resource")})`);
+            }
+            console.log();
+        }
+        if (options.list) {
+            if (discovery.unassignedResources.length === 0) {
+                showAllSatisfyCondition("resources", "already assigned to a stack");
+                return;
+            }
+            console.log(chalk.bold(`${discovery.unassignedResources.length} resources without a stack:`));
+            for (const resource of discovery.unassignedResources) {
+                showDetail(`${resource.name}`);
+                showDetail(`${resource.configPath}`, 4);
+            }
+            return;
+        }
+        if (!process.stdin.isTTY) {
+            if (options.resources === undefined) {
+                throw new TdkError("Interactive resource selection requires a TTY.", [
+                    "Pass --resources <name...> to select resources without a prompt.",
+                    "Use --list to inspect unassigned resources without changing them.",
+                ]);
+            }
+            if (!stackName) {
+                throw new TdkError("A stack name is required when stdin is not a TTY.", [
+                    "Use: flisk stack <stack-name> --resources <name...> [--yes]",
+                ]);
+            }
+            if (!options.yes) {
+                throw new TdkError("Confirmation requires a TTY.", [
+                    "Pass --yes to skip confirmation when assigning resources without a TTY.",
+                ]);
+            }
+        }
+        if (stackName)
+            assertValid(validateStackName(stackName));
+        let targetStack = stackName;
+        if (!targetStack) {
+            const name = await promptText({
+                message: "Stack name (kebab-case recommended):",
+                validate: (input) => {
+                    const validation = createKebabCaseValidator("stack")(input);
+                    return validation === true || validation;
+                },
+            });
+            targetStack = name;
+        }
+        const resourcesToUpdate = discovery.unassignedResources;
+        const selectedResources = [];
+        if (options.resources !== undefined) {
+            const requestedNames = normalizeResourceNames(options.resources);
+            if (requestedNames.length === 0) {
+                throw new TdkError("Pass at least one resource name to --resources.", [
+                    "Example: `flisk stack api --resources users-api orders-api --yes`",
+                ]);
+            }
+            const configPathsByName = new Map();
+            for (const resource of discovery.resources) {
+                const configPaths = configPathsByName.get(resource.name) ?? [];
+                configPaths.push(resource.configPath);
+                configPathsByName.set(resource.name, configPaths);
+            }
+            const duplicates = [...configPathsByName].filter(([, configPaths]) => configPaths.length > 1);
+            if (duplicates.length > 0) {
+                throw new TdkError("Cannot assign resources while duplicate names are present.", duplicates.map(([name, configPaths]) => `Duplicate "${name}" found in ${configPaths.join(" and ")}`));
+            }
+            const validNames = [...configPathsByName.keys()].sort();
+            const resourceByName = new Map(discovery.resources.map((resource) => [resource.name, resource]));
+            for (const name of requestedNames) {
+                const resource = resourceByName.get(name);
+                if (!resource) {
+                    const error = errorFactories.resourceNotFound(name, validNames);
+                    error.suggestions.unshift(`Valid resources: ${validNames.join(", ")}`);
+                    throw error;
+                }
+                if (resource.stack) {
+                    throw new TdkError(`Resource "${name}" is already assigned to stack "${resource.stack}".`, ["Run `flisk resources` to review current assignments."]);
+                }
+                selectedResources.push(resource.configPath);
+            }
+        }
+        else {
+            if (resourcesToUpdate.length === 0) {
+                console.log(chalk.yellow("\nNo resources available to add to this stack."));
+                return;
+            }
+            const promptedResources = await promptMultiSelect({
+                message: `Select resources to add to stack "${targetStack}":`,
+                choices: resourcesToUpdate.map((resource) => ({
+                    title: resource.name,
+                    value: resource.configPath,
+                })),
+                validate: (input) => {
+                    if (input.length === 0)
+                        return "Select at least one resource";
+                    return true;
+                },
+            });
+            if (promptedResources.length === 0) {
+                console.log(chalk.yellow("No resources selected. Exiting."));
+                return;
+            }
+            selectedResources.push(...promptedResources);
+        }
+        showDetail(`\nWill add "stack": "${targetStack}" to ${formatCount(selectedResources.length, "resource")}.`, 0);
+        const confirmed = options.yes || (await confirmOrCancel("Proceed?"));
+        if (!confirmed)
+            return;
+        // Clear cache since we're about to modify resources
+        clearDiscoveryCache();
+        let updated = 0;
+        for (const configPath of selectedResources) {
+            const content = readFileSync(configPath, "utf-8");
+            const config = parseStackResourceConfig(content, configPath);
+            config.stack = targetStack;
+            writeJsonFile(configPath, config);
+            updated++;
+            showSuccess(`${config.appName || configPath}`);
+        }
+        console.log();
+        showSuccess(`Updated ${formatCount(updated, "resource")}.`);
+        showDetail(`\nYou can now run: flisk up ${targetStack}`, 0);
+    });
+});

package/cli/dist/commands/stacks.js

@@ -0,0 +1,71 @@
+// Copyright (c) 2026 Flisk Landscape contributors
+// SPDX-License-Identifier: MIT
+import chalk from "chalk";
+import { Command } from "commander";
+import { createDiscoveryContext } from "../utils/discovery-context.js";
+import { errorFactories, runCommand } from "../utils/errors.js";
+import { formatCount, showDetail, showEmptyState, showStep } from "../utils/formatting.js";
+import { createMachineEnvelope, writeMachineError } from "../utils/machine-output.js";
+import { findProjectRoot } from "../utils/paths.js";
+export const stacksCommand = new Command("stacks")
+    .description("List all stacks and their resources")
+    .alias("ls") // Keep 'flisk ls' as shorthand
+    .option("-v, --verbose", "Show detailed information about each stack", false)
+    .option("--services", "Include list of services in each stack", false)
+    .option("--json", "Output a versioned JSON stack report", false)
+    .action(async (options) => {
+    const action = async () => {
+        if (options.json && !findProjectRoot()) {
+            writeMachineError(errorFactories.notInProject());
+        }
+        const discovery = createDiscoveryContext();
+        const verbose = options.verbose || stacksCommand.parent?.opts().verbose === true;
+        if (options.json) {
+            const stacks = discovery.stacks.map((stack) => ({
+                name: stack.name,
+                resourceCount: stack.resourceCount,
+                ...(verbose ? { description: stack.description } : {}),
+                ...(options.services ? { services: stack.resources.map((service) => service.name) } : {}),
+            }));
+            console.log(JSON.stringify(createMachineEnvelope({ stacks })));
+            return;
+        }
+        if (discovery.stackNames.length === 0) {
+            showEmptyState("stacks");
+            return;
+        }
+        if (verbose || options.services) {
+            showStep(`Found ${formatCount(discovery.stacks.length, "stack")}:\n`);
+            for (const stack of discovery.stacks) {
+                console.log(chalk.bold(`${stack.name}`));
+                showDetail(`${stack.description}`);
+                if (options.services) {
+                    showDetail("Services:");
+                    for (const service of stack.resources) {
+                        showDetail(`${service.name}`, 4);
+                    }
+                }
+                console.log();
+            }
+        }
+        else {
+            showStep(`Found ${formatCount(discovery.stackNames.length, "stack")}:\n`);
+            for (const name of discovery.stackNames) {
+                const serviceCount = discovery.resourcesByStack.get(name)?.length || 0;
+                console.log(chalk.bold(`  ${name}`));
+                showDetail(`${formatCount(serviceCount, "service")}`, 4);
+            }
+            showDetail("\nRun with --verbose for more details, or --services to see all services in each stack.", 0);
+        }
+    };
+    if (options.json) {
+        try {
+            await action();
+        }
+        catch (error) {
+            writeMachineError(error);
+        }
+        return;
+    }
+    await runCommand(action);
+});