@datalabrotterdam/nova-ai-cli 1.2.0-alpha.1 → 1.2.0-alpha.10

package/dist/{chunk-ZKRZIF3S.js → chunk-KDAUUQBE.js}

@@ -1,362 +1,18 @@
-import {
-  NOVA_METHODS,
-  NOVA_NOTIFICATIONS,
-  NovaAgent,
-  createAgentApp,
-  fromElicitationRequest,
-  isInteractionMode,
-  readSettings,
-  resolveWorkspaceFile,
-  toElicitationResponse
-} from "./chunk-GZZ7PY3S.js";
-import {
-  isWorkspaceTrusted
-} from "./chunk-JAEXUFAS.js";
-
-// src/client/in-process.ts
-import * as acp from "@agentclientprotocol/sdk";
-
-// src/client/nova-agent-client.ts
-var NovaAgentClient = class {
-  constructor(connection) {
-    this.connection = connection;
-  }
-  connection;
-  initialize(params) {
-    return this.connection.initialize(params);
-  }
-  newSession(params) {
-    return this.connection.newSession(params);
-  }
-  loadSession(params) {
-    return this.connection.loadSession(params);
-  }
-  resumeSession(params) {
-    return this.connection.resumeSession(params);
-  }
-  closeSession(params) {
-    return this.connection.closeSession(params);
-  }
-  prompt(params) {
-    return this.connection.prompt(params);
-  }
-  cancel(params) {
-    return this.connection.cancel(params);
-  }
-  setSessionMode(params) {
-    return this.connection.setSessionMode(params);
-  }
-  setSessionConfigOption(params) {
-    return this.connection.setSessionConfigOption(params);
-  }
-  queueEnqueue(params) {
-    return this.ext(NOVA_METHODS.queueEnqueue, params);
-  }
-  queueList(params) {
-    return this.ext(NOVA_METHODS.queueList, params);
-  }
-  queueEditBegin(params) {
-    return this.ext(NOVA_METHODS.queueEditBegin, params);
-  }
-  queueUpdate(params) {
-    return this.ext(NOVA_METHODS.queueUpdate, params);
-  }
-  queueRemove(params) {
-    return this.ext(NOVA_METHODS.queueRemove, params);
-  }
-  queueClear(params) {
-    return this.ext(NOVA_METHODS.queueClear, params);
-  }
-  queueTakeNext(params) {
-    return this.ext(NOVA_METHODS.queueTakeNext, params);
-  }
-  sessionCompact(params) {
-    return this.ext(
-      NOVA_METHODS.sessionCompact,
-      params
-    );
-  }
-  sessionContextUsage(params) {
-    return this.ext(NOVA_METHODS.sessionContextUsage, params);
-  }
-  sessionRewind(params) {
-    return this.ext(NOVA_METHODS.sessionRewind, params);
-  }
-  backgroundStartTerminal(params) {
-    return this.ext(NOVA_METHODS.backgroundStartTerminal, params);
-  }
-  backgroundStartPrompt(params) {
-    return this.ext(NOVA_METHODS.backgroundStartPrompt, params);
-  }
-  backgroundList(params) {
-    return this.ext(NOVA_METHODS.backgroundList, params);
-  }
-  backgroundOutput(params) {
-    return this.ext(NOVA_METHODS.backgroundOutput, params);
-  }
-  backgroundKill(params) {
-    return this.ext(NOVA_METHODS.backgroundKill, params);
-  }
-  backgroundRelease(params) {
-    return this.ext(NOVA_METHODS.backgroundRelease, params);
-  }
-  async ext(method, params) {
-    return await this.connection.extMethod(method, params);
-  }
-};
-
-// src/client/in-process.ts
-function startInProcessAgent(toClient, agent = new NovaAgent()) {
-  const toAgent = new TransformStream();
-  const toClientStream = new TransformStream();
-  const agentConnection = createAgentApp(agent).connect(
-    acp.ndJsonStream(toClientStream.writable, toAgent.readable)
-  );
-  const connection = new acp.ClientSideConnection(
-    toClient,
-    acp.ndJsonStream(toAgent.writable, toClientStream.readable)
-  );
-  return {
-    agent,
-    client: new NovaAgentClient(connection),
-    async close() {
-      await agent.shutdown().catch(() => {
-      });
-      agentConnection.close();
-    }
-  };
-}
-
-// src/tui/settings/workspace-mcp.ts
-import { readFileSync as readFileSync2 } from "fs";
-import { join as join2 } from "path";
-
-// src/tui/settings/workspace-settings.ts
-import { readFileSync } from "fs";
-import { join } from "path";
-function settingsPath(cwd) {
-  return join(cwd, ".nova-ai", "settings.json");
-}
-function readWorkspaceSettings(cwd) {
-  try {
-    const raw = readFileSync(settingsPath(cwd), "utf8");
-    return JSON.parse(raw);
-  } catch {
-    return {};
-  }
-}
-
-// src/tui/settings/workspace-mcp.ts
-var UNTRUSTED_MCP_MESSAGE = "Not started: MCP servers declared by this workspace only run once you trust it (/trust in the TUI, --trust-workspace headless).";
-function readWorkspaceMcpConfiguration(cwd, options = {}) {
-  const configured = readWorkspaceSettings(cwd).mcpServers ?? [];
-  const project = readProjectMcpConfiguration(cwd);
-  const servers = new Map(configured.map((server) => [server.name, server]));
-  for (const server of project.servers) servers.set(server.name, server);
-  const declared = [...servers.values()];
-  if (declared.length && !(options.trusted ?? isWorkspaceTrusted(cwd))) {
-    return {
-      servers: [],
-      failures: [
-        ...project.failures,
-        ...declared.map((server) => ({ serverName: server.name, message: UNTRUSTED_MCP_MESSAGE }))
-      ],
-      untrusted: declared.map((server) => server.name)
-    };
-  }
-  return { servers: declared, failures: project.failures };
-}
-function workspaceNeedsTrust(cwd) {
-  if (isWorkspaceTrusted(cwd)) return false;
-  if (readWorkspaceMcpConfiguration(cwd, { trusted: true }).servers.length) return true;
-  return loadWorkspaceAllowRules(cwd).length > 0;
-}
-function loadWorkspaceAllowRules(cwd) {
-  return ["settings.json", "settings.local.json"].flatMap((name) => {
-    const allow = readSettings(join2(cwd, ".nova-ai", name))?.permissions?.allow;
-    return Array.isArray(allow) ? allow : [];
-  });
-}
-function readProjectMcpConfiguration(cwd) {
-  const path = join2(cwd, ".mcp.json");
-  let raw;
-  try {
-    raw = readFileSync2(path, "utf8");
-  } catch (error) {
-    if (error.code === "ENOENT") return { servers: [], failures: [] };
-    return { servers: [], failures: [{ serverName: ".mcp.json", message: errorMessage(error, "Could not read file") }] };
-  }
-  let document;
-  try {
-    document = JSON.parse(raw);
-  } catch (error) {
-    return { servers: [], failures: [{ serverName: ".mcp.json", message: errorMessage(error, "Invalid JSON") }] };
-  }
-  const root = asRecord(document);
-  const definitions = root ? asRecord(root.mcpServers) : null;
-  if (!definitions) {
-    return {
-      servers: [],
-      failures: [{ serverName: ".mcp.json", message: 'Expected an "mcpServers" object.' }]
-    };
-  }
-  const servers = [];
-  const failures = [];
-  for (const [name, value] of Object.entries(definitions)) {
-    const config = asRecord(value);
-    if (config?.disabled === true || config?.enabled === false) continue;
-    try {
-      servers.push(normalizeProjectServer(name, config));
-    } catch (error) {
-      failures.push({ serverName: `.mcp.json:${name}`, message: errorMessage(error, "Invalid server configuration") });
-    }
-  }
-  return { servers, failures };
-}
-function normalizeProjectServer(name, config) {
-  if (!config) throw new Error("Server definition must be an object.");
-  const type = typeof config.type === "string" ? config.type : config.url ? "http" : "stdio";
-  if (type === "http" || type === "sse") {
-    if (typeof config.url !== "string" || !config.url) throw new Error(`${type} server requires a URL.`);
-    try {
-      new URL(config.url);
-    } catch {
-      throw new Error(`${type} server requires a valid URL.`);
-    }
-    return {
-      name,
-      type,
-      url: config.url,
-      headers: normalizePairs(config.headers, "headers")
-    };
-  }
-  if (type !== "stdio") throw new Error(`Unsupported transport type: ${type}.`);
-  if (typeof config.command !== "string" || !config.command) throw new Error("stdio server requires a command.");
-  if (config.args !== void 0 && (!Array.isArray(config.args) || !config.args.every((arg) => typeof arg === "string"))) {
-    throw new Error("args must be an array of strings.");
-  }
-  return {
-    name,
-    command: config.command,
-    args: config.args ?? [],
-    env: normalizePairs(config.env, "env")
-  };
-}
-function normalizePairs(value, label) {
-  if (value === void 0) return [];
-  if (Array.isArray(value)) {
-    if (!value.every((entry) => {
-      const pair = asRecord(entry);
-      return typeof pair?.name === "string" && typeof pair.value === "string";
-    })) {
-      throw new Error(`${label} must contain name/value strings.`);
-    }
-    return value.map((entry) => {
-      const pair = entry;
-      return { name: pair.name, value: pair.value };
-    });
-  }
-  const record = asRecord(value);
-  if (!record || !Object.values(record).every((entry) => typeof entry === "string")) {
-    throw new Error(`${label} must be an object of string values.`);
-  }
-  return Object.entries(record).map(([name, entry]) => ({ name, value: entry }));
-}
-function asRecord(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
-}
-function errorMessage(error, fallback) {
-  return error instanceof Error && error.message ? `${fallback}: ${error.message}` : fallback;
-}
-
 // src/tui/session/tui-acp-client.ts
