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

package/dist/{headless-ZYUSTZDL.js → headless-BQXK7TNC.js}

@@ -1,43 +1,17 @@
 import {
   TuiAcpClient,
   choosePermissionOption,
-  createStore,
-  readWorkspaceMcpConfiguration,
-  startInProcessAgent
-} from "./chunk-ZKRZIF3S.js";
-import {
-  NOVA_NOTIFICATIONS,
-  NovaAgent,
-  listStoredSessions,
-  loadStoredSession
-} from "./chunk-GZZ7PY3S.js";
-import "./chunk-Q7WL3DXP.js";
-import {
-  setWorkspaceTrusted
-} from "./chunk-JAEXUFAS.js";
+  createStore
+} from "./chunk-KDAUUQBE.js";
 
 // src/headless/index.ts
 import { resolve } from "path";
-import * as acp2 from "@agentclientprotocol/sdk";
-
-// src/client/context-client.ts
+import { NOVA_NOTIFICATIONS } from "@datalabrotterdam/nova-ai-agent/acp/extensions.js";
 import * as acp from "@agentclientprotocol/sdk";
-function clientFromContext(context) {
-  const request = (method, params) => context.request(method, params);
-  return {
-    sessionUpdate: (params) => context.notify(acp.methods.client.session.update, params),
-    requestPermission: (params) => request(acp.methods.client.session.requestPermission, params),
-    readTextFile: (params) => request(acp.methods.client.fs.readTextFile, params),
-    writeTextFile: async (params) => await request(acp.methods.client.fs.writeTextFile, params) ?? {},
-    createTerminal: (params) => request(acp.methods.client.terminal.create, params),
-    terminalOutput: (params) => request(acp.methods.client.terminal.output, params),
-    waitForTerminalExit: (params) => request(acp.methods.client.terminal.waitForExit, params),
-    killTerminal: async (params) => await request(acp.methods.client.terminal.kill, params) ?? {},
-    releaseTerminal: async (params) => await request(acp.methods.client.terminal.release, params) ?? {},
-    unstable_createElicitation: (params) => request(acp.methods.client.elicitation.create, params),
-    extNotification: (method, params) => context.notify(method, params)
-  };
-}
+import { NovaAgent } from "@datalabrotterdam/nova-ai-agent/acp/agent.js";
+import { clientFromContext } from "@datalabrotterdam/nova-ai-agent/client/context-client.js";
+import { startInProcessAgent } from "@datalabrotterdam/nova-ai-agent/client/in-process.js";
+import { listStoredSessions, loadStoredSession } from "@datalabrotterdam/nova-ai-agent/core/sessions.js";
 
 // src/headless/client.ts
 var HeadlessAcpClient = class {
@@ -215,15 +189,19 @@ ${HEADLESS_HELP}
     dependencies.agent ?? new NovaAgent()
   );
   const agent = connection.client;
