simplemdg-dev-cli 1.2.0

package/dist/commands/cf.command.js

@@ -0,0 +1,667 @@
+import path from "node:path";
+import { spawn } from "node:child_process";
+import nodeFs from "node:fs";
+import fs from "fs-extra";
+import chalk from "chalk";
+import prompts from "prompts";
+import { authenticateCloudFoundry, buildCloudFoundryTargetKey, listCloudFoundryApps, inferCloudFoundryRegionFromApiEndpoint, listCloudFoundryOrganizations, listCloudFoundrySpaces, readCloudFoundryTarget, scanCloudFoundryOrganizationsAcrossRegions, setCloudFoundryApiEndpoint, targetCloudFoundryOrg, targetCloudFoundrySpace, } from "../core/cf.js";
+import { parseCloudFoundryEnvironment } from "../core/cf-env-parser.js";
+import { readCache, rememberCloudFoundryApps, rememberCloudFoundryLoginProfile, rememberCloudFoundryOrgEntries, rememberEnvironmentFileName, rememberSelectedApp, } from "../core/cache.js";
+import { ensureCommandAvailable, runCommand, runCommandInherit } from "../core/process.js";
+import { resolveRepositoryPath } from "../core/repository.js";
+import { searchableSelectChoice, selectFromHistoryOrInput } from "../core/prompts.js";
+function validateRequired(value) {
+    return value.trim() ? true : "Value is required";
+}
+function buildCloudFoundryLogsArgs(options) {
+    const args = ["logs", options.appName];
+    if (options.recent) {
+        args.push("--recent");
+    }
+    return args;
+}
+function shouldIncludeLogLine(line, options) {
+    const trimmedInstance = options.instance?.trim();
+    const trimmedProcess = options.process?.trim();
+    if (!trimmedInstance && !trimmedProcess) {
+        return true;
+    }
+    const normalizedLine = line.toLowerCase();
+    if (trimmedProcess) {
+        const normalizedProcess = trimmedProcess.toLowerCase();
+        if (!normalizedLine.includes(`[app/proc/${normalizedProcess}/`) && !normalizedLine.includes(`[app/${normalizedProcess}/`)) {
+            return false;
+        }
+    }
+    if (trimmedInstance) {
+        const instancePattern = new RegExp(`\\/(?:${trimmedInstance})\\]`, "i");
+        if (!instancePattern.test(line)) {
+            return false;
+        }
+    }
+    return true;
+}
+function filterCloudFoundryLogsOutput(output, options) {
+    return output
+        .split(/\r?\n/)
+        .filter((line) => shouldIncludeLogLine(line, options))
+        .join("\n");
+}
+function writeFilteredLogChunk(chunk, options) {
+    const text = chunk.toString("utf8");
+    const filteredText = filterCloudFoundryLogsOutput(text, options);
+    if (!filteredText.trim()) {
+        return;
+    }
+    const outputText = filteredText.endsWith("\n") ? filteredText : `${filteredText}\n`;
+    if (options.isError) {
+        process.stderr.write(outputText);
+    }
+    else {
+        process.stdout.write(outputText);
+    }
+    options.outputStream?.write(outputText);
+}
+async function refreshAppsCacheForCurrentTarget() {
+    const target = await readCloudFoundryTarget();
+    const targetKey = buildCloudFoundryTargetKey(target);
+    const apps = await listCloudFoundryApps();
+    await rememberCloudFoundryApps(targetKey, apps);
+    return apps;
+}
+function refreshAppsCacheInDetachedProcess() {
+    const entryFilePath = process.argv[1];
+    if (!entryFilePath) {
+        return;
+    }
+    const childProcess = spawn(process.execPath, [entryFilePath, "cf", "apps-cache-refresh"], {
+        detached: true,
+        stdio: "ignore",
+        windowsHide: true,
+    });
+    childProcess.unref();
+}
+async function getAppsWithCache(options) {
+    if (options.refresh) {
+        return refreshAppsCacheForCurrentTarget();
+    }
+    const target = await readCloudFoundryTarget();
+    const targetKey = buildCloudFoundryTargetKey(target);
+    const cache = await readCache();
+    const cachedEntry = cache.cloudFoundry.appListsByTarget[targetKey];
+    if (cachedEntry?.apps.length) {
+        if (options.startBackgroundRefresh) {
+            refreshAppsCacheInDetachedProcess();
+        }
+        return cachedEntry.apps;
+    }
+    return refreshAppsCacheForCurrentTarget();
+}
+async function resolveAppSelection(options) {
+    if (options.app?.trim()) {
+        await rememberSelectedApp(options.app.trim());
+        return options.app.trim();
+    }
+    const apps = await getAppsWithCache({ refresh: options.refresh, startBackgroundRefresh: !options.refresh });
+    const cache = await readCache();
+    const cachedSelectedAppNames = cache.cloudFoundry.selectedApps;
+    const cachedSelectedApps = cachedSelectedAppNames
+        .filter((appName) => !apps.some((app) => app.name === appName))
+        .map((appName) => ({ title: `${appName} ${chalk.gray("cached selected")}`, value: appName }));
+    const appName = await searchableSelectChoice({
+        message: options.message,
+        choices: [
+            ...apps.map((app) => ({
+                title: [app.name, app.requestedState, app.routes].filter(Boolean).join(" | "),
+                value: app.name,
+            })),
+            ...cachedSelectedApps,
+        ],
+        validateCustomValue: validateRequired,
+        customValueTitle: (value) => `Use typed app name: ${value}`,
+    });
+    await rememberSelectedApp(appName);
+    return appName;
+}
+function printTarget(target) {
+    console.log(`API Endpoint: ${target.apiEndpoint ?? "N/A"}`);
+    console.log(`User: ${target.user ?? "N/A"}`);
+    console.log(`Org: ${target.org ?? "N/A"}`);
+    console.log(`Space: ${target.space ?? "N/A"}`);
+}
+const DEFAULT_CLOUD_FOUNDRY_API_ENDPOINTS = [
+    "https://api.cf.br10.hana.ondemand.com",
+    "https://api.cf.eu10.hana.ondemand.com",
+    "https://api.cf.us10.hana.ondemand.com",
+    "https://api.cf.ap10.hana.ondemand.com",
+    "https://api.cf.ap11.hana.ondemand.com",
+    "https://api.cf.ap21.hana.ondemand.com",
+    "https://api.cf.jp10.hana.ondemand.com",
+    "https://api.cf.ca10.hana.ondemand.com",
+    "https://api.cf.ch20.hana.ondemand.com",
+    "https://api.cf.eu20.hana.ondemand.com",
+    "https://api.cf.us20.hana.ondemand.com",
+];
+function uniqueValues(values) {
+    return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
+}
+async function selectCloudFoundryApiEndpoint(options) {
+    if (options.api?.trim()) {
+        return options.api.trim();
+    }
+    const cachedApiEndpoints = uniqueValues(options.cachedApiEndpoints);
+    if (cachedApiEndpoints.length === 1) {
+        return cachedApiEndpoints[0];
+    }
+    const choices = [
+        ...cachedApiEndpoints.map((apiEndpoint) => ({
+            title: `${apiEndpoint} ${chalk.gray("cached")}`,
+            value: apiEndpoint,
+        })),
+        ...DEFAULT_CLOUD_FOUNDRY_API_ENDPOINTS
+            .filter((apiEndpoint) => !cachedApiEndpoints.includes(apiEndpoint))
+            .map((apiEndpoint) => ({ title: apiEndpoint, value: apiEndpoint })),
+        { title: "Enter CF API endpoint manually", value: "__ENTER_MANUAL__" },
+    ];
+    return searchableSelectChoice({
+        message: "Select CF API endpoint",
+        choices: choices.filter((choice) => choice.value !== "__ENTER_MANUAL__"),
+        validateCustomValue: validateRequired,
+        customValueTitle: (value) => `Use typed CF API endpoint: ${value}`,
+    });
+}
+async function selectCloudFoundryOrganization(options) {
+    if (options.org?.trim()) {
+        return options.org.trim();
+    }
+    const organizations = await listCloudFoundryOrganizations();
+    if (organizations.length === 0) {
+        return selectFromHistoryOrInput({
+            message: "Select CF org",
+            values: options.cachedOrganizations,
+            initialValue: options.cachedOrganizations[0],
+            validate: validateRequired,
+        });
+    }
+    return searchableSelectChoice({
+        message: "Select CF org",
+        choices: organizations.map((organization) => ({ title: organization, value: organization })),
+        validateCustomValue: validateRequired,
+        customValueTitle: (value) => `Use typed CF org: ${value}`,
+    });
+}
+async function selectCloudFoundrySpace(options) {
+    if (options.space?.trim()) {
+        return options.space.trim();
+    }
+    const spaces = await listCloudFoundrySpaces();
+    if (spaces.length === 0) {
+        return selectFromHistoryOrInput({
+            message: "Select CF space",
+            values: options.cachedSpaces,
+            initialValue: options.cachedSpaces[0] ?? "app",
+        });
+    }
+    const initialSpace = spaces.includes("app") ? "app" : spaces[0];
+    return searchableSelectChoice({
+        message: "Select CF space",
+        choices: [
+            ...spaces
+                .filter((space) => space === initialSpace)
+                .map((space) => ({ title: space, value: space })),
+            ...spaces
+                .filter((space) => space !== initialSpace)
+                .map((space) => ({ title: space, value: space })),
+        ],
+        validateCustomValue: validateRequired,
+        customValueTitle: (value) => `Use typed CF space: ${value}`,
+    });
+}
+async function runLoginCommand(options) {
+    const cache = await readCache();
+    const lastProfile = cache.cloudFoundry.loginProfiles[0];
+    const apiEndpoint = await selectCloudFoundryApiEndpoint({
+        api: options.api,
+        cachedApiEndpoints: cache.cloudFoundry.loginProfiles.map((item) => item.apiEndpoint),
+    });
+    const username = options.username ?? await selectFromHistoryOrInput({
+        message: "Select CF username",
+        values: cache.cloudFoundry.loginProfiles.map((item) => item.username),
+        initialValue: lastProfile?.username,
+        validate: validateRequired,
+    });
+    let password = options.password ?? lastProfile?.password;
+    if (!password) {
+        const response = await prompts({
+            type: "password",
+            name: "password",
+            message: "Enter CF password",
+            validate: validateRequired,
+        });
+        if (!response.password) {
+            throw new Error("Cancelled");
+        }
+        password = response.password;
+    }
+    else {
+        const response = await prompts({
+            type: "select",
+            name: "useCachedPassword",
+            message: "Use cached password?",
+            choices: [
+                { title: "Yes", value: true },
+                { title: "No, enter password again", value: false },
+            ],
+            initial: 0,
+        });
+        if (!response.useCachedPassword) {
+            const passwordResponse = await prompts({
+                type: "password",
+                name: "password",
+                message: "Enter CF password",
+                validate: validateRequired,
+            });
+            if (!passwordResponse.password) {
+                throw new Error("Cancelled");
+            }
+            password = passwordResponse.password;
+        }
+    }
+    const apiExitCode = await setCloudFoundryApiEndpoint(apiEndpoint);
+    if (apiExitCode !== 0) {
+        process.exitCode = apiExitCode;
+        return;
+    }
+    const authExitCode = await authenticateCloudFoundry({ username, password });
+    if (authExitCode !== 0) {
+        process.exitCode = authExitCode;
+        return;
+    }
+    const org = await selectCloudFoundryOrganization({
+        org: options.org,
+        cachedOrganizations: cache.cloudFoundry.loginProfiles
+            .filter((item) => item.apiEndpoint === apiEndpoint && item.username === username)
+            .map((item) => item.org),
+    });
+    const orgExitCode = await targetCloudFoundryOrg(org);
+    if (orgExitCode !== 0) {
+        process.exitCode = orgExitCode;
+        return;
+    }
+    const space = await selectCloudFoundrySpace({
+        space: options.space,
+        cachedSpaces: cache.cloudFoundry.loginProfiles
+            .filter((item) => item.apiEndpoint === apiEndpoint && item.username === username && item.org === org)
+            .map((item) => item.space ?? "")
+            .filter(Boolean),
+    });
+    if (space) {
+        const spaceExitCode = await targetCloudFoundrySpace(space);
+        if (spaceExitCode !== 0) {
+            process.exitCode = spaceExitCode;
+            return;
+        }
+    }
+    await rememberCloudFoundryLoginProfile({
+        apiEndpoint,
+        username,
+        org,
+        space,
+        password: options.savePassword ? password : undefined,
+        updatedAt: new Date().toISOString(),
+    });
+    if (options.savePassword) {
+        console.log(chalk.yellow("Password was cached in ~/.simplemdg/cache.json. Do not use --save-password on shared machines."));
+    }
+    console.log(chalk.green("CF login completed."));
+}
+function formatCloudFoundryOrgEntry(entry, target) {
+    const isCurrent = entry.apiEndpoint === target.apiEndpoint && entry.org === target.org;
+    const spaceText = typeof entry.spaceCount === "number"
+        ? `${entry.spaceCount} ${entry.spaceCount === 1 ? "space" : "spaces"}`
+        : "spaces unknown";
+    return `${entry.org} ${chalk.gray(`${entry.region} · ${spaceText}${isCurrent ? " · current" : ""}`)}`;
+}
+function getCloudFoundryApiEndpointsForOrgSearch(options, target, cache) {
+    return uniqueValues([
+        options.api ?? "",
+        target.apiEndpoint ?? "",
+        ...cache.cloudFoundry.loginProfiles.map((item) => item.apiEndpoint),
+        ...DEFAULT_CLOUD_FOUNDRY_API_ENDPOINTS,
+    ]);
+}
+async function getCloudFoundryOrganizationsAcrossRegions(options) {
+    const target = await readCloudFoundryTarget();
+    const cache = await readCache();
+    const cachedEntries = cache.cloudFoundry.orgsAcrossRegions ?? [];
+    if (!options.refresh && cachedEntries.length) {
+        return cachedEntries;
+    }
+    const apiEndpoints = getCloudFoundryApiEndpointsForOrgSearch(options, target, cache);
+    console.log(chalk.gray(`Searching CF orgs across ${apiEndpoints.length} region endpoint(s)...`));
+    const entries = await scanCloudFoundryOrganizationsAcrossRegions(apiEndpoints);
+    if (entries.length) {
+        await rememberCloudFoundryOrgEntries(entries);
+        return entries;
+    }
+    const currentOrganizations = await listCloudFoundryOrganizations().catch(() => []);
+    const currentRegion = target.apiEndpoint ? inferCloudFoundryRegionFromApiEndpoint(target.apiEndpoint) : "current";
+    const fallbackEntries = currentOrganizations.map((organization) => ({
+        apiEndpoint: target.apiEndpoint ?? "",
+        region: currentRegion,
+        org: organization,
+        updatedAt: new Date().toISOString(),
+    }));
+    if (fallbackEntries.length) {
+        await rememberCloudFoundryOrgEntries(fallbackEntries);
+    }
+    return fallbackEntries;
+}
+async function runOrgCommand(options) {
+    const target = await readCloudFoundryTarget();
+    if (!target.apiEndpoint || !target.user) {
+        console.log(chalk.yellow("You are not logged in to Cloud Foundry yet. Run smdg cf login first."));
+        return;
+    }
+    const action = options.list
+        ? "list"
+        : options.switch
+            ? "switch"
+            : await searchableSelectChoice({
+                message: "What do you want to do with CF org?",
+                choices: [
+                    { title: "List orgs across regions", value: "list" },
+                    { title: "Switch org across regions", value: "switch" },
+                ],
+                validateCustomValue: (value) => {
+                    const normalizedValue = value.trim().toLowerCase();
+                    return normalizedValue === "list" || normalizedValue === "switch"
+                        ? true
+                        : "Type list or switch, or select one option.";
+                },
+            });
+    const organizationEntries = await getCloudFoundryOrganizationsAcrossRegions({
+        api: options.api,
+        refresh: options.refresh,
+    });
+    const latestTarget = await readCloudFoundryTarget();
+    if (action === "list") {
+        printTarget(latestTarget);
+        console.log("");
+        if (!organizationEntries.length) {
+            console.log(chalk.yellow("No orgs found for current CF user. Try smdg cf org --list --refresh after login."));
+            return;
+        }
+        for (const entry of organizationEntries) {
+            const marker = entry.apiEndpoint === latestTarget.apiEndpoint && entry.org === latestTarget.org ? chalk.green("*") : " ";
+            console.log(`${marker} ${formatCloudFoundryOrgEntry(entry, latestTarget)}`);
+        }
+        return;
+    }
+    let selectedEntry;
+    if (options.org?.trim()) {
+        selectedEntry = organizationEntries.find((entry) => {
+            return entry.org === options.org?.trim() && (!options.api?.trim() || entry.apiEndpoint === options.api.trim());
+        }) ?? {
+            apiEndpoint: options.api?.trim() || latestTarget.apiEndpoint || "",
+            region: options.api?.trim()
+                ? inferCloudFoundryRegionFromApiEndpoint(options.api.trim())
+                : inferCloudFoundryRegionFromApiEndpoint(latestTarget.apiEndpoint ?? "current"),
+            org: options.org.trim(),
+            updatedAt: new Date().toISOString(),
+        };
+    }
+    else {
+        const selectedIndex = await searchableSelectChoice({
+            message: "Search CF org across regions",
+            choices: organizationEntries.map((entry, index) => ({
+                title: formatCloudFoundryOrgEntry(entry, latestTarget),
+                value: String(index),
+            })),
+            validateCustomValue: validateRequired,
+            customValueTitle: (value) => `Use typed CF org in current region: ${value}`,
+        });
+        selectedEntry = organizationEntries[Number(selectedIndex)] ?? {
+            apiEndpoint: latestTarget.apiEndpoint ?? "",
+            region: inferCloudFoundryRegionFromApiEndpoint(latestTarget.apiEndpoint ?? "current"),
+            org: selectedIndex,
+            updatedAt: new Date().toISOString(),
+        };
+    }
+    if (!selectedEntry.apiEndpoint) {
+        throw new Error("Cannot determine CF API endpoint for selected org.");
+    }
+    const apiExitCode = await setCloudFoundryApiEndpoint(selectedEntry.apiEndpoint);
+    if (apiExitCode !== 0) {
+        process.exitCode = apiExitCode;
+        return;
+    }
+    const orgExitCode = await targetCloudFoundryOrg(selectedEntry.org);
+    if (orgExitCode !== 0) {
+        console.log(chalk.yellow("Cannot switch to this org with current CF session. Run smdg cf login for this region, then try again."));
+        process.exitCode = orgExitCode;
+        return;
+    }
+    const spaces = selectedEntry.spaces?.length ? selectedEntry.spaces : await listCloudFoundrySpaces();
+    const currentTargetAfterOrgSwitch = await readCloudFoundryTarget();
+    const preferredSpace = options.space?.trim() || currentTargetAfterOrgSwitch.space || (spaces.includes("app") ? "app" : spaces[0]);
+    const space = options.space?.trim() || await searchableSelectChoice({
+        message: "Select CF space",
+        choices: [
+            ...spaces
+                .filter((spaceName) => spaceName === preferredSpace)
+                .map((spaceName) => ({ title: `${spaceName} ${spaceName === currentTargetAfterOrgSwitch.space ? chalk.gray("current") : chalk.gray("suggested")}`, value: spaceName })),
+            ...spaces
+                .filter((spaceName) => spaceName !== preferredSpace)
+                .map((spaceName) => ({ title: spaceName, value: spaceName })),
+        ],
+        validateCustomValue: validateRequired,
+        customValueTitle: (value) => `Use typed CF space: ${value}`,
+    });
+    if (space) {
+        const spaceExitCode = await targetCloudFoundrySpace(space);
+        if (spaceExitCode !== 0) {
+            process.exitCode = spaceExitCode;
+            return;
+        }
+    }
+    const switchedTarget = await readCloudFoundryTarget();
+    console.log(chalk.green("CF org/space switched."));
+    printTarget(switchedTarget);
+}
+async function runAppsCommand(options) {
+    const target = await readCloudFoundryTarget();
+    const targetKey = buildCloudFoundryTargetKey(target);
+    const cache = await readCache();
+    const cachedEntry = cache.cloudFoundry.appListsByTarget[targetKey];
+    printTarget(target);
+    console.log("");
+    const shouldUseCache = !options.refresh && Boolean(cachedEntry?.apps.length);
+    const apps = await getAppsWithCache({
+        refresh: options.refresh,
+        startBackgroundRefresh: shouldUseCache,
+    });
+    if (shouldUseCache && cachedEntry) {
+        console.log(chalk.gray(`Using cached cf apps: ${cachedEntry.apps.length} apps, updated at ${cachedEntry.updatedAt}`));
+        console.log(chalk.gray("Refreshing cf apps cache in background. Use --refresh when you want to wait for fresh data."));
+        console.log("");
+    }
+    else if (options.refresh) {
+        console.log(chalk.green(`Refreshed cf apps cache for ${targetKey}.`));
+        console.log("");
+    }
+    if (options.select) {
+        const appName = await resolveAppSelection({ message: "Select BTP app", refresh: options.refresh });
+        console.log(appName);
+        return;
+    }
+    for (const app of apps) {
+        console.log([app.name, app.requestedState, app.processes, app.routes].filter(Boolean).join(" | "));
+    }
+}
+async function runAppsCacheRefreshCommand() {
+    await refreshAppsCacheForCurrentTarget();
+}
+async function runBindCommand(options) {
+    const repositoryPath = await resolveRepositoryPath(options.cwd ?? process.cwd());
+    const appName = await resolveAppSelection({ app: options.app, refresh: options.refresh, message: "Select app to cds bind" });
+    const exitCode = await runCommandInherit("cds", ["bind", "--to-app-services", appName], { cwd: repositoryPath });
+    process.exitCode = exitCode;
+}
+async function runEnvCommand(options) {
+    const repositoryPath = await resolveRepositoryPath(options.cwd ?? process.cwd());
+    const appName = await resolveAppSelection({ app: options.app, refresh: options.refresh, message: "Select app to export cf env" });
+    const cache = await readCache();
+    const outputFileName = options.out ?? await selectFromHistoryOrInput({
+        message: "Select output env file name",
+        values: cache.cloudFoundry.envFileNames,
+        initialValue: cache.cloudFoundry.envFileNames[0] ?? "default-env.json",
+        validate: validateRequired,
+    });
+    const result = await runCommand("cf", ["env", appName]);
+    if (result.exitCode !== 0) {
+        throw new Error(result.stderr || result.stdout || "cf env failed");
+    }
+    const outputPath = path.resolve(repositoryPath, outputFileName);
+    if (options.raw) {
+        await fs.writeFile(outputPath, result.stdout, "utf8");
+    }
+    else {
+        const parsedEnvironment = parseCloudFoundryEnvironment(result.stdout);
+        await fs.writeJson(outputPath, parsedEnvironment, { spaces: 2 });
+    }
+    await rememberSelectedApp(appName);
+    await rememberEnvironmentFileName(outputFileName);
+    console.log(chalk.green(`Exported ${options.raw ? "raw env" : "clean JSON env"} to ${outputPath}`));
+}
+async function runLogsCommand(options) {
+    const appName = await resolveAppSelection({ app: options.app, refresh: options.refresh, message: "Select app to view logs" });
+    const shouldFollow = options.follow || !options.recent;
+    const shouldReadRecent = options.recent || !shouldFollow;
+    const outputPath = options.out ? path.resolve(process.cwd(), options.out) : undefined;
+    if (outputPath) {
+        await fs.ensureDir(path.dirname(outputPath));
+    }
+    if (shouldReadRecent && !shouldFollow) {
+        const result = await runCommand("cf", buildCloudFoundryLogsArgs({ appName, recent: true }));
+        const combinedOutput = [result.stdout, result.stderr].filter(Boolean).join("\n");
+        const filteredOutput = filterCloudFoundryLogsOutput(combinedOutput, {
+            instance: options.instance,
+            process: options.process,
+        });
+        if (outputPath) {
+            await fs.writeFile(outputPath, filteredOutput.endsWith("\n") ? filteredOutput : `${filteredOutput}\n`, "utf8");
+            console.log(chalk.green(`Exported recent logs to ${outputPath}`));
+        }
+        else {
+            console.log(filteredOutput);
+        }
+        process.exitCode = result.exitCode;
+        return;
+    }
+    const outputStream = outputPath ? nodeFs.createWriteStream(outputPath, { flags: "a" }) : undefined;
+    if (outputPath) {
+        console.log(chalk.gray(`Streaming logs and appending to ${outputPath}`));
+    }
+    console.log(chalk.gray("Press Ctrl+C to stop realtime logs."));
+    const resolvedCommand = await ensureCommandAvailable("cf");
+    const childProcess = spawn(resolvedCommand.command, buildCloudFoundryLogsArgs({ appName, recent: false }), {
+        env: resolvedCommand.env,
+        stdio: ["ignore", "pipe", "pipe"],
+        shell: false,
+        windowsHide: true,
+    });
+    childProcess.stdout?.on("data", (chunk) => {
+        writeFilteredLogChunk(chunk, {
+            instance: options.instance,
+            process: options.process,
+            outputStream,
+        });
+    });
+    childProcess.stderr?.on("data", (chunk) => {
+        writeFilteredLogChunk(chunk, {
+            instance: options.instance,
+            process: options.process,
+            outputStream,
+            isError: true,
+        });
+    });
+    childProcess.on("close", (exitCode) => {
+        outputStream?.end();
+        process.exitCode = exitCode ?? 0;
+    });
+    await new Promise((resolve) => {
+        childProcess.on("close", () => resolve());
+    });
+}
+async function runTargetCommand() {
+    const target = await readCloudFoundryTarget();
+    printTarget(target);
+}
+async function runCacheCommand() {
+    const cache = await readCache();
+    console.log(JSON.stringify(cache.cloudFoundry, null, 2));
+}
+export function registerCloudFoundryCommands(program) {
+    const cfCommand = program.command("cf").description("Cloud Foundry helper commands for SimpleMDG");
+    cfCommand
+        .command("login")
+        .description("Login to Cloud Foundry and cache login profile")
+        .option("--api <apiEndpoint>", "CF API endpoint")
+        .option("--username <username>", "CF username")
+        .option("--password <password>", "CF password")
+        .option("--org <org>", "CF org")
+        .option("--space <space>", "CF space")
+        .option("--save-password", "Cache password in ~/.simplemdg/cache.json. Avoid on shared machines.")
+        .action(runLoginCommand);
+    cfCommand.command("target").description("Show current cf target").action(runTargetCommand);
+    cfCommand
+        .command("org")
+        .description("List orgs or switch to another org/space without logging in again")
+        .option("--list", "List orgs across known CF regions")
+        .option("--switch", "Switch to another org and space across known CF regions")
+        .option("--refresh", "Search orgs from CF region endpoints and update cache")
+        .option("--api <apiEndpoint>", "Limit org search/switch to one CF API endpoint")
+        .option("--org <org>", "CF org name")
+        .option("--space <space>", "CF space name")
+        .action(runOrgCommand);
+    cfCommand
+        .command("apps")
+        .description("List BTP apps in current org and space with per-target cache")
+        .option("--refresh", "Wait for fresh app list from cf apps and update cache")
+        .option("--select", "Select one app and print its name")
+        .action(runAppsCommand);
+    cfCommand
+        .command("bind")
+        .description("Run cds bind --to-app-services <app>")
+        .option("--app <appName>", "BTP app name")
+        .option("--cwd <path>", "Repository path", process.cwd())
+        .option("--refresh", "Refresh app list before selecting")
+        .action(runBindCommand);
+    cfCommand
+        .command("env")
+        .description("Export cf env <app> to clean JSON file")
+        .option("--app <appName>", "BTP app name")
+        .option("--out <fileName>", "Output file name", undefined)
+        .option("--cwd <path>", "Repository path", process.cwd())
+        .option("--refresh", "Refresh app list before selecting")
+        .option("--raw", "Export raw cf env output instead of clean JSON")
+        .action(runEnvCommand);
+    cfCommand
+        .command("logs")
+        .description("View realtime or recent logs for a BTP app")
+        .option("--app <appName>", "BTP app name")
+        .option("--refresh", "Refresh app list before selecting")
+        .option("--recent", "Show recent logs and exit")
+        .option("--follow", "Follow realtime logs. This is the default when --recent is not used")
+        .option("--out <fileName>", "Export logs to file. With realtime logs, append until Ctrl+C")
+        .option("--instance <index>", "Filter logs by app instance index, for example 0 or 1")
+        .option("--process <processName>", "Filter logs by process name, for example WEB")
+        .action(runLogsCommand);
+    cfCommand
+        .command("apps-cache-refresh")
+        .description("Refresh cached cf apps for current target. Internal command used by smdg cf apps.")
+        .action(runAppsCacheRefreshCommand);
+    cfCommand.command("cache").description("Print cached Cloud Foundry values").action(runCacheCommand);
+}
+//# sourceMappingURL=cf.command.js.map