@monster-orange/den 0.0.0-stage → 0.1.0

package/src/ui/cli/invocation-target.ts

@@ -0,0 +1,175 @@
+import * as fs from "fs";
+import * as path from "path";
+import { getInvokeCwd } from "../../shared/paths.js";
+import type {
+  ResolvedService,
+  ServiceCatalog,
+  WorkspaceConfig,
+} from "../../shared/types/index.js";
+import {
+  listWorkspaceServices,
+  parseAddress,
+} from "../../shared/environment-manager/workspaces.js";
+import { readManifest } from "../../shared/manifest/read-manifest.js";
+import { getGitHubCoords } from "../../shared/smoke/git-remote.js";
+import type { AliasResolver } from "../../shared/environment-manager/derivation/alias.js";
+import { loadAliasResolver } from "../../shared/environment-manager/derivation/load-alias.js";
+
+import { product } from "../../shared/product.js";
+export interface InvocationTarget {
+  repoRoot: string;
+  repoName: string;
+  addresses: string[];
+}
+
+function realPathSafe(input: string): string {
+  try {
+    return fs.realpathSync.native(input);
+  } catch {
+    return path.resolve(input);
+  }
+}
+
+function hasRepoMarker(dir: string): boolean {
+  return (
+    fs.existsSync(path.join(dir, `${product().manifestYml}`)) ||
+    fs.existsSync(path.join(dir, `${product().manifestJson}`)) ||
+    fs.existsSync(path.join(dir, ".git"))
+  );
+}
+
+export function findInvocationRepoRoot(
+  cwd: string = getInvokeCwd(),
+): string | null {
+  let dir = path.resolve(cwd);
+  while (dir.length > 0) {
+    if (hasRepoMarker(dir)) return dir;
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+  return null;
+}
+
+/**
+ * The canonical repo-system the cwd belongs to (and its repo root), identified by
+ * IDENTITY not exact path — so it resolves whether you're in a sibling checkout
+ * or a managed clone. Tries, in order: the repo's `.den.yml` name, the
+ * folder name, the parent folder name (managed clones live at `<repo>/<branch>/`).
+ * Returns null when the cwd isn't inside a known repo.
+ */
+export function resolveCwdRepo(
+  alias: AliasResolver = loadAliasResolver(),
+): { repo: string; root: string } | null {
+  const root = findInvocationRepoRoot();
+  if (!root) return null;
+  const candidates = [
+    readManifest(root)?.name,
+    path.basename(root),
+    path.basename(path.dirname(root)),
+  ];
+  for (const c of candidates) {
+    if (!c) continue;
+    const resolved = alias.resolve(c);
+    const node =
+      resolved && alias.knownRepos.has(resolved)
+        ? resolved
+        : alias.knownRepos.has(c)
+          ? c
+          : undefined;
+    if (node) return { repo: node, root };
+  }
+  return null;
+}
+
+function uniqueServices(services: ResolvedService[]): ResolvedService[] {
+  const seen = new Set<string>();
+  const result: ResolvedService[] = [];
+  for (const svc of services) {
+    if (seen.has(svc.address)) continue;
+    seen.add(svc.address);
+    result.push(svc);
+  }
+  return result;
+}
+
+function servicesForRepoPath(
+  repoRoot: string,
+  services: ResolvedService[],
+): ResolvedService[] {
+  const target = realPathSafe(repoRoot);
+  return services.filter((svc) => realPathSafe(svc.repoPath) === target);
+}
+
+function servicesForGitRemote(
+  repoRoot: string,
+  services: ResolvedService[],
+  catalog: ServiceCatalog,
+): ResolvedService[] {
+  const coords = getGitHubCoords(repoRoot);
+  if (!coords) return [];
+
+  const slug = `${coords.owner}/${coords.repo}`.toLowerCase();
+  return services.filter((svc) => {
+    const catalogSlug = catalog[svc.repoName]?.gh?.toLowerCase();
+    return catalogSlug === slug || svc.repoName === coords.repo;
+  });
+}
+
+function selectAddresses(
+  repoRoot: string,
+  repoName: string,
+  services: ResolvedService[],
+): string[] {
+  const unique = uniqueServices(services);
+  const manifest = readManifest(repoRoot);
+  const serviceKeys = Object.keys(manifest?.services ?? {});
+
+  if (serviceKeys.length <= 1 || unique.length <= 1) {
+    return [unique[0].address];
+  }
+
+  if (manifest?.entrypoint) {
+    const entrypointAddress = `${repoName}/${manifest.entrypoint}`;
+    const matched = unique.find(
+      (svc) =>
+        svc.address === entrypointAddress ||
+        svc.subsystem === manifest.entrypoint,
+    );
+    return [matched?.address ?? entrypointAddress];
+  }
+
+  return unique.map((svc) => svc.address);
+}
+
+export function resolveInvocationTarget(
+  workspaceName: string,
+  workspace: WorkspaceConfig,
+  catalog: ServiceCatalog,
+  cwd: string = getInvokeCwd(),
+): InvocationTarget | null {
+  const repoRoot = findInvocationRepoRoot(cwd);
+  if (!repoRoot) return null;
+
+  const workspaceServices = listWorkspaceServices(
+    workspace,
+    catalog,
+    workspaceName,
+  );
+  const matched = uniqueServices([
+    ...servicesForRepoPath(repoRoot, workspaceServices),
+    ...servicesForGitRemote(repoRoot, workspaceServices, catalog),
+  ]);
+  if (matched.length === 0) return null;
+
+  const repoName =
+    matched[0].repoName ||
+    parseAddress(matched[0].address, catalog).repoName ||
+    path.basename(repoRoot);
+
+  return {
+    repoRoot,
+    repoName,
+    addresses: selectAddresses(repoRoot, repoName, matched),
+  };
+}

package/src/ui/cli/logs-command.ts

@@ -0,0 +1,104 @@
+import chalk from "chalk";
+import type { AliasResolver } from "../../shared/environment-manager/derivation/alias.js";
+import {
+  followTailSources,
+  resolveTailSources,
+} from "../../shared/environment-manager/log-tail.js";
+import type { ResolvedService } from "../../shared/types/index.js";
+import { resolveCwdRepo } from "./invocation-target.js";
+
+import { product } from "../../shared/product.js";
+export type LogsTarget =
+  | { kind: "repo"; target: string }
+  | { kind: "address"; target: string }
+  | { kind: "unknown-repo"; arg: string }
+  | { kind: "no-cwd-repo" };
+
+/**
+ * `den logs [repo]` target resolution: an explicit arg is alias-resolved
+ * against the known repo-systems (a `repo/subsystem` address passes through
+ * untouched); with no arg, the cwd repo is used.
+ */
+export function resolveLogsTarget(
+  args: string[],
+  alias: AliasResolver,
+  cwdRepo: () => { repo: string; root: string } | null = () =>
+    resolveCwdRepo(alias),
+): LogsTarget {
+  const arg = args.find((a) => !a.startsWith("-"));
+  if (arg) {
+    if (arg.includes("/")) return { kind: "address", target: arg };
+    const resolved = alias.resolve(arg);
+    const repo =
+      resolved && alias.knownRepos.has(resolved)
+        ? resolved
+        : alias.knownRepos.has(arg)
+          ? arg
+          : undefined;
+    return repo
+      ? { kind: "repo", target: repo }
+      : { kind: "unknown-repo", arg };
+  }
+  const cwd = cwdRepo();
+  return cwd ? { kind: "repo", target: cwd.repo } : { kind: "no-cwd-repo" };
+}
+
+/**
+ * Tail the service's live logs to stdout until the stream ends or the user
+ * hits Ctrl-C. Returns the exit code the CLI should finish with.
+ * `waitForSourceMs` keeps polling for a log source to appear — used right
+ * after starting a service, when its container/daemon log may not exist yet
+ * (e.g. tab-runtime ups write no daemon file until the container is up).
+ */
+export async function tailServiceLogs(
+  resolved: ResolvedService,
+  opts: { waitForSourceMs?: number } = {},
+): Promise<number> {
+  let candidates = resolveTailSources(resolved);
+  if (candidates.length === 0 && opts.waitForSourceMs) {
+    const deadline = Date.now() + opts.waitForSourceMs;
+    while (candidates.length === 0 && Date.now() < deadline) {
+      await new Promise((resolve) => setTimeout(resolve, 1_000));
+      candidates = resolveTailSources(resolved);
+    }
+  }
+  if (candidates.length === 0) {
+    console.log(
+      chalk.yellow(`\n  No local log source found for ${resolved.address}.`),
+    );
+    console.log(
+      chalk.gray(
+        `  (no manifest logs.local command, no running container, and no ${product().cli}`,
+      ),
+    );
+    console.log(
+      chalk.gray(
+        `  daemon log — services started outside ${product().cli} don't get one; '${product().cli} up ${resolved.repoName}' does.)\n`,
+      ),
+    );
+    return 1;
+  }
+
+  console.log(
+    chalk.gray(`\n  Tailing logs for ${resolved.address} — Ctrl-C to stop.`),
+  );
+  const handle = followTailSources(candidates, {
+    onLine: (line) => console.log(line),
+    onMeta: (line) => console.log(chalk.gray(`  ${line}`)),
+  });
+  // Ctrl-C stops the tail (the child shares our process group); SIGTERM/SIGHUP
+  // land only on this process, so without stop() they'd orphan a live
+  // `docker logs -f`/`tail -F` child.
+  const onSignal = (): void => handle.stop();
+  const signals: NodeJS.Signals[] = ["SIGINT", "SIGTERM", "SIGHUP"];
+  for (const sig of signals) process.once(sig, onSignal);
+  // `den logs x | head` closes stdout mid-stream: without a handler the
+  // next console.log crashes node with an unhandled EPIPE and orphans the
+  // detached tail child. Standard pipe semantics: stop tailing, exit clean.
+  const onStdoutError = (): void => handle.stop();
+  process.stdout.on("error", onStdoutError);
+  const code = await handle.done;
+  for (const sig of signals) process.removeListener(sig, onSignal);
+  process.stdout.removeListener("error", onStdoutError);
+  return code;
+}

package/src/ui/cli/module-selection.ts

@@ -0,0 +1,31 @@
+interface NamedModule {
+  name: string;
+}
+
+interface ResolvePerformanceModulesOptions {
+  availableModules: NamedModule[];
+  selectedModule?: string | null;
+  repoName?: string | null;
+}
+
+export function resolvePerformanceModules({
+  availableModules,
+  selectedModule,
+  repoName,
+}: ResolvePerformanceModulesOptions): string[] {
+  if (selectedModule) {
+    return [selectedModule];
+  }
+
+  if (repoName) {
+    const repoModules = availableModules
+      .map((module) => module.name)
+      .filter((name) => name.startsWith(`${repoName}/`));
+    if (repoModules.length === 0) {
+      throw new Error(`No performance modules found for repo "${repoName}"`);
+    }
+    return repoModules;
+  }
+
+  return availableModules.map((module) => module.name);
+}