-  if (options.trustWorkspace) setWorkspaceTrusted(options.cwd, true);
-  const mcpConfiguration = options.mcp ? readWorkspaceMcpConfiguration(options.cwd) : { servers: [], failures: [] };
-  for (const failure of mcpConfiguration.failures) {
-    output.write({
-      type: "mcp.configuration_error",
-      serverName: failure.serverName,
-      message: failure.message
-    });
-  }
+  const sessionMeta = { "nova-ai-cli/workspaceMcp": options.mcp };
+  const reportMcpFailures = (meta) => {
+    const failures = toRecord(toRecord(meta)?.["nova-ai-cli/mcp"])?.failures;
+    for (const failure of Array.isArray(failures) ? failures : []) {
+      const item = toRecord(failure);
+      if (typeof item?.serverName !== "string" || typeof item.message !== "string") continue;
+      output.write({
+        type: "mcp.configuration_error",
+        serverName: item.serverName,
+        message: item.message
+      });
+    }
+  };
   let sessionId = null;
   let interrupted = false;
   const onInterrupt = () => {
@@ -235,22 +213,27 @@ ${HEADLESS_HELP}
     process.once("SIGINT", onInterrupt);
   try {
     await agent.initialize({
-      protocolVersion: acp2.PROTOCOL_VERSION,
+      protocolVersion: acp.PROTOCOL_VERSION,
       clientCapabilities: client.capabilities,
       clientInfo: { name: "nova-ai-cli-headless", version: "1" }
     });
+    if (options.trustWorkspace) await agent.workspaceTrust({ cwd: options.cwd, trusted: true });
     if (options.resume) {
-      await agent.resumeSession({
+      const resumed = await agent.resumeSession({
         sessionId: options.resume,
         cwd: options.cwd,
-        mcpServers: mcpConfiguration.servers
+        mcpServers: [],
+        _meta: sessionMeta
       });
+      reportMcpFailures(resumed._meta);
       sessionId = options.resume;
     } else {
       const created = await agent.newSession({
         cwd: options.cwd,
-        mcpServers: mcpConfiguration.servers
+        mcpServers: [],
+        _meta: sessionMeta
       });
+      reportMcpFailures(created._meta);
       sessionId = created.sessionId;
     }
     await agent.setSessionConfigOption({

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
-  readPackageVersion
-} from "./chunk-Q7WL3DXP.js";
+  cliVersion
+} from "./chunk-FMHWW3E6.js";
 
 // src/cli.ts
 var SUBCOMMANDS = {
@@ -17,8 +17,7 @@ var MODE_FLAGS = {
   "--headless": "print",
   "--setup": "login",
   "--version": "version",
-  "-v": "version",
-  "--web": "web"
+  "-v": "version"
 };
 function parseCli(argv) {
   const first = argv[0];
@@ -34,11 +33,11 @@ function parseCli(argv) {
   const mode = [...modes][0];
   const wantsHelp = options.includes("--help") || options.includes("-h");
   if (!mode) return wantsHelp ? { mode: "help", args: [] } : { mode: "tui", args: argv };
-  const drop = /* @__PURE__ */ new Set(["--acp", "--headless", "--setup", "--version", "-v", "--web"]);
+  const drop = /* @__PURE__ */ new Set(["--acp", "--headless", "--setup", "--version", "-v"]);
   return { mode, args: argv.filter((arg, index) => !(drop.has(arg) && (end < 0 || index < end))) };
 }
 function versionText() {
-  return `nova-ai ${readPackageVersion() ?? "unknown"}`;
+  return `nova-ai ${cliVersion() ?? "unknown"}`;
 }
 var MAIN_HELP = `Nova AI \u2014 agentic coding in your terminal, and an ACP agent for editors.
 
@@ -86,8 +85,35 @@ function parseTuiArgs(args) {
 }
 
 // src/index.ts
+function startUpdateCheck() {
+  if (!process.stderr.isTTY) return null;
+  const abort = new AbortController();
+  const result = import("./update-check-G3PYCRWM.js").then(({ checkForUpdate }) => checkForUpdate({ signal: abort.signal })).catch(() => null);
+  return { result, cancel: () => abort.abort() };
+}
+async function noticeUpdate(check, waitMs) {
+  let timer;
+  const update = await Promise.race([
+    check.result,
+    new Promise((resolve) => {
+      timer = setTimeout(() => resolve(null), waitMs);
+    })
+  ]);
+  clearTimeout(timer);
+  check.cancel();
+  if (!update) return;
+  const { formatUpdateNotice } = await import("./update-check-G3PYCRWM.js");
+  process.stderr.write(`
+${formatUpdateNotice(update)}
+`);
+}
+var BROWSER_MODES = /* @__PURE__ */ new Set(["tui", "print", "acp", "web"]);
 async function main() {
   const command = parseCli(process.argv.slice(2));
+  if (BROWSER_MODES.has(command.mode)) {
+    const { setUpBrowserInBackground } = await import("./browser-setup-7SWHUQEL.js");
+    setUpBrowserInBackground();
+  }
   switch (command.mode) {
     case "error":
       process.stderr.write(`${command.message}
@@ -99,37 +125,49 @@ ${MAIN_HELP}
       process.stdout.write(`${MAIN_HELP}
 `);
       return 0;
-    case "version":
+    case "version": {
+      const update = startUpdateCheck();
       process.stdout.write(`${versionText()}
 `);
+      if (update) await noticeUpdate(update, 800);
       return 0;
+    }
     case "acp": {
       if (command.args.length) {
         process.stderr.write(`--acp takes no other arguments (got ${command.args.join(" ")}).
 `);
         return 2;
       }
-      const { default: runAcp } = await import("./acp-ZYOQ6PON.js");
+      const { default: runAcp } = await import("@datalabrotterdam/nova-ai-agent/acp/index.js");
       await runAcp();
       return 0;
     }
     case "print": {
-      const { default: runHeadless } = await import("./headless-ZYUSTZDL.js");
-      return runHeadless(command.args);
+      const update = startUpdateCheck();
+      const { default: runHeadless } = await import("./headless-BQXK7TNC.js");
+      const code = await runHeadless(command.args);
+      if (update) await noticeUpdate(update, 500);
+      return code;
     }
     case "login": {
-      const { runLogin } = await import("./login-6U7QS7EA.js");
-      return runLogin(command.args);
+      const { runLogin } = await import("@datalabrotterdam/nova-ai-agent/commands/login.js");
+      const code = await runLogin(command.args);
+      if (code === 0) {
+        const { browserSetupDisabled, describeBrowserSetup, setUpBrowser } = await import("./browser-setup-7SWHUQEL.js");
+        if (!browserSetupDisabled()) {
+          await setUpBrowser().then(
+            (result) => process.stderr.write(`${describeBrowserSetup(result)}
+`),
+            () => void 0
+          );
+        }
+      }
+      return code;
     }
     case "logout": {
-      const { runLogout } = await import("./login-6U7QS7EA.js");
+      const { runLogout } = await import("@datalabrotterdam/nova-ai-agent/commands/login.js");
       return runLogout();
     }
-    case "web": {
-      const { default: runWebUi } = await import("./webui-L4GGMXJ3.js");
-      await runWebUi();
-      return 0;
-    }
     case "tui": {
       let options;
       try {
@@ -147,7 +185,7 @@ ${MAIN_HELP}
         );
         return 2;
       }
-      const { default: runChat } = await import("./tui-XOKXPXN2.js");
+      const { default: runChat } = await import("./tui-TJFV6NC6.js");
       return runChat(options);
     }
   }