nolo-cli 0.8.0 → 0.9.0

package/chunk-GAKEBQD6.js

@@ -0,0 +1,30 @@
+// packages/core/retryAfterMs.ts
+function normalizeNonNegativeMs(value, fallbackMs) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed >= 0 ? Math.round(parsed) : Math.round(Number(fallbackMs)) || 0;
+}
+function parseRetryAfterHeaderMs(value, nowMs = Date.now()) {
+  if (typeof value !== "string" || !value.trim()) return null;
+  const trimmed = value.trim();
+  const seconds = Number(trimmed);
+  if (Number.isFinite(seconds)) {
+    if (seconds < 0) return null;
+    return Math.round(seconds * 1e3);
+  }
+  const parsedDateMs = Date.parse(trimmed);
+  if (Number.isFinite(parsedDateMs)) {
+    return Math.max(0, parsedDateMs - nowMs);
+  }
+  return null;
+}
+
+// packages/core/gatewayHttpStatus.ts
+function isGatewayHttpStatus(status) {
+  return status === 502 || status === 503 || status === 504;
+}
+
+export {
+  normalizeNonNegativeMs,
+  parseRetryAfterHeaderMs,
+  isGatewayHttpStatus
+};

package/chunk-GBRG75BQ.js

@@ -0,0 +1,86 @@
+import {
+  asOptionalPositiveFiniteNumber
+} from "./chunk-U6VC4MU4.js";
+
+// packages/database/tombstones.ts
+var TOMBSTONE_DETAIL_RETENTION_MS = 90 * 24 * 60 * 60 * 1e3;
+var isRecord = (value) => value !== null && typeof value === "object";
+var readRecord = (value) => isRecord(value) ? value : null;
+var parseTimestamp = (value) => {
+  const asNumber = asOptionalPositiveFiniteNumber(value);
+  if (asNumber !== void 0) return asNumber;
+  if (typeof value === "string" && value.trim()) {
+    return asOptionalPositiveFiniteNumber(Date.parse(value)) ?? 0;
+  }
+  return 0;
+};
+var getRecordTimestamp = (record) => {
+  const value = readRecord(record);
+  if (!value) return 0;
+  const candidates = [
+    value.updatedAt,
+    value.updated_at,
+    value.createdAt,
+    value.created,
+    isRecord(value.meta) ? value.meta.createdAt : void 0
+  ];
+  for (const candidate of candidates) {
+    const timestamp = parseTimestamp(candidate);
+    if (timestamp > 0) return timestamp;
+  }
+  return 0;
+};
+var getTombstoneTimestamp = (record) => {
+  const value = readRecord(record);
+  if (!value) return 0;
+  return parseTimestamp(value.deletedAt) || getRecordTimestamp(value);
+};
+var getRestoreTimestamp = (record) => {
+  const value = readRecord(record);
+  if (!value) return 0;
+  return parseTimestamp(value.restoredAt);
+};
+var isTombstoneRecord = (record) => {
+  const value = readRecord(record);
+  if (!value) return false;
+  const deletedAt = value.deletedAt;
+  if (typeof deletedAt === "string") return deletedAt.trim().length > 0;
+  return Boolean(deletedAt);
+};
+var isRestoredAfterTombstone = (activeRecord, tombstoneRecord) => {
+  if (isTombstoneRecord(activeRecord) || !isTombstoneRecord(tombstoneRecord)) {
+    return false;
+  }
+  const restoreTs = getRestoreTimestamp(activeRecord);
+  const tombstoneTs = getTombstoneTimestamp(tombstoneRecord);
+  return restoreTs > 0 && tombstoneTs > 0 && restoreTs > tombstoneTs;
+};
+var shouldReplaceWithNextRecord = (nextRecord, currentRecord) => {
+  const nextIsTombstone = isTombstoneRecord(nextRecord);
+  const currentIsTombstone = isTombstoneRecord(currentRecord);
+  if (currentIsTombstone && !nextIsTombstone) {
+    return isRestoredAfterTombstone(nextRecord, currentRecord);
+  }
+  if (nextIsTombstone && !currentIsTombstone) {
+    return !isRestoredAfterTombstone(currentRecord, nextRecord);
+  }
+  const nextTs = nextIsTombstone ? getTombstoneTimestamp(nextRecord) : getRecordTimestamp(nextRecord);
+  const currentTs = currentIsTombstone ? getTombstoneTimestamp(currentRecord) : getRecordTimestamp(currentRecord);
+  if (nextTs !== currentTs) return nextTs > currentTs;
+  return nextIsTombstone && !currentIsTombstone;
+};
+var buildTombstoneRecord = (record, nowIso) => {
+  const { restoredAt: _restoredAt, ...baseRecord } = record;
+  return {
+    ...baseRecord,
+    deletedAt: nowIso,
+    updatedAt: nowIso
+  };
+};
+
+export {
+  getRecordTimestamp,
+  isTombstoneRecord,
+  shouldReplaceWithNextRecord,
+  buildTombstoneRecord
+};

