nolo-cli 0.8.0-alpha.2 → 0.8.0-alpha.20

package/chunk-63W5N6P3.js

@@ -0,0 +1,150 @@
+// packages/create/editor/transforms/slateToRenderMarkdown.ts
+function renderTextNode(node) {
+  if (!node || typeof node.text !== "string") return "";
+  let text = node.text;
+  if (!text) return "";
+  if (node.bold) text = `**${text}**`;
+  if (node.italic) text = `*${text}*`;
+  if (node.strikethrough) text = `~~${text}~~`;
+  return text;
+}
+function renderPlainText(node, options = {}) {
+  if (!node) return "";
+  if (typeof node.text === "string") return renderTextNode(node);
+  if (!Array.isArray(node.children)) return "";
+  return node.children.map((child) => renderPlainText(child, options)).join("");
+}
+function renderTable(node, options) {
+  const rows = Array.isArray(node.children) ? node.children : [];
+  if (rows.length === 0) return "";
+  const alignments = Array.isArray(node.columns) ? node.columns.map((column) => column?.align || "left") : [];
+  const renderedRows = rows.map(
+    (row) => (Array.isArray(row?.children) ? row.children : []).map((cell) => {
+      const content = renderPlainText(cell, options).replace(/\n+/g, " ").trim();
+      return content || " ";
+    })
+  );
+  const header = renderedRows[0] || [];
+  const divider = header.map((_, index) => {
+    const align = alignments[index];
+    if (align === "center") return ":---:";
+    if (align === "right") return "---:";
+    return "---";
+  });
+  const body = renderedRows.slice(1);
+  return [header, divider, ...body].map((cells) => `| ${cells.join(" | ")} |`).join("\n") + "\n\n";
+}
+function renderListItem(node, listDepth, ordered, start, index, options = {}) {
+  const indentation = "  ".repeat(listDepth);
+  const marker = node.checked === true ? "- [x]" : node.checked === false ? "- [ ]" : ordered ? `${start + index}.` : "-";
+  const segments = Array.isArray(node.children) ? node.children : [];
+  const renderedSegments = segments.flatMap((child) => {
+    const rendered = renderNode(child, listDepth + 1, options).trimEnd();
+    return rendered ? [rendered] : [];
+  });
+  if (renderedSegments.length === 0) {
+    return `${indentation}${marker}
+`;
+  }
+  const [first, ...rest] = renderedSegments;
+  const lines = first.split("\n");
+  const firstLine = lines.shift() || "";
+  const restFirst = lines.map((line) => `${indentation}  ${line}`).join("\n");
+  const restBlocks = rest.map((block) => `${indentation}  ${block}`).join("\n");
+  return [
+    `${indentation}${marker} ${firstLine}`,
+    restFirst,
+    restBlocks
+  ].filter(Boolean).join("\n") + "\n";
+}
+function renderNode(node, listDepth = 0, options = {}) {
+  if (!node) return "";
+  switch (node.type) {
+    case "heading-one":
+      return `# ${node.children.map((n) => renderNode(n, listDepth, options)).join("")}
+
+`;
+    case "heading-two":
+      return `## ${node.children.map((n) => renderNode(n, listDepth, options)).join("")}
+
+`;
+    case "heading-three":
+      return `### ${node.children.map((n) => renderNode(n, listDepth, options)).join("")}
+
+`;
+    case "heading-four":
+      return `#### ${node.children.map((n) => renderNode(n, listDepth, options)).join("")}
+
+`;
+    case "heading-five":
+      return `##### ${node.children.map((n) => renderNode(n, listDepth, options)).join("")}
+
+`;
+    case "heading-six":
+      return `###### ${node.children.map((n) => renderNode(n, listDepth, options)).join("")}
+
+`;
+    case "paragraph":
+      return `${node.children.map((n) => renderNode(n, listDepth, options)).join("")}
+
+`;
+    case "list":
+      return node.children.map(
+        (item, index) => renderListItem(item, listDepth, !!node.ordered, node.start || 1, index, options)
+      ).join("");
+    case "list-item":
+      return renderListItem(node, listDepth, false, 1, 0, options);
+    case "quote": {
+      const content = node.children.map((n) => renderNode(n, listDepth, options)).join("").trim();
+      return `> ${content.replace(/\n/g, "\n> ")}
+
+`;
+    }
+    case "code-block": {
+      const code = node.children.map(
+        (line) => (line.children || []).map((text) => text.text).join("")
+      ).join("\n");
+      return "```" + (node.language || "") + "\n" + code + "\n```\n\n";
+    }
+    case "link": {
+      const linkText = node.children.map((n) => renderNode(n, listDepth, options)).join("");
+      return `[${linkText}](${node.url})`;
+    }
+    case "table":
+      return renderTable(node, options);
+    case "code-inline":
+      return `\`${node.children.map((n) => renderNode(n, listDepth, options)).join("")}\``;
+    case "mention": {
+      if (options.mentionResolver) {
+        return options.mentionResolver(node);
+      }
+      const label = node.label || node.resourceId || "mention";
+      const resourceType = node.resourceType || "unknown";
+      const resourceId = node.resourceId || "unknown";
+      return `@[${resourceType}:${resourceId}|${label}]`;
+    }
+    case "image": {
+      const alt = node.alt || "";
+      const title = node.title ? ` "${node.title}"` : "";
+      return `![${alt}](${node.url || ""}${title})`;
+    }
+    case "html-inline":
+      return typeof node.html === "string" ? node.html : "";
+    case "html-block":
+      return typeof node.html === "string" ? `${node.html}
+
+` : "";
+    case "thematic-break":
+      return "---\n\n";
+    default:
+      return renderTextNode(node) || (node.children ? node.children.map((child) => renderNode(child, listDepth, options)).join("") : "");
+  }
+}
+function slateToRenderMarkdown(nodes, options = {}) {
+  if (!nodes || nodes.length === 0) return "";
+  return nodes.map((node) => renderNode(node, 0, options)).join("").trim() + "\n";
+}
+
+export {
+  slateToRenderMarkdown
+};

