@flisk-sh/flisk 1.4.5 → 1.4.7

package/cli/dist/commands/ui.js

@@ -7,6 +7,7 @@ import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { DetailPanel, FileTree, ResourceSelectInput, ResourceTable, ServiceIssues, TabBar, TUIHeader, } from "../components/index.js";
 import { TABS } from "../components/TabBar.js";
 import { createTUITheme, sectionTitle, TUIThemeContext, useTUITheme, } from "../components/ui-theme.js";
+import { fetchAgentOverview } from "../utils/agent-sessions.js";
 import { errorFactories, requireProjectRoot } from "../utils/errors.js";
 import { readSavedHostPortPlan } from "../utils/host-port-config.js";
 import { findProjectRoot, getPackageVersion } from "../utils/paths.js";
@@ -16,6 +17,7 @@ import { buildAdvertisedTargets } from "../utils/service-urls.js";
 import { clearMetadataCache, discoverResources, discoverStacks, getResourceMetadata, getStackMetadata, } from "../utils/services.js";
 import { singleFlight } from "../utils/single-flight.js";
 import { createStatusMessageController } from "../utils/status-message.js";
+import { buildServicePorts } from "../utils/status-ports.js";
 import { getListRowFromMouseY, getTerminalRuleWidth } from "../utils/terminal-layout.js";
 import { isTiltAvailable } from "../utils/tilt.js";
 import { loadTiltEvents, stripTerminalControls, TiltEventsLoadError, } from "../utils/tilt-events.js";
@@ -134,12 +136,45 @@ export const TUIApp = ({ animated = true }) => {
         });
         const poll = () => run(() => fetchServiceStates(services, tiltPort));
         void poll();
-        const timer = setInterval(() => void poll(), 5000);
+        // The agent panel rides on this same timer: the selected agent is read once per tick, never one loop per agent.
+        const timer = setInterval(() => {
+            void poll();
+            void agentPollRef.current();
+        }, 5000);
         return () => {
             cancelled = true;
             clearInterval(timer);
         };
     }, [services]);
