@saptools/bruno 0.3.4 → 0.3.6

package/README.md

@@ -13,7 +13,7 @@ Scaffold a CF-aware collection. Resolve requests by `region/org/space/app` short
 [![types](https://img.shields.io/npm/types/@saptools/bruno.svg?style=flat&color=3178C6&logo=typescript&logoColor=white)](https://www.typescriptlang.org)
 [![build](https://img.shields.io/github/actions/workflow/status/dongitran/saptools/bruno.yml?style=flat&logo=github&label=CI)](https://github.com/dongitran/saptools/actions/workflows/bruno.yml)
 
-[**Install**](#-install) · [**Quick Start**](#-quick-start) · [**CLI**](#-cli) · [**API**](#-programmatic-usage) · [**FAQ**](#-faq) · [**Roadmap**](#-roadmap)
+[**Install**](#-install) · [**Quick Start**](#-quick-start) · [**CLI**](#-cli) · [**FAQ**](#-faq) · [**Roadmap**](#-roadmap)
 
 </div>
 
@@ -22,10 +22,12 @@ Scaffold a CF-aware collection. Resolve requests by `region/org/space/app` short
 ## ⚡ At a glance
 
 ```console
-$ saptools-bruno use ap10/demo-prod/api/orders-srv
+$ bruno use ap10/demo-prod/api/orders-srv
 ✔ Default context set to ap10/demo-prod/api/orders-srv
 
-$ saptools-bruno run --env dev
+$ bruno
+# chọn Run .bru file (folder tree)
+# duyệt cây thư mục rồi chọn file .bru để chạy
 ▶ bru run --env dev --env-var accessToken=eyJhbGciOi…  (cwd=…/orders-srv)
 Running Folder Recursively
 ✓ GET /orders              204 OK   54ms
@@ -43,8 +45,8 @@ You just ran Bruno against a production-grade XSUAA-protected service **without
 - 🏗️ **Interactive `setup-app`** — pick a region → org → space, then **search apps as you type** before choosing exactly the environments you want (or typing a custom name like `qa-eu`). Every env file is seeded with `__cf_*` metadata so the runner knows where to fetch a token.
 - 🧭 **Shorthand paths** — `region/org/space/app[/folder/file.bru]` expands to the right filesystem path. No more `cd`-ing through nested folders.
 - 🔐 **Automatic XSUAA tokens** — every `run` fetches (or reuses) a cached token via [`@saptools/cf-xsuaa`](https://www.npmjs.com/package/@saptools/cf-xsuaa), writes it into the selected env file as `accessToken`, and still injects it for `bru` at execution time.
-- 📦 **Bundled Bruno CLI fallback** — if `bru` is already on your `PATH`, `saptools-bruno` uses it. If not, it falls back to the bundled [`@usebruno/cli`](https://www.npmjs.com/package/@usebruno/cli).
-- 🎯 **Default context** — `saptools-bruno use <shorthand>` pins a target so subsequent `run` calls need zero arguments. Feels like `cf target` for Bruno.
+- 📦 **Bundled Bruno CLI fallback** — if `bru` is already on your `PATH`, `bruno` uses it. If not, it falls back to the bundled [`@usebruno/cli`](https://www.npmjs.com/package/@usebruno/cli).
+- 🎯 **Default context** — `bruno use <shorthand>` pins a target so subsequent `run` calls need zero arguments. Feels like `cf target` for Bruno.
 - 🧩 **CLI & typed API** — every command has a zero-config Node.js equivalent. Full TypeScript definitions shipped. Bring your own prompts for headless/CI use.
 - 🧪 **Fully tested** — unit tests plus offline e2e coverage (stub `bru` binary + fixture CF snapshot). No network required in CI.
 - 🪶 **Small + boring** — a small runtime surface, no background daemons, no plugin system, no magic.
@@ -80,8 +82,8 @@ You just ran Bruno against a production-grade XSUAA-protected service **without
 <td valign="top">
 
 ```bash
-saptools-bruno use ap10/demo-prod/api/orders-srv
-saptools-bruno run --env dev
+bruno use ap10/demo-prod/api/orders-srv
+bruno run --env dev
 ```
 
 *That's it. Token is cached, refreshed on expiry, written back to the env file, and injected automatically.*
@@ -118,13 +120,13 @@ npm install @saptools/bruno
 cf-sync sync
 
 # 2. Scaffold an app folder with seeded __cf_* metadata
-saptools-bruno setup-app
+bruno setup-app
 
 # 3. Pin a default CF context so future runs need zero args
-saptools-bruno use ap10/my-org/dev/my-srv
+bruno use ap10/my-org/dev/my-srv
 
 # 4. Run — XSUAA token is fetched, written to the env file, and injected automatically
-saptools-bruno run --env dev
+bruno run --env dev
 ```
 
 After `setup-app`, your workspace looks like this:
@@ -160,17 +162,38 @@ Your `.bru` requests reference `{{accessToken}}` like any other Bruno variable
 
 ## 🧰 CLI
 
-### 🏗️ `saptools-bruno setup-app`
+
+### 🗂️ `bruno` (interactive tree mode)
+
+Chạy `bruno` không kèm subcommand sẽ mở menu tương tác:
+- Run `.bru` file
+- Set default context
+- Setup app folder
+- Set Bruno root folder
+
+Ở chế độ chạy file, danh sách browse chỉ hiển thị cấp thư mục hiện tại (tên gần nhất). Bạn có thể duyệt vào thư mục con/back, hoặc chọn `Search .bru file` để tìm toàn cây và kết quả sẽ hiển thị theo đường dẫn tree tương đối.
+
+### 📌 `bruno set-root [dir]`
+
+Lưu Bruno root folder mặc định vào `~/.saptools/bruno/cli-state.json`.
+
+```bash
+bruno set-root /path/to/your/collection
+```
+
+Sau khi set, lần gọi `bruno` tiếp theo sẽ dùng root này nếu bạn không truyền `--collection` và không set env var.
+
+### 🏗️ `bruno setup-app`
 
 Interactively scaffold a Bruno app folder inside the current Bruno collection directory. Walks you through **region → org → space → app**, with the **app step using a searchable picker** for large spaces, then lets you **pick which environments to create** and add custom names without leaving the environment picker.
 
 ```bash
-saptools-bruno setup-app
-saptools-bruno --collection ./collections setup-app
+bruno setup-app
+bruno --collection ./collections setup-app
 ```
 
 > [!TIP]
-> `--collection` only applies to the current command. If you omit it, `saptools-bruno` falls back to `$SAPTOOLS_BRUNO_COLLECTION`, then to your current working directory.
+> `--collection` only applies to the current command. If you omit it, `bruno` falls back to `$SAPTOOLS_BRUNO_COLLECTION`, then to your current working directory.
 
 > [!IMPORTANT]
 > `setup-app` reads the cached CF landscape prepared by `cf-sync`. If the cache is missing or stale, run `cf-sync sync` first.
@@ -185,22 +208,22 @@ saptools-bruno --collection ./collections setup-app
 > [!TIP]
 > The env prompt shows the common names (`local`, `dev`, `staging`, `prod`) plus any envs already on disk. Pre-existing envs are **pre-checked**; common ones are **not** — so you only create what you actually need. The menu also includes **Add custom environment**, and once you enter a value like `qa-eu` or `uat.us`, it appears back in the same checklist already selected so you can review the full set before finishing.
 
-### ▶️ `saptools-bruno run`
+### ▶️ `bruno run`
 
 Run a Bruno request or folder, refreshing `accessToken` in the chosen env file and auto-injecting the same token for the current execution.
 
 ```bash
 # Use the default context
-saptools-bruno run --env dev
+bruno run --env dev
 
 # Explicit shorthand
-saptools-bruno run ap10/my-org/dev/my-srv --env dev
+bruno run ap10/my-org/dev/my-srv --env dev
 
 # Drill into a subfolder or a single file
-saptools-bruno run ap10/my-org/dev/my-srv/users/get-all.bru --env dev
+bruno run ap10/my-org/dev/my-srv/users/get-all.bru --env dev
 
 # Or pass a real filesystem path (absolute or relative)
-saptools-bruno run ./region__ap10/org__my-org/space__dev/my-srv --env dev
+bruno run ./region__ap10/org__my-org/space__dev/my-srv --env dev
 ```
 
 | Flag | Description |
@@ -213,13 +236,13 @@ Under the hood this:
 - writes `accessToken: <token>` into the selected `.bru` env file
 - spawns `bru run <target> --env <name> --env-var accessToken=<token>`
 
-### 🎯 `saptools-bruno use`
+### 🎯 `bruno use`
 
 Pin a default CF context so `run` can be called without arguments.
 
 ```bash
-saptools-bruno use ap10/my-org/dev/my-srv
-saptools-bruno use ap10/my-org/dev/my-srv --no-verify
+bruno use ap10/my-org/dev/my-srv
+bruno use ap10/my-org/dev/my-srv --no-verify
 ```
 
 | Flag | Description |
@@ -230,82 +253,6 @@ The context lives at `~/.saptools/bruno-context.json`.
 
 ---
 
-## 🧑‍💻 Programmatic Usage
-
-```ts
-import {
-  buildRunPlan,
-  readContext,
-  runBruno,
-  scanCollection,
-  setupApp,
-  useContext,
-} from "@saptools/bruno";
-
-// 1. Scaffold an app folder (BYO prompts — perfect for headless/CI)
-const result = await setupApp({
-  root: "./collections",
-  prompts: {
-    selectRegion: async (choices) => choices[0]!.value,
-    selectOrg:    async (choices) => choices[0]!.value,
-    selectSpace:  async (choices) => choices[0]!.value,
-    selectApp:    async (choices) => choices[0]!.value,
-    confirmCreate: async () => true,
-    selectEnvironments: async ({ common }) => [...common, "qa-eu"],
-  },
-});
-console.log(`Created ${result.environments.length} env files at ${result.appPath}`);
-
-// 2. Pin a default context for later runs
-await useContext({ shorthand: "ap10/my-org/dev/my-srv" });
-
-// 3. Run Bruno — token is fetched and injected for you
-const run = await runBruno({
-  root: "./collections",
-  target: "ap10/my-org/dev/my-srv",
-  environment: "dev",
-});
-process.exit(run.code);
-
-// 4. Need the plan without spawning `bru`? (CI dry-runs, IDE integrations)
-const plan = await buildRunPlan({
-  root: "./collections",
-  target: "ap10/my-org/dev/my-srv",
-  environment: "dev",
-});
-console.log(plan.bruArgs);
-// → ["run", "--env", "dev", "--env-var", "accessToken=..."]
-
-// 5. Walk a whole collection to build a UI tree
-const tree = await scanCollection("./collections");
-console.log(tree.regions.map((r) => r.key));
-
-// 6. Inspect the active default context
-const ctx = await readContext();
-console.log(ctx?.app);
-```
-
-<details>
-<summary><b>📚 Full export list</b></summary>
-
-| Export | Description |
-| --- | --- |
-| `setupApp(options)` | Interactive app-folder scaffolder with pluggable prompts |
-| `COMMON_ENVIRONMENTS` | Default environment-name suggestions (`local`, `dev`, `staging`, `prod`) |
-| `runBruno(options)` | Build a plan and spawn `bru run` with token injected |
-| `buildRunPlan(options)` | Build the plan (args, cwd, env file, token) without spawning |
-| `useContext({ shorthand, verify })` | Pin a default region/org/space/app context |
-| `readContext()` | Read the pinned context, or `undefined` |
-| `writeContext(ctx)` | Persist a new default context |
-| `scanCollection(root)` | Walk the folder tree and return a typed `region → org → space → app → env` view |
-| `parseShorthandPath(shorthand)` | Split `region/org/space/app[/file]` into a typed ref |
-| `parseBruEnvFile(raw)` / `writeBruEnvFile(...)` | Minimal `.bru` env reader/writer |
-| `readCfMetaFromFile(path)` / `writeCfMetaToFile(path, ref)` | Round-trip `__cf_*` vars in an env file |
-
-</details>
-
----
-
 ## 📁 Folder Layout
 
 All state lives under your home directory or your collection root:
@@ -365,7 +312,7 @@ The `__cf_*` vars drive XSUAA lookup. `run` adds `accessToken` on the fly via `b
 | Hand-edit `environments/*.bru` | ❌ manual | ❌ | ❌ | ❌ | ❌ |
 | Bruno GUI OAuth2 | ✅ | ❌ | ❌ | partial | ❌ (GUI) |
 | `bru run` alone | ❌ | ❌ | ❌ | ❌ | ✅ |
-| **`saptools-bruno`** | ✅ **automatic** | ✅ | ✅ | ✅ | ✅ |
+| **`bruno`** | ✅ **automatic** | ✅ | ✅ | ✅ | ✅ |
 
 ---
 
@@ -384,7 +331,7 @@ The `__cf_*` vars drive XSUAA lookup. `run` adds `accessToken` on the fly via `b
 <details>
 <summary><b>Why does Bruno need a wrapper — can't I just call <code>bru run</code>?</b></summary>
 
-You can, but every CF service behind XSUAA needs a fresh OAuth2 token, and Bruno doesn't mint them. `saptools-bruno run` fetches the token (cached when possible), injects it as `accessToken`, and gets out of the way. Your `.bru` requests stay portable.
+You can, but every CF service behind XSUAA needs a fresh OAuth2 token, and Bruno doesn't mint them. `bruno run` fetches the token (cached when possible), injects it as `accessToken`, and gets out of the way. Your `.bru` requests stay portable.
 
 </details>
 
@@ -431,8 +378,8 @@ Use the programmatic API with your own prompt stubs (every field just returns th
 - [x] Shorthand path resolution (`region/org/space/app[/file]`)
 - [x] Default CF context via `use`
 - [x] Offline e2e via stubbed `bru`
-- [ ] `saptools-bruno doctor` — diagnose missing `__cf_*` vars, stale tokens, missing `bru`
-- [ ] `saptools-bruno migrate` — move collections from a flat layout into the CF-aware layout
+- [ ] `bruno doctor` — diagnose missing `__cf_*` vars, stale tokens, missing `bru`
+- [ ] `bruno migrate` — move collections from a flat layout into the CF-aware layout
 - [ ] First-class `--reporter json` support for piping test results into dashboards
 
 Have an idea? [Open an issue](https://github.com/dongitran/saptools/issues/new) — the roadmap is driven by real use.

package/dist/cli.js

@@ -1,8 +1,10 @@
 #!/usr/bin/env node
 
 // src/cli/main.ts
+import { readdir as readdir3 } from "fs/promises";
+import { isAbsolute as isAbsolute2, join as join5, resolve as resolve2 } from "path";
 import process2 from "process";
-import { confirm, select } from "@inquirer/prompts";
+import { confirm, input as input2, search as search2, select } from "@inquirer/prompts";
 import { Command, Option } from "commander";
 
 // src/commands/run.ts
@@ -191,6 +193,8 @@ import { homedir } from "os";
 import { join } from "path";
 var SAPTOOLS_DIR_NAME = ".saptools";
 var BRUNO_CONTEXT_FILENAME = "bruno-context.json";
+var BRUNO_DIR_NAME = "bruno";
+var BRUNO_CLI_STATE_FILENAME = "cli-state.json";
 var REGION_FOLDER_PREFIX = "region__";
 var ORG_FOLDER_PREFIX = "org__";
 var SPACE_FOLDER_PREFIX = "space__";
@@ -216,6 +220,12 @@ function parsePrefixedName(dirName, prefix) {
   }
   return dirName.slice(prefix.length);
 }
+function brunoDir() {
+  return join(saptoolsDir(), BRUNO_DIR_NAME);
+}
+function brunoCliStatePath() {
+  return join(brunoDir(), BRUNO_CLI_STATE_FILENAME);
+}
 
 // src/collection/folder-scan.ts
 async function safeReaddir(path) {
@@ -846,6 +856,28 @@ async function writeContext(ctx) {
 `, "utf8");
   return updated;
 }
+async function readBrunoCliState() {
+  try {
+    const raw = await readFile4(brunoCliStatePath(), "utf8");
+    return JSON.parse(raw);
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return void 0;
+    }
+    throw err;
+  }
+}
+async function writeBrunoCliState(input3) {
+  const next = {
+    rootDir: input3.rootDir,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const path = brunoCliStatePath();
+  await mkdir2(dirname2(path), { recursive: true });
+  await writeFile4(path, `${JSON.stringify(next, null, 2)}
+`, "utf8");
+  return next;
+}
 
 // src/commands/use.ts
 function parseContextShorthand(shorthand) {
@@ -1016,18 +1048,18 @@ async function promptForEnvironments(opts, deps = {}) {
 // src/cli/main.ts
 function resolveCollectionDir(explicitCollection, explicitRoot) {
   if (explicitCollection) {
-    return explicitCollection;
+    return Promise.resolve(explicitCollection);
   }
   if (explicitRoot) {
-    return explicitRoot;
+    return Promise.resolve(explicitRoot);
   }
   if (process2.env["SAPTOOLS_BRUNO_COLLECTION"]) {
-    return process2.env["SAPTOOLS_BRUNO_COLLECTION"];
+    return Promise.resolve(process2.env["SAPTOOLS_BRUNO_COLLECTION"]);
   }
   if (process2.env["SAPTOOLS_BRUNO_ROOT"]) {
-    return process2.env["SAPTOOLS_BRUNO_ROOT"];
+    return Promise.resolve(process2.env["SAPTOOLS_BRUNO_ROOT"]);
   }
-  return process2.cwd();
+  return readBrunoCliState().then((state) => state?.rootDir ?? process2.cwd());
 }
 function resolveProgramCollectionDir(program) {
   const opts = program.opts();
@@ -1037,10 +1069,121 @@ function writeLine(message) {
   process2.stdout.write(`${message}
 `);
 }
+async function listDir(path) {
+  const entries = await readdir3(path, { withFileTypes: true });
+  const dirs = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+  const bruFiles = entries.filter((entry) => entry.isFile() && entry.name.endsWith(".bru")).map((entry) => entry.name).sort();
+  return { dirs, bruFiles };
+}
+async function collectBruFiles(root, current) {
+  const { dirs, bruFiles } = await listDir(current);
+  const nested = await Promise.all(dirs.map(async (dir) => await collectBruFiles(root, join5(current, dir))));
+  const currentFiles = bruFiles.map((name) => join5(current, name));
+  return [...currentFiles, ...nested.flat()].sort();
+}
+function formatTreePath(root, fullPath) {
+  const rel = fullPath.startsWith(root) ? fullPath.slice(root.length).replace(/^[/\\]/, "") : fullPath;
+  return rel.replace(/\\/g, "/");
+}
+function formatTreeResultLabel(relativePath) {
+  const segments = relativePath.split("/").filter((segment) => segment.length > 0);
+  if (segments.length === 0) {
+    return "\u{1F4C4}";
+  }
+  const lines = [];
+  for (const [index, segment] of segments.entries()) {
+    const isFile = index === segments.length - 1;
+    const icon = isFile ? "\u{1F4C4}" : "\u{1F4C1}";
+    if (index === 0) {
+      lines.push(`${icon} ${segment}`);
+      continue;
+    }
+    const indent = "  ".repeat(index);
+    lines.push(`${indent}\u2514\u2500${icon} ${segment}`);
+  }
+  return lines.join("\n");
+}
+function formatEntryTreePath(root, current, entryName) {
+  const fullPath = join5(current, entryName);
+  return formatTreePath(root, fullPath);
+}
+async function browseBruFile(root) {
+  let current = root;
+  for (; ; ) {
+    const currentLevel = await listDir(current);
+    const allFiles = await collectBruFiles(root, root);
+    const selected = await search2({
+      message: "",
+      source: (inputValue) => {
+        const query = (inputValue ?? "").trim().toLowerCase();
+        if (query.length === 0) {
+          const localChoices = [
+            { name: "\u{1F50E}", value: { kind: "search", name: "" } },
+            ...currentLevel.dirs.map((dir) => ({
+              name: `\u{1F4C1} ${dir}/`,
+              value: { kind: "dir", name: dir }
+            })),
+            ...currentLevel.bruFiles.map((file) => ({
+              name: `\u{1F4C4} ${file}`,
+              value: { kind: "file", name: file }
+            })),
+            ...current === root ? [] : [{ name: "\u2B05 ../", value: { kind: "back", name: "" } }],
+            { name: "\u2716 Exit", value: { kind: "exit", name: "" } }
+          ];
+          return localChoices;
+        }
+        const matchedFiles = allFiles.filter((file) => formatTreePath(root, file).toLowerCase().includes(query)).slice(0, 200).map((file) => ({
+          name: formatTreeResultLabel(formatTreePath(root, file)),
+          value: { kind: "file", name: formatEntryTreePath(root, root, formatTreePath(root, file)) }
+        }));
+        const matchedDirs = Array.from(
+          new Set(
+            allFiles.map((file) => formatTreePath(root, file)).flatMap((path) => {
+              const parts = path.split("/");
+              if (parts.length <= 1) {
+                return [];
+              }
+              const folders = parts.slice(0, -1);
+              return folders.map((_, index) => folders.slice(0, index + 1).join("/"));
+            }).filter((dirPath) => dirPath.toLowerCase().includes(query))
+          )
+        ).slice(0, 100).map((dirPath) => ({
+          name: formatTreeResultLabel(dirPath),
+          value: { kind: "dir", name: dirPath }
+        }));
+        return [
+          { name: `\u{1F50E} ${query}`, value: { kind: "search", name: query } },
+          ...matchedDirs,
+          ...matchedFiles,
+          ...current === root ? [] : [{ name: "\u2B05 ../", value: { kind: "back", name: "" } }],
+          { name: "\u2716 Exit", value: { kind: "exit", name: "" } }
+        ];
+      }
+    });
+    if (selected.kind === "dir") {
+      current = selected.name.includes("/") ? join5(root, selected.name) : join5(current, selected.name);
+      continue;
+    }
+    if (selected.kind === "back") {
+      current = resolve2(current, "..");
+      continue;
+    }
+    if (selected.kind === "search") {
+      continue;
+    }
+    if (selected.kind === "file") {
+      if (selected.name.endsWith(".bru") && selected.name.includes("/")) {
+        return join5(root, selected.name);
+      }
+      return join5(current, selected.name);
+    }
+    return void 0;
+  }
+}
 function registerSetupAppCommand(program) {
   program.command("setup-app").description("Interactively scaffold a bruno app folder and seed __cf_* variables").action(async () => {
     const result = await setupApp({
-      root: resolveProgramCollectionDir(program),
+      root: await resolveProgramCollectionDir(program),
       prompts: {
         selectRegion: async (choices) => await select({ message: "Select region", choices: [...choices] }),
         selectOrg: async (choices) => await select({ message: "Select org", choices: [...choices] }),
@@ -1064,41 +1207,82 @@ async function resolveRunTarget(target) {
   }
   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."
-    );
+    throw new Error("No target specified and no default context is set. Run `bruno use <region/org/space/app>` first.");
   }
   return `${ctx.region}/${ctx.org}/${ctx.space}/${ctx.app}`;
 }
 function registerRunCommand(program) {
-  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 result = await runBruno({
-        root: resolveProgramCollectionDir(program),
-        target: await resolveRunTarget(target),
-        ...opts.env ? { environment: opts.env } : {},
-        log: writeLine
-      });
-      process2.exit(result.code);
-    }
-  );
+  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 result = await runBruno({
+      root: await resolveProgramCollectionDir(program),
+      target: await resolveRunTarget(target),
+      ...opts.env ? { environment: opts.env } : {},
+      log: writeLine
+    });
+    process2.exit(result.code);
+  });
 }
 function registerUseCommand(program) {
   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
-    });
+    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}
 `);
   });
 }
+function registerSetRootCommand(program) {
+  program.command("set-root").description("Persist default Bruno root folder under ~/.saptools/bruno/").argument("[dir]", "Root folder path").action(async (dir) => {
+    const raw = dir ?? await input2({ message: "Enter Bruno root folder path", default: process2.cwd() });
+    const rootDir = isAbsolute2(raw) ? raw : resolve2(process2.cwd(), raw);
+    const saved = await writeBrunoCliState({ rootDir });
+    writeLine(`\u2714 Bruno root saved: ${saved.rootDir}`);
+  });
+}
+async function launchInteractiveMenu(program) {
+  const root = await resolveProgramCollectionDir(program);
+  const action = await select({
+    message: `Bruno menu (${root}) \u2014 choose an action`,
+    choices: [
+      { name: "Run .bru file", value: "run-file" },
+      { name: "Set default context (use)", value: "use" },
+      { name: "Setup app folder", value: "setup-app" },
+      { name: "Set Bruno root folder", value: "set-root" },
+      { name: "Exit", value: "exit" }
+    ]
+  });
+  if (action === "run-file") {
+    const filePath = await browseBruFile(root);
+    if (!filePath) {
+      writeLine("Aborted.");
+      return;
+    }
+    const result = await runBruno({ root, target: filePath, log: writeLine });
+    process2.exit(result.code);
+  }
+  if (action === "use") {
+    const shorthand = await input2({ message: "Enter context shorthand (region/org/space/app)" });
+    const ctx = await useContext({ shorthand, verify: true });
+    writeLine(`\u2714 Default context set to ${ctx.region}/${ctx.org}/${ctx.space}/${ctx.app}`);
+    return;
+  }
+  if (action === "setup-app") {
+    await program.parseAsync(["node", "bruno", "setup-app"]);
+    return;
+  }
+  if (action === "set-root") {
+    await program.parseAsync(["node", "bruno", "set-root"]);
+  }
+}
 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").addOption(new Option("--collection <dir>", "Bruno collection directory (default: SAPTOOLS_BRUNO_COLLECTION or cwd)")).addOption(new Option("--root <dir>", "Legacy alias for --collection").hideHelp());
+  program.name("bruno").description("Smart runner for Bruno with CF-aware env metadata and automatic token injection").addOption(new Option("--collection <dir>", "Bruno collection directory (default: configured root, SAPTOOLS_BRUNO_COLLECTION or cwd)")).addOption(new Option("--root <dir>", "Legacy alias for --collection").hideHelp());
   registerSetupAppCommand(program);
   registerRunCommand(program);
   registerUseCommand(program);
+  registerSetRootCommand(program);
+  if (argv.length <= 2) {
+    await launchInteractiveMenu(program);
+    return;
+  }
   await program.parseAsync([...argv]);
 }
 try {