+import { NOVA_NOTIFICATIONS } from "@datalabrotterdam/nova-ai-agent/acp/extensions.js";
+import { openBrowser } from "@datalabrotterdam/nova-ai-agent/acp/auth-server.js";
 import { readFile, writeFile, mkdir } from "fs/promises";
 import { dirname } from "path";
-
-// src/core/process-tree.ts
-import { spawn, spawnSync } from "child_process";
-var KILL_GRACE_MS = 1e3;
-var liveChildren = /* @__PURE__ */ new Set();
-var exitHookInstalled = false;
-function spawnCommand(command, options) {
-  installExitHook();
-  const common = {
-    cwd: options.cwd,
-    env: options.env ?? process.env,
-    detached: process.platform !== "win32",
-    windowsHide: true,
-    stdio: ["ignore", "pipe", "pipe"]
-  };
-  const child = options.args?.length ? spawn(command, options.args, common) : spawn(command, { ...common, shell: true });
-  liveChildren.add(child);
-  const forget = () => liveChildren.delete(child);
-  child.once("exit", forget);
-  child.once("error", forget);
-  return child;
-}
-function killProcessTree(child, signal = "SIGTERM") {
-  if (child.pid === void 0) return;
-  try {
-    if (process.platform === "win32") {
-      spawn("taskkill", ["/pid", String(child.pid), "/T", "/F"], {
-        stdio: "ignore",
-        windowsHide: true
-      }).on("error", () => {
-      });
-    } else {
-      process.kill(-child.pid, signal);
-    }
-  } catch {
-    try {
-      child.kill(signal);
-    } catch {
-    }
-  }
-}
-function terminateProcessTree(child, graceMs = KILL_GRACE_MS) {
-  if (hasExited(child)) return Promise.resolve();
-  return new Promise((resolve) => {
-    let forceTimer;
-    let giveUpTimer;
-    const done = () => {
-      clearTimeout(forceTimer);
-      clearTimeout(giveUpTimer);
-      resolve();
-    };
-    child.once("exit", done);
-    killProcessTree(child, "SIGTERM");
-    forceTimer = setTimeout(() => {
-      killProcessTree(child, "SIGKILL");
-      giveUpTimer = setTimeout(done, graceMs);
-    }, graceMs);
-  });
-}
-function hasExited(child) {
-  return child.exitCode !== null || child.signalCode !== null;
-}
-function installExitHook() {
-  if (exitHookInstalled) return;
-  exitHookInstalled = true;
-  process.once("exit", () => {
-    for (const child of liveChildren) {
-      if (process.platform === "win32" && child.pid !== void 0) {
-        try {
-          spawnSync("taskkill", ["/pid", String(child.pid), "/T", "/F"], {
-            stdio: "ignore",
-            windowsHide: true,
-            timeout: 2e3
-          });
-        } catch {
-        }
-      } else {
-        killProcessTree(child, "SIGKILL");
-      }
-    }
-    liveChildren.clear();
-  });
-}
-
-// src/tui/session/tui-acp-client.ts
+import {
+  spawnCommand,
+  terminateProcessTree
+} from "@datalabrotterdam/nova-ai-agent/core/process-tree.js";
+import { resolveWorkspaceFile } from "@datalabrotterdam/nova-ai-agent/core/tools/workspace-paths.js";
+import {
+  fromElicitationRequest,
+  toElicitationResponse
+} from "@datalabrotterdam/nova-ai-agent/acp/user-questions.js";
+import { INTERACTION_MODES } from "@datalabrotterdam/nova-ai-agent/core/interaction-modes.js";
 var DEFAULT_OUTPUT_LIMIT = 1e5;
 var nextMessageId = 0;
 function uid() {
@@ -374,6 +30,10 @@ var TuiAcpClient = class {
   cwd;
   onBackgroundLifecycle;
   onInteractionModeChange;
+  /** The modes the agent offers (built-in, then the user's agent files); set by the runner. */
+  modeIds = [...INTERACTION_MODES];
+  /** Slash commands the agent understands, such as the user's command files. */
+  agentCommands = [];
   capabilities = {
     fs: { readTextFile: true, writeTextFile: true },
     terminal: true,
@@ -434,6 +94,29 @@ var TuiAcpClient = class {
   appendUserMessage(text) {
     this.appendMessage({ id: uid(), role: "user", text });
   }
+  /** An MCP server's sign-in page: opened in the browser, and printed in case that fails. */
+  mcpAuthUrl(params) {
+    const { serverName, url } = params ?? {};
+    if (typeof serverName !== "string" || typeof url !== "string") return;
+    let page;
+    try {
+      page = new URL(url);
+    } catch {
+      return;
+    }
+    if (page.protocol !== "https:" && page.protocol !== "http:") {
+      this.appendError(`MCP server "${serverName}" sent a sign-in address that is not a web page; not opened.`);
+      return;
+    }
+    openBrowser(page.toString());
+    this.appendMessage({
+      id: uid(),
+      role: "assistant",
+      streaming: false,
+      text: `Sign in to MCP server "${serverName}" in your browser. If it did not open, visit:
+${page}`
+    });
+  }
   appendError(text) {
     this.appendMessage({ id: uid(), role: "error", text });
   }
@@ -637,8 +320,15 @@ ${err.message}`;
           });
         }
         return;
+      case "available_commands_update":
+        this.agentCommands = update.availableCommands.map(({ name, description, input }) => ({
+          name,
+          description,
+          ...input && "hint" in input && input.hint ? { hint: input.hint } : {}
+        }));
+        return;
       case "current_mode_update":
-        if (isInteractionMode(update.currentModeId)) {
+        if (this.modeIds.includes(update.currentModeId)) {
           this.onInteractionModeChange?.(update.currentModeId);
         }
         return;
@@ -758,6 +448,8 @@ ${err.message}`;
         return this.backgroundUpdate(params);
       case NOVA_NOTIFICATIONS.queueChanged:
         return this.queueChanged(params);
+      case NOVA_NOTIFICATIONS.mcpAuthUrl:
+        return this.mcpAuthUrl(params);
       default:
         return;
     }
@@ -945,9 +637,6 @@ function createStore(initial) {
 }
 
 export {
-  startInProcessAgent,
-  readWorkspaceMcpConfiguration,
-  workspaceNeedsTrust,
   TuiAcpClient,
   choosePermissionOption,
   createStore

package/dist/chunk-L77KQRGZ.js

@@ -0,0 +1,170 @@
+import {
+  CLI_PACKAGE_NAME,
+  cliVersion
+} from "./chunk-FMHWW3E6.js";
+
+// src/update-check.ts
+import { mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+import { novaHomeRoot } from "@datalabrotterdam/nova-ai-agent/core/nova-home.js";
+var DIST_TAGS_URL = `https://registry.npmjs.org/-/package/${CLI_PACKAGE_NAME.replace("/", "%2F")}/dist-tags`;
+var DEFAULT_TIMEOUT_MS = 3e3;
+var CACHE_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
+function updateCachePath() {
+  return join(novaHomeRoot(), "update-check.json");
+}
+function updateChecksDisabled(env = process.env) {
+  return Boolean(env.NOVA_NO_UPDATE_CHECK || env.NO_UPDATE_NOTIFIER || env.CI);
+}
+async function checkForUpdate(options = {}) {
+  try {
+    if (updateChecksDisabled(options.env)) return null;
+    const currentVersion = options.currentVersion ?? cliVersion();
+    if (!currentVersion) return null;
+    const distTags = await readDistTags(options);
+    if (!distTags) return null;
+    return chooseUpdate(currentVersion, distTags);
+  } catch {
+    return null;
+  }
+}
+function chooseUpdate(currentVersion, distTags) {
+  const channel = prereleaseChannel(currentVersion);
+  const tags = channel && distTags[channel] ? [channel, "latest"] : ["latest"];
+  let best = null;
+  for (const tag of tags) {
+    const version = distTags[tag];
+    if (!version || !isNewerVersion(version, currentVersion)) continue;
+    if (!best || isNewerVersion(version, best.version)) best = { tag, version };
+  }
+  if (!best) return null;
+  return {
+    currentVersion,
+    latestVersion: best.version,
+    tag: best.tag,
+    command: `npm install -g ${CLI_PACKAGE_NAME}@${best.tag}`
+  };
+}
+async function readDistTags(options) {
+  const now = (options.now ?? Date.now)();
+  const cachePath = options.cachePath === void 0 ? updateCachePath() : options.cachePath;
+  const cached = cachePath ? readCache(cachePath) : null;
+  if (cached && now - cached.checkedAt >= 0 && now - cached.checkedAt < CACHE_MAX_AGE_MS) {
+    return cached.distTags;
+  }
+  const response = await (options.fetchImpl ?? fetch)(DIST_TAGS_URL, {
+    headers: { accept: "application/json" },
+    signal: AbortSignal.any([
+      AbortSignal.timeout(options.timeoutMs ?? DEFAULT_TIMEOUT_MS),
+      ...options.signal ? [options.signal] : []
+    ])
+  });
+  if (!response.ok) return null;
+  const payload = await response.json();
+  if (!isDistTags(payload)) return null;
+  if (cachePath) writeCache(cachePath, { ...cached, checkedAt: now, distTags: payload });
+  return payload;
+}
+function readCache(path) {
+  try {
+    const value = JSON.parse(readFileSync(path, "utf8"));
+    if (value && typeof value === "object" && typeof value.checkedAt === "number" && isDistTags(value.distTags)) {
+      return value;
+    }
+  } catch {
+  }
+  return null;
+}
+var SNOOZE_MS = 24 * 60 * 60 * 1e3;
+function shouldAskAboutUpdate(update, options = {}) {
+  const cachePath = options.cachePath === void 0 ? updateCachePath() : options.cachePath;
+  const cached = cachePath ? readCache(cachePath) : null;
+  if (!cached) return true;
+  if (cached.skippedVersion === update.latestVersion) return false;
+  const now = (options.now ?? Date.now)();
+  return !(typeof cached.snoozedUntil === "number" && now < cached.snoozedUntil);
+}
+function rememberUpdateAnswer(answer, update, options = {}) {
+  const cachePath = options.cachePath === void 0 ? updateCachePath() : options.cachePath;
+  if (!cachePath) return;
+  const cached = readCache(cachePath);
+  const base = cached ?? { checkedAt: 0, distTags: {} };
+  const now = (options.now ?? Date.now)();
+  writeCache(
+    cachePath,
+    answer === "skip" ? { ...base, skippedVersion: update.latestVersion, snoozedUntil: void 0 } : { ...base, snoozedUntil: now + SNOOZE_MS }
+  );
+}
+function writeCache(path, value) {
+  try {
+    mkdirSync(dirname(path), { recursive: true, mode: 448 });
+    writeFileSync(path, `${JSON.stringify(value)}
+`, { mode: 384 });
+  } catch {
+  }
+}
+function isDistTags(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.values(value).every((version) => typeof version === "string");
+}
+function prereleaseChannel(version) {
+  const parsed = parseVersion(version);
+  const first = parsed?.prerelease[0];
+  return first && !/^\d+$/.test(first) ? first : null;
+}
+function readInstalledVersion() {
+  return cliVersion();
+}
+function isNewerVersion(candidate, current) {
+  const next = parseVersion(candidate);
+  const installed = parseVersion(current);
+  if (!next || !installed) return false;
+  for (let index = 0; index < 3; index++) {
+    const difference = next.core[index] - installed.core[index];
+    if (difference !== 0) return difference > 0;
+  }
+  return comparePrerelease(next.prerelease, installed.prerelease) > 0;
+}
+function parseVersion(value) {
+  const match = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/.exec(value);
+  if (!match) return null;
+  return {
+    core: [Number(match[1]), Number(match[2]), Number(match[3])],
+    prerelease: match[4]?.split(".") ?? []
+  };
+}
+function comparePrerelease(left, right) {
+  if (left.length === 0 || right.length === 0) {
+    if (left.length === right.length) return 0;
+    return left.length === 0 ? 1 : -1;
+  }
+  const length = Math.max(left.length, right.length);
+  for (let index = 0; index < length; index++) {
+    const leftPart = left[index];
+    const rightPart = right[index];
+    if (leftPart === void 0 || rightPart === void 0) {
+      return leftPart === rightPart ? 0 : leftPart === void 0 ? -1 : 1;
+    }
+    if (leftPart === rightPart) continue;
+    const leftNumber = /^\d+$/.test(leftPart) ? Number(leftPart) : null;
+    const rightNumber = /^\d+$/.test(rightPart) ? Number(rightPart) : null;
+    if (leftNumber !== null && rightNumber !== null) return leftNumber - rightNumber;
+    if (leftNumber !== null || rightNumber !== null) return leftNumber !== null ? -1 : 1;
+    return leftPart < rightPart ? -1 : 1;
+  }
+  return 0;
+}
+function formatUpdateNotice(update) {
+  return `Update available: nova-ai ${update.currentVersion} \u2192 ${update.latestVersion}. Run: ${update.command}`;
+}
+
+export {
+  updateCachePath,
+  updateChecksDisabled,
+  checkForUpdate,
+  chooseUpdate,
+  shouldAskAboutUpdate,
+  rememberUpdateAnswer,
+  readInstalledVersion,
+  isNewerVersion,
+  formatUpdateNotice
+};