@monster-orange/den 0.4.4 → 0.4.6

package/src/ui/mcp/connect.ts

@@ -46,6 +46,13 @@ export type ConnectAction =
       name: string;
       entry: Record<string, unknown>;
     }
+  | {
+      /** One `[mcp_servers.<name>]` table in a TOML config (Grok CLI). */
+      kind: "toml";
+      file: string;
+      name: string;
+      entry: Record<string, unknown>;
+    }
   | {
       kind: "exec";
       /** Run first, failure ignored: makes the add idempotent. */
@@ -209,12 +216,49 @@ export const MCP_CLIENTS: readonly McpClient[] = [
         s,
       ),
   },
+  {
+    // Grok CLI (xAI). Its MCP servers live in ~/.grok/config.toml (user)
+    // or .grok/config.toml (project), one [mcp_servers.<name>] table each,
+    // with command, args and env keys; `grok mcp add` documents no env flag,
+    // so Den writes the table itself, PATH and all.
+    // https://docs.x.ai/build/features/mcp-servers
+    id: "grok",
+    title: "Grok CLI",
+    scopes: ["user", "project"],
+    detect: (e) => e.which("grok") || e.exists(path.join(e.home, ".grok")),
+    plan: (s, scope, e) => ({
+      kind: "toml",
+      file: path.join(
+        scope === "project" ? e.projectDir : e.home,
+        ".grok",
+        "config.toml",
+      ),
+      name: s.name,
+      entry: stdioEntry(s),
+    }),
+  },
 ];
 
 export function findClient(id: string): McpClient | undefined {
   return MCP_CLIENTS.find((c) => c.id === id);
 }
 
+/**
+ * `mcp connect --runtime <runtime>` (ON-2): the agent runtime's own name
+ * (AG-0.5's catalog: claude, codex, gemini, grok) to its MCP client id.
+ */
+export const RUNTIME_CLIENTS: Readonly<Record<string, string>> = {
+  claude: "claude-code",
+  codex: "codex",
+  gemini: "gemini",
+  grok: "grok",
+};
+
+export function clientForRuntime(runtime: string): McpClient | undefined {
+  const id = RUNTIME_CLIENTS[runtime];
+  return id ? findClient(id) : undefined;
+}
+
 /** The PATH a launched server needs: node's own directory first. */
 export function serverPath(nodeBinDir: string, platform: NodeJS.Platform) {
   const base =
@@ -304,3 +348,93 @@ export function genericSnippet(spec: ServerSpec): string {
     2,
   );
 }
