@flisk-sh/flisk 1.3.190 → 1.3.192

package/cli/dist/utils/cli-command.js

@@ -0,0 +1,107 @@
+// Copyright (c) 2026 Flisk Landscape contributors
+// SPDX-License-Identifier: MIT
+import { execFileSync } from "node:child_process";
+import { accessSync, constants, readdirSync } from "node:fs";
+import { delimiter, join } from "node:path";
+/** The command users install and type. */
+export const CLI_COMMAND = "flisk";
+/** The npm package that installs it. */
+export const CLI_PACKAGE = "@flisk-sh/flisk";
+/** The package the CLI was published under before the rename. It owns the old `flisk` command. */
+export const LEGACY_PACKAGE = "@tdk-landscape/tdk-cli-core";
+/** True when the command can be typed as-is, so `flisk ...` resolves. */
+export function isCommandOnPath(command = CLI_COMMAND, env = process.env) {
+    const path = env.PATH ?? env.Path ?? "";
+    for (const dir of path.split(delimiter)) {
+        if (!dir)
+            continue;
+        const candidates = [
+            join(dir, command),
+            join(dir, `${command}.cmd`),
+            join(dir, `${command}.exe`),
+        ];
+        for (const candidate of candidates) {
+            try {
+                accessSync(candidate, constants.X_OK);
+                return true;
+            }
+            catch {
+                // Not on this PATH entry; keep looking.
+            }
+        }
+    }
+    return false;
+}
+/**
+ * A folder to start a project in. It follows the platform convention: Documents when the
+ * machine has one, a plain folder in the home directory otherwise.
+ */
+export function suggestedWorkspace(env = process.env) {
+    const home = env.HOME ?? env.USERPROFILE ?? "";
+    if (!home)
+        return "flisk-workspace";
+    const documents = join(home, "Documents");
+    try {
+        accessSync(documents, constants.F_OK);
+        return join(documents, "flisk");
+    }
+    catch {
+        return join(home, "flisk");
+    }
+}
+/** True when the directory holds no visible entries, so a project can start there as-is. */
+export function isEmptyWorkspace(dir) {
+    try {
+        return readdirSync(dir).every((entry) => entry.startsWith("."));
+    }
+    catch {
+        return true;
+    }
+}
+/**
+ * The next step to print once the machine is ready.
+ *
+ * An ephemeral run (`npx @flisk-sh/flisk`) never installs the command, so pointing at
+ * `flisk ...` there would fail with "command not found"; that case says how to install it
+ * instead. A project also should not start in whatever folder the shell happens to be in,
+ * so a directory that already holds files gets a workspace to move into first.
+ */
+export function readyNextStep(env = process.env, cwd = process.cwd()) {
+    if (!isCommandOnPath(CLI_COMMAND, env)) {
+        return (`The \`${CLI_COMMAND}\` command is not on PATH (this run is not a global install). ` +
+            `Install it with \`npm install -g ${CLI_PACKAGE}\`, then run \`${CLI_COMMAND} project --yes\`. ` +
+            `If npm reports EEXIST for \`flisk\`, the old package still owns that command: ` +
+            `run \`npm uninstall -g ${LEGACY_PACKAGE}\` first.`);
+    }
+    if (isEmptyWorkspace(cwd)) {
+        return `Next: ${CLI_COMMAND} project --yes`;
+    }
+    const workspace = suggestedWorkspace(env);
+    return (`Next: mkdir -p ${workspace} && cd ${workspace} && ${CLI_COMMAND} project --yes\n` +
+        `(${CLI_COMMAND} project writes .tdk/ and the master configs into the current folder, ` +
+        `so it starts clean in a folder of its own. Or clone a starter: ${CLI_COMMAND} project example)`);
+}
+/**
+ * Installs the CLI globally when it is only running ephemerally (`npx @flisk-sh/flisk`),
+ * so the `flisk` command keeps working after the run. The old package is removed first:
+ * it owns the `flisk` command and would make the install fail with EEXIST.
+ */
+export function ensureGlobalInstall(env = process.env) {
+    if (isCommandOnPath(CLI_COMMAND, env))
+        return "present";
+    const manager = env.npm_execpath?.includes("bun") ? "bun" : "npm";
+    const remove = manager === "bun" ? "bun remove -g" : "npm uninstall -g";
+    try {
+        execFileSync(remove, [LEGACY_PACKAGE], { stdio: "ignore", timeout: 120000 });
+    }
+    catch {
+        // Not installed under the old name, or the manager is missing.
+    }
+    try {
+        execFileSync(manager, ["install", "-g", CLI_PACKAGE], { stdio: "inherit", timeout: 300000 });
+        return "installed";
+    }
+    catch {
+        return "failed";
+    }
+}

