simplemdg-dev-cli 1.5.1 → 2.4.4

package/src/core/cf-env-parser.ts

@@ -0,0 +1,131 @@
+import type { TParsedCloudFoundryEnvironment } from "./types";
+
+const SECTION_MARKERS = [
+  "System-Provided:",
+  "User-Provided:",
+  "Running Environment Variable Groups:",
+  "Staging Environment Variable Groups:",
+];
+
+function stripAnsi(value: string): string {
+  return value.replace(/\u001b\[[0-9;]*m/g, "");
+}
+
+function findMatchingJsonEnd(value: string, startIndex: number): number {
+  const openingCharacter = value[startIndex];
+  const closingCharacter = openingCharacter === "{" ? "}" : "]";
+  let depth = 0;
+  let isInsideString = false;
+  let isEscaped = false;
+
+  for (let index = startIndex; index < value.length; index += 1) {
+    const character = value[index];
+
+    if (isInsideString) {
+      if (isEscaped) {
+        isEscaped = false;
+        continue;
+      }
+
+      if (character === "\\") {
+        isEscaped = true;
+        continue;
+      }
+
+      if (character === '"') {
+        isInsideString = false;
+      }
+
+      continue;
+    }
+
+    if (character === '"') {
+      isInsideString = true;
+      continue;
+    }
+
+    if (character === openingCharacter) depth += 1;
+    if (character === closingCharacter) {
+      depth -= 1;
+      if (depth === 0) return index;
+    }
+  }
+
+  return -1;
+}
+
+function parseSimpleValue(rawValue: string): unknown {
+  const value = rawValue.trim();
+
+  if (value === "true") return true;
+  if (value === "false") return false;
+  if (/^-?\d+(\.\d+)?$/.test(value)) return Number(value);
+
+  if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+    return value.slice(1, -1);
+  }
+
+  return value;
+}
+
+function parseKeyValueBlock(block: string): TParsedCloudFoundryEnvironment {
+  const result: TParsedCloudFoundryEnvironment = {};
+  let cursor = 0;
+
+  while (cursor < block.length) {
+    const nextMatch = /(^|\n)([A-Za-z_][A-Za-z0-9_]*):\s*/g;
+    nextMatch.lastIndex = cursor;
+    const match = nextMatch.exec(block);
+
+    if (!match) break;
+
+    const key = match[2];
+    const valueStart = nextMatch.lastIndex;
+    const firstCharacter = block[valueStart];
+
+    if (firstCharacter === "{" || firstCharacter === "[") {
+      const valueEnd = findMatchingJsonEnd(block, valueStart);
+      if (valueEnd === -1) {
+        throw new Error(`Cannot parse JSON value for ${key}`);
+      }
+
+      const rawJson = block.slice(valueStart, valueEnd + 1);
+      result[key] = JSON.parse(rawJson);
+      cursor = valueEnd + 1;
+      continue;
+    }
+
+    const nextLineIndex = block.indexOf("\n", valueStart);
+    const valueEnd = nextLineIndex === -1 ? block.length : nextLineIndex;
+    result[key] = parseSimpleValue(block.slice(valueStart, valueEnd));
+    cursor = valueEnd + 1;
+  }
+
+  return result;
+}
+
+function getSection(raw: string, sectionName: string): string {
+  const startIndex = raw.indexOf(sectionName);
+  if (startIndex === -1) return "";
+
+  const contentStartIndex = startIndex + sectionName.length;
+  const nextSectionIndexes = SECTION_MARKERS
+    .filter((marker) => marker !== sectionName)
+    .map((marker) => raw.indexOf(marker, contentStartIndex))
+    .filter((index) => index !== -1);
+
+  const contentEndIndex = nextSectionIndexes.length > 0 ? Math.min(...nextSectionIndexes) : raw.length;
+  return raw.slice(contentStartIndex, contentEndIndex).trim();
+}
+
+export function parseCloudFoundryEnvironment(rawOutput: string): TParsedCloudFoundryEnvironment {
+  const cleanedOutput = stripAnsi(rawOutput);
+  const systemProvidedBlock = getSection(cleanedOutput, "System-Provided:");
+  const userProvidedBlock = getSection(cleanedOutput, "User-Provided:");
+  const result: TParsedCloudFoundryEnvironment = {};
+
+  Object.assign(result, parseKeyValueBlock(systemProvidedBlock));
+  Object.assign(result, parseKeyValueBlock(userProvidedBlock));
+
+  return result;
+}