+    // Readiness and sessions of the selected agent resource, read from the agent itself through its ingress route.
+    const [agentOverview, setAgentOverview] = useState(null);
+    const agentRoute = useMemo(() => {
+        const resource = services.find((s) => s.name === selectedService);
+        if (!resource || (resource.config?.appType ?? resource.type) !== "agent")
+            return null;
+        const url = buildServicePorts(resource, ingressPort).url;
+        return url ? { name: resource.name, url } : null;
+    }, [services, selectedService, ingressPort]);
+    const agentPollRef = useRef(async () => { });
+    useEffect(() => {
+        if (!agentRoute) {
+            agentPollRef.current = async () => { };
+            setAgentOverview(null);
+            return;
+        }
+        let cancelled = false;
+        const run = singleFlight((overview) => {
+            if (!cancelled)
+                setAgentOverview({ name: agentRoute.name, overview });
+        });
+        agentPollRef.current = () => run(() => fetchAgentOverview(agentRoute.url));
+        setAgentOverview(null);
+        void agentPollRef.current();
+        return () => {
+            cancelled = true;
+            agentPollRef.current = async () => { };
+        };
+    }, [agentRoute]);
     // Re-read service.json files from disk. An empty project is not an error:
     // it renders EmptyState. Only a failed discovery shows ErrorScreen.
     const refresh = useCallback(() => {
@@ -648,7 +683,11 @@ export const TUIApp = ({ animated = true }) => {
                                                                                 ? theme.info
                                                                                 : theme.success, children: [formatEventTime(event.occurredAt), " ", event.resourceName, " ", event.title] }), event.details && (_jsx(Text, { color: theme.muted, children: formatEventDetails(event.details, mainPanelWidth) }))] }, event.id))) })) : (_jsx(Text, { color: theme.muted, children: "No recent build events are available from Tilt yet." }))] }))] })), activeTab === "config" && (_jsxs(_Fragment, { children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: theme.muted, children: sectionTitle(theme, "Configuration") }) }), selectedServiceData ? (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { color: theme.accent, children: selectedServiceData.service.configPath }), _jsx(Box, { marginTop: 1, ...(theme.ascii
                                                             ? {}
-                                                            : { borderStyle: "single", borderColor: theme.border }), paddingX: 1, children: _jsx(Text, { color: theme.muted, wrap: "wrap", children: JSON.stringify(selectedServiceData.service.config, null, 2).slice(0, 1000) }) })] })) : (_jsxs(_Fragment, { children: [_jsx(Text, { color: theme.muted, children: "Select a service to view configuration" }), _jsx(Box, { marginTop: 1, children: _jsx(ResourceSelectInput, { items: items, onSelect: handleSelect, highlightedIndex: highlightedIndex, isActive: !isSearching, maxVisibleItems: pageSize, width: mainPanelWidth, onLayout: handleListLayout }) })] }))] }))] }), showSidebar && (_jsx(Box, { marginLeft: 2, children: _jsx(DetailPanel, { stack: selectedStackData?.stack || null, service: selectedServiceData?.service || null, stackMetadata: selectedStackData?.metadata || null, visible: !!selectedStack || !!selectedService }) }))] }), _jsxs(Box, { ...(theme.ascii ? {} : { borderStyle: "single", borderColor: theme.border }), paddingX: 1, height: 3, flexDirection: "column", marginTop: 1, children: [_jsxs(Box, { justifyContent: "space-between", children: [_jsxs(Text, { color: theme.accent, bold: true, children: [theme.bannerStart, " ", activeTab] }), _jsxs(Text, { color: theme.success, children: [theme.ascii ? "[+]" : "\u25cf", " ", services.filter((s) => s.stack).length, " in stack"] }), _jsxs(Text, { color: theme.warning, children: [theme.ascii ? "-" : "\u25cb", " ", services.filter((s) => !s.stack).length, " no stack"] })] }), _jsxs(Box, { justifyContent: "space-between", children: [_jsxs(Text, { color: theme.muted, children: ["Stacks: ", stacks.length] }), _jsxs(Text, { color: theme.muted, children: ["Services: ", services.length] }), _jsxs(Text, { color: theme.muted, children: [theme.ascii ? "Mouse" : "🖱️", " ", mouseEnabled ? "ON" : "OFF", theme.separator, theme.ascii ? "Info" : "ℹ️", " ", showTooltips ? "ON" : "OFF", theme.separator, _jsx(Text, { color: showEnabledOnly ? theme.success : theme.warning, children: showEnabledOnly
+                                                            : { borderStyle: "single", borderColor: theme.border }), paddingX: 1, children: _jsx(Text, { color: theme.muted, wrap: "wrap", children: JSON.stringify(selectedServiceData.service.config, null, 2).slice(0, 1000) }) })] })) : (_jsxs(_Fragment, { children: [_jsx(Text, { color: theme.muted, children: "Select a service to view configuration" }), _jsx(Box, { marginTop: 1, children: _jsx(ResourceSelectInput, { items: items, onSelect: handleSelect, highlightedIndex: highlightedIndex, isActive: !isSearching, maxVisibleItems: pageSize, width: mainPanelWidth, onLayout: handleListLayout }) })] }))] }))] }), showSidebar && (_jsx(Box, { marginLeft: 2, children: _jsx(DetailPanel, { stack: selectedStackData?.stack || null, service: selectedServiceData?.service || null, stackMetadata: selectedStackData?.metadata || null, agent: agentRoute && selectedServiceData
+                                        ? agentOverview?.name === agentRoute.name
+                                            ? agentOverview.overview
+                                            : null
+                                        : undefined, visible: !!selectedStack || !!selectedService }) }))] }), _jsxs(Box, { ...(theme.ascii ? {} : { borderStyle: "single", borderColor: theme.border }), paddingX: 1, height: 3, flexDirection: "column", marginTop: 1, children: [_jsxs(Box, { justifyContent: "space-between", children: [_jsxs(Text, { color: theme.accent, bold: true, children: [theme.bannerStart, " ", activeTab] }), _jsxs(Text, { color: theme.success, children: [theme.ascii ? "[+]" : "\u25cf", " ", services.filter((s) => s.stack).length, " in stack"] }), _jsxs(Text, { color: theme.warning, children: [theme.ascii ? "-" : "\u25cb", " ", services.filter((s) => !s.stack).length, " no stack"] })] }), _jsxs(Box, { justifyContent: "space-between", children: [_jsxs(Text, { color: theme.muted, children: ["Stacks: ", stacks.length] }), _jsxs(Text, { color: theme.muted, children: ["Services: ", services.length] }), _jsxs(Text, { color: theme.muted, children: [theme.ascii ? "Mouse" : "🖱️", " ", mouseEnabled ? "ON" : "OFF", theme.separator, theme.ascii ? "Info" : "ℹ️", " ", showTooltips ? "ON" : "OFF", theme.separator, _jsx(Text, { color: showEnabledOnly ? theme.success : theme.warning, children: showEnabledOnly
                                                     ? theme.ascii
                                                         ? "[+] enabled"
                                                         : "\u2713 enabled"

package/cli/dist/commands/up.js

@@ -12,7 +12,7 @@ import { STANDARD_PORTS } from "../utils/constants.js";
 import { getDeferredResourceNames, summarizeTiltBuildError } from "../utils/doctor-runtime.js";
 import { applyEnvFileSelection, assertEngineSupportsEnvFile, EnvFileError, envFileWarning, PROJECT_ENV_FILE_VAR, selectEnvFile, } from "../utils/env-selection.js";
 import { completeEnvFile } from "../utils/env-validator.js";
-import { errorFactories, FliskError, getErrorMessage, handleTiltFailure, requireProjectRoot, runCommand, showError, showErrorAndExit, withTiltCheck, } from "../utils/errors.js";
+import { errorFactories, FliskError, getErrorMessage, requireProjectRoot, runCommand, showError, showErrorAndExit, withTiltCheck, } from "../utils/errors.js";
 import { ensureSmokeRecordsIgnored } from "../utils/file-helpers.js";
 import { evaluateFliskVersionFloor } from "../utils/flisk-version.js";
 import { formatCount } from "../utils/formatting.js";
@@ -20,6 +20,9 @@ import { exportHostPortPlan, getHostPortPlan, writeSavedHostPortPlan, } from "..
 import { formatHostPortPlan } from "../utils/host-port-plan.js";
 import { createJsonEmitter } from "../utils/json-output.js";
 import { toMachineError } from "../utils/machine-output.js";
+import { hasNearbyServiceJson } from "../utils/native-project.js";
+import { formatMixedRuntimeRefusal, isNativeProject, isNativeService, resolveRuntimeMode, } from "../utils/native-service.js";
+import { runNativeUp } from "../utils/native-up.js";
 import { nativeWindowsStackRefusal } from "../utils/native-windows.js";
 import { findProjectRoot, getPackageVersion } from "../utils/paths.js";
 import { findAvailablePort } from "../utils/port-assignment.js";
@@ -31,14 +34,16 @@ import { enforceServiceConfigGate, warnSchemaVersions } from "../utils/service-c
 import { appendHealthPath, resolveServiceUrl, resolveSubdomainBases, } from "../utils/service-urls.js";
 import { discoverResourcesStrict, discoverResourcesWithProblems, discoverStacks, getResourcesForStack, stackExists, warnAboutSkippedFiles, } from "../utils/services.js";
 import { buildSmokePlans, formatSmokeFailure, runSmokePlans, safeSmokeDeps, } from "../utils/smoke.js";
-import { buildStartupReport, formatStartupReport, isStartupStalled, } from "../utils/startup-report.js";
+import { buildStartupReport, formatStartupReport, isStartupStalled, machineProblemFixes, } from "../utils/startup-report.js";
 import { buildTiltUpArgs, runTilt } from "../utils/tilt.js";
 import { classifyTiltPorts } from "../utils/tilt-port-owner.js";
 import { stopTiltOnPort } from "../utils/tilt-process.js";
 import { parseTiltPort, resolveTiltPort, secondUpAction, stopTiltForUp, } from "../utils/tilt-startup.js";
+import { upFailureHints } from "../utils/up-hints.js";
 import { findUnknownServices, resolveOnlySelection } from "../utils/up-only.js";
-import { tiltGetUiResources, waitForTiltResourcesReady } from "../utils/up-readiness.js";
-import { enableDiscoveredStacks } from "./project.js";
+import { createUpProgressReporter, fetchWithProgress, shouldRedrawUpProgress, } from "../utils/up-progress.js";
+import { tiltGetUiResources, tiltResourceLogs, waitForTiltResourcesReady, } from "../utils/up-readiness.js";
+import { enableDiscoveredStacks, writeDefaultProjectConfig } from "./project.js";
 export function formatUpSuccess(port, options = {}) {
     const { appUrls = [], serviceHealth = [], showLogsHint = serviceHealth.length > 0 } = options;
     const lines = [];
@@ -235,6 +240,67 @@ function envFileFailure(error) {
         exitCode: error instanceof FliskError ? error.exitCode : 2,
     };
 }
+/**
+ * Decides whether `flisk up` runs the selection as local processes (#2229). Returns null for today's Docker + Tilt path, which
+ * a project without any `command` service always takes. Outside a project, a directory whose services all declare `command`
+ * becomes the project. Refuses (through `fail`) an unknown stack or service, an invalid service.json, and a run that would mix
+ * native and container services.
+ */
+export function selectNativeRun(stackName, only, fail, cwd = process.cwd()) {
+    const foundRoot = findProjectRoot(cwd);
+    if (!foundRoot && !hasNearbyServiceJson(cwd))
+        return null;
+    const projectRoot = foundRoot ?? cwd;
+    let discovered;
+    try {
+        discovered = discoverResourcesWithProblems(projectRoot);
+    }
+    catch {
+        return null;
+    }
+    const all = discovered.resources;
+    if (!all.some(isNativeService))
+        return null;
+    if (!foundRoot && !isNativeProject(all))
+        return null;
+    if (discovered.problems.length > 0) {
+        fail("INVALID_SERVICE_CONFIG", discovered.problems
+            .map((problem) => `Invalid service.json at ${problem.path}: ${problem.reason}`)
+            .join("\n"));
+    }
+    let requested = all;
+    if (stackName) {
+        if (!stackExists(stackName, all)) {
+            const error = errorFactories.stackNotFound(stackName, discoverStacks(all).map((s) => s.name));
+            fail("STACK_NOT_FOUND", error.message, error.suggestions);
+        }
+        requested = getResourcesForStack(stackName, all);
+    }
+    if (only) {
+        const unknown = findUnknownServices(only, requested);
+        if (unknown.length > 0) {
+            const error = errorFactories.unknownServices(unknown, requested.map((service) => service.name));
+            fail("UNKNOWN_SERVICE", error.message, error.suggestions);
+        }
+    }
+    // A process cannot start before what it depends on, so a stack or --only selection always brings its dependsOn closure.
+    const names = only ?? requested.map((service) => service.name);
+    const selection = resolveOnlySelection(names, all);
+    const { mode, mixed } = resolveRuntimeMode(selection.selected, all);
+    if (mode === "container") {
+        const containerNames = (selection.selected.some(isNativeService) ? selection.selected : all)
+            .filter((service) => !isNativeService(service))
+            .map((service) => service.name);
+        fail("MIXED_RUNTIME", formatMixedRuntimeRefusal(mixed, containerNames));
+    }
+    return {
+        projectRoot,
+        isNewProject: !foundRoot,
+        all,
+        selected: selection.selected,
+        dependencies: only ? selection.dependencies : [],
+    };
+}
 export const upCommand = new Command("up")
     .description("Start all services (optionally filtered by stack)")
     .alias("deploy")
@@ -254,8 +320,11 @@ export const upCommand = new Command("up")
         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 suggestions = upFailureHints({ kind: "invalid-tilt-port" });
+        emit?.({ ok: false }, [
+            { code: "INVALID_TILT_PORT", message: portSetting.message, suggestions },
+        ]);
+        showErrorAndExit(portSetting.message, 1, suggestions);
     }
     const configuredTiltPort = portSetting.port;
     // First, before the host/Docker checks below: an old CLI must stop with one clear line, not a half-working stack.
@@ -266,6 +335,60 @@ export const upCommand = new Command("up")
             onFail: (message) => emit?.({ ok: false }, [{ code: "FLISK_VERSION_TOO_OLD", message }]),
         });
     }
+    // Every selected service declares `command`: run them as local processes, with no Docker, Compose, Tilt or generated
+    // files (#2229). Decided before any Docker or Tilt check; a project without `command` services never enters this branch.
+    const nativeRun = selectNativeRun(stackName, options.only, (code, message, suggestions) => {
+        emit?.({ ok: false }, [
+            { code, message, ...(suggestions && suggestions.length > 0 ? { suggestions } : {}) },
+        ]);
+        return showErrorAndExit(message, 1, suggestions);
+    });
+    if (nativeRun) {
+        const platformRefusal = nativeWindowsUpRefusal(process.platform, process.env.FLISK_ALLOW_NATIVE_WINDOWS);
+        if (platformRefusal)
+            showErrorAndExit(platformRefusal);
+        const { projectRoot } = nativeRun;
+        let envFilePath;
+        if (options.envFile !== undefined) {
+            try {
+                envFilePath = selectEnvFile(projectRoot, options.envFile).path;
+            }
+            catch (error) {
+                const { failure, exitCode } = envFileFailure(error);
+                emit?.({ ok: false }, [failure]);
+                showErrorAndExit(failure.message, exitCode, failure.suggestions);
+            }
+        }
+        if (!nativeRun.isNewProject) {
+            enforceSchemaVersionGate(projectRoot, {
+                resources: nativeRun.all,
+                onInvalid: (message) => emit?.({ ok: false }, [{ code: "INVALID_SCHEMA_VERSION", message }]),
+            });
+        }
+        enforceServiceConfigGate(projectRoot, {
+            resources: nativeRun.all,
+            onInvalid: (message) => emit?.({ ok: false }, [{ code: "INVALID_SERVICE_CONFIG", message }]),
+        });
+        if (nativeRun.isNewProject && !options.dryRun) {
+            writeDefaultProjectConfig(projectRoot);
+            if (!options.quiet) {
+                console.log(chalk.gray("Created .flisk/project.json (this directory is now a Flisk project)"));
+            }
+        }
+        await runNativeUp({
+            projectRoot,
+            selected: nativeRun.selected,
+            dependencies: nativeRun.dependencies,
+            stackName,
+            only: options.only,
+            envFilePath,
+            dryRun: options.dryRun,
+            quiet: options.quiet,
+            force: options.force,
+            emit,
+        });
+        return;
+    }
     // The env file of the run. `--env-file` replaces the project .env for this run, so the file is
     // resolved and read before any prerequisite check, any write and any service starts.
     const envFileRoot = versionRoot;
@@ -323,7 +446,7 @@ export const upCommand = new Command("up")
     }
     if (!options.dryRun) {
         const { assertMachineReadyOrExit } = await import("../utils/cold-preflight.js");
-        await assertMachineReadyOrExit();
+        await assertMachineReadyOrExit({ hints: upFailureHints({ kind: "machine" }) });
     }
     const action = async () => {
         const foundRoot = options.dryRun ? requireProjectRoot() : findProjectRoot();
@@ -598,12 +721,16 @@ export const upCommand = new Command("up")
             let startedDependencies = dependencyNames;
             if (uiReady && emit) {
                 const deferred = getDeferredResourceNames(discoveredResources);
+                const dependsOn = Object.fromEntries(discoveredResources.map((r) => [r.name, r.config?.dependsOn ?? []]));
                 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,
+                    // As for the human output: stop as soon as everything left is blocked by a failure (for example init-networks),
+                    // instead of waiting out the whole timeout.
+                    isStalled: (text) => isStartupStalled(text, dependsOn, deferred),
                 });
                 if (readiness.ready) {
                     jsonReady = true;
@@ -617,11 +744,21 @@ export const upCommand = new Command("up")
                 }
                 else {
                     startupFailed = true;
-                    const detail = readiness.failures.map((f) => `${f.name}: ${f.message}`).join("; ");
+                    const fixes = await machineProblemFixes(readiness.failures, (name) => tiltResourceLogs(port, name));
+                    const detail = readiness.failures
+                        .map((f) => {
+                        const fix = fixes.get(f.name);
+                        return `${f.name}: ${f.message}${fix ? `. ${fix}` : ""}`;
+                    })
+                        .join("; ");
                     emit({ ok: false, tiltUrl: `http://localhost:${port}`, failures: readiness.failures }, [
                         {
                             code: readiness.timedOut ? "UP_TIMEOUT" : "UP_RESOURCE_FAILED",
                             message: `${readiness.timedOut ? "Timed out waiting for resources" : "Resources failed"}${detail ? ` (${detail})` : ""}. Tilt is still running; inspect it or run: flisk down`,
+                            suggestions: upFailureHints({
+                                kind: "services",
+                                failed: readiness.failures.map((failure) => failure.name),
+                            }),
                         },
                     ]);
                 }
@@ -631,10 +768,22 @@ export const upCommand = new Command("up")
             if (uiReady && !emit) {
                 const deferred = getDeferredResourceNames(discoveredResources);
                 const dependsOn = Object.fromEntries(discoveredResources.map((r) => [r.name, r.config?.dependsOn ?? []]));
+                const progress = createUpProgressReporter({
+                    write: (text) => process.stdout.write(text),
+                    redraw: shouldRedrawUpProgress({
+                        isTTY: process.stdout.isTTY,
+                        quiet: Boolean(options.quiet),
+                        env: process.env,
+                    }),
+                    deferred,
+                    columns: process.stdout.columns,
+                });
                 const readiness = await waitForTiltResourcesReady(port, {
                     deferred,
                     isStalled: (text) => isStartupStalled(text, dependsOn, deferred),
+                    fetchJson: fetchWithProgress(tiltGetUiResources, progress),
                 });
+                progress.finish();
                 if (!readiness.ready) {
                     startupFailed = true;
                     const resourcesJson = await tiltGetUiResources(port);
@@ -648,9 +797,13 @@ export const upCommand = new Command("up")
                             blocked: [],
                             starting: [],
                         };
-                    const reportLines = formatStartupReport(report, readiness.timedOut, (port) => findPortOccupant(port));
+                    const machineFixes = await machineProblemFixes(report.failed, (name) => tiltResourceLogs(port, name));
+                    const reportLines = formatStartupReport(report, readiness.timedOut, (port) => findPortOccupant(port), machineFixes);
                     if (reportLines.length > 0) {
-                        showError(reportLines.join("\n"));
+                        showError(reportLines.join("\n"), undefined, upFailureHints({
+                            kind: "services",
+                            failed: report.failed.map((failure) => failure.name),
+                        }));
                     }
                 }
             }
@@ -696,6 +849,7 @@ export const upCommand = new Command("up")
                         envFiles: envFileSelection ? [envFileSelection.path] : [],
                     }),
                 });
+                const smokeFailures = [];
                 for (const smokeResult of results) {
                     if (smokeResult.ok) {
                         if (!options.quiet)
@@ -703,13 +857,20 @@ export const upCommand = new Command("up")
                     }
                     else {
                         smokeFailed = true;
+                        smokeFailures.push(smokeResult.name);
                         showError(formatSmokeFailure(smokeResult));
                     }
                 }
                 if (smokeFailed) {
                     stopTiltOnPort(port);
+                    const suggestions = upFailureHints({ kind: "smoke", failed: smokeFailures });
+                    showError("A smoke check failed; Tilt was stopped", undefined, suggestions);
                     emit?.({ ok: false }, [
-                        { code: "UP_SMOKE_FAILED", message: "A smoke check failed; Tilt was stopped" },
+                        {
+                            code: "UP_SMOKE_FAILED",
+                            message: "A smoke check failed; Tilt was stopped",
+                            suggestions,
+                        },
                     ]);
                 }
             }
