simplemdg-dev-cli 2.5.0 → 2.7.0

package/src/commands/cf.command.ts

@@ -34,6 +34,17 @@ import { runCommand, runCommandInherit } from "../core/process";
 import { resolveRepositoryPath } from "../core/repository";
 import { searchableSelectChoice, selectFromHistoryOrInput } from "../core/prompts";
 import { ensureExternalTool } from "../core/tooling";
+import { smartRead, buildCfAppsKey, formatRelativeTime, DEFAULT_CACHE_TTL } from "../core/cache/smart-cache";
+import {
+  addFavoriteTarget,
+  addRecentTarget,
+  isFavoriteTarget,
+  listFavoriteTargets,
+  listRecentTargets,
+  removeFavoriteTarget,
+} from "../core/cf/cf-target-cache";
+import { cfTargetKey, cfTargetLabel } from "../core/cf/cf-target.types";
+import type { TCfTarget } from "../core/cf/cf-target.types";
 import type { TCloudFoundryApp, TCloudFoundryLoginProfile, TCloudFoundryOrgEntry, TCloudFoundryTarget } from "../core/types";
 
 type TCloudFoundryLoginOptions = {
@@ -1268,175 +1279,250 @@ async function getCloudFoundryOrganizationsAcrossRegions(options: { api?: string
   return fallbackEntries;
 }
 
-async function runOrgCommand(options: TCloudFoundryOrgOptions): Promise<void> {
-  const target = await ensureCloudFoundrySessionFromCache();
+function orgEntryToTarget(entry: TCloudFoundryOrgEntry): TCfTarget {
+  return { region: entry.region, apiEndpoint: entry.apiEndpoint, org: entry.org, space: "", lastRefreshedAt: entry.updatedAt };
+}
 
-  const action = options.list
-    ? "list"
-    : options.switch
-      ? "switch"
-      : await searchableSelectChoice({
-        message: "What do you want to do with CF org?",
-        choices: [
-          { title: "List orgs across regions", value: "list" },
-          { title: "Switch org across regions", value: "switch" },
-        ],
-        validateCustomValue: (value) => {
-          const normalizedValue = value.trim().toLowerCase();
-          return normalizedValue === "list" || normalizedValue === "switch"
-            ? true
-            : "Type list or switch, or select one option.";
-        },
-      });
+function dedupeTargets(targets: TCfTarget[]): TCfTarget[] {
+  const seen = new Set<string>();
+  const result: TCfTarget[] = [];
 
-  const organizationEntries = await getCloudFoundryOrganizationsAcrossRegions({
-    api: options.api,
-    refresh: options.refresh,
+  for (const target of targets) {
+    const key = cfTargetKey(target);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(target);
+  }
+
+  return result;
+}
+
+async function switchToCfTarget(target: TCfTarget, options: { space?: string }): Promise<void> {
+  const apiEndpoint = target.apiEndpoint;
+
+  if (!apiEndpoint) {
+    throw new Error("Cannot determine CF API endpoint for the selected target.");
+  }
+
+  const region = target.region || inferCloudFoundryRegionFromApiEndpoint(apiEndpoint);
+  const authenticatedProfile = await ensureCloudFoundryAuthenticatedForApiEndpoint({
+    apiEndpoint,
+    preferredOrg: target.org,
+    preferredSpace: options.space ?? target.space,
+    reason: "switch-target",
   });
-  const organizationRegionCount = new Set(organizationEntries.map((entry) => entry.region)).size;
-  const latestTarget = await readCloudFoundryTarget();
 
-  if (action === "list") {
-    printTarget(latestTarget);
-    console.log("");
+  const orgExitCode = await targetCloudFoundryOrg(target.org);
+
+  if (orgExitCode !== 0) {
+    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;
+  }
+
+  let space = options.space?.trim() || target.space?.trim() || "";
 
-    if (!organizationEntries.length) {
-      console.log(chalk.yellow("No orgs found for current CF user. Run smdg cf login, save the password, then run smdg cf org again."));
+  if (!space) {
+    const spaces = await listCloudFoundrySpaces().catch(() => [] as string[]);
+    const currentAfter = await readCloudFoundryTarget();
+    const preferred = currentAfter.space || (spaces.includes("app") ? "app" : spaces[0]);
+    space = spaces.length
+      ? await searchableSelectChoice({
+        message: "Select CF space",
+        choices: [
+          ...spaces.filter((s) => s === preferred).map((s) => ({ title: `${s} ${chalk.gray("suggested")}`, value: s })),
+          ...spaces.filter((s) => s !== preferred).map((s) => ({ title: s, value: s })),
+        ],
+        validateCustomValue: validateRequired,
+        customValueTitle: (value) => `Use typed CF space: ${value}`,
+      })
+      : await selectFromHistoryOrInput({ message: "Enter CF space", values: [], initialValue: "app" });
+  }
+
+  if (space) {
+    const spaceExitCode = await targetCloudFoundrySpace(space);
+    if (spaceExitCode !== 0) {
+      process.exitCode = spaceExitCode;
       return;
     }
+  }
 
-    console.log(chalk.gray(`Showing ${organizationEntries.length} org(s) across ${organizationRegionCount} region(s).`));
-    console.log("");
+  await addRecentTarget({ region, apiEndpoint, org: target.org, space });
+
+  if (authenticatedProfile?.password) {
+    await rememberCloudFoundryLoginProfile({ ...authenticatedProfile, apiEndpoint, org: target.org, space, updatedAt: new Date().toISOString() });
+  }
+
+  console.log(chalk.green("CF target switched."));
+  printTarget(await readCloudFoundryTarget());
 
-    for (const entry of organizationEntries) {
-      const marker = entry.apiEndpoint === latestTarget.apiEndpoint && entry.org === latestTarget.org ? chalk.green("*") : " ";
-      console.log(`${marker} ${formatCloudFoundryOrgEntry(entry, latestTarget)}`);
+  if (!(await isFavoriteTarget({ region, apiEndpoint, org: target.org, space }))) {
+    const favorite = await prompts({ type: "confirm", name: "fav", message: "Mark this target as favorite?", initial: false });
+    if (favorite.fav) {
+      await addFavoriteTarget({ region, apiEndpoint, org: target.org, space });
+      console.log(chalk.gray("Added to favorites."));
     }
+  }
+}
 
+async function manageFavoriteTargets(favorites: TCfTarget[]): Promise<void> {
+  if (!favorites.length) {
+    console.log(chalk.gray("No favorites yet. Switch to a target and choose to favorite it."));
     return;
   }
 
-  let selectedEntry: TCloudFoundryOrgEntry | undefined;
+  const selected = await searchableSelectChoice({
+    message: "Favorites — select one to remove",
+    choices: [
+      ...favorites.map((target, index) => ({ title: `★ ${cfTargetLabel(target)}`, value: String(index) })),
+      { title: "Cancel", value: "__cancel__" },
+    ],
+    allowCustomValue: false,
+  });
+
+  if (selected === "__cancel__") {
+    return;
+  }
 
-  if (options.org?.trim()) {
-    selectedEntry = organizationEntries.find((entry) => {
-      return entry.org === options.org?.trim() && (!options.api?.trim() || entry.apiEndpoint === options.api.trim());
-    }) ?? {
-      apiEndpoint: options.api?.trim() || latestTarget.apiEndpoint || "",
-      region: options.api?.trim()
-        ? inferCloudFoundryRegionFromApiEndpoint(options.api.trim())
-        : inferCloudFoundryRegionFromApiEndpoint(latestTarget.apiEndpoint ?? "current"),
-      org: options.org.trim(),
-      updatedAt: new Date().toISOString(),
-    };
-  } else {
-    if (!organizationEntries.length) {
-      console.log(chalk.yellow("No orgs were found across regions."));
-      console.log(chalk.gray("Run smdg cf login and save the password, then run smdg cf org --list --refresh."));
-      return;
-    }
+  await removeFavoriteTarget(favorites[Number(selected)]);
+  console.log(chalk.green("Removed from favorites."));
+}
 
-    const selectedIndex = await searchableSelectChoice({
-      message: `Search CF org across ${organizationRegionCount} region(s)`,
-      choices: organizationEntries.map((entry, index) => ({
-        title: formatCloudFoundryOrgEntry(entry, latestTarget),
-        value: String(index),
-      })),
-      validateCustomValue: validateRequired,
-      customValueTitle: (value) => `Use typed CF org in current region: ${value}`,
-    });
+function printTargetSections(favorites: TCfTarget[], recent: TCfTarget[], orgEntries: TCloudFoundryOrgEntry[], current: TCloudFoundryTarget): void {
+  console.log(chalk.bold("CF Target Switcher"));
+  console.log("");
 
-    selectedEntry = organizationEntries[Number(selectedIndex)] ?? {
-      apiEndpoint: latestTarget.apiEndpoint ?? "",
-      region: inferCloudFoundryRegionFromApiEndpoint(latestTarget.apiEndpoint ?? "current"),
-      org: selectedIndex,
-      updatedAt: new Date().toISOString(),
-    };
+  if (favorites.length) {
+    console.log(chalk.yellow("Favorites"));
+    favorites.forEach((target) => console.log(`  ${chalk.yellow("★")} ${cfTargetLabel(target)}`));
+    console.log("");
   }
 
-  if (!selectedEntry.apiEndpoint) {
-    throw new Error("Cannot determine CF API endpoint for selected org.");
+  if (recent.length) {
+    console.log(chalk.cyan("Recent"));
+    recent.forEach((target) => console.log(`  ${chalk.gray("◷")} ${cfTargetLabel(target)}`));
+    console.log("");
   }
 
-  const authenticatedProfile = await ensureCloudFoundryAuthenticatedForApiEndpoint({
-    apiEndpoint: selectedEntry.apiEndpoint,
-    preferredOrg: selectedEntry.org,
-    preferredSpace: options.space,
-    reason: "switch-org",
-  });
+  console.log(chalk.gray(`All Targets (${orgEntries.length})`));
+  for (const entry of orgEntries) {
+    const marker = entry.apiEndpoint === current.apiEndpoint && entry.org === current.org ? chalk.green("*") : " ";
+    console.log(`${marker} ${entry.region} / ${entry.org}`);
+  }
+}
 
-  const orgExitCode = await targetCloudFoundryOrg(selectedEntry.org);
+async function runOrgCommand(options: TCloudFoundryOrgOptions): Promise<void> {
+  const latestTarget = await readCloudFoundryTarget();
+  const favorites = await listFavoriteTargets();
+  const recent = await listRecentTargets();
 
-  if (orgExitCode !== 0) {
-    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;
+  // Direct switch via flags.
+  if (options.org?.trim()) {
+    await ensureExternalTool("cf");
+    const apiEndpoint = options.api?.trim() || latestTarget.apiEndpoint || "";
+    const region = inferCloudFoundryRegionFromApiEndpoint(apiEndpoint || "current");
+    await switchToCfTarget({ region, apiEndpoint, org: options.org.trim(), space: options.space?.trim() || "" }, { space: options.space });
     return;
   }
 
-  const spaces = selectedEntry.spaces?.length ? selectedEntry.spaces : await listCloudFoundrySpaces();
-  const currentTargetAfterOrgSwitch = await readCloudFoundryTarget();
-  const preferredSpace = options.space?.trim() || currentTargetAfterOrgSwitch.space || (spaces.includes("app") ? "app" : spaces[0]);
+  const action = options.list
+    ? "list"
+    : options.switch
+      ? "switch"
+      : await searchableSelectChoice({
+        message: "CF target switcher",
+        choices: [
+          { title: "Switch to a target (favorites, recent, all)", value: "switch" },
+          { title: "Refresh all regions", value: "refresh" },
+          { title: "List targets", value: "list" },
+          { title: "Manage favorites", value: "favorites" },
+          { title: "Show current target", value: "current" },
+        ],
+        allowCustomValue: false,
+      });
 
-  const space = options.space?.trim() || await searchableSelectChoice({
-    message: "Select CF space",
-    choices: [
-      ...spaces
-        .filter((spaceName) => spaceName === preferredSpace)
-        .map((spaceName) => ({ title: `${spaceName} ${spaceName === currentTargetAfterOrgSwitch.space ? chalk.gray("current") : chalk.gray("suggested")}`, value: spaceName })),
-      ...spaces
-        .filter((spaceName) => spaceName !== preferredSpace)
-        .map((spaceName) => ({ title: spaceName, value: spaceName })),
-    ],
-    validateCustomValue: validateRequired,
-    customValueTitle: (value) => `Use typed CF space: ${value}`,
-  });
+  if (action === "current") {
+    printTarget(latestTarget);
+    return;
+  }
 
-  if (space) {
-    const spaceExitCode = await targetCloudFoundrySpace(space);
+  if (action === "favorites") {
+    await manageFavoriteTargets(favorites);
+    return;
+  }
 
-    if (spaceExitCode !== 0) {
-      process.exitCode = spaceExitCode;
-      return;
-    }
+  let orgEntries: TCloudFoundryOrgEntry[];
+
+  if (action === "refresh" || options.refresh) {
+    await ensureExternalTool("cf");
+    console.log(chalk.gray("Refreshing CF orgs across regions..."));
+    orgEntries = await getCloudFoundryOrganizationsAcrossRegions({ api: options.api, refresh: true });
+    console.log(chalk.green(`Refresh completed · ${orgEntries.length} target(s) found.`));
+    console.log("");
+  } else {
+    const cache = await readCache();
+    orgEntries = cache.cloudFoundry.orgsAcrossRegions ?? [];
   }
 
-  if (authenticatedProfile?.password) {
-    await rememberCloudFoundryLoginProfile({
-      ...authenticatedProfile,
-      apiEndpoint: selectedEntry.apiEndpoint,
-      org: selectedEntry.org,
-      space,
-      updatedAt: new Date().toISOString(),
-    });
+  if (action === "list") {
+    printTargetSections(favorites, recent, orgEntries, latestTarget);
+    return;
+  }
+
+  const allTargets = orgEntries.map(orgEntryToTarget);
+  const recentKeys = new Set(recent.map((target) => cfTargetKey(target)));
+  const combined = dedupeTargets([...favorites, ...recent, ...allTargets]);
+
+  if (!combined.length) {
+    console.log(chalk.yellow("No cached targets yet."));
+    console.log(chalk.gray("Choose 'Refresh all regions', or run smdg cf login and save the password."));
+    return;
   }
 
-  const switchedTarget = await readCloudFoundryTarget();
-  console.log(chalk.green("CF org/space switched."));
-  printTarget(switchedTarget);
+  const selectedIndex = await searchableSelectChoice({
+    message: `Select CF target (${favorites.length} favorite · ${recent.length} recent · ${allTargets.length} all)`,
+    choices: combined.map((target, index) => {
+      const marker = target.isFavorite ? chalk.yellow("★ ") : recentKeys.has(cfTargetKey(target)) ? chalk.gray("◷ ") : "  ";
+      return { title: `${marker}${cfTargetLabel(target)}`, value: String(index) };
+    }),
+    validateCustomValue: validateRequired,
+    customValueTitle: (value) => `Use typed org in current region: ${value}`,
+  });
+
+  const chosen = combined[Number(selectedIndex)] ?? {
+    region: inferCloudFoundryRegionFromApiEndpoint(latestTarget.apiEndpoint ?? "current"),
+    apiEndpoint: latestTarget.apiEndpoint ?? "",
+    org: selectedIndex,
+    space: "",
+  };
+
+  await ensureExternalTool("cf");
+  await switchToCfTarget(chosen, { space: options.space });
 }
 
 async function runAppsCommand(options: TCloudFoundryAppsOptions): Promise<void> {
-  const target = await readCloudFoundryTarget();
-  const targetKey = buildCloudFoundryTargetKey(target);
-  const cache = await readCache();
-  const cachedEntry = cache.cloudFoundry.appListsByTarget[targetKey];
-
+  const target = await ensureCloudFoundrySessionFromCache();
   printTarget(target);
   console.log("");
 
-  const shouldUseCache = !options.refresh && Boolean(cachedEntry?.apps.length);
-  const apps = await getAppsWithCache({
-    refresh: options.refresh,
-    startBackgroundRefresh: shouldUseCache,
+  const region = target.apiEndpoint ? inferCloudFoundryRegionFromApiEndpoint(target.apiEndpoint) : "current";
+  const cacheKey = buildCfAppsKey(region, target.org ?? "?", target.space ?? "?");
+  const targetLabel = `${region} / ${target.org ?? "?"} / ${target.space ?? "?"}`;
+
+  const result = await smartRead<TCloudFoundryApp[]>({
+    namespace: "cf-apps",
+    key: cacheKey,
+    ttlMs: DEFAULT_CACHE_TTL.cfApps,
+    mode: options.refresh ? "network-only" : "stale-while-revalidate",
+    fetcher: listCloudFoundryApps,
   });
 
-  if (shouldUseCache && cachedEntry) {
-    console.log(chalk.gray(`Using cached cf apps: ${cachedEntry.apps.length} apps, updated at ${cachedEntry.updatedAt}`));
-    console.log(chalk.gray("Refreshing cf apps cache in background. Use --refresh when you want to wait for fresh data."));
-    console.log("");
-  } else if (options.refresh) {
-    console.log(chalk.green(`Refreshed cf apps cache for ${targetKey}.`));
+  if (result.fromCache) {
+    console.log(chalk.gray(`Using cached apps for ${targetLabel} from ${formatRelativeTime(result.updatedAt)}.`));
+    if (result.isRefreshing) {
+      console.log(chalk.gray("Refreshing apps in background..."));
+    }
     console.log("");
   }
 
@@ -1446,9 +1532,26 @@ async function runAppsCommand(options: TCloudFoundryAppsOptions): Promise<void>
     return;
   }
 
-  for (const app of apps) {
+  for (const app of result.data) {
     console.log([app.name, app.requestedState, app.processes, app.routes].filter(Boolean).join(" | "));
   }
+
+  // Mirror the smart-cache apps into the legacy per-target cache used by
+  // resolveAppSelection so bind/debug/logs stay in sync.
+  await rememberCloudFoundryApps(buildCloudFoundryTargetKey(target), result.data).catch(() => undefined);
+
+  if (result.refreshPromise) {
+    try {
+      const fresh = await result.refreshPromise;
+      await rememberCloudFoundryApps(buildCloudFoundryTargetKey(target), fresh).catch(() => undefined);
+      console.log("");
+      console.log(chalk.gray("Background refresh completed. Cache updated."));
+    } catch (error) {
+      console.log("");
+      console.log(chalk.yellow(`Background refresh failed: ${error instanceof Error ? error.message : String(error)}`));
+      console.log(chalk.gray("Showing cached apps. Run smdg cf login if your session expired."));
+    }
+  }
 }
 
 async function runAppsCacheRefreshCommand(): Promise<void> {

package/src/commands/gitlab.command.ts

@@ -7,6 +7,7 @@ import prompts from "prompts";
 import chalk from "chalk";
 import { Command } from "commander";
 import { searchableSelectChoice } from "../core/prompts";
+import { smartRead, buildGitLabGroupsKey, buildGitLabProjectsKey, formatRelativeTime, DEFAULT_CACHE_TTL } from "../core/cache/smart-cache";
 
 const GITLAB_CACHE_DIR = path.join(os.homedir(), ".simplemdg");
 const GITLAB_CACHE_FILE = path.join(GITLAB_CACHE_DIR, "gitlab.json");
@@ -186,15 +187,23 @@ async function runLoginFlow(): Promise<TGitLabAuth> {
   return auth;
 }
 
-async function listRootGroups(auth: TGitLabAuth, refresh: boolean): Promise<TGitLabGroup[]> {
-  const cache = await readGitLabCache();
-  const cached = cache.groupsByBaseUrl[auth.baseUrl];
-  if (!refresh && cached?.groups?.length) return cached.groups;
-  console.log(chalk.gray(`Scanning GitLab root groups from ${auth.baseUrl}...`));
-  const groups = await gitlabFetchAll<TGitLabGroup>(auth, "/groups", { min_access_level: "10", top_level_only: "true", all_available: "false", order_by: "name", sort: "asc" });
-  cache.groupsByBaseUrl[auth.baseUrl] = { updatedAt: new Date().toISOString(), groups };
-  await writeGitLabCache(cache);
-  return groups;
+async function listRootGroups(auth: TGitLabAuth, refresh: boolean, notify = false): Promise<TGitLabGroup[]> {
+  const result = await smartRead<TGitLabGroup[]>({
+    namespace: "gitlab-groups",
+    key: buildGitLabGroupsKey(auth.baseUrl, auth.username),
+    ttlMs: DEFAULT_CACHE_TTL.gitlabGroups,
+    mode: refresh ? "network-only" : "stale-while-revalidate",
+    fetcher: () => gitlabFetchAll<TGitLabGroup>(auth, "/groups", { min_access_level: "10", top_level_only: "true", all_available: "false", order_by: "name", sort: "asc" }),
+  });
+
+  if (notify && result.fromCache) {
+    console.log(chalk.gray(`Using ${result.data.length} cached GitLab groups from ${formatRelativeTime(result.updatedAt)}.${result.isRefreshing ? " Refreshing in background..." : ""}`));
+  }
+  if (notify && result.refreshPromise) {
+    result.refreshPromise.then(() => console.log(chalk.gray("GitLab groups cache updated."))).catch(() => console.log(chalk.yellow("GitLab groups refresh failed; using cached list.")));
+  }
+
+  return result.data;
 }
 
 async function askGroup(auth: TGitLabAuth, refresh?: boolean): Promise<TGitLabGroup> {
@@ -210,17 +219,24 @@ async function askGroup(auth: TGitLabAuth, refresh?: boolean): Promise<TGitLabGr
   return group;
 }
 
-async function listProjects(auth: TGitLabAuth, group: TGitLabGroup, refresh: boolean): Promise<TGitLabProject[]> {
-  const cache = await readGitLabCache();
-  const key = makeGroupCacheKey(auth.baseUrl, group.id);
-  const cached = cache.projectsByGroup[key];
-  if (!refresh && cached?.projects?.length) return cached.projects;
-  console.log(chalk.gray(`Scanning projects in ${group.full_path}...`));
+async function listProjects(auth: TGitLabAuth, group: TGitLabGroup, refresh: boolean, notify = false): Promise<TGitLabProject[]> {
   const encodedId = encodeURIComponent(String(group.id));
-  const projects = await gitlabFetchAll<TGitLabProject>(auth, `/groups/${encodedId}/projects`, { include_subgroups: "true", archived: "false", order_by: "path", sort: "asc" });
-  cache.projectsByGroup[key] = { updatedAt: new Date().toISOString(), projects };
-  await writeGitLabCache(cache);
-  return projects;
+  const result = await smartRead<TGitLabProject[]>({
+    namespace: "gitlab-projects",
+    key: buildGitLabProjectsKey(auth.baseUrl, group.id),
+    ttlMs: DEFAULT_CACHE_TTL.gitlabProjects,
+    mode: refresh ? "network-only" : "stale-while-revalidate",
+    fetcher: () => gitlabFetchAll<TGitLabProject>(auth, `/groups/${encodedId}/projects`, { include_subgroups: "true", archived: "false", order_by: "path", sort: "asc" }),
+  });
+
+  if (notify && result.fromCache) {
+    console.log(chalk.gray(`Using ${result.data.length} cached projects in ${group.full_path} from ${formatRelativeTime(result.updatedAt)}.${result.isRefreshing ? " Refreshing in background..." : ""}`));
+  }
+  if (notify && result.refreshPromise) {
+    result.refreshPromise.then(() => console.log(chalk.gray("GitLab projects cache updated."))).catch(() => console.log(chalk.yellow("GitLab projects refresh failed; using cached list.")));
+  }
+
+  return result.data;
 }
 
 function localProjectPath(destination: string, project: TGitLabProject): string {
@@ -359,13 +375,13 @@ export function registerGitLabCommands(program: Command): void {
   gitlab.command("logout").description("Remove cached GitLab login").action(async () => { const cache = await readGitLabCache(); cache.instances = []; await writeGitLabCache(cache); console.log("GitLab login cache cleared."); });
   gitlab.command("groups").description("List GitLab root groups").option("--refresh", "Refresh from API").action(async (options: { refresh?: boolean }) => {
     const auth = await askAuth();
-    const groups = await listRootGroups(auth, !!options.refresh);
+    const groups = await listRootGroups(auth, !!options.refresh, true);
     for (const group of groups) console.log(`${group.full_path} · #${group.id} · ${group.visibility ?? ""}`);
   });
   gitlab.command("projects").description("List projects in a GitLab root group").option("--refresh", "Refresh from API").action(async (options: { refresh?: boolean }) => {
     const auth = await askAuth();
     const group = await askGroup(auth, options.refresh);
-    const projects = await listProjects(auth, group, !!options.refresh);
+    const projects = await listProjects(auth, group, !!options.refresh, true);
     for (const project of projects) console.log(`${project.path_with_namespace} · #${project.id}`);
   });
   gitlab.command("sync").alias("clone").description("Clone or update GitLab projects without ghorg").option("--refresh", "Refresh groups/projects from API").action(runSync);

package/src/core/cache/smart-cache-events.ts

@@ -0,0 +1,20 @@
+import { EventEmitter } from "node:events";
+import type { TCacheEvent } from "./smart-cache.types";
+
+/**
+ * Process-local event bus for Smart Cache background refreshes. The DB Studio
+ * server subscribes to this and forwards events to the browser over SSE.
+ */
+const emitter = new EventEmitter();
+emitter.setMaxListeners(50);
+
+const EVENT_NAME = "cache-event";
+
+export function emitCacheEvent(event: TCacheEvent): void {
+  emitter.emit(EVENT_NAME, event);
+}
+
+export function onCacheEvent(listener: (event: TCacheEvent) => void): () => void {
+  emitter.on(EVENT_NAME, listener);
+  return () => emitter.off(EVENT_NAME, listener);
+}