package/cli/dist/utils/cold-preflight.js

@@ -6,6 +6,7 @@ import { join } from "node:path";
 import { checkDockerCompose, checkDockerRuntime, checkDockerVersions, checkTilt, DOCTOR_FIXES, } from "../commands/doctor.js";
 import { BUN_FLOOR_LABEL, bunMeetsFloor } from "./bun-floor.js";
 import { projectNeedsBun } from "./bun-requirement.js";
+import { readyNextStep } from "./cli-command.js";
 import { PROJECT_JSON } from "./constants.js";
 import { checkNatsBroker } from "./doctor-wiring.js";
 import { getHostPortPlan } from "./host-port-config.js";
@@ -200,7 +201,7 @@ export async function runColdPreflight(opts = {}) {
         ? ""
         : inProject
             ? "Environment ready for Flisk"
-            : "This machine is ready for Flisk.\nNext: flisk project --yes";
+            : `This machine is ready for Flisk.\n${readyNextStep()}`;
     return { ok: failures.length === 0, inProject, items: failures, header, footer };
 }
 /** Formats only failed preflight checks and the applicable readiness message. */

package/cli/dist/utils/constants.js

@@ -89,7 +89,7 @@ export const STANDARD_PORTS = {
     tiltUi: 10350,
     traefik: 8080,
 };
-export const QUICKSTART_DOCS_URL = "https://tdk-landscape.github.io/tdk-website/docs/quickstart/";
+export const QUICKSTART_DOCS_URL = "https://flisk.sh/docs/quickstart/";
 export const BASE_DOMAIN_DEFAULT = "tdk-project.localhost";
 export const APP_SUBDOMAIN_PREFIX = "app";
 export const API_SUBDOMAIN_PREFIX = "api";

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

@@ -7,13 +7,12 @@ import { join } from "node:path";
 import { promisify } from "node:util";
 import { DISK_WARN_GIB } from "./doctor-host.js";
 import { findProjectTiltUpPids, projectNetworkNames, tdkNetworkOwner, tdkNetworkPrefixes, } from "./down-cleanup.js";
-import { executableName, legacyExecutableName } from "./platform.js";
 import { tiltGetUiResources } from "./up-readiness.js";
 import { findAllOnPath } from "./which.js";
 const execFilePromise = promisify(execFile);
 const DOCKER_TIMEOUT_MS = 15_000;
 /** The networks `flisk doctor` creates to test capacity; an interrupted run leaves one behind. */
