@monster-orange/den 0.4.13 → 0.4.15

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

@@ -28,6 +28,13 @@
  *           same conversation id (there is nothing to continue).
  *           --all-interrupted (AG-14.3): every agent interrupted when Den or
  *           the machine restarted that can resume.
+ *   import  (AG-17.1) bring in a conversation started outside Den: with
+ *           no --session, the runtime's own conversations in the
+ *           workspace's folder (newest first); with --session <id> and
+ *           --persona <p>, the runtime's resume of it (den-claude:
+ *           --resume <id>) in the folder it ran in, as a new agent under
+ *           Den's token, hooks and guards. Refused while it is still open
+ *           in another terminal (written in the last minute).
  *   rm      (AG-14.1b) forgets a stopped, interrupted or exited agent (never
  *           a running one); --stopped forgets every one of -w <ws> (or of
  *           every workspace). The runtime's own history stays.
@@ -69,7 +76,9 @@ import {
 } from "../../shared/agents/records.js";
 import {
   AgentError,
+  importAgent,
   listAgents,
+  listConversations,
   listPersonas as personaList,
   listRuntimes,
   loadAgentWorkspaces,
@@ -107,14 +116,14 @@ export {
 
 export const AGENTS_HELP = {
   usage:
-    "agents <list|start|stop|resume|relaunch|rm|personas|doctor|handback-check|handoff-check> ...",
+    "agents <list|start|stop|resume|relaunch|import|rm|personas|doctor|handback-check|handoff-check> ...",
   lines: [
     "Agents: a persona and a workspace, run by a runtime in a session that",
     "outlives the web server (see `{cli} sessions`).",
     "",
     "{cli} agents list -w <ws> [--stopped] [--json]",
     "    --stopped: only the stopped, interrupted and exited ones",
-    "{cli} agents start -w <ws> --persona <p> [--runtime <r>] [--model <m>] [--id <id>]",
+    "{cli} agents start -w <ws> --persona <p> [--runtime <r>] [--model <m>] [--name <name>] [--id <id>]",
     "    runs in the workspace's dir as <dist>-<ws>:<id>; its MCP is pinned to <ws>",
     "    (plus agents.<id>.grants); capped by agents.max_concurrent",
     "{cli} agents stop <id> [-w <ws>] [--no-wait]",
@@ -132,6 +141,12 @@ export const AGENTS_HELP = {
     "    compactions (default 3) or its pull request merged, and its handoff.md",
     "    passes the check, a fresh conversation (same persona, workspace, folder,",
     "    grants) whose first prompt is the handoff",
+    "{cli} agents import -w <ws> [--runtime <r>] [--json]",
+    "{cli} agents import -w <ws> --session <id> --persona <p> [--runtime <r>] [--id <id>]",
+    "    bring in a conversation started outside Den: the first lists the runtime's",
+    "    own (default den-claude) in the workspace's folder; the second continues",
+    "    one as a Den agent (its resume, in the folder it ran in). Refused while it",
+    "    is still open in another terminal: close it there first",
     "{cli} agents rm <id> [-w <ws>]",
     "{cli} agents rm --stopped [-w <ws>]",
     "    forget a stopped, interrupted or exited agent (never a running one);",
@@ -258,12 +273,14 @@ async function start(args: string[], d: AgentsResolved): Promise<number> {
     "--persona": true,
     "--runtime": true,
     "--model": true,
+    "--name": true,
     "--id": true,
   });
   noExtra(where, p);
   const ws = workspaceFlag(where, p);
   if (!ws) throw new UsageError(`${where} needs -w <workspace>`);
   const persona = str(p, "--persona");
+  const name = str(p, "--name");
   if (!persona) throw new UsageError(`${where} needs --persona <p>`);
   const s = await startAgent(d, {
     workspace: ws,
@@ -271,6 +288,7 @@ async function start(args: string[], d: AgentsResolved): Promise<number> {
     runtime: str(p, "--runtime"),
     model: str(p, "--model"),
     id: str(p, "--id"),
+    ...(name !== undefined ? { name } : {}),
   });
   return report(
     d,
@@ -279,6 +297,72 @@ async function start(args: string[], d: AgentsResolved): Promise<number> {
   );
 }
 
+/** `agents import` (AG-17.1): list, or bring one in. */
+async function bringIn(args: string[], d: AgentsResolved): Promise<number> {
+  const where = "agents import";
+  const p = parseArgs(where, args, {
+    "--workspace": true,
+    "--runtime": true,
+    "--session": true,
+    "--persona": true,
+    "--id": true,
+    "--json": false,
+  });
+  noExtra(where, p);
+  const ws = workspaceFlag(where, p);
+  if (!ws) throw new UsageError(`${where} needs -w <workspace>`);
+  const runtime = str(p, "--runtime");
+  const session = str(p, "--session");
+  if (!session) {
+    if (str(p, "--persona") || str(p, "--id"))
+      throw new UsageError(`${where}: --persona and --id need --session <id>`);
+    const { runtimes, conversations } = listConversations(d, ws, runtime);
+    if (p.flags["--json"]) {
+      d.out(
+        JSON.stringify({ workspace: ws, runtimes, conversations }, null, 2),
+      );
+      return 0;
+    }
+    for (const r of runtimes)
+      if (!r.bringIn && (!runtime || runtime === r.id)) d.err(`${r.why}`);
+    if (!conversations.length) {
+      d.out(`no conversations to bring in for workspace ${ws}`);
+      return 0;
+    }
+    d.out(
+      columns([
+        ["ID", "RUNTIME", "LAST", "TITLE", "FOLDER", "NOTE"],
+        ...conversations.map((c) => [
+          c.id,
+          c.runtime,
+          c.lastAt.slice(0, 16).replace("T", " "),
+          c.title ?? "(untitled)",
+          c.cwd,
+          c.agent ? `agent ${c.agent}` : c.open ? "open elsewhere" : "",
+        ]),
+      ]).join("\n"),
+    );
+    d.out(
+      `bring one in: ${d.cli} agents import -w ${ws} --session <id> --persona <p>`,
+    );
+    return 0;
+  }
+  const persona = str(p, "--persona");
+  if (!persona) throw new UsageError(`${where} needs --persona <p>`);
+  const s = await importAgent(d, {
+    workspace: ws,
+    session,
+    persona,
+    runtime,
+    id: str(p, "--id"),
+  });
+  return report(
+    d,
+    s,
+    `brought in ${session} as agent ${s.rec.id} (${s.rec.persona}, ${s.rec.runtime}) as ${s.rec.sessionName} in ${s.rec.cwd}`,
+  );
+}
+
 /** `<id> [-w <ws>]`. */
 function idAndWorkspace(
   where: string,
@@ -616,6 +700,9 @@ export async function cmdAgents(
         case "relaunch":
           await loadAgentWorkspaces(deps);
           return await relaunch(rest, d);
+        case "import":
+          await loadAgentWorkspaces(deps);
+          return await bringIn(rest, d);
         case "rm":
           await loadAgentWorkspaces(deps);
           return await rm(rest, d);

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

@@ -22,7 +22,12 @@
  * nothing is sent.
  */
 import chalk from "chalk";
-import { readDenConfig, type DenConfig } from "../../shared/den-config.js";
+import {
+  readDenConfig,
+  readMcpConfig,
+  type DenConfig,
+} from "../../shared/den-config.js";
+import { approvalsState } from "../mcp/tools.js";
 import { getStateDir } from "../../shared/paths.js";
 import { product } from "../../shared/product.js";
 import { listRecords } from "../../shared/agents/records.js";
@@ -216,6 +221,25 @@ export function agentsConfigured(
   }
 }
 
+/**
+ * The held writes' state (mcp.approvals), as doctor prints it. A bad value
+ * is a problem: the MCP server refuses to start on it.
+ */
+export function approvalsLines(read: () => boolean): {
+  lines: string[];
+  problem: boolean;
+} {
+  try {
+    const state = approvalsState({ approvals: read() });
+    return { lines: ["", `  ℹ MCP ${state}`], problem: false };
+  } catch (err) {
+    return {
+      lines: ["", chalk.red(`  ✗ MCP ${(err as Error).message}`)],
+      problem: true,
+    };
+  }
+}
+
 /** Informational lines after the rows: never a failure. */
 export function doctorNotes(cli: string, configured: boolean): string[] {
   return configured
@@ -312,6 +336,8 @@ export async function cmdDoctor(args: string[]): Promise<number> {
   }
   const rows = doctorRows();
   for (const l of formatDoctor(rows, readBrand().name)) console.log(l);
+  const held = approvalsLines(() => readMcpConfig().approvals);
+  for (const l of held.lines) console.log(l);
   for (const l of pollingLines(eventsFile(), readBrand().name)) console.log(l);
   const cli = product().cli;
   if (!probe) {
@@ -320,7 +346,7 @@ export async function cmdDoctor(args: string[]): Promise<number> {
       agentsConfigured(readConfigOrNull(), getStateDir()),
     ))
       console.log(l);
-    return rows.some((r) => r.problem) ? 1 : 0;
+    return rows.some((r) => r.problem) || held.problem ? 1 : 0;
   }
   const { runEnvProbe, formatProbe } = await import("./env-probe.js");
   const { resolveDeps, plainSessionEnv } =
@@ -339,5 +365,5 @@ export async function cmdDoctor(args: string[]): Promise<number> {
   console.log("");
   for (const l of formatProbe(results)) console.log(l);
   const found = results.some((r) => r.findings.length);
-  return rows.some((r) => r.problem) || found ? 1 : 0;
+  return rows.some((r) => r.problem) || held.problem || found ? 1 : 0;
 }

package/src/ui/cli/doctor-onboard.ts

@@ -28,6 +28,8 @@ import {
 import { readWebPort } from "../../shared/edge/config.js";
 import { DEFAULT_PORT } from "../../shared/constants.js";
 import { needsDocker } from "./repo-detect.js";
+import { readMcpConfig } from "../../shared/den-config.js";
+import { approvalsState } from "../mcp/tools.js";
 import type { WebProbe } from "./mcp-connect.js";
 
 export type CheckStatus = "ok" | "warn" | "fail";
@@ -59,6 +61,8 @@ export interface OnboardDeps {
   probeWeb: (url: string) => Promise<WebProbe>;
   /** The MCP one-shot against the web server: exit 0, or why not. */
   mcpCall: () => { ok: boolean; detail?: string };
+  /** `mcp.approvals` (throws on a bad value): whether the held writes are on. */
+  approvals: () => boolean;
   /** The command an agent runs, e.g. `./bin/acme`. */
   bin: string;
 }
@@ -193,9 +197,30 @@ export async function onboardingChecks(
           },
     );
   }
+  out.push(approvalsCheck(d));
   return out;
 }
 
+/** `mcp:approvals`: which state the held writes are in. Never needs the server. */
+function approvalsCheck(d: OnboardDeps): OnboardCheck {
+  let on: boolean;
+  try {
+    on = d.approvals();
+  } catch (err) {
+    return {
+      id: "mcp:approvals",
+      status: "fail",
+      detail: (err as Error).message,
+      ask: "Set mcp.approvals in the distribution config to true or false.",
+    };
+  }
+  return {
+    id: "mcp:approvals",
+    status: "ok",
+    detail: approvalsState({ approvals: on }),
+  };
+}
+
 function onPath(bin: string): boolean {
   for (const dir of (process.env.PATH ?? "").split(path.delimiter)) {
     if (!dir) continue;
@@ -286,6 +311,7 @@ export function defaultOnboardDeps(
               `exit ${r.status ?? "timeout"}`,
           };
     },
+    approvals: () => readMcpConfig().approvals,
     bin: runnableCli(),
   };
 }

package/src/ui/cli/flag-parser.ts

@@ -181,7 +181,15 @@ function validateFlagScopes(parsed: ParsedCliArgs): void {
  */
 export const SUBCOMMAND_OWN_HELP: Readonly<Record<string, readonly string[]>> =
   {
-    web: ["token", "login", "sessions", "logout", "owner", "approve"],
+    web: [
+      "token",
+      "login",
+      "sessions",
+      "logout",
+      "owner",
+      "approve",
+      "claim-link",
+    ],
     mcp: ["connect", "disconnect", "clients", "config"],
     repo: ["add"],
   };

package/src/ui/cli/index.ts

@@ -366,12 +366,22 @@ const COMMAND_HELP: Record<string, { usage: string; lines: string[] }> = {
   },
   repo: {
     usage:
-      'repo add <path|git-url> [--sidecar] [-w <workspace>] [--name <repo>] [--run "<cmd>"] [--health <url>] [--json]',
+      'repo add <path|git-url> [--sidecar] [-w <workspace>] [--name <repo>] [--run "<cmd>"] [--health <url>] [--dry-run] [--json] | repo detect <folder> [--json]',
     lines: [
       "Add a repo with no prompts, never writing into it. A repo with no",
       "manifest (or --sidecar) gets a side-car manifest in manifests/, detected",
       "from its Makefile, compose file or package.json scripts. Safe to re-run.",
-      "`{cli} repo add --help` says more.",
+      "--dry-run prints the side-car it would write, validated, and writes nothing.",
+      "detect: the git repos in a folder in your home, how each runs, and",
+      "suggested workspaces. `{cli} repo add --help` says more.",
+    ],
+  },
+  onboard: {
+    usage: "onboard status [--json]",
+    lines: [
+      "What's set up (a distribution, the web server, workspaces, repos, a",
+      "running service, Den's MCP) and the one next step, with its command.",
+      "Reads only; it never runs an agent's CLI.",
     ],
   },
   relocate: {
@@ -595,6 +605,7 @@ const TELEMETRY_COMMANDS = new Set<string>([
   "theme",
   "plugin",
   "repo",
+  "onboard",
 ]);
 
 /**
@@ -975,6 +986,15 @@ class DenCLI {
           break;
         }
 
+        case "onboard": {
+          const { cmdOnboard } = await import("./onboard-command.js");
+          const { probeWebServer } = await import("./mcp-connect.js");
+          process.exitCode = await cmdOnboard(args.slice(1), (u) =>
+            probeWebServer(u),
+          );
+          break;
+        }
+
         case "relocate":
           await this.cmdRelocate(args.slice(1));
           break;
@@ -5271,7 +5291,13 @@ class DenCLI {
       "  register [path]      Register a repo in the service catalog",
     );
     console.log(
-      "  repo add <path|url>  Add a repo with no prompts, never changing it (--sidecar, --json)",
+      "  repo add <path|url>  Add a repo with no prompts, never changing it (--sidecar, --dry-run, --json)",
+    );
+    console.log(
+      "  repo detect <folder> Find the repos in a folder and suggest workspaces (--json)",
+    );
+    console.log(
+      "  onboard status       What's set up, and the next step (--json)",
     );
     console.log(
       "  relocate <repo> <path>  Point a moved checkout's workspace entries at its new path",

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

@@ -0,0 +1,180 @@
+/**
+ * `<cli> onboard status [--json]` (ON-3): what's set up and the one next
+ * step, the CLI twin of the MCP tool `onboard_status` and of
+ * GET /api/onboard/status. `doctor --json` has the machine checks (Node,
+ * git, Docker, the web server, Den's MCP); this adds what onboarding needs
+ * on top (a distribution, workspaces, repos, a running service) and picks
+ * the next step. Reads only. It never runs an agent's CLI: Den's MCP is
+ * checked in the agents' config files (onboard-reads.ts mcpRegistration).
+ * Exit 0 whenever it answers, whatever is left to do.
+ */
+import { execFile } from "child_process";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { product } from "../../shared/product.js";
+import { getDistRoot } from "../../shared/paths.js";
+import {
+  DEN_SERVICES_DIR,
+  readWorkspacesFile,
+} from "../../shared/environment-manager/workspaces.js";
+import { listDaemons } from "../../shared/environment-manager/service-runner.js";
+import { defaultOnboardDeps, runnableCli } from "./doctor-onboard.js";
+import type { WebProbe } from "./mcp-connect.js";
+import {
+  mcpRegistration,
+  onboardStatus,
+  type OnboardStatus,
+  type OnboardStatusDeps,
+  type RegisteredRepo,
+} from "./onboard-reads.js";
+import { printJson } from "./json-out.js";
+
+/** Every repo in a workspace, at the folder Den runs it from. */
+export function registeredRepos(): RegisteredRepo[] {
+  let file;
+  try {
+    file = readWorkspacesFile();
+  } catch {
+    return [];
+  }
+  const out: RegisteredRepo[] = [];
+  for (const [workspace, ws] of Object.entries(file.workspaces))
+    for (const [addr, entry] of Object.entries(ws?.services ?? {})) {
+      const repo = addr.split("/")[0];
+      const dir =
+        entry.mode === "dev-managed"
+          ? entry.path
+          : path.join(DEN_SERVICES_DIR, repo, entry.branch ?? "main");
+      if (dir) out.push({ path: dir, workspace, repo });
+    }
+  return out;
+}
+
+function readText(file: string): string | null {
+  try {
+    return fs.readFileSync(file, "utf-8");
+  } catch {
+    return null;
+  }
+}
+
+/** Whether the Docker daemon answers, without blocking the event loop. */
+function dockerUpAsync(): Promise<boolean> {
+  return new Promise((resolve) => {
+    execFile(
+      "docker",
+      ["info", "--format", "{{.ServerVersion}}"],
+      { timeout: 10_000 },
+      (err) => resolve(!err),
+    );
+  });
+}
+
+/** This machine's deps for onboardStatus. */
+export async function defaultStatusDeps(o: {
+  probeWeb: (url: string) => Promise<WebProbe>;
+  webUrl?: string;
+  viaMcp?: boolean;
+}): Promise<OnboardStatusDeps> {
+  const doctor = defaultOnboardDeps(o.probeWeb);
+  if (o.webUrl) doctor.webUrl = o.webUrl;
+  // Docker is asked only when a registered repo needs it, and asynchronously:
+  // the web server answers this route too.
+  const dockerRepos = doctor.dockerRepos();
+  const dockerUp =
+    dockerRepos.length && doctor.which("docker")
+      ? await dockerUpAsync()
+      : false;
+  const bin = runnableCli();
+  return {
+    bin,
+    distribution: fs.existsSync(path.join(getDistRoot(), "bin", product().cli)),
+    doctor: {
+      ...doctor,
+      dockerRepos: () => dockerRepos,
+      dockerUp: () => dockerUp,
+    },
+    workspaces: () => {
+      let file;
+      try {
+        file = readWorkspacesFile();
+      } catch {
+        return { names: [], active: [], repos: [] };
+      }
+      const repos = new Set<string>();
+      for (const ws of Object.values(file.workspaces))
+        for (const addr of Object.keys(ws?.services ?? {}))
+          repos.add(addr.split("/")[0]);
+      return {
+        names: Object.keys(file.workspaces),
+        active: file.active.filter((n) => n in file.workspaces),
+        repos: [...repos],
+      };
+    },
+    running: () => {
+      try {
+        return listDaemons().map((d) => d.address);
+      } catch {
+        return [];
+      }
+    },
+    mcp: () =>
+      mcpRegistration({
+        cli: bin,
+        home: os.homedir(),
+        platform: process.platform,
+        appData: process.env.APPDATA,
+        projectDir: getDistRoot(),
+        which: doctor.which,
+        read: readText,
+        viaMcp: o.viaMcp,
+      }),
+  };
+}
+
+const MARK: Record<string, string> = { ok: "✓", warn: "!", todo: "·" };
+
+function printHuman(r: OnboardStatus): void {
+  for (const c of r.checks)
+    console.log(`  ${MARK[c.status] ?? " "} ${c.id.padEnd(12)} ${c.detail}`);
+  console.log(`\n  Next: ${r.next.step}`);
+  if (r.next.command) console.log(`  Run:  ${r.next.command}`);
+}
+
+export const ONBOARD_USAGE = () => `${product().cli} onboard status [--json]`;
+
+/** `onboard <sub> …`; returns the exit code. */
+export async function cmdOnboard(
+  argv: string[],
+  probeWeb: (url: string) => Promise<WebProbe>,
+): Promise<number> {
+  const [sub, ...rest] = argv;
+  const json = rest.includes("--json");
+  const unknown = rest.filter((a) => a !== "--json");
+  if (sub !== "status" || unknown.length) {
+    const error =
+      sub === undefined || sub === "--help" || sub === "-h"
+        ? null
+        : sub !== "status"
+          ? `unknown onboard subcommand "${sub}"`
+          : `unknown flag ${unknown[0]}`;
+    if (json && error)
+      printJson({
+        ok: false,
+        error,
+        fix: `${runnableCli()} onboard status --json`,
+      });
+    else {
+      if (error) console.error(`✗ ${error}`);
+      console.log(
+        `\n  ${ONBOARD_USAGE()}\n\n  What's set up (a distribution, the web server, workspaces, repos,\n  a running service, Den's MCP) and the one next step, with its command.\n`,
+      );
+    }
+    return error ? 2 : sub === undefined ? 1 : 0;
+  }
+  const r = await onboardStatus(await defaultStatusDeps({ probeWeb }));
+  if (json) printJson(r);
+  else printHuman(r);
+  return 0;
+}