@@ -731,7 +892,7 @@ export const upCommand = new Command("up")
             process.exit(1);
         }
         if (result.exitCode !== 0) {
-            handleTiltFailure("up", result.exitCode);
+            showErrorAndExit(`tilt up failed with exit code ${result.exitCode}`, result.exitCode, upFailureHints({ kind: "tilt-exited" }));
         }
         if (startupFailed && result.exitCode === 0) {
             process.exit(1);

package/cli/dist/commands/upgrade.js

@@ -140,7 +140,7 @@ export function detectAllInstallations() {
     return [...unique.values()];
 }
 const BINARY_RELEASE_REPO = "flisk-sh/releases";
-const ENGINE_ASSET_NAME = "tdk-cli-engine.tar.gz";
+const ENGINE_ASSET_NAME = "flisk-cli-engine.tar.gz";
 const CHECKSUMS_ASSET_NAME = "checksums.txt";
 /** Parses `shasum -a 256` / `sha256sum` output ("<hash>  <name>" or "<hash> *<name>"). */
 /** @internal Exported for unit tests only; not part of the package API. */
@@ -656,7 +656,7 @@ export function createUpgradeCommand() {
                     showErrorAndExit("Flisk Windows v1 supports AMD64 only. Use WSL2 Ubuntu or a 64-bit Intel/AMD PC.");
                 }
                 if (process.platform === "win32") {
-                    showErrorAndExit("No Windows AMD64 binary in this Flisk release. Need asset tdk-windows-amd64.exe.");
+                    showErrorAndExit("No Windows AMD64 binary in this Flisk release. Need asset flisk-windows-amd64.exe.");
                 }
                 showErrorAndExit(`Unsupported OS: Flisk does not support this OS: ${process.platform}. Supported: linux, darwin, win32.`);
             }