+
+// ── TOML configs (Grok CLI) ─────────────────────────────────────────────────
+
+/** A TOML basic string: JSON's escaping is a subset TOML reads the same. */
+const tomlString = (v: string): string => JSON.stringify(v);
+
+function tomlValue(v: unknown): string {
+  if (typeof v === "string") return tomlString(v);
+  if (Array.isArray(v)) return `[${v.map(tomlValue).join(", ")}]`;
+  if (v && typeof v === "object")
+    return `{ ${Object.entries(v as Record<string, unknown>)
+      .map(
+        ([k, x]) =>
+          `${/^[A-Za-z0-9_-]+$/.test(k) ? k : tomlString(k)} = ${tomlValue(x)}`,
+      )
+      .join(", ")} }`;
+  return String(v);
+}
+
+/** The `[mcp_servers.<name>]` table for `entry`, newline-terminated. */
+export function tomlTable(
+  name: string,
+  entry: Record<string, unknown>,
+): string {
+  return [
+    `[mcp_servers.${name}]`,
+    ...Object.entries(entry).map(([k, v]) => `${k} = ${tomlValue(v)}`),
+    "",
+  ].join("\n");
+}
+
+/** Whether a header line opens `name`'s table or one of its sub-tables. */
+function ownsHeader(line: string, name: string): boolean {
+  const m =
+    /^\s*\[\s*mcp_servers\.(?:"([^"]+)"|([A-Za-z0-9_-]+))\s*(\]|\.)/.exec(line);
+  return !!m && (m[1] ?? m[2]) === name;
+}
+
+/** `text` split into [before, name's table, after] (the table may be ""). */
+function splitTable(text: string, name: string): [string, string, string] {
+  const lines = text.split("\n");
+  const start = lines.findIndex((l) => ownsHeader(l, name));
+  if (start === -1) return [text, "", ""];
+  let end = start + 1;
+  while (
+    end < lines.length &&
+    !(/^\s*\[/.test(lines[end]) && !ownsHeader(lines[end], name))
+  )
+    end++;
+  return [
+    lines.slice(0, start).join("\n"),
+    lines.slice(start, end).join("\n"),
+    lines.slice(end).join("\n"),
+  ];
+}
+
+/**
+ * `text` (a TOML config, or null) with `name`'s `[mcp_servers.<name>]`
+ * table replaced by `entry` (or removed, for null). Everything else in the
+ * file is kept as written.
+ */
+export function mergeTomlConfig(
+  text: string | null,
+  name: string,
+  entry: Record<string, unknown> | null,
+): string {
+  const [before, , after] = splitTable(text ?? "", name);
+  const head = before.replace(/\n*$/, "");
+  const tail = after.replace(/^\n*/, "").replace(/\n*$/, "");
+  const parts = [
+    head,
+    entry ? tomlTable(name, entry).trimEnd() : "",
+    tail,
+  ].filter(Boolean);
+  return parts.length ? `${parts.join("\n\n")}\n` : "";
+}
+
+/** Whether a TOML config already has `name`'s table, as `entry` writes it. */
+export function tomlHasEntry(
+  text: string | null,
+  name: string,
+  entry: Record<string, unknown>,
+): "connected" | "different" | "absent" {
+  if (!text) return "absent";
+  const [, table] = splitTable(text, name);
+  if (!table) return "absent";
+  return table.trim() === tomlTable(name, entry).trim()
+    ? "connected"
+    : "different";
+}

package/src/ui/server/device-flows.ts

@@ -0,0 +1,274 @@
+/**
+ * SEC-2a: the device flows the server runs for the browser. The page asks
+ * for one (Sign in with GitHub on the signed-out page, or Link your GitHub
+ * account in Settings › Access); the server starts it with GitHub, polls
+ * GitHub itself at GitHub's interval, and the page polls the server for the
+ * outcome by the flow's id (a random handle only the page that started it
+ * holds).
+ *
+ *  - The device code never leaves the server; the user code goes to that
+ *    page only. The token lives for one `GET /user` call and is dropped.
+ *  - At most `max` flows (default 3) are pending at once: another start is
+ *    refused (`busy`) until one ends. A pending flow ends at GitHub's
+ *    expiry; a finished one is forgotten a minute later, or when the page
+ *    claims it.
+ *  - What an identity means is the caller's (`decide`): for a sign-in,
+ *    whether it is the owner; for a link, storing it as the owner.
+ *
+ * Clock and timers are injected, so a test drives every step.
+ */
+import { randomBytes } from "crypto";
+import { GITHUB_DEVICE_PAGE } from "../../shared/github-app.js";
+import type {
+  GithubDeviceClient,
+  GithubIdentity,
+} from "../../shared/github-device.js";
+
+export type FlowPurpose = "signin" | "link";
+export type FlowState =
+  | "pending"
+  | "ok"
+  | "refused"
+  | "expired"
+  | "denied"
+  | "error";
+
+/** What the page is told about a flow (never the device code). */
+export interface FlowView {
+  id: string;
+  purpose: FlowPurpose;
+  state: FlowState;
+  userCode: string;
+  verificationUri: string;
+  expiresAt: number;
+  /** ok or refused: the GitHub login that approved it. */
+  login?: string;
+  /** error: what went wrong (no secret in it). */
+  message?: string;
+}
+
+interface Flow extends FlowView {
+  deviceCode: string;
+  intervalMs: number;
+  errors: number;
+  /** ok: who approved it (the id, for the caller). */
+  identity?: GithubIdentity;
+  /** When a finished flow is forgotten. */
+  forgetAt?: number;
+  cancel?: () => void;
+}
+
+export type Schedule = (fn: () => void, ms: number) => () => void;
+
+const defaultSchedule: Schedule = (fn, ms) => {
+  const t = setTimeout(fn, ms);
+  t.unref?.();
+  return () => clearTimeout(t);
+};
+
+/** How long a finished flow waits for its page to claim it. */
+export const FINISHED_KEEP_MS = 60_000;
+/** The most pending flows at once (SEC-2a: "rate-limit concurrent device flows"). */
+export const MAX_PENDING_FLOWS = 3;
+const MAX_ERRORS = 5;
+
+export class DeviceFlows {
+  private readonly flows = new Map<string, Flow>();
+  private readonly client: GithubDeviceClient;
+  private readonly clientId: () => string;
+  private readonly now: () => number;
+  private readonly schedule: Schedule;
+  private readonly max: number;
+  private readonly minIntervalMs: number;
+  private readonly onExpiringToken?: () => void;
+  private readonly decide: (
+    purpose: FlowPurpose,
+    identity: GithubIdentity,
+  ) => "ok" | "refused";
+
+  constructor(opts: {
+    client: GithubDeviceClient;
+    clientId: () => string;
+    decide: (
+      purpose: FlowPurpose,
+      identity: GithubIdentity,
+    ) => "ok" | "refused";
+    now?: () => number;
+    schedule?: Schedule;
+    max?: number;
+    /** The floor between polls (GitHub's interval is never shortened). */
+    minIntervalMs?: number;
+    /**
+     * A token answer carried expires_in or a refresh_token: the app has
+     * token expiry on (a misconfiguration). Called with no token.
+     */
+    onExpiringToken?: () => void;
+  }) {
+    this.onExpiringToken = opts.onExpiringToken;
+    this.client = opts.client;
+    this.clientId = opts.clientId;
+    this.decide = opts.decide;
+    this.now = opts.now ?? Date.now;
+    this.schedule = opts.schedule ?? defaultSchedule;
+    this.max = opts.max ?? MAX_PENDING_FLOWS;
+    this.minIntervalMs = opts.minIntervalMs ?? 1000;
+  }
+
+  /** Pending flows now. */
+  pending(): number {
+    this.sweep();
+    return [...this.flows.values()].filter((f) => f.state === "pending").length;
+  }
+
+  /**
+   * Start a flow with GitHub. `busy` past the cap; `no_client_id` when none
+   * is configured; a GitHub failure throws (its message names no secret).
+   */
+  async start(
+    purpose: FlowPurpose,
+  ): Promise<FlowView | { error: "busy" | "no_client_id" }> {
+    const clientId = this.clientId();
+    if (!clientId) return { error: "no_client_id" };
+    if (this.pending() >= this.max) return { error: "busy" };
+    // Held as pending while GitHub answers, so a burst can't pass the cap.
+    const id = randomBytes(24).toString("base64url");
+    const placeholder: Flow = {
+      id,
+      purpose,
+      state: "pending",
+      userCode: "",
+      verificationUri: GITHUB_DEVICE_PAGE,
+      expiresAt: this.now() + 60_000,
+      deviceCode: "",
+      intervalMs: this.minIntervalMs,
+      errors: 0,
+    };
+    this.flows.set(id, placeholder);
+    let code;
+    try {
+      code = await this.client.start(clientId);
+    } catch (e) {
+      this.flows.delete(id);
+      throw e;
+    }
+    const flow: Flow = {
+      ...placeholder,
+      userCode: code.userCode,
+      deviceCode: code.deviceCode,
+      expiresAt: this.now() + code.expiresIn * 1000,
+      intervalMs: Math.max(code.interval * 1000, this.minIntervalMs),
+    };
+    this.flows.set(id, flow);
+    this.arm(flow);
+    return view(flow);
+  }
+
+  /** A flow's view, or null when there is none (or it was forgotten). */
+  get(id: string, purpose?: FlowPurpose): FlowView | null {
+    this.sweep();
+    const f = this.flows.get(id);
+    if (!f || (purpose && f.purpose !== purpose)) return null;
+    return view(f);
+  }
+
+  /**
+   * The identity of a finished, approved flow, once: the flow is forgotten,
+   * so a second claim gets null (a sign-in makes one session).
+   */
+  claim(id: string, purpose: FlowPurpose): GithubIdentity | null {
+    this.sweep();
+    const f = this.flows.get(id);
+    if (!f || f.purpose !== purpose || f.state !== "ok" || !f.identity)
+      return null;
+    this.flows.delete(id);
+    return f.identity;
+  }
+
+  /** Stop every flow (the server is stopping). */
+  stopAll(): void {
+    for (const f of this.flows.values()) f.cancel?.();
+    this.flows.clear();
+  }
+
+  private arm(f: Flow): void {
+    f.cancel = this.schedule(() => void this.tick(f.id), f.intervalMs);
+  }
+
+  private finish(
+    f: Flow,
+    state: Exclude<FlowState, "pending">,
+    extra: Partial<Flow> = {},
+  ): void {
+    Object.assign(f, extra, {
+      state,
+      deviceCode: "",
+      forgetAt: this.now() + FINISHED_KEEP_MS,
+    });
+    f.cancel?.();
+    f.cancel = undefined;
+  }
+
+  private async tick(id: string): Promise<void> {
+    const f = this.flows.get(id);
+    if (!f || f.state !== "pending") return;
+    if (this.now() >= f.expiresAt) return this.finish(f, "expired");
+    const r = await this.client.poll(this.clientId(), f.deviceCode);
+    if (this.flows.get(id) !== f || f.state !== "pending") return;
+    switch (r.kind) {
+      case "pending":
+        return this.arm(f);
+      case "slow_down":
+        f.intervalMs = Math.max(
+          r.interval !== undefined ? r.interval * 1000 : f.intervalMs + 5000,
+          this.minIntervalMs,
+        );
+        return this.arm(f);
+      case "expired":
+        return this.finish(f, "expired");
+      case "denied":
+        return this.finish(f, "denied");
+      case "error":
+        if (++f.errors >= MAX_ERRORS)
+          return this.finish(f, "error", { message: r.message });
+        return this.arm(f);
+      case "token": {
+        if (r.expiring) this.onExpiringToken?.();
+        let identity: GithubIdentity;
+        try {
+          // The token is used for this one call and dropped with `r`.
+          identity = await this.client.user(r.token);
+        } catch (e) {
+          return this.finish(f, "error", { message: (e as Error).message });
+        }
+        const outcome = this.decide(f.purpose, identity);
+        return this.finish(f, outcome, {
+          login: identity.login,
+          ...(outcome === "ok" ? { identity } : {}),
+        });
+      }
+    }
+  }
+
+  /** Expire pending flows past their time; forget old finished ones. */
+  private sweep(): void {
+    const now = this.now();
+    for (const [id, f] of this.flows) {
+      if (f.state === "pending" && f.deviceCode && now >= f.expiresAt)
+        this.finish(f, "expired");
+      if (f.forgetAt !== undefined && now >= f.forgetAt) this.flows.delete(id);
+    }
+  }
+}
+
+function view(f: Flow): FlowView {
+  return {
+    id: f.id,
+    purpose: f.purpose,
+    state: f.state,
+    userCode: f.userCode,
+    verificationUri: f.verificationUri,
+    expiresAt: f.expiresAt,
+    ...(f.login !== undefined ? { login: f.login } : {}),
+    ...(f.message !== undefined ? { message: f.message } : {}),
+  };
+}

package/src/ui/server/edge-exposure.ts

@@ -1,6 +1,7 @@
 /**
- * The edge counts as local (0.4.3): with no sign-in through the edge, who
- * can reach the edge can use terminals. When Den can tell the edge is
+ * The edge counts as local (0.4.3) when it shows the client is this
+ * machine; since 0.4.5 any other client signs in (unless
+ * web.edge_unattested: local). When Den can tell the edge is
  * reachable beyond this machine it says so, once in web.log and in a
  * banner on every page (the shell, dismissible per browser).
  *
@@ -16,8 +17,19 @@ import { execFile } from "child_process";
 import { promises as dns } from "dns";
 import { isLoopbackAddress } from "./request-guard.js";
 
-export const EDGE_EXPOSED_MESSAGE =
-  "Your edge is reachable from other machines; anyone who can reach it can use terminals. Auth is coming.";
+/**
+ * The warning, by `web.edge_unattested` (SEC-2a): with `signin` (the
+ * default) a browser the edge can't place as this machine signs in first;
+ * with `local` it is let in, as in 0.4.3.
+ */
+export function edgeExposedMessage(unattested: "local" | "signin"): string {
+  return unattested === "local"
+    ? "Your edge is reachable from other machines, and web.edge_unattested is local: anyone it can't place can use terminals. Remove the key to have them sign in."
+    : "Your edge is reachable from other machines. A browser it can't place as this one signs in first (Sign in with GitHub, or a pairing link).";
+}
+
+/** 0.4.5's default wording (web.edge_unattested: signin). */
+export const EDGE_EXPOSED_MESSAGE = edgeExposedMessage("signin");
 
 export interface ExposureDeps {
   /** Every address a hostname resolves to (none when it doesn't). */