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

package/dist/chunk-JAEXUFAS.js

@@ -0,0 +1,451 @@
+// src/core/nova-home.ts
+import { createHash, randomUUID } from "crypto";
+import {
+  mkdirSync,
+  readFileSync,
+  realpathSync,
+  renameSync,
+  rmSync,
+  writeFileSync
+} from "fs";
+import { homedir } from "os";
+import { basename, dirname, join, posix, resolve, win32 } from "path";
+var DIR_MODE = 448;
+var FILE_MODE = 384;
+var SLUG_MAX_LENGTH = 40;
+function novaHomeRoot() {
+  return process.env.NOVA_AI_HOME?.trim() || join(homedir(), ".nova-ai");
+}
+function projectsDir() {
+  return join(novaHomeRoot(), "projects");
+}
+function projectPaths(cwd) {
+  const key = workspaceKey(cwd);
+  const dir2 = join(projectsDir(), key);
+  return {
+    key,
+    dir: dir2,
+    info: join(dir2, "project.json"),
+    settings: join(dir2, "settings.json"),
+    cliSessions: join(dir2, "cli-sessions")
+  };
+}
+function ensureProject(cwd) {
+  const paths = projectPaths(cwd);
+  mkdirSync(paths.dir, { recursive: true, mode: DIR_MODE });
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const workspacePath = resolve(cwd);
+  let info = {
+    path: workspacePath,
+    name: basename(workspacePath),
+    createdAt: now,
+    lastOpenedAt: now
+  };
+  try {
+    const existing = JSON.parse(readFileSync(paths.info, "utf8"));
+    if (existing && typeof existing === "object" && !Array.isArray(existing)) {
+      info = { ...existing, path: workspacePath, lastOpenedAt: now };
+    }
+  } catch {
+  }
+  try {
+    writeFileSync(paths.info, `${JSON.stringify(info, null, 2)}
+`, {
+      mode: FILE_MODE
+    });
+  } catch {
+  }
+  return paths;
+}
+function workspaceKey(cwd, platform = process.platform) {
+  const slug = slugify(basename(resolve(cwd))) || "workspace";
+  const hash = createHash("sha256").update(normalizeWorkspacePath(cwd, platform)).digest("hex").slice(0, 8);
+  return `${slug}-${hash}`;
+}
+function normalizeWorkspacePath(cwd, platform = process.platform) {
+  let resolved = resolve(cwd);
+  try {
+    resolved = realpathSync(resolved);
+  } catch {
+  }
+  const pathApi = platform === "win32" ? win32 : posix;
+  let normalized = pathApi.normalize(resolved);
+  while (normalized.length > 1 && /[\\/]$/.test(normalized) && !/^[a-zA-Z]:\\$/.test(normalized)) {
+    normalized = normalized.slice(0, -1);
+  }
+  return platform === "win32" || platform === "darwin" ? normalized.toLowerCase() : normalized;
+}
+function slugify(name) {
+  return name.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/-{2,}/g, "-").replace(/^[-.]+|[-.]+$/g, "").slice(0, SLUG_MAX_LENGTH).replace(/[-.]+$/g, "");
+}
+function isWorkspaceTrusted(cwd) {
+  try {
+    const info = JSON.parse(readFileSync(projectPaths(cwd).info, "utf8"));
+    return info?.trusted === true;
+  } catch {
+    return false;
+  }
+}
+function setWorkspaceTrusted(cwd, trusted) {
+  const paths = ensureProject(cwd);
+  const info = JSON.parse(readFileSync(paths.info, "utf8"));
+  writePrivateFile(paths.info, `${JSON.stringify({ ...info, trusted }, null, 2)}
+`);
+}
+function writePrivateFile(path, content) {
+  const dir2 = dirname(path);
+  mkdirSync(dir2, { recursive: true, mode: DIR_MODE });
+  const temp = join(dir2, `.${basename(path)}.${process.pid}.${randomUUID()}.tmp`);
+  try {
+    writeFileSync(temp, content, { encoding: "utf8", flag: "wx", mode: FILE_MODE });
+    renameSync(temp, path);
+  } catch (error) {
+    rmSync(temp, { force: true });
+    throw error;
+  }
+}
+
+// src/core/credentials.ts
+import {
+  chmodSync,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync2,
+  renameSync as renameSync2,
+  rmSync as rmSync2,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { dirname as dirname2, join as join2 } from "path";
+var DIR_MODE2 = 448;
+var FILE_MODE2 = 384;
+function credentialsPath() {
+  return join2(novaHomeRoot(), "credentials.json");
+}
+function readCredentials() {
+  const envApiKey = process.env.NOVA_API_KEY;
+  if (envApiKey) {
+    return { apiKey: envApiKey, defaultModel: process.env.NOVA_MODEL };
+  }
+  return readStoredCredentials();
+}
+function readStoredCredentials() {
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync2(credentialsPath(), "utf8"));
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return null;
+  }
+  const { apiKey, defaultModel } = parsed;
+  if (typeof apiKey !== "string" || !apiKey.trim()) return null;
+  return {
+    apiKey,
+    defaultModel: typeof defaultModel === "string" && defaultModel ? defaultModel : void 0
+  };
+}
+function writeCredentials(credentials) {
+  const path = credentialsPath();
+  const dir2 = dirname2(path);
+  mkdirSync2(dir2, { recursive: true, mode: DIR_MODE2 });
+  chmodSync(dir2, DIR_MODE2);
+  const temp = `${path}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    writeFileSync2(temp, `${JSON.stringify(credentials, null, 2)}
+`, {
+      mode: FILE_MODE2
+    });
+    chmodSync(temp, FILE_MODE2);
+    renameSync2(temp, path);
+  } catch (error) {
+    rmSync2(temp, { force: true });
+    throw error;
+  }
+  chmodSync(path, FILE_MODE2);
+}
+function saveDefaultModel(model) {
+  const stored = readStoredCredentials();
+  if (!stored) return false;
+  writeCredentials({ ...stored, defaultModel: model });
+  return true;
+}
+function deleteCredentials() {
+  try {
+    rmSync2(credentialsPath());
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT") return false;
+    throw error;
+  }
+}
+
+// src/acp/auth-server.ts
+import { spawn } from "child_process";
+import { randomBytes, timingSafeEqual } from "crypto";
+import { existsSync } from "fs";
+import { dirname as dirname3, join as join3 } from "path";
+import { fileURLToPath } from "url";
+import { NovaAIError } from "@datalabrotterdam/nova-sdk";
+
+// src/core/model-capabilities.ts
+var IMAGE_INPUT_CAPABILITIES = /* @__PURE__ */ new Set([
+  "image",
+  "images",
+  "image_input",
+  "input_image",
+  "vision",
+  "multimodal",
+  "multimodal_input"
+]);
+var TOOL_CALL_CAPABILITIES = /* @__PURE__ */ new Set([
+  "function_calling",
+  "functions",
+  "tools",
+  "tool_calling",
+  "tool_calls",
+  "tool_use"
+]);
+var TEXT_CAPABILITIES = /* @__PURE__ */ new Set([
+  "text",
+  "chat",
+  "completion",
+  "completions",
+  "chat_completion",
+  "chat_completions",
+  ...TOOL_CALL_CAPABILITIES
+]);
+function modelSupportsToolCalls(model) {
+  return (model?.capabilities ?? []).some(
+    (capability) => TOOL_CALL_CAPABILITIES.has(normalizeCapability(capability))
+  );
+}
+function isChatModel(model) {
+  const capabilities = model?.capabilities;
+  if (!Array.isArray(capabilities) || capabilities.length === 0) return true;
+  return capabilities.some(
+    (capability) => TEXT_CAPABILITIES.has(normalizeCapability(capability))
+  );
+}
+function chatModels(models) {
+  return models.filter((model) => model.enabled !== false && isChatModel(model));
+}
+function chooseDefaultModel(models) {
+  const usable = chatModels(models);
+  return (usable.find(modelSupportsToolCalls) ?? usable[0])?.id;
+}
+function resolveDefaultModel(models, preferred) {
+  if (preferred) {
+    const known = findModelMetadata(models, preferred);
+    if (!known || known.enabled !== false && isChatModel(known)) return preferred;
+  }
+  return chooseDefaultModel(models) ?? preferred ?? void 0;
+}
+function modelSupportsImageInput(model) {
+  return (model?.capabilities ?? []).some(
+    (capability) => IMAGE_INPUT_CAPABILITIES.has(normalizeCapability(capability))
+  );
+}
+function findModelMetadata(models, modelId) {
+  return models.find(
+    (model) => model.id === modelId || model.aliases?.includes(modelId)
+  );
+}
+async function resolveModelMetadata(client, modelId) {
+  let after;
+  do {
+    const response = await client.models.list({
+      limit: 100,
+      ...after ? { after } : {}
+    });
+    const model = findModelMetadata(response.data, modelId);
+    if (model) return model;
+    if (!response.has_more || !response.last_id || response.last_id === after) {
+      return void 0;
+    }
+    after = response.last_id;
+  } while (true);
+}
+async function resolveModelSupportsImageInput(client, modelId) {
+  return modelSupportsImageInput(await resolveModelMetadata(client, modelId));
+}
+function normalizeCapability(value) {
+  return value.trim().toLowerCase().replace(/[\s:-]+/g, "_");
+}
+
+// src/core/nova-client.ts
+import { NovaAI } from "@datalabrotterdam/nova-sdk";
+function createNovaClient(apiKey) {
+  const baseUrl = process.env.NOVA_BASE_URL?.trim();
+  return new NovaAI({ apiKey, ...baseUrl ? { baseUrl } : {} });
+}
+
+// src/acp/auth-server.ts
+import { dir, json, WebServer } from "@sourceregistry/node-webserver";
+var AUTH_TIMEOUT_MS = 5 * 60 * 1e3;
+var HOST = "127.0.0.1";
+var SETUP_TOKEN_HEADER = "x-nova-setup-token";
+function resolveUiDir() {
+  const moduleDir = dirname3(fileURLToPath(import.meta.url));
+  const candidates = [
+    // Running from src/acp/auth-server.ts via tsx.
+    join3(moduleDir, "web", "dist"),
+    // Running from the bundled package entry in dist/index.js.
+    join3(moduleDir, "..", "src", "acp", "web", "dist")
+  ];
+  const uiDir = candidates.find((candidate) => existsSync(candidate));
+  if (!uiDir) {
+    throw new Error(
+      `Nova AI setup UI is missing. Expected it at one of: ${candidates.join(", ")}. Run npm run build before using --setup from a source checkout.`
+    );
+  }
+  return uiDir;
+}
+function openBrowser(url) {
+  const [command, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["rundll32", ["url.dll,FileProtocolHandler", url]] : ["xdg-open", [url]];
+  try {
+    spawn(command, args, { stdio: "ignore", detached: true }).on("error", () => {
+    }).unref();
+  } catch {
+  }
+}
+async function validateApiKey(apiKey) {
+  const client = createNovaClient(apiKey);
+  const { data: models } = await client.models.list({ limit: 100 });
+  return { apiKey, defaultModel: chooseDefaultModel(models) };
+}
+function startAuthServer(options = {}) {
+  const uiDir = options.uiDir ?? resolveUiDir();
+  const validate = options.validateApiKey ?? validateApiKey;
+  const store = options.writeCredentials ?? writeCredentials;
+  const token = randomBytes(32).toString("base64url");
+  const expectedToken = Buffer.from(token);
+  let resolveDone;
+  let rejectDone;
+  const done = new Promise((resolve2, reject) => {
+    resolveDone = resolve2;
+    rejectDone = reject;
+  });
+  done.catch(() => {
+  });
+  const app = new WebServer();
+  let origin = "";
+  let settled = false;
+  let timeout;
+  const settle = (error) => {
+    if (settled) return;
+    settled = true;
+    clearTimeout(timeout);
+    const shutdown = app.shutdown().catch(() => {
+    });
+    if (error) void shutdown.then(() => rejectDone(error));
+    else void shutdown.then(resolveDone);
+  };
+  app.POST("/api/authenticate", async (event) => {
+    const rejection = rejectUntrustedRequest(
+      event.request,
+      origin,
+      expectedToken
+    );
+    if (rejection) return rejection;
+    if (settled) {
+      return json({ message: "Setup already finished." }, { status: 409 });
+    }
+    const body = await event.request.json().catch(() => null);
+    const apiKey = typeof body?.apiKey === "string" ? body.apiKey.trim() : "";
+    if (!apiKey) {
+      return json({ message: "API key is required." }, { status: 400 });
+    }
+    try {
+      store(await validate(apiKey));
+    } catch (err) {
+      const message = err instanceof NovaAIError ? `Nova AI rejected this key (status ${err.status}): ${err.message}` : "Unexpected error validating the key.";
+      return json({ message }, { status: 401 });
+    }
+    setImmediate(() => settle());
+    return json({ ok: true });
+  });
+  app.GET("/", dir(uiDir, { spa: true }));
+  app.GET("/[...path]", dir(uiDir, { spa: true }));
+  return new Promise((resolve2, reject) => {
+    app.listen(0, HOST, () => {
+      const address = app.address();
+      if (typeof address !== "object" || !address) {
+        void app.shutdown().catch(() => {
+        });
+        reject(new Error("Nova AI setup server failed to bind."));
+        return;
+      }
+      origin = `http://${HOST}:${address.port}`;
+      timeout = setTimeout(
+        () => settle(
+          new Error("Nova AI authentication timed out after 5 minutes.")
+        ),
+        options.timeoutMs ?? AUTH_TIMEOUT_MS
+      );
+      resolve2({
+        url: `${origin}/#token=${token}`,
+        origin,
+        token,
+        done,
+        close: async () => {
+          settle(new Error("Nova AI authentication was cancelled."));
+          await done.catch(() => {
+          });
+        }
+      });
+    });
+  });
+}
+function rejectUntrustedRequest(request, origin, expectedToken) {
+  const forbidden = () => json(
+    {
+      message: "Request not allowed. Open the setup link printed by nova-ai-cli."
+    },
+    { status: 403 }
+  );
+  if (!origin || request.headers.get("host") !== new URL(origin).host) {
+    return forbidden();
+  }
+  const requestOrigin = request.headers.get("origin");
+  if (requestOrigin !== null && requestOrigin !== origin) return forbidden();
+  const contentType = request.headers.get("content-type") ?? "";
+  if (contentType.split(";")[0].trim().toLowerCase() !== "application/json") {
+    return json(
+      { message: "Content-Type must be application/json." },
+      { status: 415 }
+    );
+  }
+  const provided = Buffer.from(request.headers.get(SETUP_TOKEN_HEADER) ?? "");
+  if (provided.length !== expectedToken.length || !timingSafeEqual(provided, expectedToken)) {
+    return forbidden();
+  }
+  return null;
+}
+async function runBrowserAuth() {
+  const server = await startAuthServer();
+  console.error(`Opening browser to authenticate with Nova AI: ${server.url}`);
+  openBrowser(server.url);
+  await server.done;
+}
+
+export {
+  createNovaClient,
+  novaHomeRoot,
+  projectsDir,
+  projectPaths,
+  ensureProject,
+  isWorkspaceTrusted,
+  setWorkspaceTrusted,
+  writePrivateFile,
+  chatModels,
+  resolveDefaultModel,
+  resolveModelMetadata,
+  resolveModelSupportsImageInput,
+  credentialsPath,
+  readCredentials,
+  writeCredentials,
+  saveDefaultModel,
+  deleteCredentials,
+  validateApiKey,
+  runBrowserAuth
+};

package/dist/chunk-Q7WL3DXP.js

@@ -0,0 +1,19 @@
+// src/core/version.ts
+import { createRequire } from "module";
+function readPackageVersion() {
+  const require2 = createRequire(import.meta.url);
+  for (const path of ["../package.json", "../../package.json", "../../../package.json"]) {
+    try {
+      const metadata = require2(path);
+      if (metadata && typeof metadata === "object" && metadata.name === "@datalabrotterdam/nova-ai-cli" && typeof metadata.version === "string") {
+        return metadata.version;
+      }
+    } catch {
+    }
+  }
+  return process.env.npm_package_version ?? null;
+}
+
+export {
+  readPackageVersion
+};