@monster-orange/den 0.4.3 → 0.4.5

package/src/shared/agents/runtime-search.ts

@@ -5,10 +5,13 @@
  * Claude Code's native installer puts `claude`.
  *
  * The search, first match wins:
+ *   0. workspace    `<ws>.agents.runtimes.<id>.bin` in
+ *                   config/local/workspaces.yml (AG-0.5), for an agent of
+ *                   that workspace;
  *   1. setting      `agents.runtimes.<id>.bin` in config/local/user.yml
  *                   (per machine, so never in the distribution's config):
- *                   an absolute path to an executable file; a bad one is
- *                   refused with its reason, never skipped.
+ *                   an absolute path to an executable file; a bad one (at
+ *                   either scope) is refused with its reason, never skipped.
  *   2. login-shell  the login shell's PATH (`$SHELL -lc`), resolved once
  *                   at server start, async, under a 3-second timeout; on
  *                   any failure it is left out (the current PATH remains).
@@ -18,6 +21,11 @@
  *                   /opt/homebrew/bin, /usr/local/bin and npm's global
  *                   bin, derived from npm_config_prefix and node's own
  *                   directory, never by running npm).
+ *   5. interactive-shell  only when a runtime is still missing: the
+ *                   interactive login shell's PATH (`$SHELL -ilc`, where
+ *                   some people set PATH in .zshrc/.bashrc), asked once per
+ *                   process with stdin closed under the same 3-second
+ *                   timeout, and kept (ensureInteractivePath).
  *
  * Sessions and agents Den starts get the same directories on their PATH
  * (sessionPath), so the runtime's own tools are found too.
@@ -32,7 +40,13 @@ import { spawn } from "child_process";
 import * as fs from "fs";
 import * as path from "path";
 
-export type BinSource = "setting" | "login-shell" | "well-known" | "PATH";
+export type BinSource =
+  | "workspace"
+  | "setting"
+  | "login-shell"
+  | "well-known"
+  | "PATH"
+  | "interactive-shell";
 
 /** The shell asked for the login PATH instead of $SHELL; "off" for none. */
 export const LOGIN_SHELL_ENV = "DEN_LOGIN_SHELL";
