simplemdg-dev-cli 1.3.1 → 1.4.1

package/dist/commands/cf.command.js

@@ -74,6 +74,71 @@ async function ensureCloudFoundrySessionFromCache() {
     });
     return readCloudFoundryTarget();
 }
+function sortCloudFoundryProfilesForEndpoint(options) {
+    const profilesWithPassword = options.profiles.filter((profile) => profile.password?.trim());
+    return [
+        ...profilesWithPassword.filter((profile) => profile.apiEndpoint === options.apiEndpoint && profile.org === options.preferredOrg),
+        ...profilesWithPassword.filter((profile) => profile.apiEndpoint === options.apiEndpoint && profile.org !== options.preferredOrg),
+        ...profilesWithPassword.filter((profile) => profile.apiEndpoint !== options.apiEndpoint && profile.org === options.preferredOrg),
+        ...profilesWithPassword.filter((profile) => profile.apiEndpoint !== options.apiEndpoint && profile.org !== options.preferredOrg),
+    ].filter((profile, index, array) => {
+        return array.findIndex((item) => {
+            return item.apiEndpoint === profile.apiEndpoint
+                && item.username === profile.username
+                && item.password === profile.password
+                && item.org === profile.org
+                && item.space === profile.space;
+        }) === index;
+    });
+}
+async function ensureCloudFoundryAuthenticatedForApiEndpoint(options) {
+    const apiExitCode = await setCloudFoundryApiEndpoint(options.apiEndpoint);
+    if (apiExitCode !== 0) {
+        process.exitCode = apiExitCode;
+        throw new Error(`Cannot set CF API endpoint: ${options.apiEndpoint}`);
+    }
+    const orgsCheck = await runCommand("cf", ["orgs"]);
+    if (orgsCheck.exitCode === 0) {
+        return undefined;
+    }
+    const cache = await readCache();
+    const profiles = sortCloudFoundryProfilesForEndpoint({
+        profiles: cache.cloudFoundry.loginProfiles,
+        apiEndpoint: options.apiEndpoint,
+        preferredOrg: options.preferredOrg,
+    });
+    if (!profiles.length) {
+        console.log(chalk.yellow(`Not logged in to ${inferCloudFoundryRegionFromApiEndpoint(options.apiEndpoint)} and no cached password was found for automatic login.`));
+        console.log(chalk.gray("Run smdg cf login once, choose to save password, then retry this command."));
+        throw new Error("Cloud Foundry automatic login is required");
+    }
+    let lastError = orgsCheck.stderr || orgsCheck.stdout || "cf orgs failed";
+    for (const profile of profiles) {
+        console.log(chalk.gray(`Auto auth CF ${inferCloudFoundryRegionFromApiEndpoint(options.apiEndpoint)} as ${profile.username}...`));
+        const authExitCode = await authenticateCloudFoundry({
+            username: profile.username,
+            password: profile.password,
+        });
+        if (authExitCode !== 0) {
+            lastError = `cf auth failed for ${profile.username}`;
+            continue;
+        }
+        const nextOrgsCheck = await runCommand("cf", ["orgs"]);
+        if (nextOrgsCheck.exitCode === 0) {
+            const updatedProfile = {
+                ...profile,
+                apiEndpoint: options.apiEndpoint,
+                org: options.preferredOrg || profile.org,
+                space: options.preferredSpace || profile.space,
+                updatedAt: new Date().toISOString(),
+            };
+            await rememberCloudFoundryLoginProfile(updatedProfile);
+            return updatedProfile;
+        }
+        lastError = nextOrgsCheck.stderr || nextOrgsCheck.stdout || lastError;
+    }
+    throw new Error(`CF automatic login failed for ${options.apiEndpoint}. ${lastError}`);
+}
 function buildCloudFoundryLogsArgs(options) {
     const args = ["logs", options.appName];
     if (options.recent) {
@@ -96,15 +161,28 @@ function buildNodeInspectorRemoteCommand(remotePort) {
         return [
             `echo "Remote port ${remotePort} was requested."`,
             `echo "SIGUSR1 starts the Node.js inspector on its default port 9229 for a running Node process."`,
-            `echo "Use remote port 9229, or start the app process with NODE_OPTIONS=--inspect=127.0.0.1:${remotePort}."`,
+            `echo "Use remote port 9229, or start the app process with NODE_OPTIONS=--inspect=0.0.0.0:${remotePort}."`,
             `exit 2`,
         ].join("; ");
     }
+    const detectNodePidScript = [
+        `PID=""`,
+        `if command -v pgrep >/dev/null 2>&1; then PID=$(pgrep -f "(^|/| )node( |$)" 2>/dev/null | head -n 1 || true); fi`,
+        `if [ -z "$PID" ]; then PID=$(ps -eo pid=,args= 2>/dev/null | awk '/[n]ode/ && $0 !~ /awk/ && $0 !~ /pgrep/ {print $1; exit}'); fi`,
+        `if [ -z "$PID" ]; then echo "No Node.js PID found in app container. Use prepare mode: Set NODE_OPTIONS and restart app." >&2; ps -eo pid,args 2>/dev/null | head -n 40 >&2; exit 1; fi`,
+        `echo "Detected Node.js PID: $PID"`,
+        `if command -v ss >/dev/null 2>&1 && ss -H -ntl "sport = :9229" | grep -q .; then echo "Node inspector already listening on 127.0.0.1:9229"; tail -f /dev/null; fi`,
+        `if command -v netstat >/dev/null 2>&1 && netstat -ntl 2>/dev/null | awk '{print $4}' | grep -Eq '(^|:)9229$'; then echo "Node inspector already listening on 127.0.0.1:9229"; tail -f /dev/null; fi`,
+        `kill -USR1 "$PID" || { echo "Cannot send SIGUSR1 to Node.js PID $PID. Use prepare mode: Set NODE_OPTIONS and restart app." >&2; exit 1; }`,
+        `echo "Requested Node inspector for PID $PID on 127.0.0.1:9229"`,
+        `COUNT=0; while [ "$COUNT" -lt 20 ]; do if command -v ss >/dev/null 2>&1 && ss -H -ntl "sport = :9229" | grep -q .; then echo "Node inspector is listening on 127.0.0.1:9229"; break; fi; if command -v netstat >/dev/null 2>&1 && netstat -ntl 2>/dev/null | awk '{print $4}' | grep -Eq '(^|:)9229$'; then echo "Node inspector is listening on 127.0.0.1:9229"; break; fi; COUNT=$((COUNT + 1)); sleep 1; done`,
+        `tail -f /dev/null`,
+    ];
+    return detectNodePidScript.join("; ");
+}
+function buildKeepAliveRemoteCommand() {
     return [
-        `PID=$(pgrep -xo node || pgrep -x node | head -n 1)`,
-        `if [ -z "$PID" ]; then echo "No Node.js PID found in app container" >&2; exit 1; fi`,
-        `if command -v ss >/dev/null 2>&1 && ss -H -ntl "sport = :9229" | grep -q .; then echo "Node inspector already listening on 127.0.0.1:9229"`,
-        `else kill -s SIGUSR1 "$PID" && echo "Started Node inspector for PID $PID on 127.0.0.1:9229"; fi`,
+        `echo "SSH tunnel is open. Keep this terminal running."`,
         `tail -f /dev/null`,
     ].join("; ");
 }
@@ -118,9 +196,69 @@ function buildCloudFoundryDebugSshArgs(options) {
     if (options.processName?.trim()) {
         args.push("--process", options.processName.trim());
     }
-    args.push("-T", "-L", `${options.localPort}:127.0.0.1:${options.remotePort}`, "-c", buildNodeInspectorRemoteCommand(options.remotePort));
+    const remoteCommand = options.prepareMode === "running-process"
+        ? buildNodeInspectorRemoteCommand(options.remotePort)
+        : buildKeepAliveRemoteCommand();
+    args.push("-T", "-L", `${options.localPort}:127.0.0.1:${options.remotePort}`, "-c", remoteCommand);
     return args;
 }
+async function selectNodeInspectorPrepareMode(options) {
+    return searchableSelectChoice({
+        message: "Prepare Node.js inspector",
+        choices: [
+            {
+                title: "Set NODE_OPTIONS and restart app (recommended first time)",
+                value: "set-env-restart",
+                description: `Runs cf set-env ${options.appName} NODE_OPTIONS --inspect=0.0.0.0:${options.remotePort} and cf restart`,
+            },
+            {
+                title: "Try start inspector on running Node process without restart",
+                value: "running-process",
+                description: "Uses cf ssh + SIGUSR1. Fast, but may fail if Node PID cannot be detected.",
+            },
+            {
+                title: "Inspector is already enabled, only open SSH tunnel",
+                value: "already-enabled",
+                description: "Use when NODE_OPTIONS already contains --inspect and app was restarted.",
+            },
+        ],
+        allowCustomValue: false,
+    });
+}
+async function ensureSshEnabledForDebug(appName) {
+    const sshEnabledResult = await runCommand("cf", ["ssh-enabled", appName]);
+    const combinedOutput = `${sshEnabledResult.stdout}
+${sshEnabledResult.stderr}`;
+    if (sshEnabledResult.exitCode === 0 && /enabled/i.test(combinedOutput) && !/not enabled/i.test(combinedOutput)) {
+        return;
+    }
+    console.log(chalk.yellow("SSH is not enabled for this app. Enabling SSH..."));
+    const enableResult = await runCommand("cf", ["enable-ssh", appName]);
+    if (enableResult.stdout)
+        console.log(enableResult.stdout);
+    if (enableResult.stderr)
+        console.error(enableResult.stderr);
+    if (enableResult.exitCode !== 0) {
+        throw new Error("cf enable-ssh failed. You may not have permission to enable SSH for this app.");
+    }
+}
+async function setNodeInspectorEnvironmentAndRestart(options) {
+    const nodeOptions = `--inspect=0.0.0.0:${options.remotePort} --enable-source-maps`;
+    console.log(chalk.gray(`Setting NODE_OPTIONS for ${options.appName}: ${nodeOptions}`));
+    const setEnvResult = await runCommand("cf", ["set-env", options.appName, "NODE_OPTIONS", nodeOptions]);
+    if (setEnvResult.stdout)
+        console.log(setEnvResult.stdout);
+    if (setEnvResult.stderr)
+        console.error(setEnvResult.stderr);
+    if (setEnvResult.exitCode !== 0) {
+        throw new Error("cf set-env NODE_OPTIONS failed");
+    }
+    console.log(chalk.yellow("Restarting app so NODE_OPTIONS takes effect..."));
+    const restartExitCode = await runCommandInherit("cf", ["restart", options.appName]);
+    if (restartExitCode !== 0) {
+        throw new Error(`cf restart ${options.appName} failed`);
+    }
+}
 async function getNodeInspectorDebugUrl(localPort) {
     const response = await fetch(`http://127.0.0.1:${localPort}/json/list`);
     if (!response.ok) {
@@ -240,18 +378,34 @@ async function writeVscodeLaunchConfiguration(options) {
 }
 function printVscodeAttachInstructions(options) {
     console.log("");
-    console.log(chalk.green(`VS Code debug config is ready for ${options.appName} instance ${options.instanceIndex}.`));
+    if (options.inspectorReady === false) {
+        console.log(chalk.yellow(`VS Code config was created, but the Node inspector is not reachable yet for ${options.appName} instance ${options.instanceIndex}.`));
+        console.log(chalk.yellow("The VS Code debug toolbar appears only after the inspector is reachable and you start the attach config."));
+    }
+    else {
+        console.log(chalk.green(`VS Code debug config is ready for ${options.appName} instance ${options.instanceIndex}.`));
+    }
     console.log(`Launch file: ${chalk.cyan(options.launchJsonPath)}`);
     console.log(`Attach config: ${chalk.cyan(`Attach BTP ${options.appName}`)}`);
     console.log(`Inspector: ${chalk.cyan(`127.0.0.1:${options.localPort}`)}`);
     console.log("");
-    console.log(chalk.gray("Keep this terminal open, then open VS Code Run and Debug and choose the attach config above."));
+    console.log(chalk.cyan("How to start debugging in VS Code:"));
+    console.log("1. Keep this terminal open. It owns the CF SSH tunnel.");
+    console.log("2. Open VS Code Run and Debug panel with Ctrl+Shift+D.");
+    console.log(`3. Select ${chalk.cyan(`Attach BTP ${options.appName}`)}.`);
+    console.log("4. Press F5 or the green Start Debugging button.");
+    console.log("5. Debug buttons such as pause, step over, step into, restart, and stop appear only after attach succeeds.");
+    console.log("");
     console.log(chalk.gray("Press Ctrl+C in this terminal to close the tunnel."));
 }
 async function openVisualStudioCode(options) {
-    const result = await runCommand("code", [options.cwd]);
+    const args = options.debugPanel
+        ? ["--reuse-window", options.cwd, "--command", "workbench.view.debug"]
+        : [options.cwd];
+    const result = await runCommand("code", args);
     if (result.exitCode !== 0) {
         console.log(chalk.yellow("Could not open VS Code automatically. Open this folder manually in VS Code."));
+        console.log(chalk.gray("Then open Run and Debug with Ctrl+Shift+D."));
         if (result.stderr)
             console.log(chalk.gray(result.stderr));
     }
@@ -273,9 +427,9 @@ async function selectDebugMode(options) {
         message: "Select debug mode",
         choices: [
             {
-                title: "VS Code attach debugger (recommended)",
+                title: "VS Code guided debugging (recommended)",
                 value: "vscode",
-                description: "Create/update .vscode/launch.json and open a CF SSH tunnel",
+                description: "Create launch.json, open VS Code Debug panel, prepare inspector, and open CF SSH tunnel",
             },
             {
                 title: "Chrome DevTools / chrome://inspect",
@@ -430,6 +584,7 @@ function refreshAppsCacheInDetachedProcess() {
     childProcess.unref();
 }
 async function getAppsWithCache(options) {
+    await ensureCloudFoundrySessionFromCache();
     if (options.refresh) {
         return refreshAppsCacheForCurrentTarget();
     }
@@ -480,15 +635,24 @@ function printTarget(target) {
 const DEFAULT_CLOUD_FOUNDRY_API_ENDPOINTS = [
     "https://api.cf.br10.hana.ondemand.com",
     "https://api.cf.eu10.hana.ondemand.com",
+    "https://api.cf.eu10-004.hana.ondemand.com",
+    "https://api.cf.eu10-005.hana.ondemand.com",
+    "https://api.cf.eu20.hana.ondemand.com",
+    "https://api.cf.eu20-001.hana.ondemand.com",
+    "https://api.cf.eu20-002.hana.ondemand.com",
     "https://api.cf.us10.hana.ondemand.com",
+    "https://api.cf.us10-001.hana.ondemand.com",
+    "https://api.cf.us11.hana.ondemand.com",
+    "https://api.cf.us20.hana.ondemand.com",
+    "https://api.cf.us21.hana.ondemand.com",
     "https://api.cf.ap10.hana.ondemand.com",
     "https://api.cf.ap11.hana.ondemand.com",
+    "https://api.cf.ap20.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",
+    "https://api.cf.sa10.hana.ondemand.com",
 ];
 function uniqueValues(values) {
     return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
@@ -689,6 +853,7 @@ function getCloudFoundryApiEndpointsForOrgSearch(options, target, cache) {
         options.api ?? "",
         target.apiEndpoint ?? "",
         ...cache.cloudFoundry.loginProfiles.map((item) => item.apiEndpoint),
+        ...cache.cloudFoundry.orgsAcrossRegions.map((item) => item.apiEndpoint),
         ...DEFAULT_CLOUD_FOUNDRY_API_ENDPOINTS,
     ]);
 }
@@ -696,8 +861,12 @@ 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 cachedRegionCount = new Set(cachedEntries.map((entry) => entry.region)).size;
+    if (!options.refresh && cachedEntries.length && cachedRegionCount > 1) {
+        return cachedEntries.sort((left, right) => {
+            const byOrg = left.org.localeCompare(right.org);
+            return byOrg !== 0 ? byOrg : left.region.localeCompare(right.region);
+        });
     }
     const apiEndpoints = getCloudFoundryApiEndpointsForOrgSearch(options, target, cache);
     console.log(chalk.gray(`Searching CF orgs across ${apiEndpoints.length} region endpoint(s)...`));
@@ -708,6 +877,8 @@ async function getCloudFoundryOrganizationsAcrossRegions(options) {
     }));
     const entries = await scanCloudFoundryOrganizationsAcrossRegions(apiEndpoints, credentials);
     if (entries.length) {
+        const regionCount = new Set(entries.map((entry) => entry.region)).size;
+        console.log(chalk.green(`Found ${entries.length} org(s) across ${regionCount} region(s).`));
         await rememberCloudFoundryOrgEntries(entries);
         return entries;
     }
@@ -747,14 +918,17 @@ async function runOrgCommand(options) {
         api: options.api,
         refresh: options.refresh,
     });
+    const organizationRegionCount = new Set(organizationEntries.map((entry) => entry.region)).size;
     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."));
+            console.log(chalk.yellow("No orgs found for current CF user. Run smdg cf login, save the password, then run smdg cf org again."));
             return;
         }
+        console.log(chalk.gray(`Showing ${organizationEntries.length} org(s) across ${organizationRegionCount} region(s).`));
+        console.log("");
         for (const entry of organizationEntries) {
             const marker = entry.apiEndpoint === latestTarget.apiEndpoint && entry.org === latestTarget.org ? chalk.green("*") : " ";
             console.log(`${marker} ${formatCloudFoundryOrgEntry(entry, latestTarget)}`);
@@ -781,7 +955,7 @@ async function runOrgCommand(options) {
             return;
         }
         const selectedIndex = await searchableSelectChoice({
-            message: "Search CF org across regions",
+            message: `Search CF org across ${organizationRegionCount} region(s)`,
             choices: organizationEntries.map((entry, index) => ({
                 title: formatCloudFoundryOrgEntry(entry, latestTarget),
                 value: String(index),
@@ -799,14 +973,16 @@ async function runOrgCommand(options) {
     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 authenticatedProfile = await ensureCloudFoundryAuthenticatedForApiEndpoint({
+        apiEndpoint: selectedEntry.apiEndpoint,
+        preferredOrg: selectedEntry.org,
+        preferredSpace: options.space,
+        reason: "switch-org",
+    });
     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."));
+        console.log(chalk.yellow("Cannot switch to this org after automatic authentication."));
+        console.log(chalk.gray("Run smdg cf login, save the password, then try again."));
         process.exitCode = orgExitCode;
         return;
     }
@@ -833,6 +1009,15 @@ async function runOrgCommand(options) {
             return;
         }
     }
+    if (authenticatedProfile?.password) {
+        await rememberCloudFoundryLoginProfile({
+            ...authenticatedProfile,
+            apiEndpoint: selectedEntry.apiEndpoint,
+            org: selectedEntry.org,
+            space,
+            updatedAt: new Date().toISOString(),
+        });
+    }
     const switchedTarget = await readCloudFoundryTarget();
     console.log(chalk.green("CF org/space switched."));
     printTarget(switchedTarget);
@@ -962,6 +1147,7 @@ async function runLogsCommand(options) {
 }
 async function runDebugCommand(options) {
     await maybeSwitchCloudFoundryTargetForDebug(options);
+    await ensureCloudFoundrySessionFromCache();
     const appName = await resolveAppSelection({
         app: options.app,
         refresh: options.refresh,
@@ -1033,7 +1219,7 @@ async function runDebugCommand(options) {
             initial: options.open ? 1 : 0,
         });
         if (openResponse.open) {
-            await openVisualStudioCode({ cwd: repositoryPath });
+            await openVisualStudioCode({ cwd: repositoryPath, debugPanel: debugMode === "vscode" });
         }
     }
     if (debugMode === "config-only") {
@@ -1071,6 +1257,15 @@ async function runDebugCommand(options) {
             console.log(chalk.yellow("SSH was enabled. If cf ssh still fails, restart the app or run: cf restart " + appName));
         }
     }
+    console.log("");
+    console.log(chalk.cyan("BTP debug works by opening a CF SSH tunnel to the Node.js inspector."));
+    console.log(chalk.gray("If this is the first time debugging this app, choose: Set NODE_OPTIONS and restart app."));
+    console.log(chalk.gray("If the app was already restarted with NODE_OPTIONS=--inspect, choose: Inspector is already enabled."));
+    const prepareMode = await selectNodeInspectorPrepareMode({ appName, remotePort });
+    await ensureSshEnabledForDebug(appName);
+    if (prepareMode === "set-env-restart") {
+        await setNodeInspectorEnvironmentAndRestart({ appName, remotePort });
+    }
     console.log(chalk.gray(`Starting Node.js inspector tunnel for ${appName} instance ${instanceIndex}...`));
     console.log(chalk.gray(`Forwarding localhost:${localPort} -> app container 127.0.0.1:${remotePort}`));
     const childProcess = spawn("cf", buildCloudFoundryDebugSshArgs({
@@ -1079,6 +1274,7 @@ async function runDebugCommand(options) {
         processName: options.process,
         localPort,
         remotePort,
+        prepareMode,
     }), {
         stdio: ["ignore", "pipe", "pipe"],
         shell: false,
@@ -1090,16 +1286,20 @@ async function runDebugCommand(options) {
             return;
         }
         hasPrintedAttachInfo = true;
+        const debugUrl = await waitForNodeInspectorDebugUrl(localPort);
         if (debugMode === "vscode") {
+            if (!debugUrl) {
+                console.log(chalk.yellow("Inspector is not reachable yet on localhost. If you selected running-process mode and see a Node PID error, run debug again and choose 'Set NODE_OPTIONS and restart app'."));
+            }
             printVscodeAttachInstructions({
                 appName,
                 instanceIndex,
                 localPort,
                 launchJsonPath: launchJsonPath ?? path.resolve(repositoryPath, ".vscode", "launch.json"),
+                inspectorReady: Boolean(debugUrl),
             });
             return;
         }
-        const debugUrl = await waitForNodeInspectorDebugUrl(localPort);
         printNodeInspectorAttachInfo({ appName, instanceIndex, localPort, debugUrl });
     };
     childProcess.stdout?.on("data", (chunk) => {
@@ -1117,6 +1317,12 @@ async function runDebugCommand(options) {
     }, 3000);
     childProcess.on("close", (exitCode) => {
         clearTimeout(fallbackTimer);
+        if (!hasPrintedAttachInfo || (exitCode ?? 0) !== 0) {
+            console.log("");
+            console.log(chalk.red("Debug tunnel stopped before a working inspector connection was confirmed."));
+            console.log(chalk.yellow("Run smdg cf debug again and choose 'Set NODE_OPTIONS and restart app' when asked to prepare Node.js inspector."));
+            console.log(chalk.gray("After the app restarts, choose VS Code guided debugging and start the attach config from VS Code Run and Debug."));
+        }
         process.exitCode = exitCode ?? 0;
     });
     await new Promise((resolve) => {