@saptools/bruno 0.1.0

package/dist/cli.js

@@ -0,0 +1,852 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import process2 from "process";
+import { checkbox, confirm, input, select } from "@inquirer/prompts";
+import { Command } from "commander";
+
+// src/context.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { dirname } from "path";
+
+// src/paths.ts
+import { homedir } from "os";
+import { join } from "path";
+var SAPTOOLS_DIR_NAME = ".saptools";
+var BRUNO_CONTEXT_FILENAME = "bruno-context.json";
+var REGION_FOLDER_PREFIX = "region__";
+var ORG_FOLDER_PREFIX = "org__";
+var SPACE_FOLDER_PREFIX = "space__";
+var ENVIRONMENTS_DIR = "environments";
+function saptoolsDir() {
+  return join(homedir(), SAPTOOLS_DIR_NAME);
+}
+function brunoContextPath() {
+  return join(saptoolsDir(), BRUNO_CONTEXT_FILENAME);
+}
+function regionFolderName(key) {
+  return `${REGION_FOLDER_PREFIX}${key}`;
+}
+function orgFolderName(name) {
+  return `${ORG_FOLDER_PREFIX}${name}`;
+}
+function spaceFolderName(name) {
+  return `${SPACE_FOLDER_PREFIX}${name}`;
+}
+function parsePrefixedName(dirName, prefix) {
+  if (!dirName.startsWith(prefix)) {
+    return void 0;
+  }
+  return dirName.slice(prefix.length);
+}
+
+// src/context.ts
+async function readContext() {
+  try {
+    const raw = await readFile(brunoContextPath(), "utf8");
+    return JSON.parse(raw);
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return void 0;
+    }
+    throw err;
+  }
+}
+async function writeContext(ctx) {
+  const updated = { ...ctx, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  const path = brunoContextPath();
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, `${JSON.stringify(updated, null, 2)}
+`, "utf8");
+  return updated;
+}
+
+// src/run.ts
+import { spawn } from "child_process";
+import { stat } from "fs/promises";
+import { isAbsolute, join as join3, relative, resolve, sep } from "path";
+import { getTokenCached as getTokenCachedApi } from "@saptools/cf-xsuaa";
+
+// src/cf-meta.ts
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+
+// src/bru-parser.ts
+var HEADER_REGEX = /(^|\n)\s*([a-zA-Z][a-zA-Z0-9:_-]*)\s*([{[])/g;
+function findMatchingClose(raw, open, openIdx) {
+  const close = open === "{" ? "}" : "]";
+  let depth = 1;
+  let i = openIdx + 1;
+  while (i < raw.length) {
+    const ch = raw[i];
+    if (ch === open) {
+      depth++;
+    } else if (ch === close) {
+      depth--;
+      if (depth === 0) {
+        return i;
+      }
+    }
+    i++;
+  }
+  return -1;
+}
+function listBlocks(raw) {
+  const blocks = [];
+  HEADER_REGEX.lastIndex = 0;
+  let match;
+  while ((match = HEADER_REGEX.exec(raw)) !== null) {
+    const leadingNewline = match[1] ?? "";
+    const header = match[2];
+    const open = match[3];
+    if (header === void 0 || open !== "{" && open !== "[") {
+      continue;
+    }
+    const headerStart = match.index + leadingNewline.length;
+    const openIdx = match.index + match[0].length - 1;
+    const closeIdx = findMatchingClose(raw, open, openIdx);
+    if (closeIdx === -1) {
+      continue;
+    }
+    blocks.push({
+      header,
+      start: headerStart,
+      end: closeIdx + 1,
+      bodyStart: openIdx + 1,
+      bodyEnd: closeIdx,
+      open,
+      close: open === "{" ? "}" : "]"
+    });
+  }
+  return blocks;
+}
+function parseKeyValueBody(body) {
+  const entries = /* @__PURE__ */ new Map();
+  for (const lineRaw of body.split("\n")) {
+    const line = lineRaw.trim();
+    if (line.length === 0 || line.startsWith("//")) {
+      continue;
+    }
+    const colon = line.indexOf(":");
+    if (colon === -1) {
+      continue;
+    }
+    const key = line.slice(0, colon).trim();
+    const value = line.slice(colon + 1).trim();
+    if (key.length > 0) {
+      entries.set(key, value);
+    }
+  }
+  return entries;
+}
+function parseListBody(body) {
+  const items = [];
+  for (const lineRaw of body.split("\n")) {
+    const line = lineRaw.trim();
+    if (line.length === 0 || line.startsWith("//")) {
+      continue;
+    }
+    items.push(line);
+  }
+  return items;
+}
+function parseBruEnvFile(raw) {
+  const blocks = listBlocks(raw);
+  const varsBlock = blocks.find((b) => b.header === "vars" && b.open === "{");
+  const secretsBlock = blocks.find((b) => b.header === "vars:secret" && b.open === "[");
+  const entries = varsBlock ? parseKeyValueBody(raw.slice(varsBlock.bodyStart, varsBlock.bodyEnd)) : /* @__PURE__ */ new Map();
+  const secrets = secretsBlock ? parseListBody(raw.slice(secretsBlock.bodyStart, secretsBlock.bodyEnd)) : [];
+  return { vars: { entries }, secrets };
+}
+
+// src/bru-writer.ts
+function formatVarsBlock(entries) {
+  const lines = [];
+  for (const [key, value] of entries) {
+    lines.push(`  ${key}: ${value}`);
+  }
+  return lines.join("\n");
+}
+function upsertVars(raw, updates) {
+  const blocks = listBlocks(raw);
+  const varsBlock = blocks.find((b) => b.header === "vars" && b.open === "{");
+  if (!varsBlock) {
+    const newBlock = `vars {
+${formatVarsBlock(updates)}
+}
+`;
+    const sep2 = raw.length > 0 && !raw.endsWith("\n") ? "\n\n" : raw.length > 0 ? "\n" : "";
+    return { content: `${raw}${sep2}${newBlock}`, changed: updates.size > 0 };
+  }
+  const body = raw.slice(varsBlock.bodyStart, varsBlock.bodyEnd);
+  const existing = parseKeyValueBody(body);
+  let changed = false;
+  for (const [k, v] of updates) {
+    if (existing.get(k) !== v) {
+      existing.set(k, v);
+      changed = true;
+    }
+  }
+  if (!changed) {
+    return { content: raw, changed: false };
+  }
+  const rebuilt = `
+${formatVarsBlock(existing)}
+`;
+  const before = raw.slice(0, varsBlock.bodyStart);
+  const after = raw.slice(varsBlock.bodyEnd);
+  return { content: `${before}${rebuilt}${after}`, changed: true };
+}
+
+// src/cf-meta.ts
+function readCfMetaFromVars(vars) {
+  const region = vars.get("__cf_region");
+  const org = vars.get("__cf_org");
+  const space = vars.get("__cf_space");
+  const app = vars.get("__cf_app");
+  if (!region || !org || !space || !app) {
+    return void 0;
+  }
+  return { region, org, space, app };
+}
+function buildCfMetaUpdates(ref, baseUrl) {
+  const updates = /* @__PURE__ */ new Map();
+  const pairs = [
+    ["__cf_region", ref.region],
+    ["__cf_org", ref.org],
+    ["__cf_space", ref.space],
+    ["__cf_app", ref.app]
+  ];
+  for (const [k, v] of pairs) {
+    updates.set(k, v);
+  }
+  if (baseUrl !== void 0) {
+    updates.set("baseUrl", baseUrl);
+  }
+  return updates;
+}
+async function readCfMetaFromFile(path) {
+  const raw = await readFile2(path, "utf8");
+  const parsed = parseBruEnvFile(raw);
+  return readCfMetaFromVars(parsed.vars.entries);
+}
+async function writeCfMetaToFile(path, ref, baseUrl) {
+  const raw = await readFile2(path, "utf8");
+  const updates = buildCfMetaUpdates(ref, baseUrl);
+  const { content, changed } = upsertVars(raw, updates);
+  if (changed) {
+    await writeFile2(path, content, "utf8");
+  }
+  return changed;
+}
+
+// src/folder-scan.ts
+import { readdir, readFile as readFile3 } from "fs/promises";
+import { join as join2 } from "path";
+async function safeReaddir(path) {
+  try {
+    const entries = await readdir(path, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch {
+    return [];
+  }
+}
+async function listFiles(path) {
+  try {
+    const entries = await readdir(path, { withFileTypes: true });
+    return entries.filter((e) => e.isFile()).map((e) => e.name);
+  } catch {
+    return [];
+  }
+}
+async function loadEnvFile(path, name) {
+  const raw = await readFile3(path, "utf8");
+  const parsed = parseBruEnvFile(raw);
+  return {
+    path,
+    name: name.replace(/\.bru$/, ""),
+    raw,
+    vars: parsed.vars,
+    secrets: parsed.secrets
+  };
+}
+async function scanAppEnvironments(appPath) {
+  const envDir = join2(appPath, ENVIRONMENTS_DIR);
+  const files = await listFiles(envDir);
+  const bruFiles = files.filter((f) => f.endsWith(".bru"));
+  const loaded = [];
+  for (const file of bruFiles) {
+    loaded.push(await loadEnvFile(join2(envDir, file), file));
+  }
+  return loaded;
+}
+async function scanApp(spacePath, name) {
+  const appPath = join2(spacePath, name);
+  const environments = await scanAppEnvironments(appPath);
+  return { path: appPath, name, environments };
+}
+async function scanSpace(orgPath, dirName) {
+  const name = parsePrefixedName(dirName, SPACE_FOLDER_PREFIX);
+  if (name === void 0) {
+    return void 0;
+  }
+  const spacePath = join2(orgPath, dirName);
+  const appDirs = await safeReaddir(spacePath);
+  const apps = [];
+  for (const appDir of appDirs) {
+    apps.push(await scanApp(spacePath, appDir));
+  }
+  return { path: spacePath, name, apps };
+}
+async function scanOrg(regionPath, dirName) {
+  const name = parsePrefixedName(dirName, ORG_FOLDER_PREFIX);
+  if (name === void 0) {
+    return void 0;
+  }
+  const orgPath = join2(regionPath, dirName);
+  const spaceDirs = await safeReaddir(orgPath);
+  const spaces = [];
+  for (const spaceDir of spaceDirs) {
+    const space = await scanSpace(orgPath, spaceDir);
+    if (space) {
+      spaces.push(space);
+    }
+  }
+  return { path: orgPath, name, spaces };
+}
+async function scanRegion(root, dirName) {
+  const key = parsePrefixedName(dirName, REGION_FOLDER_PREFIX);
+  if (key === void 0) {
+    return void 0;
+  }
+  const regionPath = join2(root, dirName);
+  const orgDirs = await safeReaddir(regionPath);
+  const orgs = [];
+  for (const orgDir of orgDirs) {
+    const org = await scanOrg(regionPath, orgDir);
+    if (org) {
+      orgs.push(org);
+    }
+  }
+  return { path: regionPath, key, orgs };
+}
+async function scanCollection(root) {
+  const regionDirs = await safeReaddir(root);
+  const regions = [];
+  for (const dir of regionDirs) {
+    const region = await scanRegion(root, dir);
+    if (region) {
+      regions.push(region);
+    }
+  }
+  return { root, regions };
+}
+function parseShorthandPath(shorthand) {
+  const cleaned = shorthand.replace(/^[./]+/, "").replace(/\\/g, "/");
+  const segs = cleaned.split("/").filter((s) => s.length > 0);
+  if (segs.length < 4) {
+    return void 0;
+  }
+  const [region, org, space, app, ...rest] = segs;
+  if (!region || !org || !space || !app) {
+    return void 0;
+  }
+  if (rest.length === 0) {
+    return { region, org, space, app };
+  }
+  const filePath = rest.join("/");
+  const last = rest[rest.length - 1] ?? "";
+  const environment = last.endsWith(".bru") ? last.replace(/\.bru$/, "") : void 0;
+  return environment ? { region, org, space, app, environment, filePath } : { region, org, space, app, filePath };
+}
+
+// src/run.ts
+function defaultSpawnBru(args, env, cwd) {
+  return new Promise((resolvePromise, rejectPromise) => {
+    const child = spawn("bru", [...args], { cwd, env, stdio: "pipe" });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString("utf8");
+      process.stdout.write(chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString("utf8");
+      process.stderr.write(chunk);
+    });
+    child.on("error", rejectPromise);
+    child.on("close", (code) => {
+      resolvePromise({ code: code ?? 0, stdout, stderr });
+    });
+  });
+}
+async function exists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function resolveTarget(root, target) {
+  const direct = isAbsolute(target) ? target : resolve(process.cwd(), target);
+  if (await exists(direct)) {
+    return { filePath: direct, shorthand: void 0 };
+  }
+  const shorthand = parseShorthandPath(target);
+  if (!shorthand) {
+    throw new Error(`Target not found: ${target}`);
+  }
+  const { region, org, space, app, filePath } = shorthand;
+  const appDir = join3(
+    root,
+    regionFolderName(region),
+    orgFolderName(org),
+    spaceFolderName(space),
+    app
+  );
+  if (!filePath) {
+    return { filePath: appDir, shorthand };
+  }
+  const candidate = join3(appDir, filePath);
+  if (await exists(candidate)) {
+    return { filePath: candidate, shorthand };
+  }
+  const withExt = candidate.endsWith(".bru") ? candidate : `${candidate}.bru`;
+  if (await exists(withExt)) {
+    return { filePath: withExt, shorthand };
+  }
+  throw new Error(`File not found: ${candidate}`);
+}
+async function chooseEnvironmentFile(appDir, environment) {
+  if (environment) {
+    const envFile = join3(appDir, ENVIRONMENTS_DIR, `${environment}.bru`);
+    if (!await exists(envFile)) {
+      throw new Error(`Environment file not found: ${envFile}`);
+    }
+    return { envFile, environment };
+  }
+  const collection = await scanCollection(resolve(appDir, "..", "..", "..", ".."));
+  for (const region of collection.regions) {
+    for (const org of region.orgs) {
+      for (const space of org.spaces) {
+        for (const app of space.apps) {
+          if (app.path === appDir && app.environments.length > 0) {
+            const first = app.environments[0];
+            if (first) {
+              return { envFile: first.path, environment: first.name };
+            }
+          }
+        }
+      }
+    }
+  }
+  throw new Error(`No environment files found under ${appDir}/${ENVIRONMENTS_DIR}`);
+}
+function findAppDirFromFile(filePath, root) {
+  const rel = relative(root, filePath).split(sep);
+  if (rel.length < 4) {
+    throw new Error(`File is not inside a CF-structured bruno collection: ${filePath}`);
+  }
+  const [regionDir, orgDir, spaceDir, appDir] = rel;
+  if (!regionDir || !orgDir || !spaceDir || !appDir) {
+    throw new Error(`File is not inside a CF-structured bruno collection: ${filePath}`);
+  }
+  return join3(root, regionDir, orgDir, spaceDir, appDir);
+}
+async function buildRunPlan(options) {
+  const { filePath } = await resolveTarget(options.root, options.target);
+  const stats = await stat(filePath);
+  let appDir;
+  let requestFile;
+  if (stats.isDirectory()) {
+    appDir = filePath;
+    requestFile = void 0;
+  } else {
+    appDir = findAppDirFromFile(filePath, options.root);
+    requestFile = filePath;
+  }
+  const { envFile, environment } = await chooseEnvironmentFile(appDir, options.environment);
+  const meta = await readCfMetaFromFile(envFile);
+  if (!meta) {
+    throw new Error(
+      `Missing __cf_region/__cf_org/__cf_space/__cf_app in ${envFile}. Run \`saptools-bruno setup-app\` first.`
+    );
+  }
+  const getToken = options.getTokenCached ?? getTokenCachedApi;
+  const token = await getToken(meta);
+  const bruArgs = ["run"];
+  if (requestFile) {
+    bruArgs.push(relative(appDir, requestFile) || ".");
+  }
+  bruArgs.push("--env", environment, "--env-var", `accessToken=${token}`);
+  if (options.extraArgs) {
+    bruArgs.push(...options.extraArgs);
+  }
+  return {
+    filePath,
+    environment,
+    envFile,
+    meta,
+    token,
+    bruArgs,
+    cwd: appDir
+  };
+}
+async function runBruno(options) {
+  const plan = await buildRunPlan(options);
+  const spawnFn = options.spawnBru ?? defaultSpawnBru;
+  const env = { ...process.env, SAPTOOLS_ACCESS_TOKEN: plan.token };
+  options.log?.(`\u25B6 bru ${plan.bruArgs.join(" ")}  (cwd=${plan.cwd})`);
+  const result = await spawnFn(plan.bruArgs, env, plan.cwd);
+  return { ...plan, ...result };
+}
+
+// src/setup-app.ts
+import { mkdir as mkdir2, readdir as readdir2, writeFile as writeFile3 } from "fs/promises";
+import { join as join4 } from "path";
+
+// src/cf-info.ts
+import {
+  getRegionView as getRegionViewApi,
+  readRegionsView,
+  readRegionView,
+  readStructureView,
+  REGION_KEYS
+} from "@saptools/cf-sync";
+var defaultCfInfoDeps = {
+  readStructureView,
+  readRegionsView,
+  readRegionView,
+  getRegionView: getRegionViewApi
+};
+function isValidRegionKey(value) {
+  return REGION_KEYS.includes(value);
+}
+async function getStructureSnapshot(deps = defaultCfInfoDeps) {
+  const view = await deps.readStructureView();
+  if (!view) {
+    return {
+      source: "empty",
+      structure: void 0,
+      stale: true,
+      message: "No CF structure cached. Run `cf-sync sync` first."
+    };
+  }
+  const stale = view.source === "runtime" && view.metadata?.status === "running";
+  return {
+    source: view.source,
+    structure: view.structure,
+    stale,
+    message: stale ? "A CF sync is still running \u2014 showing partial data." : void 0
+  };
+}
+async function listRegionsWithContent(deps = defaultCfInfoDeps) {
+  const snapshot = await getStructureSnapshot(deps);
+  if (!snapshot.structure) {
+    return [];
+  }
+  return snapshot.structure.regions.filter((r) => r.accessible && r.orgs.length > 0).map((r) => ({ key: r.key, label: r.label, orgCount: r.orgs.length }));
+}
+async function getRegion(key, deps = defaultCfInfoDeps) {
+  const view = await deps.readRegionView(key);
+  return view?.region;
+}
+function findOrg(region, orgName) {
+  return region.orgs.find((o) => o.name === orgName);
+}
+function findSpace(org, spaceName) {
+  return org.spaces.find((s) => s.name === spaceName);
+}
+function findApp(space, appName) {
+  return space.apps.find((a) => a.name === appName);
+}
+async function resolveRef(ref, deps = defaultCfInfoDeps) {
+  const region = await getRegion(ref.region, deps);
+  if (!region) {
+    return void 0;
+  }
+  const org = findOrg(region, ref.org);
+  if (!org) {
+    return void 0;
+  }
+  const space = findSpace(org, ref.space);
+  if (!space) {
+    return void 0;
+  }
+  const app = findApp(space, ref.app);
+  if (!app) {
+    return void 0;
+  }
+  return { region, org, space, app };
+}
+
+// src/setup-app.ts
+var COMMON_ENVIRONMENTS = ["local", "dev", "staging", "prod"];
+function emptyEnvContent(envName, ref) {
+  const lines = [
+    "vars {",
+    `  __cf_region: ${ref.region}`,
+    `  __cf_org: ${ref.org}`,
+    `  __cf_space: ${ref.space}`,
+    `  __cf_app: ${ref.app}`,
+    `  environment: ${envName}`,
+    "  baseUrl: ",
+    "}",
+    ""
+  ];
+  return lines.join("\n");
+}
+async function ensureEnvFile(appPath, envName, ref) {
+  const envDir = join4(appPath, ENVIRONMENTS_DIR);
+  await mkdir2(envDir, { recursive: true });
+  const filePath = join4(envDir, `${envName}.bru`);
+  try {
+    await writeFile3(filePath, emptyEnvContent(envName, ref), { encoding: "utf8", flag: "wx" });
+  } catch (err) {
+    if (err.code !== "EEXIST") {
+      throw err;
+    }
+    await writeCfMetaToFile(filePath, ref);
+  }
+  return filePath;
+}
+function pickRegion(regions) {
+  return regions.map((r) => ({ value: r.key, name: `${r.key} \u2014 ${r.label} (${r.orgCount.toString()} org${r.orgCount === 1 ? "" : "s"})` }));
+}
+function pickOrg(region) {
+  return region.orgs.map((o) => ({ value: o.name, name: `${o.name} (${o.spaces.length.toString()} space${o.spaces.length === 1 ? "" : "s"})` }));
+}
+function pickSpace(org) {
+  return org.spaces.map((s) => ({ value: s.name, name: `${s.name} (${s.apps.length.toString()} app${s.apps.length === 1 ? "" : "s"})` }));
+}
+function pickApp(space) {
+  return space.apps.map((a) => ({ value: a.name, name: a.name }));
+}
+async function setupApp(options) {
+  const deps = options.deps ?? defaultCfInfoDeps;
+  const log = options.log ?? (() => void 0);
+  const regions = await listRegionsWithContent(deps);
+  if (regions.length === 0) {
+    throw new Error(
+      "No CF regions with orgs are cached. Run `cf-sync sync` first, or pass SAP_EMAIL/SAP_PASSWORD to refresh."
+    );
+  }
+  const regionKey = await options.prompts.selectRegion(pickRegion(regions));
+  const regionView = await deps.readRegionView(regionKey);
+  if (!regionView) {
+    throw new Error(`Region ${regionKey} is not cached. Run \`cf-sync sync\` or \`cf-sync region ${regionKey}\`.`);
+  }
+  const region = regionView.region;
+  if (region.orgs.length === 0) {
+    throw new Error(`Region ${regionKey} has no accessible orgs.`);
+  }
+  const orgName = await options.prompts.selectOrg(pickOrg(region));
+  const org = region.orgs.find((o) => o.name === orgName);
+  if (!org) {
+    throw new Error(`Org ${orgName} not found in region ${regionKey}`);
+  }
+  if (org.spaces.length === 0) {
+    throw new Error(`Org ${orgName} has no spaces.`);
+  }
+  const spaceName = await options.prompts.selectSpace(pickSpace(org));
+  const space = org.spaces.find((s) => s.name === spaceName);
+  if (!space) {
+    throw new Error(`Space ${spaceName} not found in org ${orgName}`);
+  }
+  if (space.apps.length === 0) {
+    throw new Error(`Space ${spaceName} has no apps.`);
+  }
+  const appName = await options.prompts.selectApp(pickApp(space));
+  const ref = { region: regionKey, org: orgName, space: spaceName, app: appName };
+  const appPath = join4(
+    options.root,
+    regionFolderName(regionKey),
+    orgFolderName(orgName),
+    spaceFolderName(spaceName),
+    appName
+  );
+  const confirmed = await options.prompts.confirmCreate(appPath);
+  if (!confirmed) {
+    return { ref, appPath, environments: [], created: false };
+  }
+  await mkdir2(appPath, { recursive: true });
+  const existingEnvs = await listExistingEnvs(appPath);
+  const common = [...COMMON_ENVIRONMENTS];
+  const selected = await options.prompts.selectEnvironments({ common, existing: existingEnvs });
+  const custom = await options.prompts.inputCustomEnvName();
+  const merged = [];
+  for (const name of [...selected, ...custom ? [custom] : []]) {
+    const trimmed = name.trim();
+    if (trimmed.length > 0 && !merged.includes(trimmed)) {
+      merged.push(trimmed);
+    }
+  }
+  if (merged.length === 0) {
+    throw new Error("At least one environment is required.");
+  }
+  const created = [];
+  for (const envName of merged) {
+    const path = await ensureEnvFile(appPath, envName, ref);
+    created.push(path);
+    log(`\u2022 ${path}`);
+  }
+  return { ref, appPath, environments: created, created: true };
+}
+async function listExistingEnvs(appPath) {
+  try {
+    const entries = await readdir2(join4(appPath, ENVIRONMENTS_DIR), { withFileTypes: true });
+    return entries.filter((e) => e.isFile() && e.name.endsWith(".bru")).map((e) => e.name.replace(/\.bru$/, ""));
+  } catch {
+    return [];
+  }
+}
+
+// src/use.ts
+function parseContextShorthand(shorthand) {
+  const segs = shorthand.split("/").filter((s) => s.length > 0);
+  if (segs.length !== 4) {
+    return void 0;
+  }
+  const [region, org, space, app] = segs;
+  if (!region || !org || !space || !app) {
+    return void 0;
+  }
+  return { region, org, space, app };
+}
+async function useContext(options) {
+  const parsed = parseContextShorthand(options.shorthand);
+  if (!parsed) {
+    throw new Error(
+      `Invalid context shorthand: ${options.shorthand}. Expected <region>/<org>/<space>/<app>.`
+    );
+  }
+  if (!isValidRegionKey(parsed.region)) {
+    throw new Error(`Unknown region key: ${parsed.region}`);
+  }
+  if (options.verify !== false) {
+    const resolved = await resolveRef({ ...parsed, region: parsed.region }, options.deps);
+    if (!resolved) {
+      throw new Error(
+        `Could not verify ${options.shorthand} against the cached CF structure. Run \`cf-sync sync\` first.`
+      );
+    }
+  }
+  return await writeContext(parsed);
+}
+
+// src/cli.ts
+function resolveRoot(explicit) {
+  if (explicit) {
+    return explicit;
+  }
+  if (process2.env["SAPTOOLS_BRUNO_ROOT"]) {
+    return process2.env["SAPTOOLS_BRUNO_ROOT"];
+  }
+  return process2.cwd();
+}
+async function main(argv) {
+  const program = new Command();
+  program.name("saptools-bruno").description("Smart runner for Bruno with CF-aware env metadata and automatic token injection").option("--root <dir>", "Root directory of the bruno collection (default: cwd)");
+  program.command("setup-app").description("Interactively scaffold a bruno app folder and seed __cf_* variables").action(async () => {
+    const root = resolveRoot(program.opts().root);
+    const result = await setupApp({
+      root,
+      prompts: {
+        selectRegion: async (choices) => await select({ message: "Select region", choices: [...choices] }),
+        selectOrg: async (choices) => await select({ message: "Select org", choices: [...choices] }),
+        selectSpace: async (choices) => await select({ message: "Select space", choices: [...choices] }),
+        selectApp: async (choices) => await select({ message: "Select app", choices: [...choices] }),
+        confirmCreate: async (path) => await confirm({ message: `Create ${path}?`, default: true }),
+        selectEnvironments: async ({ common, existing }) => {
+          const seen = /* @__PURE__ */ new Set();
+          const all = [...common, ...existing].filter((name) => {
+            if (seen.has(name)) {
+              return false;
+            }
+            seen.add(name);
+            return true;
+          });
+          return await checkbox({
+            message: "Environments to create (space to toggle, enter to confirm)",
+            choices: all.map((name) => ({
+              name,
+              value: name,
+              checked: existing.includes(name)
+            }))
+          });
+        },
+        inputCustomEnvName: async () => {
+          const raw = await input({
+            message: "Custom environment name (leave empty to skip)",
+            default: "",
+            validate: (v) => {
+              const t = v.trim();
+              if (t.length === 0) {
+                return true;
+              }
+              return /^[A-Za-z0-9._-]+$/.test(t) ? true : "Only letters, digits, dot, underscore, and dash are allowed.";
+            }
+          });
+          const trimmed = raw.trim();
+          return trimmed.length > 0 ? trimmed : null;
+        }
+      },
+      log: (msg) => {
+        process2.stdout.write(`${msg}
+`);
+      }
+    });
+    if (!result.created) {
+      process2.stdout.write("Aborted.\n");
+      return;
+    }
+    process2.stdout.write(`\u2714 App folder ready at ${result.appPath}
+`);
+  });
+  program.command("run").description("Run a bruno request or folder, auto-injecting an XSUAA token").argument("[target]", "Shorthand path (region/org/space/app[/folder/file.bru]) or real path").option("-e, --env <name>", "Environment name (default: context or first)").action(
+    async (target, opts) => {
+      const root = resolveRoot(program.opts().root);
+      let effectiveTarget = target;
+      if (!effectiveTarget) {
+        const ctx = await readContext();
+        if (!ctx) {
+          throw new Error(
+            "No target specified and no default context is set. Run `saptools-bruno use <region/org/space/app>` first."
+          );
+        }
+        effectiveTarget = `${ctx.region}/${ctx.org}/${ctx.space}/${ctx.app}`;
+      }
+      const result = await runBruno({
+        root,
+        target: effectiveTarget,
+        ...opts.env ? { environment: opts.env } : {},
+        log: (msg) => {
+          process2.stdout.write(`${msg}
+`);
+        }
+      });
+      process2.exit(result.code);
+    }
+  );
+  program.command("use").description("Set the default CF context (region/org/space/app) for future `run` calls").argument("<shorthand>", "region/org/space/app").option("--no-verify", "Skip verifying the context against the cached CF structure").action(async (shorthand, opts) => {
+    const ctx = await useContext({
+      shorthand,
+      verify: opts.verify !== false
+    });
+    process2.stdout.write(`\u2714 Default context set to ${ctx.region}/${ctx.org}/${ctx.space}/${ctx.app}
+`);
+  });
+  await program.parseAsync([...argv]);
+}
+try {
+  await main(process2.argv);
+} catch (err) {
+  const msg = err instanceof Error ? err.message : String(err);
+  process2.stderr.write(`Error: ${msg}
+`);
+  process2.exit(1);
+}
+export {
+  main
+};
+//# sourceMappingURL=cli.js.map