@@ -52,7 +66,7 @@ export interface RuntimeFind {
 
 export interface SearchDir {
   dir: string;
-  source: Exclude<BinSource, "setting">;
+  source: Exclude<BinSource, "setting" | "workspace">;
 }
 
 export interface Located {
@@ -96,6 +110,8 @@ const END = "__DEN_PATH_END__";
 export interface LoginPathOptions {
   env?: NodeJS.ProcessEnv;
   timeoutMs?: number;
+  /** The shell's flags: "-lc" (a login shell), "-ilc" (interactive too). */
+  flags?: "-lc" | "-ilc";
 }
 
 /**
@@ -127,10 +143,14 @@ export function resolveLoginPath(
     };
     let child: ReturnType<typeof spawn>;
     try {
-      child = spawn(shell, ["-lc", `printf '${BEGIN}%s${END}' "$PATH"`], {
-        env,
-        stdio: ["ignore", "pipe", "ignore"],
-      });
+      child = spawn(
+        shell,
+        [o.flags ?? "-lc", `printf '${BEGIN}%s${END}' "$PATH"`],
+        {
+          env,
+          stdio: ["ignore", "pipe", "ignore"],
+        },
+      );
     } catch {
       resolve(undefined);
       return;
@@ -167,6 +187,38 @@ export async function initLoginPath(o: LoginPathOptions = {}): Promise<void> {
   if (p) setLoginPath(p);
 }
 
+// ── the interactive shell's PATH (the fallback) ─────────────────────────────
+
+let interactiveDirs: string[] | null = null;
+let interactiveAsked: Promise<void> | null = null;
+
+/**
+ * Ask the interactive login shell (`$SHELL -ilc`) for its PATH, once per
+ * process (stdin closed, the same timeout), and keep its directories as
+ * the last place a runtime is looked for. Only for a runtime still missing
+ * after the login PATH and the install directories; a second call waits
+ * on (or returns) the first. Never throws.
+ */
+export function ensureInteractivePath(
+  o: Omit<LoginPathOptions, "flags"> = {},
+): Promise<void> {
+  interactiveAsked ??= resolveLoginPath({ ...o, flags: "-ilc" }).then((p) => {
+    if (p) interactiveDirs = absoluteDirs(p);
+  });
+  return interactiveAsked;
+}
+
+/** Whether the interactive shell was asked already (the answer is kept). */
+export function interactivePathAsked(): boolean {
+  return interactiveAsked !== null;
+}
+
+/** Forget the interactive shell's PATH and that it was asked (tests). */
+export function resetInteractivePath(): void {
+  interactiveDirs = null;
+  interactiveAsked = null;
+}
+
 // ── the directories ─────────────────────────────────────────────────────────
 
 /** A PATH-style list's absolute entries, in order, once each. */
@@ -213,7 +265,10 @@ export function wellKnownDirs(
     : [];
 }
 
-/** Where a runtime is looked for, in order: login shell, PATH, well-known. */
+/**
+ * Where a runtime is looked for, in order: login shell, PATH, well-known,
+ * then (once asked) the interactive shell's PATH.
+ */
 export function searchDirs(
   find: RuntimeFind | undefined,
   env: NodeJS.ProcessEnv,
@@ -226,6 +281,7 @@ export function searchDirs(
   add(loginDirs ?? [], "login-shell");
   add(absoluteDirs(env.PATH ?? ""), "PATH");
   add(wellKnownDirs(find, env), "well-known");
+  add(interactiveDirs ?? [], "interactive-shell");
   return out;
 }
 
@@ -248,8 +304,8 @@ export const binSettingKey = (id: string) => `agents.runtimes.${id}.bin`;
 export function checkBinSetting(
   id: string,
   value: unknown,
+  key: string = binSettingKey(id),
 ): { path: string } | { why: string } {
-  const key = binSettingKey(id);
   if (
     value &&
     typeof value === "object" &&
@@ -268,10 +324,18 @@ export function checkBinSetting(
   return { path: p };
 }
 
+/** A path someone set: where (global or the workspace's) and its key. */
+export interface BinSetting {
+  value: unknown;
+  source: "setting" | "workspace";
+  /** The key it is under, for a refusal ("agents.runtimes.codex.bin"). */
+  key?: string;
+}
+
 /**
  * Find runtime `id`'s CLI: the setting when there is one (refused with its
  * reason when bad), else the first of `find.bins` in searchDirs. Runs
- * nothing.
+ * nothing. `setting` is a value (global, as before) or a BinSetting.
  */
 export function locateRuntime(
   id: string,
@@ -279,11 +343,17 @@ export function locateRuntime(
   env: NodeJS.ProcessEnv,
   setting?: unknown,
 ): Located {
-  if (setting !== undefined && setting !== null) {
-    const c = checkBinSetting(id, setting);
+  const set: BinSetting | null =
+    setting === undefined || setting === null
+      ? null
+      : isBinSetting(setting)
+        ? setting
+        : { value: setting, source: "setting" };
+  if (set && set.value !== undefined && set.value !== null) {
+    const c = checkBinSetting(id, set.value, set.key);
     return "path" in c
-      ? { available: true, path: c.path, source: "setting", searched: [] }
-      : { available: false, why: c.why, source: "setting", searched: [] };
+      ? { available: true, path: c.path, source: set.source, searched: [] }
+      : { available: false, why: c.why, source: set.source, searched: [] };
   }
   const dirs = searchDirs(find, env);
   for (const { dir, source } of dirs)
@@ -304,6 +374,17 @@ export function locateRuntime(
   };
 }
 
+function isBinSetting(v: unknown): v is BinSetting {
+  return (
+    !!v &&
+    typeof v === "object" &&
+    "source" in v &&
+    "value" in v &&
+    ((v as BinSetting).source === "setting" ||
+      (v as BinSetting).source === "workspace")
+  );
+}
+
 /**
  * The PATH a session Den starts gets: the login shell's, the caller's,
  * then each runtime's well-known directories that exist, and `extra` (a
@@ -410,6 +491,52 @@ export function runtimeVersion(
   return p;
 }
 
+/**
+ * Run `<bin> <args>` (stdin closed, under a timeout, never cached) and
+ * return what it printed and whether it exited 0: to check a path someone
+ * sets is the runtime it claims to be. Never throws.
+ */
+export function versionOutput(
+  bin: string,
+  args: readonly string[],
+  env: NodeJS.ProcessEnv,
+  timeoutMs: number = VERSION_TIMEOUT_MS,
+): Promise<{ ok: boolean; out: string }> {
+  return new Promise((resolve) => {
+    let out = "";
+    let done = false;
+    const finish = (ok: boolean) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      resolve({ ok, out });
+    };
+    let child: ReturnType<typeof spawn>;
+    try {
+      child = spawn(bin, [...args], { env, stdio: ["ignore", "pipe", "pipe"] });
+    } catch {
+      resolve({ ok: false, out: "" });
+      return;
+    }
+    const timer = setTimeout(() => {
+      try {
+        child.kill("SIGKILL");
+      } catch {
+        /* gone */
+      }
+      finish(false);
+    }, timeoutMs);
+    timer.unref?.();
+    const take = (d: Buffer) => {
+      if (out.length < 4096) out += d.toString("utf-8");
+    };
+    child.stdout?.on("data", take);
+    child.stderr?.on("data", take);
+    child.on("error", () => finish(false));
+    child.on("close", (code) => finish(code === 0));
+  });
+}
+
 /** Forget every version asked (tests). */
 export function clearVersionCache(): void {
   versions.clear();

package/src/shared/agents/runtime.ts

@@ -13,8 +13,10 @@ import {
   getStrategy,
   registerStrategy,
   strategyIds,
+  unregisterStrategy,
   type StrategyEntry,
 } from "../strategies/registry.js";
+import type { CatalogEntry } from "./catalog.js";
 import type { Persona } from "./personas.js";
 import type { BinSource, RuntimeFind } from "./runtime-search.js";
 
@@ -39,7 +41,8 @@ export interface RuntimeDetect {
 export interface DetectOptions {
   /**
    * `agents.runtimes.<id>.bin` as configured in user.yml (undefined:
-   * read it there; null: none).
+   * read it there; null: none), or a BinSetting (runtime-search.ts) that
+   * says where it was set (the workspace's, or global).
    */
   bin?: unknown;
 }
@@ -107,6 +110,15 @@ export interface Runtime {
   id: string;
   /** Its name for people ("Claude Code"), in the Start agent form. */
   label?: string;
+  /** Who makes it ("Anthropic"): a catalog runtime's vendor (AG-0.5). */
+  vendor?: string;
+  /** Its catalog entry (catalog.ts), when it is one. */
+  catalog?: CatalogEntry;
+  /**
+   * Whether it runs with Den's tools (its MCP config and guards). false:
+   * it runs as its own CLI, tagged "Den tools: coming" (AG-0.5).
+   */
+  denTools?: boolean;
   /**
    * How its CLI is found and its version asked (AG-0.1): the search's
    * binary names and install directories, per runtime, so a catalog can
@@ -143,6 +155,11 @@ export class LaunchError extends Error {
   }
 }
 
+/** Remove a runtime (a configured catalog entry that is gone). */
+export function unregisterRuntime(id: string): void {
+  unregisterStrategy(RUNTIME_KIND, id);
+}
+
 /** Register a runtime as strategy kind `runtime` (doctor lists it). */
 export function registerRuntime(rt: Runtime): void {
   const entry: StrategyEntry<typeof RUNTIME_KIND, Runtime> = {

package/src/shared/agents/runtimes.ts

@@ -1,7 +1,12 @@
 /**
  * Den's built-in runtimes, registered as strategy kind `runtime`: import
- * this module to have them. den-claude first: it is the default.
+ * this module to have them. den-claude first: it is the default. Then the
+ * rest of the runtime catalog (AG-0.5: codex, gemini, grok), then generic.
+ * Entries a distribution or user.yml adds are registered by
+ * syncConfiguredRuntimes, after the built-ins.
  */
+import { BUILTIN_CATALOG, type CatalogEntry } from "./catalog.js";
+import { catalogRuntime } from "./catalog-runtime.js";
 import { denClaude } from "./den-claude.js";
 import { generic } from "./generic.js";
 import {
@@ -9,6 +14,7 @@ import {
   getRuntime,
   registerRuntime,
   runtimeIds,
+  unregisterRuntime,
   type Runtime,
 } from "./runtime.js";
 import { sessionPath, type RuntimeFind } from "./runtime-search.js";
@@ -16,8 +22,24 @@ import { ACTOR_TOKEN_ENV } from "../actor-token.js";
 import { AGENT_ACTOR_ENV, buildSessionEnv } from "../sessions/env.js";
 
 registerRuntime(denClaude);
+for (const e of BUILTIN_CATALOG)
+  if (e.id !== denClaude.id) registerRuntime(catalogRuntime(e));
 registerRuntime(generic);
 
+let configured: string[] = [];
+
+/**
+ * Register the catalog entries a distribution and user.yml add (already
+ * checked: catalog.ts validateCatalog), replacing the last set: an entry
+ * taken out of the config is no runtime any more.
+ */
+export function syncConfiguredRuntimes(entries: readonly CatalogEntry[]): void {
+  const ids = entries.map((e) => e.id);
+  for (const id of configured) if (!ids.includes(id)) unregisterRuntime(id);
+  for (const e of entries) registerRuntime(catalogRuntime(e));
+  configured = ids;
+}
+
 export {
   allScrubEnv,
   DEFAULT_RUNTIME_ID,

package/src/shared/auth/sudo-vault.ts

@@ -2,10 +2,13 @@
  * Secrets-backed persistence for the local-dev sudo password.
  *
  * Goes through the configured secrets strategy (see src/shared/secrets),
- * addressing the named ref `sudo`. There is no built-in location: a
- * distribution that wants the saved password sets `secrets.refs.sudo` in its
- * config. Without it, the vault path is "not configured" and only the
- * interactive unlock is offered; nothing is spawned.
+ * addressing the named ref `sudo`. A distribution may set
+ * `secrets.refs.sudo` in its config; that ref always wins. Without one, the
+ * vault path is "not configured" until the person saves the password
+ * (LK-4): when a backend that keeps secrets (1Password, Doppler) is
+ * available, saving creates the item and writes the ref to their own
+ * user.yml, because the password is the person's, not the distribution's.
+ * Nothing is spawned until then.
  *
  * All read helpers fail *soft*: if the backend isn't installed, the user isn't
  * signed in, the ref is not configured or the value is missing, they return
@@ -21,22 +24,64 @@ import {
   secretsStatus,
   SecretsNotConfiguredError,
   type SecretRef,
+  type SecretsConfig,
   type SecretsProviderName,
 } from "../secrets/index.js";
-import { product } from "../product.js";
+import {
+  readDenConfig,
+  readUserConfig,
+  writeUserConfig,
+} from "../den-config.js";
+import { envKey, product } from "../product.js";
 
 /** Name of the sudo ref under `secrets.refs`. */
 export const SUDO_REF_NAME = "sudo";
 
-/** The configured sudo ref, or null when `secrets.refs.sudo` is not set. */
+/**
+ * The configured sudo ref, or null when `secrets.refs.sudo` is not set. The
+ * distribution's own ref wins over one in user.yml (the merged config lets
+ * user.yml override refs in general; not this one).
+ */
 export function sudoRef(): SecretRef | null {
   try {
-    return namedSecretRef(SUDO_REF_NAME, readSecretsConfig());
+    const cfg = readSecretsConfig();
+    let team: SecretsConfig["refs"];
+    try {
+      team = readDenConfig().secrets?.refs;
+    } catch {
+      team = undefined;
+    }
+    const fromTeam = team?.[SUDO_REF_NAME]
+      ? namedSecretRef(SUDO_REF_NAME, {
+          ...cfg,
+          refs: { [SUDO_REF_NAME]: team[SUDO_REF_NAME] },
+        })
+      : null;
+    return fromTeam ?? namedSecretRef(SUDO_REF_NAME, cfg);
   } catch {
     return null;
   }
 }
 
+/**
+ * LK-4: where a password saved with no `secrets.refs.sudo` goes, for a
+ * backend that keeps it: a new 1Password item in the person's default
+ * vault, or a Doppler key. Null for `env` (process memory only: nothing
+ * survives a restart) and `none`.
+ */
+export function newSudoRef(
+  backend: SecretsProviderName,
+): Partial<SecretRef> | null {
+  switch (backend) {
+    case "1password":
+      return { item: `${product().title} admin password`, field: "password" };
+    case "doppler":
+      return { key: envKey("LOCAL_ADMIN_PWD") };
+    default:
+      return null;
+  }
+}
+
 /** True when the sudo ref is configured AND its backend is ready. */
 export async function isSecretsBackendReady(): Promise<boolean> {
   if (!sudoRef()) return false;
@@ -58,12 +103,64 @@ export async function hasSudoInVault(): Promise<boolean> {
   return (await readSudoFromVault()) !== null;
 }
 
-/** Save (or overwrite) the sudo password. Throws on backend errors. */
-export async function saveSudoToVault(password: string): Promise<void> {
+/**
+ * A backend error, without the command line it ran: a CLI's failure message
+ * can quote its arguments, and a password can be one of them.
+ */
+function withoutSecret(err: unknown, password: string): Error {
+  const msg = String((err as Error)?.message ?? err)
+    .split("\n")
+    .filter((l) => !/^Command failed:/.test(l))
+    .join(" ")
+    .split(password)
+    .join("***")
+    .trim();
+  return new Error(msg || "the secrets backend refused it");
+}
+
+/**
+ * Save (or overwrite) the sudo password. With no `secrets.refs.sudo` and a
+ * backend that keeps secrets (LK-4), it creates the item and then writes
+ * the ref to user.yml (`ref: "created"`); a failed save writes nothing.
+ * Throws on backend errors, never with the password in the message.
+ */
+export async function saveSudoToVault(
+  password: string,
+): Promise<{ ref: "configured" | "created" }> {
   const ref = sudoRef();
-  if (!ref)
+  if (ref) {
+    try {
+      await getSecretsProvider().set(ref, password);
+    } catch (err) {
+      throw withoutSecret(err, password);
+    }
+    return { ref: "configured" };
+  }
+  const st = secretsStatus(readSecretsConfig(), process.env);
+  // Only a backend someone chose (an unset provider is never used here).
+  const fresh =
+    !st.implicit && st.detect.available ? newSudoRef(st.backend) : null;
+  const made = fresh
+    ? namedSecretRef(
+        SUDO_REF_NAME,
+        { refs: { [SUDO_REF_NAME]: fresh } },
+        st.backend,
+      )
+    : null;
+  if (!fresh || !made)
     throw new SecretsNotConfiguredError(notConfiguredMessage(SUDO_REF_NAME));
-  await getSecretsProvider().set(ref, password);
+  try {
+    await getSecretsProvider().set(made, password);
+  } catch (err) {
+    throw withoutSecret(err, password);
+  }
+  const user = readUserConfig();
+  const secrets = user.secrets ?? {};
+  writeUserConfig({
+    ...user,
+    secrets: { ...secrets, refs: { ...secrets.refs, [SUDO_REF_NAME]: fresh } },
+  });
+  return { ref: "created" };
 }
 
 /** What the UI's unlock form may offer: `/api/sudo-password/vault-status`. */
@@ -74,6 +171,12 @@ export interface SudoVaultStatus {
   label: string;
   /** `secrets.refs.sudo` is set for this backend. */
   configured: boolean;
+  /**
+   * Saving works without editing YAML: the ref is configured, or (LK-4) it
+   * isn't and the backend keeps secrets, so saving creates the item and
+   * writes the ref to user.yml.
+   */
+  canSave: boolean;
   /**
    * The backend can work here, whether or not a sudo ref is configured
    * (`configured` says that). With no ref: detect() only (a PATH check,
@@ -106,6 +209,7 @@ export async function sudoVaultStatus(): Promise<SudoVaultStatus> {
     backend: st.backend,
     label: st.label,
     configured: !!ref,
+    canSave: backendAvailable && (!!ref || !!newSudoRef(st.backend)),
     backendAvailable,
     ...(reason ? { reason } : {}),
     configFile: product().configFile,
@@ -125,6 +229,22 @@ export async function sudoVaultStatus(): Promise<SudoVaultStatus> {
   return out(true, await hasSudoInVault());
 }
 
+/**
+ * Where a saved password would be kept, for Settings' "saved in <label>"
+ * (LK-0): read from the config alone, nothing spawned (a page view never
+ * wakes the vault).
+ */
+export function sudoVaultWhere(): { configured: boolean; label: string } {
+  try {
+    const st = secretsStatus(readSecretsConfig(), process.env, {
+      detect: false,
+    });
+    return { configured: !!sudoRef(), label: st.label };
+  } catch {
+    return { configured: false, label: "" };
+  }
+}
+
 /** Name of the active backend, for UI copy ("Save to Doppler"). */
 export function secretsBackendLabel(): string {
   return secretsStatus().label;