package/chunk-GG4AJPSR.js

@@ -0,0 +1,191 @@
+import {
+  listUserRecordsFromServers,
+  readLiveDbRecordAfterTombstoneMerge
+} from "./chunk-WKM6FH35.js";
+import {
+  agentRecordHasConfiguredCredential
+} from "./chunk-7OOXPE3N.js";
+
+// packages/cli/agentListHelpers.ts
+function parseAgentRecordId(privateKey, explicitId) {
+  if (explicitId) return explicitId;
+  const agentMatch = privateKey.match(/^agent-[^-]+-(.+)$/i);
+  return agentMatch?.[1] ?? "";
+}
+function buildCompanionKeys(rawId, userId) {
+  return {
+    privateKey: `agent-${userId}-${rawId}`,
+    publicKey: `agent-pub-${rawId}`
+  };
+}
+function normalizeListedAgent(record) {
+  const privateKey = typeof record?.dbKey === "string" ? record.dbKey : "";
+  const explicitId = typeof record?.id === "string" && record.id ? record.id : void 0;
+  const ownerUserId = typeof record?.userId === "string" ? record.userId : "";
+  const rawId = explicitId || (ownerUserId && privateKey.startsWith(`agent-${ownerUserId}-`) ? privateKey.slice(`agent-${ownerUserId}-`.length) : parseAgentRecordId(privateKey, explicitId));
+  if (!privateKey || !rawId || !ownerUserId) return null;
+  const keys = buildCompanionKeys(rawId, ownerUserId);
+  const credentialConfigured = agentRecordHasConfiguredCredential(record);
+  const credentialRef = typeof record?.credentialRef === "string" && record.credentialRef ? record.credentialRef : void 0;
+  const apiKeyRef = typeof record?.apiKeyRef === "string" && record.apiKeyRef ? record.apiKeyRef : void 0;
+  return {
+    id: rawId,
+    privateKey,
+    publicKey: keys.publicKey,
+    name: typeof record?.name === "string" && record.name ? record.name : "(unnamed)",
+    model: typeof record?.model === "string" && record.model ? record.model : "-",
+    updatedAt: typeof record?.updatedAt === "string" || typeof record?.updatedAt === "number" ? record.updatedAt : typeof record?.createdAt === "string" || typeof record?.createdAt === "number" ? record.createdAt : typeof record?.created === "string" || typeof record?.created === "number" ? record.created : null,
+    isPublicFlag: !!record?.isPublic,
+    publicRecordExists: false,
+    type: typeof record?.type === "string" ? record.type : null,
+    tools: Array.isArray(record?.tools) ? record.tools.filter((tool) => typeof tool === "string") : [],
+    credentialConfigured,
+    credentialRef,
+    apiKeyRef,
+    ...typeof record?.apiSource === "string" && record.apiSource ? { apiSource: record.apiSource } : {},
+    ...typeof record?.cliProvider === "string" && record.cliProvider ? { cliProvider: record.cliProvider } : {}
+  };
+}
+function sortListedAgents(agents) {
+  agents.sort((a, b) => {
+    const ta = a.updatedAt == null ? 0 : new Date(a.updatedAt).getTime();
+    const tb = b.updatedAt == null ? 0 : new Date(b.updatedAt).getTime();
+    return tb - ta;
+  });
+  return agents;
+}
+function parseAgentListArgs(args) {
+  return {
+    wantJson: args.includes("--json"),
+    publicOnly: args.includes("--public-only"),
+    idsOnly: args.includes("--ids-only")
+  };
+}
+async function listLocalCachedAgents(args) {
+  const privateRecords = /* @__PURE__ */ new Map();
+  const publicKeys = /* @__PURE__ */ new Set();
+  for await (const [key, value] of args.db.iterator({ gte: "", lte: "\uFFFF" })) {
+    if (typeof key !== "string" || !value || typeof value !== "object") continue;
+    if (key.startsWith(`agent-${args.userId}-`)) {
+      privateRecords.set(key, { ...value, dbKey: key });
+      continue;
+    }
+    if (key.startsWith("agent-pub-")) {
+      publicKeys.add(key);
+    }
+  }
+  const agents = sortListedAgents(
+    [...privateRecords.values()].map((record) => normalizeListedAgent(record)).filter((agent) => agent != null)
+  );
+  for (const agent of agents) {
+    agent.publicRecordExists = publicKeys.has(agent.publicKey);
+  }
+  return agents;
+}
+async function hasReadableRecord(args) {
+  try {
+    await args.readDbRecord(args);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function listRemoteAgents(args) {
+  const recordGroups = [await args.queryUserRecords({ ...args, type: "agent" })];
+  const agents = sortListedAgents(
+    recordGroups.flat().map((record) => normalizeListedAgent(record)).filter((agent) => agent != null)
+  );
+  await Promise.all(
+    agents.map(async (agent) => {
+      agent.publicRecordExists = await hasReadableRecord({
+        authToken: args.authToken,
+        dbKey: agent.publicKey,
+        fallbackFetchImpl: args.fallbackFetchImpl,
+        fetchImpl: args.fetchImpl,
+        serverUrl: args.serverUrl,
+        readDbRecord: args.readDbRecord
+      });
+    })
+  );
+  return agents;
+}
+async function listRemoteAgentsAcrossServers(args) {
+  const remoteResult = await listUserRecordsFromServers({
+    authToken: args.authToken,
+    fallbackFetchImpl: args.fallbackFetchImpl,
+    fetchImpl: args.fetchImpl,
+    label: "agent query",
+    serverUrls: args.serverUrls,
+    type: "agent",
+    userId: args.userId
+  });
+  const agents = sortListedAgents(
+    remoteResult.records.map((record) => normalizeListedAgent(record)).filter((agent) => agent != null)
+  );
+  return { agents, failures: remoteResult.failures };
+}
+async function listFavoriteAgentIdsAcrossServers(args) {
+  const favoritedAtByKey = {};
+  await Promise.all(
+    args.serverUrls.map(async (serverUrl) => {
+      try {
+        const res = await args.fetchImpl(`${serverUrl}/rpc/listFavorites`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${args.authToken}`
+          },
+          body: JSON.stringify({ targetType: "agent" })
+        });
+        if (!res.ok) return;
+        const data = await res.json().catch(() => ({}));
+        const items = Array.isArray(data?.items) ? data.items : [];
+        for (const item of items) {
+          const id = typeof item?.id === "string" ? item.id : "";
+          if (!id) continue;
+          const at = Number(item?.favoritedAt) || 0;
+          favoritedAtByKey[id] = Math.max(
+            favoritedAtByKey[id] ?? 0,
+            at || Date.now()
+          );
+        }
+        const ids = Array.isArray(data?.ids) ? data.ids : [];
+        for (const id of ids) {
+          if (typeof id === "string" && id && !(id in favoritedAtByKey)) {
+            favoritedAtByKey[id] = 1;
+          }
+        }
+      } catch {
+      }
+    })
+  );
+  return favoritedAtByKey;
+}
+async function decorateAgentsWithPublicStatusAcrossServers(args) {
+  await Promise.all(
+    args.agents.map(async (agent) => {
+      try {
+        const result = await readLiveDbRecordAfterTombstoneMerge({
+          authToken: args.authToken,
+          dbKey: agent.publicKey,
+          fallbackFetchImpl: args.fallbackFetchImpl,
+          fetchImpl: args.fetchImpl,
+          serverUrls: args.serverUrls
+        });
+        agent.publicRecordExists = result.record?.isPublic === true;
+      } catch {
+        agent.publicRecordExists = false;
+      }
+    })
+  );
+  return args.agents;
+}
+
+export {
+  parseAgentListArgs,
+  listLocalCachedAgents,
+  listRemoteAgents,
+  listRemoteAgentsAcrossServers,
+  listFavoriteAgentIdsAcrossServers,
+  decorateAgentsWithPublicStatusAcrossServers
+};

package/chunk-H33743XH.js

@@ -0,0 +1,25 @@
+import {
+  resolveNoloHome
+} from "./chunk-LM6IYQ3F.js";
+
+// packages/cli/localRuntimeDb.ts
+import path from "node:path";
+function resolveCliLocalRuntimeDbPath(options = {}) {
+  return path.join(resolveNoloHome(options), "data", "leveldb");
+}
+function buildCliLocalRuntimeDbEnv(env = process.env) {
+  return {
+    ...env,
+    NOLO_SERVER_DB_PATH: env.NOLO_SERVER_DB_PATH?.trim() || resolveCliLocalRuntimeDbPath({ env })
+  };
+}
+async function getDefaultCliLocalRuntimeDb(options = {}) {
+  const { getDefaultCliLocalRuntimeDb: getAuthorityBackedDb } = await import("./localRuntimeAuthority-TEGCOWX4.js");
+  return getAuthorityBackedDb(options);
+}
+
+export {
+  resolveCliLocalRuntimeDbPath,
+  buildCliLocalRuntimeDbEnv,
+  getDefaultCliLocalRuntimeDb
+};

package/chunk-HNMXYYJR.js

@@ -0,0 +1,12 @@
+// packages/core/errorMessage.ts
+function toErrorMessage(error) {
+  if (error instanceof Error) return error.message;
+  if (error !== null && typeof error === "object" && "message" in error && typeof error.message === "string") {
+    return error.message;
+  }
+  return String(error);
+}
+
+export {
+  toErrorMessage
+};

package/chunk-I42VC5KR.js

@@ -0,0 +1,15 @@
+// packages/core/stringArray.ts
+function asNonEmptyStringArray(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter(
+    (item) => typeof item === "string" && !!item.trim()
+  );
+}
+function asTrimmedNonEmptyStringArray(value) {
+  return asNonEmptyStringArray(value).map((item) => item.trim());
+}
+
+export {
+  asNonEmptyStringArray,
+  asTrimmedNonEmptyStringArray
+};

package/chunk-IDZTNRP2.js

@@ -0,0 +1,85 @@
+// packages/cli/processSpawn.ts
+import { spawn } from "node:child_process";
+function spawnProcess(options) {
+  let [command, ...args] = options.cmd;
+  if (process.platform === "win32") {
+    const lower = command.toLowerCase();
+    if ((lower === "npm" || lower === "npx" || lower === "pnpm" || lower === "yarn" || lower === "nolo") && !lower.endsWith(".cmd") && !lower.endsWith(".exe") && !lower.endsWith(".bat")) {
+      command = `${command}.cmd`;
+    }
+  }
+  let child;
+  try {
+    child = spawn(command, args, {
+      cwd: options.cwd,
+      env: options.env,
+      stdio: [
+        options.stdin ?? "pipe",
+        options.stdout ?? "pipe",
+        options.stderr ?? "pipe"
+      ]
+    });
+  } catch {
+    return {
+      exited: Promise.resolve(127),
+      stdin: null,
+      stdout: null,
+      stderr: null
+    };
+  }
+  const exited = new Promise((resolve) => {
+    child.on("exit", (code) => resolve(code ?? 1));
+    child.on("error", () => resolve(127));
+  });
+  return {
+    exited,
+    stdin: child.stdin,
+    stdout: child.stdout,
+    stderr: child.stderr
+  };
+}
+async function readPipeText(stream) {
+  if (!stream) return "";
+  const anyStream = stream;
+  if (typeof anyStream.setEncoding !== "function" && typeof anyStream[Symbol.asyncIterator] === "function") {
+    const chunks = [];
+    for await (const chunk of anyStream) {
+      if (typeof chunk === "string") chunks.push(chunk);
+      else if (chunk instanceof Uint8Array) chunks.push(Buffer.from(chunk).toString("utf8"));
+      else if (Buffer.isBuffer(chunk)) chunks.push(chunk.toString("utf8"));
+      else chunks.push(String(chunk ?? ""));
+    }
+    return chunks.join("");
+  }
+  return new Promise((resolve) => {
+    let data = "";
+    let done = false;
+    const finish = () => {
+      if (done) return;
+      done = true;
+      resolve(data);
+    };
+    if (typeof anyStream.setEncoding === "function") {
+      anyStream.setEncoding("utf8");
+    }
+    stream.on("data", (chunk) => {
+      data += typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8");
+    });
+    stream.on("end", finish);
+    stream.on("close", finish);
+    stream.on("error", finish);
+  });
+}
+function resolveDefaultSpawn() {
+  const bunSpawn = globalThis.Bun?.spawn;
+  if (typeof bunSpawn === "function") {
+    return bunSpawn;
+  }
+  return spawnProcess;
+}
+
+export {
+  spawnProcess,
+  readPipeText,
+  resolveDefaultSpawn
+};

package/chunk-ISNCLGUZ.js

@@ -0,0 +1,146 @@
+import {
+  DEFAULT_NOLO_SERVER_URL
+} from "./chunk-OLZBQWZU.js";
+import {
+  DEFAULT_LOCAL_API_ORIGIN
+} from "./chunk-4SN6J65J.js";
+import {
+  NOLO_CLUSTER_SERVERS
+} from "./chunk-LCBAMY2M.js";
+import {
+  normalizeServerOrigin
+} from "./chunk-CF7PE763.js";
+import {
+  asOptionalTrimmedString
+} from "./chunk-G3SUCT4W.js";
+
+// packages/cli/cliEnvHelpers.ts
+import { dirname, extname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+function resolveServerUrlFromEnv(env) {
+  return normalizeServerOrigin(
+    env.NOLO_SERVER || env.BASE_URL || DEFAULT_NOLO_SERVER_URL
+  );
+}
+function isCliArgs(value) {
+  return Array.isArray(value);
+}
+function buildServerCandidates(values) {
+  return [...new Set(
+    values.filter((value) => typeof value === "string" && value.trim().length > 0).map((value) => normalizeServerOrigin(value))
+  )];
+}
+function resolveServerUrl(input, env) {
+  if (isCliArgs(input)) {
+    const explicit = readOption(input, "--server-url") || readOption(input, "--server");
+    return normalizeServerOrigin(explicit) || resolveServerUrlFromEnv(env ?? {});
+  }
+  return resolveServerUrlFromEnv(input);
+}
+function resolveServerCandidates(input, envOrPreferred, preferred) {
+  if (isCliArgs(input)) {
+    const env2 = envOrPreferred ?? {};
+    const explicitServer = resolveServerUrl(input, env2);
+    return buildServerCandidates([
+      explicitServer,
+      preferred?.trim(),
+      env2.NOLO_SERVER,
+      env2.BASE_URL,
+      env2.NOLO_SERVER_URL,
+      DEFAULT_NOLO_SERVER_URL,
+      ...NOLO_CLUSTER_SERVERS
+    ]);
+  }
+  const env = input;
+  return buildServerCandidates([
+    asOptionalTrimmedString(envOrPreferred),
+    env.NOLO_SERVER,
+    env.BASE_URL,
+    env.NOLO_SERVER_URL,
+    DEFAULT_NOLO_SERVER_URL,
+    ...NOLO_CLUSTER_SERVERS
+  ]);
+}
+function resolveDeleteServerCandidatesFromEnv(env, ...preferredValues) {
+  return buildServerCandidates([
+    ...preferredValues,
+    env.NOLO_SERVER,
+    env.BASE_URL,
+    env.NOLO_SERVER_URL,
+    env.READ_DIALOG_BASE,
+    DEFAULT_NOLO_SERVER_URL,
+    ...NOLO_CLUSTER_SERVERS,
+    DEFAULT_LOCAL_API_ORIGIN
+  ]);
+}
+function resolveDeleteServerCandidates(input, envOrPreferred, preferred) {
+  if (isCliArgs(input)) {
+    const env2 = envOrPreferred ?? {};
+    const explicitServer = resolveServerUrl(input, env2);
+    return resolveDeleteServerCandidatesFromEnv(env2, explicitServer, preferred?.trim());
+  }
+  const env = input;
+  return resolveDeleteServerCandidatesFromEnv(
+    env,
+    asOptionalTrimmedString(envOrPreferred)
+  );
+}
+function resolveAuthTokenFromEnv(env, extraEnvKeys = []) {
+  for (const key of ["AUTH_TOKEN", "AUTH", ...extraEnvKeys]) {
+    const value = env[key];
+    if (typeof value === "string" && value.trim()) return value;
+  }
+  return "";
+}
+function resolveAuthToken(input, envOrExtraEnvKeys, extraEnvKeys = []) {
+  if (isCliArgs(input)) {
+    const env = envOrExtraEnvKeys ?? {};
+    return readOption(input, "--token") || readOption(input, "--machine-key") || resolveAuthTokenFromEnv(env, extraEnvKeys);
+  }
+  return resolveAuthTokenFromEnv(input, envOrExtraEnvKeys ?? []);
+}
+function parseUserIdFromAuthToken(token) {
+  const parts = token.trim().split(".").filter(Boolean);
+  const payloadCandidates = parts.length >= 3 ? [parts[1], parts[0]] : [parts[0]];
+  for (const payload of payloadCandidates) {
+    if (!payload) continue;
+    try {
+      const parsed = JSON.parse(Buffer.from(payload, "base64").toString("utf8"));
+      if (typeof parsed?.userId === "string") return parsed.userId;
+    } catch {
+    }
+  }
+  return "";
+}
+function readOption(args, flag) {
+  const index = args.indexOf(flag);
+  return index >= 0 ? args[index + 1] : void 0;
+}
+function isCompiledBinary() {
+  try {
+    const url = import.meta.url;
+    return url.startsWith("file:///$bunfs/root/") || url.startsWith("/$bunfs/root/");
+  } catch {
+    return false;
+  }
+}
+function resolveCliEntrypointPath(fromModuleUrl = import.meta.url) {
+  if (isCompiledBinary()) {
+    return process.execPath;
+  }
+  const sourcePath = fileURLToPath(fromModuleUrl);
+  const ext = extname(sourcePath) || ".ts";
+  return join(dirname(sourcePath), "..", `index${ext}`);
+}
+
+export {
+  resolveServerUrl,
+  resolveServerCandidates,
+  resolveDeleteServerCandidates,
+  resolveAuthTokenFromEnv,
+  resolveAuthToken,
+  parseUserIdFromAuthToken,
+  readOption,
+  isCompiledBinary,
+  resolveCliEntrypointPath
+};