package/chunk-6HYVJV7B.js

@@ -0,0 +1,102 @@
+import {
+  resolveLaunchableCodexCommand
+} from "./chunk-JBTJAPUF.js";
+
+// packages/connector-experimental/machineInfo.ts
+import { existsSync as existsSync2, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { dirname, join as join2 } from "node:path";
+import { arch, hostname, homedir, platform } from "node:os";
+import { randomUUID } from "node:crypto";
+
+// packages/connector-experimental/capabilities.ts
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+var COMMAND_CAPABILITIES = [
+  [[{ command: "codex", args: ["--version"] }], ["codex-cli"]],
+  [[{ command: "claude", args: ["--version"] }], ["claude-code"]],
+  [
+    [
+      { command: "gh", args: ["--version"] },
+      { command: "gh", args: ["copilot", "--", "--help"] }
+    ],
+    ["copilot-cli"]
+  ],
+  [[{ command: "gemini", args: ["--version"] }], ["gemini-cli"]],
+  [[{ command: "kimi", args: ["--version"] }], ["kimi-cli"]],
+  [[{ command: "agy", args: ["--help"] }], ["agy-cli"]],
+  [[{ command: "qoder", args: ["--version"] }], ["qoder-cli"]],
+  [[{ command: "opencode", args: ["--version"] }], ["opencode-cli"]],
+  [[{ command: "grok", args: ["--version"] }], ["grok-cli"]]
+];
+function defaultCommandExists(command) {
+  const pathEntries = (process.env.PATH ?? "").split(process.platform === "win32" ? ";" : ":");
+  const extensions = process.platform === "win32" ? [".exe", ".cmd", ".bat", ""] : [""];
+  return pathEntries.some(
+    (entry) => extensions.some((extension) => existsSync(join(entry, `${command}${extension}`)))
+  );
+}
+function defaultCommandLaunchable(command, args) {
+  const executable = command === "codex" ? resolveLaunchableCodexCommand() : command;
+  const result = spawnSync(executable, args, {
+    stdio: "pipe",
+    timeout: 3e3,
+    windowsHide: true
+  });
+  return !result.error && result.status === 0;
+}
+function detectRuntimeCapabilities(options = {}) {
+  const commandExists = options.commandExists ?? defaultCommandExists;
+  const commandLaunchable = options.commandLaunchable ?? defaultCommandLaunchable;
+  const env = options.env ?? process.env;
+  const capabilities = [];
+  for (const [probes, detectedCapabilities] of COMMAND_CAPABILITIES) {
+    if (!probes.every((probe) => commandExists(probe.command))) continue;
+    if (options.probeLaunchable && !probes.every((probe) => commandLaunchable(probe.command, probe.args))) {
+      continue;
+    }
+    capabilities.push(...detectedCapabilities);
+  }
+  if (env.NOLO_LOCAL_LLM_ENDPOINT || env.LLAMA_SERVER_URL) {
+    capabilities.push("local-llm");
+  }
+  return capabilities;
+}
+
+// packages/connector-experimental/machineInfo.ts
+var CONNECTOR_VERSION = "0.1.0-experimental";
+function defaultMachineIdPath() {
+  return join2(homedir(), ".nolo", "machine-id");
+}
+function resolveMachineId(path = defaultMachineIdPath()) {
+  try {
+    if (existsSync2(path)) {
+      const existing = readFileSync(path, "utf8").trim();
+      if (existing) return existing;
+    }
+    const next = `machine-${randomUUID()}`;
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${next}
+`, "utf8");
+    return next;
+  } catch {
+    return `machine-${hostname().toLowerCase()}`;
+  }
+}
+function detectMachineInfo(overrides) {
+  return {
+    machineId: overrides?.machineId ?? resolveMachineId(),
+    name: overrides?.name ?? hostname(),
+    platform: platform(),
+    arch: arch(),
+    connectorVersion: CONNECTOR_VERSION,
+    capabilities: overrides?.capabilities ?? detectRuntimeCapabilities({
+      probeLaunchable: overrides?.probeLaunchable
+    })
+  };
+}
+
+export {
+  resolveMachineId,
+  detectMachineInfo
+};

package/chunk-6WD3OOJS.js

@@ -0,0 +1,20 @@
+// packages/cli/levelLazyShim.mjs
+import { createRequire } from "node:module";
+var _require = createRequire(import.meta.url);
+var _RealLevel;
+function ensureLevel() {
+  if (!_RealLevel) {
+    _RealLevel = _require("level").Level;
+  }
+  return _RealLevel;
+}
+var Level = class {
+  constructor(...args) {
+    const RealLevel = ensureLevel();
+    return new RealLevel(...args);
+  }
+};
+
+export {
+  Level
+};

package/chunk-7DAJ4AI4.js

@@ -0,0 +1,191 @@
+import {
+  listUserRecordsFromServers,
+  readLiveDbRecordAfterTombstoneMerge
+} from "./chunk-RL776AGR.js";
+import {
+  agentRecordHasConfiguredCredential
+} from "./chunk-SDJDLO5W.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
+};