-const PROBE_NETWORK = /^flisk_doctor_probe_(\d+)$/;
+const PROBE_NETWORK = /^tdk_doctor_probe_(\d+)$/;
 const runDocker = async (args) => {
     const { stdout } = await execFilePromise("docker", args, {
         encoding: "utf-8",
@@ -335,8 +334,8 @@ async function readTdkVersion(path) {
         return null;
     }
 }
-/** Every distinct Flisk install on PATH (symlinks to one binary count once), in PATH order. */
-export async function findTdkInstalls(paths = [...findAllOnPath(executableName()), ...findAllOnPath(legacyExecutableName())], readVersion = readTdkVersion) {
+/** Every distinct `flisk` on PATH (symlinks to one binary count once), in PATH order. */
+export async function findTdkInstalls(paths = findAllOnPath("flisk"), readVersion = readTdkVersion) {
     const seen = new Set();
     const installs = [];
     for (const path of paths) {
@@ -367,7 +366,7 @@ export async function checkDuplicateTdkInstalls(installs) {
         didPass: false,
         isWarning: true,
         message: `${found.length} flisk installs on PATH${versions.size > 1 ? " with different versions" : ""}: ${list}`,
-        fix: "Keep one: remove the others, or run flisk upgrade. The first on PATH is the one your shell runs; tools that launch /usr/local/bin/flisk directly may use another",
+        fix: "Keep one: remove the others, or run flisk upgrade. The first on PATH is the one your shell runs; tools that launch /usr/local/bin/tdk directly may use another",
     };
 }
 /**

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

@@ -311,7 +311,7 @@ export function checkPrivateNpmRegistry(exec = execSync, projectRoot = findProje
     return {
         name: "Private npm registry",
         didPass: false,
-        message: `Private npm registry (Verdaccio) is not reachable at ${registryUrl}. Docker ImageBuilds will fail with ConnectionRefused downloading package manifests for @tdk-landscape/* and project-scoped packages.`,
+        message: `Private npm registry (Verdaccio) is not reachable at ${registryUrl}. Docker ImageBuilds will fail with ConnectionRefused downloading package manifests for @flisk-sh/* and project-scoped packages.`,
         fix: "Start the registry with `bun run verdaccio:start` (or `docker compose -f docker-compose.verdaccio.yml up -d`), publish packages with `bun run publish:all` / `scripts/build/publish-to-verdaccio.sh`, then `tilt trigger` failed resources or re-run `flisk up`.",
     };
 }

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

@@ -22,7 +22,7 @@ export function findPrivateStarlarkLoadExports(content) {
     return Array.from(privateExports).sort();
 }
 export function resolveStarlarkLoadTarget(file, modulePath, projectRoot) {
-    if (modulePath === "ext://flisk" || modulePath === "ext://tdk-cli") {
+    if (modulePath === "ext://tdk-cli") {
         return join(projectRoot, ".tdk", ".tdk-out", "tdk-cli-ext", "Tiltfile");
     }
     if (modulePath.startsWith(".") || (!modulePath.includes("://") && !modulePath.startsWith("@"))) {

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

@@ -667,7 +667,7 @@ export function checkTiltInstances(projectRoot = findProjectRoot() ?? process.cw
     return { name: "Tilt processes", didPass: true, message: "No stray Tilt processes" };
 }
 export async function checkDockerNetworkCapacity(exec = execAsync) {
-    const probe = `flisk_doctor_probe_${process.pid}`;
+    const probe = `tdk_doctor_probe_${process.pid}`;
     try {
         await exec(`docker network create ${probe}`, EXEC_TIMEOUT_MS);
     }
@@ -692,7 +692,7 @@ export async function checkDockerNetworkCapacity(exec = execAsync) {
         await exec(`docker network rm ${probe}`, EXEC_TIMEOUT_MS);
     }
     catch {
-        // A leftover probe network is harmless and flisk_doctor_probe_* is easy to prune.
+        // A leftover probe network is harmless and tdk_doctor_probe_* is easy to prune.
     }
     return { name: "Docker networks", didPass: true, message: "Docker can create networks" };
 }

package/cli/dist/utils/env-selection.js

@@ -0,0 +1,201 @@
+// Copyright (c) 2026 Flisk Landscape contributors
+// SPDX-License-Identifier: MIT
+import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
+import { isAbsolute, relative, resolve, sep } from "node:path";
+import { COMPLETED_ENV_VARS, parseEnv } from "./env-validator.js";
+import { TdkError } from "./errors.js";
+/**
+ * The environment variable the engine reads the env file of the run from. The CLI resolves the
+ * requested path and exports it, so the engine reads one file for the whole run: the Tilt
+ * environment (engine/topologies/tilt/common/utils_env.star) and the Compose interpolation alike.
+ */
+export const PROJECT_ENV_FILE_VAR = "TDK_ENV_FILE";
+/**
+ * The keys the platform needs in the env file of a run. They are the keys `completeEnvFile` keeps
+ * complete in the project `.env`: the Tilt environment, the Postgres password and the JWT secret.
+ * A selected file replaces the project `.env` for the run, so it has to carry them too.
+ */
+export const REQUIRED_ENV_FILE_KEYS = COMPLETED_ENV_VARS;
+/** Exit code for a rejected `--env-file`: invalid arguments (see docs/reference/machine-readable-cli.md). */
+export const ENV_FILE_ERROR_EXIT_CODE = 2;
+/** Exit code when the project's vendored engine is too old for the option: a blocking finding. */
+export const ENV_FILE_ENGINE_EXIT_CODE = 1;
+/**
+ * A rejected `--env-file`. It carries a code so a JSON consumer can tell an unusable file from
+ * another failure, and it is a TdkError so the CLI shows it in the house style.
+ */
+export class EnvFileError extends TdkError {
+    code;
+    constructor(code, message, suggestions = [], exitCode = ENV_FILE_ERROR_EXIT_CODE) {
+        super(message, suggestions, exitCode);
+        this.code = code;
+        this.name = "EnvFileError";
+    }
+}
+/** True when the path is inside the project directory. */
+export function isInsideProject(projectRoot, path) {
+    const relativePath = relative(resolve(projectRoot), resolve(path));
+    if (relativePath === "")
+        return true;
+    if (isAbsolute(relativePath))
+        return false;
+    return relativePath !== ".." && !relativePath.startsWith(`..${sep}`);
+}
+/**
+ * Resolves the requested env file to an absolute path inside the project.
+ *
+ * A relative path is resolved against the current directory, the way `docker compose --env-file`
+ * and Node.js' own `--env-file` resolve it. Resolving it the same way keeps the check Node.js does
+ * before the CLI starts in step with this one.
+ *
+ * The file has to live in the project: it is the project env file of the run, and the wake gateway
+ * (which mounts the project read-only and runs Compose itself) can only read a file inside it. A
+ * path outside the project would also turn the flag into a way to read any file on the machine.
+ *
+ * @throws TdkError when the path is empty, leaves the project, or does not exist
+ */
+export function resolveEnvFilePath(projectRoot, requested, options = {}) {
+    const trimmed = requested.trim();
+    if (!trimmed) {
+        throw new EnvFileError("ENV_FILE_INVALID", "No env file was given", [
+            "Pass the path of a project env file, for example: flisk up --env-file .env.integration",
+        ]);
+    }
+    const baseDir = options.baseDir ?? process.cwd();
+    const absolute = isAbsolute(trimmed) ? resolve(trimmed) : resolve(baseDir, trimmed);
+    if (!existsSync(absolute)) {
+        throw new EnvFileError("ENV_FILE_INVALID", `Env file not found: ${trimmed}`, [
+            "Create it first, for example: cp .env .env.integration",
+            "A relative path is resolved against the current directory",
+        ]);
+    }
+    if (!statSync(absolute).isFile()) {
+        throw new EnvFileError("ENV_FILE_INVALID", `Env file is not a file: ${trimmed}`, [
+            "Point --env-file at an env file, not at a directory",
+        ]);
+    }
+    // The real paths decide whether the file belongs to the project: a project directory reached
+    // through a symbolic link (macOS /var -> /private/var) is still the project, and a symbolic link
+    // inside the project can point at a file outside it. The engine reads the file through the
+    // project mount, so a file outside the project would break the run in the wake gateway.
+    if (!isInsideProject(realPathOrSelf(projectRoot), realPathOrSelf(absolute))) {
+        throw new EnvFileError("ENV_FILE_INVALID", `Env file is outside the project: ${trimmed}`, [
+            "The env file of a run belongs to the project, next to its .env",
+            `The project directory is ${projectRoot}`,
+        ]);
+    }
+    return absolute;
+}
+/** The real path of a file, or the path itself when it cannot be resolved. */
+function realPathOrSelf(path) {
+    try {
+        return realpathSync(path);
+    }
+    catch {
+        return path;
+    }
+}
+/**
+ * Reads the env file. The values are secrets, so they are only used to configure the run and to
+ * mask output; they are never printed.
+ *
+ * @throws TdkError when the file cannot be read
+ */
+export function readEnvFileValues(path) {
+    let content;
+    try {
+        content = readFileSync(path, "utf-8");
+    }
+    catch (error) {
+        throw new EnvFileError("ENV_FILE_INVALID", `Could not read env file ${path}: ${error instanceof Error ? error.message : String(error)}`, ["Check the permissions of the env file"]);
+    }
+    return parseEnv(content);
+}
+/** The platform keys the file is missing, so the run would start without them. */
+export function missingRequiredEnvKeys(values) {
+    return REQUIRED_ENV_FILE_KEYS.filter((key) => !(values.get(key) ?? "").trim());
+}
+/**
+ * Selects the env file of the run and checks that it can carry the run.
+ *
+ * The selected file replaces the project `.env` for the run, so it has to carry the same keys. Flisk
+ * does not complete it: a file the user named may well be committed, and writing a generated
+ * credential into it would leak one.
+ *
+ * @throws TdkError when the file is unusable or misses a key the platform needs
+ */
+export function selectEnvFile(projectRoot, requested, options = {}) {
+    const path = resolveEnvFilePath(projectRoot, requested, options);
+    const values = readEnvFileValues(path);
+    const missing = missingRequiredEnvKeys(values);
+    if (missing.length > 0) {
+        throw new EnvFileError("ENV_FILE_INVALID", `Env file ${requested} is missing ${missing.join(", ")}`, [
+            "The selected env file replaces the project .env for this run, so it needs the same keys",
+            "Copy them from the project .env (they are per-project credentials)",
+            "Run without --env-file to use the project .env",
+        ]);
+    }
+    return {
+        path,
+        relativePath: relative(projectRoot, path).split(sep).join("/"),
+        values,
+    };
+}
+/**
+ * Points the engine at the selected env file for this run. The engine reads the same variable for
+ * the Tilt environment and for the Compose interpolation, so one file drives both.
+ */
+export function applyEnvFileSelection(selection) {
+    process.env[PROJECT_ENV_FILE_VAR] = selection.path;
+}
+/**
+ * The vendored engine copy that resolves the env file of the run. A project vendors it at generation
+ * time, so a project created before this option existed runs an engine that ignores the selection.
+ */
+const VENDORED_ENGINE_ENV_FILE = ".tdk/.tdk-out/tdk-cli-ext/engine/topologies/tilt/common/utils_env.star";
+/**
+ * Refuses the run when the project's vendored engine cannot honour the selection. Without this check
+ * the flag would be ignored silently and the run would use the project .env after all.
+ *
+ * @throws TdkError when the vendored engine is older than this option
+ */
+export function assertEngineSupportsEnvFile(projectRoot) {
+    const vendored = resolve(projectRoot, VENDORED_ENGINE_ENV_FILE);
+    if (!existsSync(vendored))
+        return;
+    let content;
+    try {
+        content = readFileSync(vendored, "utf-8");
+    }
+    catch {
+        // An unreadable engine copy fails on its own, with a clearer message than this one.
+        return;
+    }
+    if (content.includes(PROJECT_ENV_FILE_VAR))
+        return;
+    throw new EnvFileError("ENV_FILE_ENGINE_TOO_OLD", "The Flisk engine in this project does not support --env-file yet", [
+        "Run `flisk config regenerate` to refresh the vendored engine, then run `flisk up --env-file ...` again",
+        `The engine copy is at ${VENDORED_ENGINE_ENV_FILE}`,
+    ], ENV_FILE_ENGINE_EXIT_CODE);
+}
+/**
+ * A warning when the selected env file would break the local database. The Postgres volume keeps the
+ * password it was created with, so a different DB_PASSWORD does not change it.
+ */
+export function envFileWarning(projectRoot, selection) {
+    const projectEnvPath = resolve(projectRoot, ".env");
+    if (!existsSync(projectEnvPath))
+        return null;
+    let projectValues;
+    try {
+        projectValues = parseEnv(readFileSync(projectEnvPath, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+    const projectPassword = (projectValues.get("DB_PASSWORD") ?? "").trim();
+    const selectedPassword = (selection.values.get("DB_PASSWORD") ?? "").trim();
+    if (!projectPassword || !selectedPassword || projectPassword === selectedPassword)
+        return null;
+    return "The selected env file sets a different DB_PASSWORD than the project .env. The local Postgres volume keeps the password it was created with, so the database may refuse the new one.";
+}

package/cli/dist/utils/env-validator.js

@@ -53,6 +53,12 @@ const REQUIRED_ENV_VARS = [
 ];
 const generateDbPassword = () => randomBytes(16).toString("hex");
 const generateJwtSecret = () => randomBytes(32).toString("hex");
+/**
+ * The keys `completeEnvFile` keeps complete in the project `.env`. An env file that replaces the
+ * project `.env` for a run (`flisk up --env-file`) carries the same keys, so it is read from here
+ * instead of from a second list.
+ */
+export const COMPLETED_ENV_VARS = REQUIRED_ENV_VARS.filter((v) => v.complete).map((v) => v.name);
 function generatedValue(name, password) {
     if (name === "DB_PASSWORD")
         return password;

package/cli/dist/utils/one-command.js

@@ -0,0 +1,50 @@
+// Copyright (c) 2026 Flisk Landscape contributors
+// SPDX-License-Identifier: MIT
+import { spawn } from "node:child_process";
+/** The marker the stack prints before the frontend URLs. */
+const FRONTEND_MARKER = "Frontend URLs";
+/** Picks the first frontend URL out of the `flisk up` output, if it printed one. */
+export function findFrontendUrl(output) {
+    const lines = output.split("\n");
+    const markerIndex = lines.findIndex((line) => line.includes(FRONTEND_MARKER));
+    if (markerIndex === -1)
+        return undefined;
+    for (const line of lines.slice(markerIndex + 1)) {
+        const match = line.match(/^\s*-\s+\S+:\s+(https?:\/\/\S+)/);
+        if (match)
+            return match[1];
+        if (line.trim() === "" || line.includes("URLs:"))
+            break;
+    }
+    return undefined;
+}
+/**
+ * Runs `flisk up` in the project directory and streams its output to the terminal. The stack
+ * keeps running in the foreground, so the caller is told about the frontend URL as soon as it
+ * shows up instead of waiting for the process to exit.
+ */
+export function runStack(binPath, cwd, env = process.env, spawnFn = spawn, onFrontendUrl) {
+    return new Promise((resolve) => {
+        const child = spawnFn(process.execPath, [binPath, "up"], {
+            cwd,
+            env,
+            stdio: ["inherit", "pipe", "inherit"],
+        });
+        let output = "";
+        let announced = false;
+        child.stdout?.on("data", (chunk) => {
+            const text = String(chunk);
+            output += text;
+            process.stdout.write(text);
+            if (!announced) {
+                const url = findFrontendUrl(output);
+                if (url) {
+                    announced = true;
+                    onFrontendUrl?.(url);
+                }
+            }
+        });
+        child.on("error", (error) => resolve({ code: 1, output: `${output}\n${error.message}` }));
+        child.on("close", (code) => resolve({ code, output }));
+    });
+}

package/cli/dist/utils/platform.js

@@ -33,18 +33,14 @@ export function binaryAssetNameFor(platformName, architecture) {
         return null;
     if (osName === "windows" && archName !== "amd64")
         return null;
-    const base = `flisk-${osName}-${archName}`;
+    const base = `tdk-${osName}-${archName}`;
     return osName === "windows" ? `${base}.exe` : base;
 }
 export function binaryAssetName() {
     return binaryAssetNameFor(process.platform, process.arch);
 }
 export function executableName() {
-    return isWindows() ? "flisk.exe" : "flisk";
-}
-/** Installs published before the Flisk rename shipped the binary as `tdk`. */
-export function legacyExecutableName() {
-    return isWindows() ? "tdk.exe" : "tdk";
+    return isWindows() ? "tdk.exe" : "flisk";
 }
 export function pathLookups(binName, windows = isWindows()) {
     if (!windows)

package/cli/dist/utils/project-templates.js

@@ -1,32 +1,36 @@
 /** Public starter repositories plus the bundled default product example. */
 export const PROJECT_TEMPLATES = {
+    demo: {
+        repo: "https://github.com/flisk-sh/tdk-restaurant-example.git",
+        description: "The demo stack: restaurant ops with reservations, kitchen and floor control",
+    },
     restaurant: {
-        repo: "https://github.com/tdk-landscape/tdk-restaurant-example.git",
+        repo: "https://github.com/flisk-sh/tdk-restaurant-example.git",
         description: "Restaurant ops: reservations, kitchen, floor control (Hono + Vite + Bun)",
     },
     saas: {
-        repo: "https://github.com/tdk-landscape/tdk-saas-starter.git",
+        repo: "https://github.com/flisk-sh/tdk-saas-starter.git",
         description: "SaaS starter: account dashboard and a working checkout button (Hono + Vite + Bun)",
     },
     erp: {
-        repo: "https://github.com/tdk-landscape/tdk-erp-system.git",
+        repo: "https://github.com/flisk-sh/tdk-erp-system.git",
         description: "Enterprise ERP: 100 microservices across 7 business domains",
     },
     "user-management": {
-        repo: "https://github.com/tdk-landscape/tdk-user-management.git",
+        repo: "https://github.com/flisk-sh/tdk-user-management.git",
         description: "User/auth management services",
     },
     ecommerce: {
-        repo: "https://github.com/tdk-landscape/tdk-ecommerce-example.git",
+        repo: "https://github.com/flisk-sh/tdk-ecommerce-example.git",
         description: "Vue 3 storefront and Hono catalog API (needs Flisk 1.3.75+ for --framework vue)",
     },
     example: {
-        repo: "https://github.com/tdk-landscape/tdk-example.git",
+        repo: "https://github.com/flisk-sh/tdk-example.git",
         bundledPath: "examples/tdk-example",
         description: "Hono + Postgres + NATS worker + Vite example with a routed write path",
     },
     "agent-stack": {
-        repo: "https://github.com/tdk-landscape/tdk-agent-stack.git",
+        repo: "https://github.com/flisk-sh/tdk-agent-stack.git",
         description: "AI agent stack: Bun agent + MCP tool server + Postgres + NATS",
     },
 };

package/cli/dist/utils/secret-redaction.js

@@ -21,8 +21,15 @@ export const MIN_REDACTED_VALUE_LENGTH = 8;
  * Values of the project's own .env file, longest first so a value that contains another is masked whole. Throws when the
  * file exists but cannot be read: continuing without the values would print secrets unmasked.
  */
-export function envSecretValues(projectRoot) {
-    const envPath = join(projectRoot, ".env");
+export function envSecretValues(projectRoot, extraEnvPaths = []) {
+    const values = [
+        ...secretValuesOf(join(projectRoot, ".env")),
+        ...extraEnvPaths.flatMap((path) => secretValuesOf(path)),
+    ];
+    return [...new Set(values)].sort((a, b) => b.length - a.length);
+}
+/** The values of one env file, long enough to be worth masking. Throws when the file cannot be read. */
+function secretValuesOf(envPath) {
     if (!existsSync(envPath))
         return [];
     let content;
@@ -32,8 +39,7 @@ export function envSecretValues(projectRoot) {
     catch (error) {
         throw new EnvUnreadableError(envPath, error instanceof Error ? error.message : String(error));
     }
-    const values = [...parseEnv(content).values()].filter((value) => value.length >= MIN_REDACTED_VALUE_LENGTH);
-    return [...new Set(values)].sort((a, b) => b.length - a.length);
+    return [...parseEnv(content).values()].filter((value) => value.length >= MIN_REDACTED_VALUE_LENGTH);
 }
 export function redactSecrets(text, secrets) {
     let result = text;
@@ -58,11 +64,14 @@ export function redactValue(value, secrets) {
  * A redactor for text that may hold the project's own secrets. When the project's .env exists but cannot be read, the values
  * are unknown, so the redactor throws instead of guessing: the caller then shows and stores nothing rather than raw text. The
  * original error is kept, so a caller can still tell an unreadable .env from another failure.
+ *
+ * `extraEnvPaths` are the other env files of the run (the file `flisk up --env-file` selected): their values are secrets as
+ * much as the ones in the project .env.
  */
-export function createEnvRedactor(projectRoot) {
+export function createEnvRedactor(projectRoot, extraEnvPaths = []) {
     let secrets;
     try {
-        secrets = envSecretValues(projectRoot);
+        secrets = envSecretValues(projectRoot, extraEnvPaths);
     }
     catch (error) {
         return () => {

package/cli/dist/utils/service-manifest.js

@@ -3,7 +3,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import { validateSmoke } from "./smoke.js";
 export const SERVICE_MANIFEST_SCHEMA_VERSION = 1;
-export const SERVICE_MANIFEST_SCHEMA_URL = "https://tdk-landscape.github.io/schema.service.json";
+export const SERVICE_MANIFEST_SCHEMA_URL = "https://flisk.sh/schema.service.json";
 /**
  * Fields that are still read, or still tolerated, but should not be used. The warning says what replaces each one. `jwtSecret` is
  * ignored outright: a secret must not be committed (see docs/environment.md).

package/cli/dist/utils/smoke.js

@@ -389,9 +389,9 @@ export function formatSmokeFailure(result) {
  * The dependencies that keep smoke text safe: the project's own secret values are masked before anything is shown or stored.
  * Both `flisk up` and `flisk doctor` use them, so neither prints a body that holds a secret.
  */
-export function safeSmokeDeps(projectRoot, warn) {
+export function safeSmokeDeps(projectRoot, warn, options = {}) {
     return {
-        redact: createEnvRedactor(projectRoot),
+        redact: createEnvRedactor(projectRoot, options.envFiles ?? []),
         ...(warn ? { warn } : {}),
     };
 }

package/cli/dist/utils/tar.js

@@ -10,7 +10,7 @@ import { join } from "node:path";
  * implementation - available by default on macOS and Linux.
  */
 export function extractTarball(data, destDir) {
-    const tempDir = mkdtempSync(join(tmpdir(), "flisk-ext-"));
+    const tempDir = mkdtempSync(join(tmpdir(), "tdk-ext-"));
     const tmpFile = join(tempDir, "bundle.tar.gz");
     writeFileSync(tmpFile, data);
     mkdirSync(destDir, { recursive: true });