package/cli/dist/components/DetailPanel.js

@@ -1,10 +1,30 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 // Copyright (c) 2026 Flisk Landscape contributors
 // SPDX-License-Identifier: MIT
 import { Box, Text } from "ink";
+import { formatAge } from "../utils/agent-format.js";
 import { formatDate, getStatusColor, getStatusIcon } from "../utils/formatting.js";
 import { getTUIStatusColor, getTUIStatusIcon, useTUITheme } from "./ui-theme.js";
-export const DetailPanel = ({ stack, service, stackMetadata, visible, }) => {
+const MAX_LISTED_SESSIONS = 5;
+/** Readiness, session count, last activity and the newest sessions of an agent; `null` while the first poll is pending. */
+const AgentSection = ({ agent }) => {
+    const theme = useTUITheme();
+    const row = (label, value, color = theme.foreground) => (_jsxs(Box, { children: [_jsxs(Text, { color: theme.muted, children: [label, ": "] }), _jsx(Text, { color: color, children: value })] }));
+    let body;
+    if (agent === null) {
+        body = row("Agent", "checking...", theme.muted);
+    }
+    else if (agent.state === "not-running") {
+        body = row("Agent", "not running", theme.warning);
+    }
+    else {
+        const { sessions } = agent;
+        const newest = sessions?.sessions[0]?.lastActivity ?? null;
+        body = (_jsxs(_Fragment, { children: [row("Ready", agent.ready ? "yes" : "no", agent.ready ? theme.success : theme.warning), sessions ? (_jsxs(_Fragment, { children: [row("Sessions", String(sessions.total)), row("Last activity", formatAge(newest)), sessions.sessions.slice(0, MAX_LISTED_SESSIONS).map((s) => (_jsxs(Box, { children: [_jsx(Text, { color: theme.foreground, children: s.sessionId.slice(0, 18) }), _jsxs(Text, { color: theme.muted, children: [" ", formatAge(s.lastActivity), " ", s.status] })] }, s.sessionId))), sessions.total > MAX_LISTED_SESSIONS && (_jsxs(Text, { color: theme.muted, children: ["... ", sessions.total - MAX_LISTED_SESSIONS, " more"] }))] })) : (row("Sessions", "not available (agent has no /sessions)", theme.muted))] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { color: theme.muted, underline: true, children: "Agent" }), body] }));
+};
+export const DetailPanel = ({ stack, service, stackMetadata, agent, visible, }) => {
     const theme = useTUITheme();
     if (!visible) {
         return _jsx(Box, { width: 0 });
@@ -13,7 +33,7 @@ export const DetailPanel = ({ stack, service, stackMetadata, visible, }) => {
         const title = theme.ascii
             ? `--- ${service.name.toUpperCase()} ---`
             : `\u250C\u2500 ${service.name.toUpperCase()} \u2500\u2510`;
-        return (_jsxs(Box, { width: 40, flexDirection: "column", borderStyle: theme.ascii ? undefined : "single", borderColor: theme.border, paddingX: 1, paddingY: 1, children: [_jsx(Box, { marginBottom: 1, justifyContent: "center", children: _jsx(Text, { color: theme.accent, bold: true, children: title }) }), _jsxs(Box, { flexDirection: "column", marginY: 1, children: [_jsxs(Box, { children: [_jsx(Text, { color: theme.muted, children: "Name: " }), _jsx(Text, { color: theme.foreground, children: service.name })] }), _jsxs(Box, { children: [_jsx(Text, { color: theme.muted, children: "Stack: " }), _jsx(Text, { color: theme.foreground, children: service.stack || "unknown" })] }), _jsxs(Box, { children: [_jsx(Text, { color: theme.muted, children: "Type: " }), _jsx(Text, { color: theme.warning, bold: theme.highContrast, children: (service.stack || "") === "platform" ? "PLATFORM" : "PRODUCT" })] })] }), _jsx(Box, { marginTop: 2, children: _jsxs(Text, { color: theme.muted, dimColor: theme.dimMuted, children: ["Press ", _jsx(Text, { color: theme.accent, children: "[Esc]" }), " to close"] }) })] }));
+        return (_jsxs(Box, { width: 40, flexDirection: "column", borderStyle: theme.ascii ? undefined : "single", borderColor: theme.border, paddingX: 1, paddingY: 1, children: [_jsx(Box, { marginBottom: 1, justifyContent: "center", children: _jsx(Text, { color: theme.accent, bold: true, children: title }) }), _jsxs(Box, { flexDirection: "column", marginY: 1, children: [_jsxs(Box, { children: [_jsx(Text, { color: theme.muted, children: "Name: " }), _jsx(Text, { color: theme.foreground, children: service.name })] }), _jsxs(Box, { children: [_jsx(Text, { color: theme.muted, children: "Stack: " }), _jsx(Text, { color: theme.foreground, children: service.stack || "unknown" })] }), _jsxs(Box, { children: [_jsx(Text, { color: theme.muted, children: "Type: " }), _jsx(Text, { color: theme.warning, bold: theme.highContrast, children: (service.stack || "") === "platform" ? "PLATFORM" : "PRODUCT" })] })] }), agent !== undefined && _jsx(AgentSection, { agent: agent }), _jsx(Box, { marginTop: 2, children: _jsxs(Text, { color: theme.muted, dimColor: theme.dimMuted, children: ["Press ", _jsx(Text, { color: theme.accent, children: "[Esc]" }), " to close"] }) })] }));
     }
     if (stack && stackMetadata) {
         const statusColor = getTUIStatusColor(theme, getStatusColor(stackMetadata.overallStatus));

package/cli/dist/mcp/tools.js

@@ -328,23 +328,26 @@ export function createFliskTools(run = runFliskCli, up = defaultUpDeps) {
         },
         {
             name: "get_agent_sessions",
-            description: "Inspect session checkpoints from a running AI agent resource. Set projectPath when the MCP server is not running from the project root.",
+            description: "List the sessions of a running AI agent resource (id, last activity, status, checkpoint size), or read one session's checkpoint when sessionId is set. Set projectPath when the MCP server is not running from the project root.",
             inputSchema: {
                 ...OBJECT({
                     projectPath: PROJECT_PATH,
                     resource: { type: "string", description: "Name of the agent resource" },
-                    sessionId: { type: "string", description: "Session ID to fetch (required)" },
+                    sessionId: {
+                        type: "string",
+                        description: "Session ID to read; omit it to list all sessions",
+                    },
                 }),
-                required: ["resource", "sessionId"],
+                required: ["resource"],
             },
             handler: viaCli((args) => {
                 const resource = optionalName(args.resource, "resource");
                 if (!resource)
                     throw new Error("resource is required");
                 const sessionId = optionalName(args.sessionId, "sessionId");
-                if (!sessionId)
-                    throw new Error("sessionId is required");
-                return ["agent", "sessions", resource, `--session-id=${sessionId}`, "--json"];
+                return sessionId
+                    ? ["agent", "sessions", resource, `--session-id=${sessionId}`, "--json"]
+                    : ["agent", "sessions", resource, "--json"];
             }),
         },
     ];

package/cli/dist/types/index.js

@@ -1,5 +1,3 @@
-// Copyright (c) 2026 Flisk Landscape contributors
-// SPDX-License-Identifier: MIT
 import { RESOURCE_DEFAULTS_FILE, TECH_STACK_FILE } from "../utils/constants.js";
 export const RESOURCE_CONFIG_APP_TYPES = [
     "backend",

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

@@ -0,0 +1,18 @@
+// Copyright (c) 2026 Flisk Landscape contributors
+// SPDX-License-Identifier: MIT
+/** "12s ago", "5m ago", "3h ago", "2d ago"; "-" when the agent sent no time. */
+export function formatAge(iso, now = Date.now()) {
+    if (!iso)
+        return "-";
+    const at = Date.parse(iso);
+    if (Number.isNaN(at))
+        return iso;
+    const seconds = Math.max(0, Math.round((now - at) / 1000));
+    if (seconds < 60)
+        return `${seconds}s ago`;
+    if (seconds < 3600)
+        return `${Math.floor(seconds / 60)}m ago`;
+    if (seconds < 86_400)
+        return `${Math.floor(seconds / 3600)}h ago`;
+    return `${Math.floor(seconds / 86_400)}d ago`;
+}

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

@@ -0,0 +1,122 @@
+// Copyright (c) 2026 Flisk Landscape contributors
+// SPDX-License-Identifier: MIT
+import * as http from "node:http";
+export const AGENT_REQUEST_TIMEOUT_MS = 10_000;
+/** GET with node:http because fetch silently drops a custom Host header, which is what Traefik routes on. */
+export function httpGet(url, headers, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        // One signal covers the connection and the body read, so a hung agent cannot block the CLI.
+        const req = http.get(url, { headers, signal: AbortSignal.timeout(timeoutMs) }, (res) => {
+            const chunks = [];
+            res.on("data", (chunk) => chunks.push(chunk));
+            res.on("end", () => {
+                const status = res.statusCode ?? 0;
+                resolve({
+                    ok: status >= 200 && status < 300,
+                    status,
+                    text: Buffer.concat(chunks).toString("utf-8"),
+                });
+            });
+            res.on("error", reject);
+        });
+        req.on("error", reject);
+    });
+}
+/**
+ * Agent containers publish no host port; the only way in is the Traefik route that `flisk status` prints as `url`
+ * (for example http://api.<project>.localhost:8080/api/bot). `*.localhost` does not resolve everywhere (glibc without
+ * systemd-resolved), so connect to loopback and keep the route's host in the Host header, which is all Traefik matches on.
+ */
+export function agentRequest(routeUrl, path, headers = {}) {
+    const route = new URL(routeUrl);
+    const allHeaders = { ...headers };
+    if (route.hostname.endsWith(".localhost")) {
+        allHeaders.host = route.host;
+        route.hostname = "127.0.0.1";
+    }
+    return { url: `${route.origin}${route.pathname.replace(/\/$/, "")}${path}`, headers: allHeaders };
+}
+/** The request for one session's checkpoint: `GET /session`, keyed by the `x-session-id` header. */
+export function agentSessionRequest(routeUrl, sessionId) {
+    return agentRequest(routeUrl, "/session", { "x-session-id": sessionId });
+}
+/** The request for the session list: `GET /sessions`, which needs no session id. */
+export function agentSessionListRequest(routeUrl) {
+    return agentRequest(routeUrl, "/sessions");
+}
+export async function fetchAgent(request, timeoutMs = AGENT_REQUEST_TIMEOUT_MS) {
+    let reply;
+    try {
+        reply = await httpGet(request.url, request.headers, timeoutMs);
+    }
+    catch {
+        return { kind: "not-running" };
+    }
+    let body = {};
+    let isJson = true;
+    try {
+        body = reply.text ? JSON.parse(reply.text) : {};
+    }
+    catch {
+        body = { raw: reply.text };
+        isJson = false;
+    }
+    if (reply.ok)
+        return { kind: "ok", body };
+    // Traefik answers 502/503/504 when the route has no live container and a plain-text 404 when it has no route at
+    // all. An agent's own errors are JSON, so a non-JSON 404 is the gateway, not the agent.
+    if ([502, 503, 504].includes(reply.status) || (reply.status === 404 && !isJson)) {
+        return { kind: "not-running" };
+    }
+    if (reply.status === 404)
+        return { kind: "not-found", body };
+    const detail = body?.error;
+    return {
+        kind: "error",
+        status: reply.status,
+        detail: typeof detail === "string" ? detail : reply.text,
+    };
+}
+/**
+ * Reads a `GET /sessions` body. Returns null when it is not the list shape, so a caller can tell a wrong endpoint from
+ * an agent with no sessions. Rows without a usable id are dropped; the agent owns its other fields.
+ */
+export function parseAgentSessionList(body) {
+    if (typeof body !== "object" || body === null)
+        return null;
+    const raw = body.sessions;
+    if (!Array.isArray(raw))
+        return null;
+    const sessions = [];
+    for (const row of raw) {
+        if (typeof row !== "object" || row === null)
+            continue;
+        const r = row;
+        if (typeof r.sessionId !== "string" || !r.sessionId)
+            continue;
+        sessions.push({
+            sessionId: r.sessionId,
+            lastActivity: typeof r.lastActivity === "string" ? r.lastActivity : null,
+            status: typeof r.status === "string" ? r.status : "unknown",
+            checkpointBytes: typeof r.checkpointBytes === "number" ? r.checkpointBytes : null,
+        });
+    }
+    const total = body.total;
+    return { sessions, total: typeof total === "number" ? total : sessions.length };
+}
+/** Reads `/ready` and `/sessions` once, in parallel. Never throws: a failure is part of the answer. */
+export async function fetchAgentOverview(routeUrl, timeoutMs = 3_000) {
+    const [ready, list] = await Promise.all([
+        fetchAgent(agentRequest(routeUrl, "/ready"), timeoutMs),
+        fetchAgent(agentRequest(routeUrl, "/sessions"), timeoutMs),
+    ]);
+    if (ready.kind === "not-running" && list.kind === "not-running")
+        return { state: "not-running" };
+    // /ready answers 503 with { ready: false } when the checkpoint store is down, which fetchAgent reports as "not-running".
+    const isReady = ready.kind === "ok" && ready.body?.ready === true;
+    return {
+        state: "up",
+        ready: isReady,
+        sessions: list.kind === "ok" ? parseAgentSessionList(list.body) : null,
+    };
+}