package/src/core/cf.ts

@@ -0,0 +1,271 @@
+import type { TCloudFoundryApp, TCloudFoundryOrgEntry, TCloudFoundryTarget } from "./types";
+import { runCommand } from "./process";
+
+export function buildCloudFoundryTargetKey(target: TCloudFoundryTarget): string {
+  return [
+    target.apiEndpoint ?? "unknown-api",
+    target.org ?? "unknown-org",
+    target.space ?? "unknown-space",
+  ].join("|");
+}
+
+export async function readCloudFoundryTarget(): Promise<TCloudFoundryTarget> {
+  const result = await runCommand("cf", ["target"]);
+
+  if (result.exitCode !== 0) {
+    return {};
+  }
+
+  const target: TCloudFoundryTarget = {};
+
+  for (const line of result.stdout.split(/\r?\n/)) {
+    const [rawKey, ...rawValueParts] = line.split(":");
+    const key = rawKey.trim().toLowerCase();
+    const value = rawValueParts.join(":").trim();
+
+    if (key === "api endpoint") target.apiEndpoint = value;
+    if (key === "user") target.user = value;
+    if (key === "org") target.org = value;
+    if (key === "space") target.space = value;
+  }
+
+  return target;
+}
+
+
+export async function setCloudFoundryApiEndpoint(apiEndpoint: string): Promise<number> {
+  const result = await runCommand("cf", ["api", apiEndpoint]);
+
+  if (result.stdout) console.log(result.stdout);
+  if (result.stderr) console.error(result.stderr);
+
+  return result.exitCode;
+}
+
+export async function authenticateCloudFoundry(options: {
+  username: string;
+  password: string;
+}): Promise<number> {
+  const result = await runCommand("cf", ["auth", options.username, options.password]);
+
+  if (result.stdout) console.log(result.stdout);
+  if (result.stderr) console.error(result.stderr);
+
+  return result.exitCode;
+}
+
+export async function targetCloudFoundryOrg(org: string): Promise<number> {
+  const result = await runCommand("cf", ["target", "-o", org]);
+
+  if (result.stdout) console.log(result.stdout);
+  if (result.stderr) console.error(result.stderr);
+
+  return result.exitCode;
+}
+
+export async function targetCloudFoundrySpace(space: string): Promise<number> {
+  const result = await runCommand("cf", ["target", "-s", space]);
+
+  if (result.stdout) console.log(result.stdout);
+  if (result.stderr) console.error(result.stderr);
+
+  return result.exitCode;
+}
+
+export async function listCloudFoundryOrganizations(): Promise<string[]> {
+  const result = await runCommand("cf", ["orgs"]);
+
+  if (result.exitCode !== 0) {
+    throw new Error(result.stderr || result.stdout || "cf orgs failed");
+  }
+
+  return parseCloudFoundryNameList(result.stdout, "name");
+}
+
+export async function listCloudFoundrySpaces(): Promise<string[]> {
+  const result = await runCommand("cf", ["spaces"]);
+
+  if (result.exitCode !== 0) {
+    throw new Error(result.stderr || result.stdout || "cf spaces failed");
+  }
+
+  return parseCloudFoundryNameList(result.stdout, "name");
+}
+
+function parseCloudFoundryNameList(output: string, headerName: string): string[] {
+  const lines = output.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  const headerIndex = lines.findIndex((line) => line.toLowerCase() === headerName.toLowerCase());
+
+  if (headerIndex === -1) {
+    return [];
+  }
+
+  return lines
+    .slice(headerIndex + 1)
+    .filter((line) => !/^Getting\s+/i.test(line))
+    .filter((line) => !/^OK$/i.test(line))
+    .filter(Boolean);
+}
+export function inferCloudFoundryRegionFromApiEndpoint(apiEndpoint: string): string {
+  const match = apiEndpoint.match(/api\.cf\.([^.]+)\./i);
+  return match?.[1] ?? apiEndpoint.replace(/^https?:\/\//, "");
+}
+
+export async function scanCloudFoundryOrganizationsAcrossRegions(apiEndpoints: string[], credentials: Array<{ apiEndpoint: string; username: string; password?: string }> = []): Promise<TCloudFoundryOrgEntry[]> {
+  const originalTarget = await readCloudFoundryTarget();
+  const orgEntries: TCloudFoundryOrgEntry[] = [];
+  const uniqueApiEndpoints = [...new Set(apiEndpoints.map((apiEndpoint) => apiEndpoint.trim()).filter(Boolean))];
+
+  for (const apiEndpoint of uniqueApiEndpoints) {
+    const apiResult = await runCommand("cf", ["api", apiEndpoint]);
+
+    if (apiResult.exitCode !== 0) {
+      continue;
+    }
+
+    let orgResult = await runCommand("cf", ["orgs"]);
+
+    if (orgResult.exitCode !== 0) {
+      const endpointCredentials = [
+        ...credentials.filter((item) => item.apiEndpoint === apiEndpoint && item.password?.trim()),
+        ...credentials.filter((item) => item.apiEndpoint !== apiEndpoint && item.password?.trim()),
+      ];
+      const triedUsers = new Set<string>();
+
+      for (const credential of endpointCredentials) {
+        const credentialKey = `${credential.username}|${credential.password ?? ""}`;
+
+        if (triedUsers.has(credentialKey)) {
+          continue;
+        }
+
+        triedUsers.add(credentialKey);
+        const authResult = await runCommand("cf", ["auth", credential.username, credential.password as string]);
+
+        if (authResult.exitCode !== 0) {
+          continue;
+        }
+
+        orgResult = await runCommand("cf", ["orgs"]);
+
+        if (orgResult.exitCode === 0) {
+          break;
+        }
+      }
+    }
+
+    if (orgResult.exitCode !== 0) {
+      continue;
+    }
+
+    const organizations = parseCloudFoundryNameList(orgResult.stdout, "name");
+    const region = inferCloudFoundryRegionFromApiEndpoint(apiEndpoint);
+
+    for (const org of organizations) {
+      let spaces: string[] = [];
+      const orgTargetResult = await runCommand("cf", ["target", "-o", org]);
+
+      if (orgTargetResult.exitCode === 0) {
+        const spacesResult = await runCommand("cf", ["spaces"]);
+        spaces = spacesResult.exitCode === 0 ? parseCloudFoundryNameList(spacesResult.stdout, "name") : [];
+      }
+
+      orgEntries.push({
+        apiEndpoint,
+        region,
+        org,
+        spaceCount: spaces.length,
+        spaces,
+        updatedAt: new Date().toISOString(),
+      });
+    }
+  }
+
+  if (originalTarget.apiEndpoint) {
+    await runCommand("cf", ["api", originalTarget.apiEndpoint]);
+
+    if (originalTarget.org) {
+      await runCommand("cf", ["target", "-o", originalTarget.org]);
+    }
+
+    if (originalTarget.space) {
+      await runCommand("cf", ["target", "-s", originalTarget.space]);
+    }
+  }
+
+  return orgEntries.sort((left, right) => {
+    const byOrg = left.org.localeCompare(right.org);
+    return byOrg !== 0 ? byOrg : left.region.localeCompare(right.region);
+  });
+}
+
+export async function loginCloudFoundry(options: {
+  apiEndpoint: string;
+  username: string;
+  password: string;
+  org: string;
+  space?: string;
+}): Promise<number> {
+  const apiExitCode = await setCloudFoundryApiEndpoint(options.apiEndpoint);
+
+  if (apiExitCode !== 0) {
+    return apiExitCode;
+  }
+
+  const authExitCode = await authenticateCloudFoundry({
+    username: options.username,
+    password: options.password,
+  });
+
+  if (authExitCode !== 0) {
+    return authExitCode;
+  }
+
+  const orgExitCode = await targetCloudFoundryOrg(options.org);
+
+  if (orgExitCode !== 0) {
+    return orgExitCode;
+  }
+
+  if (!options.space?.trim()) {
+    return 0;
+  }
+
+  return targetCloudFoundrySpace(options.space.trim());
+}
+
+export async function listCloudFoundryApps(): Promise<TCloudFoundryApp[]> {
+  const result = await runCommand("cf", ["apps"]);
+
+  if (result.exitCode !== 0) {
+    throw new Error(result.stderr || result.stdout || "cf apps failed");
+  }
+
+  return parseCloudFoundryApps(result.stdout);
+}
+
+export function parseCloudFoundryApps(output: string): TCloudFoundryApp[] {
+  const lines = output.split(/\r?\n/).map((line) => line.trimEnd()).filter(Boolean);
+  const nameHeaderIndex = lines.findIndex((line) => /^name\s+/i.test(line.trim()));
+
+  if (nameHeaderIndex === -1) {
+    return [];
+  }
+
+  const result: TCloudFoundryApp[] = [];
+
+  for (const line of lines.slice(nameHeaderIndex + 1)) {
+    if (/^Getting apps/i.test(line) || /^OK$/i.test(line)) {
+      continue;
+    }
+
+    const columns = line.trim().split(/\s{2,}|\t+/).filter(Boolean);
+    const [name, requestedState, processes, routes] = columns;
+
+    if (name && name !== "name") {
+      result.push({ name, requestedState, processes, routes });
+    }
+  }
+
+  return result;
+}

package/src/core/db/db-btp.ts

@@ -0,0 +1,207 @@
+import { readCache, rememberCloudFoundryApps } from "../cache";
+import {
+  buildCloudFoundryTargetKey,
+  authenticateCloudFoundry,
+  inferCloudFoundryRegionFromApiEndpoint,
+  listCloudFoundryApps,
+  readCloudFoundryTarget,
+  setCloudFoundryApiEndpoint,
+  targetCloudFoundryOrg,
+  targetCloudFoundrySpace,
+} from "../cf";
+import { runCommand } from "../process";
+import { parseCloudFoundryEnvironment } from "../cf-env-parser";
+import { detectDatabaseServiceCandidates } from "./db-vcap-parser";
+import { upsertConnectionFromDraft } from "./db-cache";
+import type { TConnectionDraft } from "./db-cache";
+import type { TDatabaseConnectionProfile, TDatabaseServiceCandidate, TDatabaseType } from "./db-types";
+import type { TCloudFoundryApp, TCloudFoundryTarget } from "../types";
+
+export type TCloudFoundrySessionState = {
+  loggedIn: boolean;
+  target: TCloudFoundryTarget;
+  message?: string;
+};
+
+async function isCloudFoundryCliAvailable(): Promise<boolean> {
+  const result = await runCommand("cf", ["--version"]).catch(() => undefined);
+  return Boolean(result && result.exitCode === 0);
+}
+
+/**
+ * Confirm there is a usable CF session. When the CF CLI reports no session, try
+ * to silently re-login using a cached profile that stored its password.
+ */
+export async function ensureCloudFoundrySession(): Promise<TCloudFoundrySessionState> {
+  if (!(await isCloudFoundryCliAvailable())) {
+    return {
+      loggedIn: false,
+      target: {},
+      message: "Cloud Foundry CLI 'cf' is not installed or not on PATH. Install it, then run: smdg cf login",
+    };
+  }
+
+  const orgsCheck = await runCommand("cf", ["orgs"]);
+
+  if (orgsCheck.exitCode === 0) {
+    return { loggedIn: true, target: await readCloudFoundryTarget() };
+  }
+
+  const cache = await readCache();
+  const target = await readCloudFoundryTarget();
+  const profilesWithPassword = cache.cloudFoundry.loginProfiles.filter((profile) => profile.password?.trim());
+
+  if (profilesWithPassword.length === 0) {
+    return {
+      loggedIn: false,
+      target,
+      message: "Not logged in to Cloud Foundry and no cached password was found. Run: smdg cf login",
+    };
+  }
+
+  const preferredProfiles = target.apiEndpoint
+    ? [
+        ...profilesWithPassword.filter((profile) => profile.apiEndpoint === target.apiEndpoint),
+        ...profilesWithPassword.filter((profile) => profile.apiEndpoint !== target.apiEndpoint),
+      ]
+    : profilesWithPassword;
+
+  for (const profile of preferredProfiles) {
+    const apiExitCode = await setCloudFoundryApiEndpoint(profile.apiEndpoint);
+    if (apiExitCode !== 0) continue;
+
+    const authExitCode = await authenticateCloudFoundry({ username: profile.username, password: profile.password as string });
+    if (authExitCode !== 0) continue;
+
+    await targetCloudFoundryOrg(profile.org).catch(() => undefined);
+    if (profile.space) {
+      await targetCloudFoundrySpace(profile.space).catch(() => undefined);
+    }
+
+    const recheck = await runCommand("cf", ["orgs"]);
+    if (recheck.exitCode === 0) {
+      return { loggedIn: true, target: await readCloudFoundryTarget() };
+    }
+  }
+
+  return {
+    loggedIn: false,
+    target,
+    message: "Automatic Cloud Foundry re-login failed. Run: smdg cf login",
+  };
+}
+
+export async function getCloudFoundryTargetSummary(): Promise<TCloudFoundryTarget & { region?: string }> {
+  const target = await readCloudFoundryTarget();
+  return {
+    ...target,
+    region: target.apiEndpoint ? inferCloudFoundryRegionFromApiEndpoint(target.apiEndpoint) : undefined,
+  };
+}
+
+export async function listCloudFoundryAppsWithCache(options?: { refresh?: boolean }): Promise<TCloudFoundryApp[]> {
+  const target = await readCloudFoundryTarget();
+  const targetKey = buildCloudFoundryTargetKey(target);
+
+  if (!options?.refresh) {
+    const cache = await readCache();
+    const cachedEntry = cache.cloudFoundry.appListsByTarget[targetKey];
+    if (cachedEntry?.apps.length) {
+      return cachedEntry.apps;
+    }
+  }
+
+  const apps = await listCloudFoundryApps();
+  await rememberCloudFoundryApps(targetKey, apps).catch(() => undefined);
+  return apps;
+}
+
+/**
+ * Read and parse VCAP_SERVICES from `cf env <app>`. Never logs the raw output
+ * because it contains credentials.
+ */
+export async function readAppVcapServices(appName: string): Promise<unknown> {
+  const result = await runCommand("cf", ["env", appName]);
+
+  if (result.exitCode !== 0) {
+    throw new Error(result.stderr || result.stdout || `cf env ${appName} failed`);
+  }
+
+  const parsed = parseCloudFoundryEnvironment(result.stdout);
+
+  if (parsed.VCAP_SERVICES === undefined) {
+    throw new Error(`VCAP_SERVICES was not found in cf env ${appName}`);
+  }
+
+  return parsed.VCAP_SERVICES;
+}
+
+export async function detectAppDatabaseServices(appName: string): Promise<TDatabaseServiceCandidate[]> {
+  const vcapServices = await readAppVcapServices(appName);
+  const candidates = detectDatabaseServiceCandidates(vcapServices);
+
+  if (candidates.length === 0) {
+    throw new Error(`No HANA or PostgreSQL service was detected in cf env ${appName}`);
+  }
+
+  return candidates;
+}
+
+export function buildDraftFromCandidate(
+  candidate: TDatabaseServiceCandidate,
+  context: { region?: string; org?: string; space?: string; app?: string },
+): TConnectionDraft {
+  const databaseTypeLabel: Record<TDatabaseType, string> = { hana: "HANA", postgresql: "PostgreSQL" };
+  const namePieces = [context.app ?? "btp-app", candidate.serviceName, databaseTypeLabel[candidate.type]].filter(Boolean);
+
+  return {
+    name: namePieces.join(" / "),
+    type: candidate.type,
+    region: context.region,
+    org: context.org,
+    space: context.space,
+    app: context.app,
+    serviceName: candidate.serviceName,
+    servicePlan: candidate.servicePlan,
+    host: candidate.host,
+    port: candidate.port,
+    database: candidate.database,
+    schema: candidate.schema,
+    username: candidate.username,
+    password: candidate.password,
+    ssl: candidate.ssl,
+    sslValidateCertificate: candidate.sslValidateCertificate,
+  };
+}
+
+/**
+ * Import a single detected database service from a BTP app into the encrypted
+ * connection cache.
+ */
+export async function importConnectionFromApp(options: {
+  app: string;
+  serviceName?: string;
+  type?: TDatabaseType;
+  context?: { region?: string; org?: string; space?: string };
+}): Promise<{ profile: TDatabaseConnectionProfile; candidates: TDatabaseServiceCandidate[] }> {
+  const candidates = await detectAppDatabaseServices(options.app);
+  const target = await readCloudFoundryTarget();
+
+  const chosen = options.serviceName
+    ? candidates.find((candidate) => candidate.serviceName === options.serviceName && (!options.type || candidate.type === options.type))
+    : candidates[0];
+
+  if (!chosen) {
+    throw new Error(`Service '${options.serviceName ?? ""}' was not found among detected database services for ${options.app}`);
+  }
+
+  const draft = buildDraftFromCandidate(chosen, {
+    region: options.context?.region ?? (target.apiEndpoint ? inferCloudFoundryRegionFromApiEndpoint(target.apiEndpoint) : undefined),
+    org: options.context?.org ?? target.org,
+    space: options.context?.space ?? target.space,
+    app: options.app,
+  });
+
+  const profile = await upsertConnectionFromDraft(draft);
+  return { profile, candidates };
+}