nolo-cli 0.8.0 → 0.9.1

package/chunk-63SLEOLK.js

@@ -0,0 +1,175 @@
+import {
+  selectCurrentServer,
+  selectRemoteServers
+} from "./chunk-TSS3XJY4.js";
+import {
+  createUserKey,
+  extractAgentInfo,
+  extractCoverImage,
+  resolveShareAuthorIdentity,
+  sanitizeShareData,
+  shareKey,
+  toNonEmptyString
+} from "./chunk-SH2CFQOH.js";
+import {
+  noloDeleteRequest,
+  noloWriteRequest,
+  selectIdentityUser,
+  selectIdentityUserId
+} from "./chunk-EYEEHCU4.js";
+import {
+  normalizeTimeFields
+} from "./chunk-QYXLLLGL.js";
+
+// packages/share/action.ts
+var generateToken = () => {
+  const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
+  const charsLen = chars.length;
+  const maxValid = 252;
+  let token = "";
+  while (token.length < 10) {
+    const bytes = new Uint8Array(16);
+    crypto.getRandomValues(bytes);
+    for (let i = 0; i < bytes.length && token.length < 10; i++) {
+      if (bytes[i] < maxValid) {
+        token += chars.charAt(bytes[i] % charsLen);
+      }
+    }
+  }
+  return token;
+};
+var assertDialogShareMessagesPresent = (type, data) => {
+  if (type !== "dialog") return;
+  const messages = Array.isArray(data.messages) ? data.messages : Array.isArray(data.history) ? data.history : [];
+  if (messages.length > 0) return;
+  throw new Error("Cannot share dialog without persisted messages.");
+};
+var resolveTableSharePayload = (type, data, userId, originServer) => {
+  if (type !== "table") return sanitizeShareData(data);
+  const tableDbKey = typeof data.dbKey === "string" && data.dbKey.trim().length > 0 ? data.dbKey : void 0;
+  const tableOwnerId = typeof data.tenantId === "string" && data.tenantId.trim().length > 0 ? data.tenantId : userId;
+  if (!tableDbKey) {
+    throw new Error("Table share requires a dbKey.");
+  }
+  return {
+    mode: "live",
+    tableDbKey,
+    tableOwnerId,
+    originServer
+  };
+};
+var shareResourceAction = async (config, thunkApi) => {
+  const state = thunkApi.getState();
+  const userId = selectIdentityUserId(state);
+  const currentUser = selectIdentityUser(state);
+  if (!userId) {
+    throw new Error("User must be logged in to share resources.");
+  }
+  const token = generateToken();
+  const key = shareKey.create(token);
+  const currentServer = selectCurrentServer(state);
+  assertDialogShareMessagesPresent(config.type, config.data);
+  const snapshotData = resolveTableSharePayload(
+    config.type,
+    config.data,
+    userId,
+    currentServer
+  );
+  const coverImage = extractCoverImage(config.type, snapshotData);
+  const agentInfo = extractAgentInfo(config.type, snapshotData);
+  const createdAt = Date.now();
+  const { db: clientDb } = thunkApi.extra;
+  let authorProfile = null;
+  if (clientDb) {
+    try {
+      authorProfile = await clientDb.get(createUserKey.profile(userId));
+    } catch {
+      authorProfile = null;
+    }
+  }
+  const { authorName, authorAvatar } = resolveShareAuthorIdentity({
+    user: currentUser,
+    profile: authorProfile
+  });
+  if (agentInfo.sourceAgentKey && !agentInfo.sourceAgentName) {
+    if (clientDb) {
+      try {
+        const agentData = await clientDb.get(agentInfo.sourceAgentKey);
+        const name = toNonEmptyString(agentData?.name);
+        if (name) agentInfo.sourceAgentName = name;
+      } catch {
+      }
+    }
+  }
+  const sharedObject = {
+    type: config.type,
+    version: 1,
+    data: snapshotData,
+    meta: {
+      authorId: userId,
+      ...authorName ? { authorName } : {},
+      ...authorAvatar ? { authorAvatar } : {},
+      createdAt,
+      visibility: config.visibility ?? "private",
+      title: config.title,
+      description: config.description,
+      originalId: config.data.dbKey ?? config.data.id,
+      coverImage,
+      ...agentInfo
+    }
+  };
+  const servers = [
+    currentServer,
+    ...selectRemoteServers(state).filter((server) => server !== currentServer)
+  ].filter(Boolean);
+  const replicaServers = servers.filter((server) => server !== currentServer);
+  if (servers.length === 0) {
+    throw new Error("No available server to publish share.");
+  }
+  if (config.type === "table" && sharedObject.data.mode === "live") {
+    sharedObject.data = {
+      ...sharedObject.data,
+      originServer: currentServer
+    };
+    sharedObject.meta = {
+      ...sharedObject.meta,
+      mode: "live",
+      tableDbKey: typeof sharedObject.data.tableDbKey === "string" ? sharedObject.data.tableDbKey : void 0,
+      tableOwnerId: typeof sharedObject.data.tableOwnerId === "string" ? sharedObject.data.tableOwnerId : void 0,
+      originServer: currentServer,
+      replicaServers
+    };
+  }
+  const persistedSharedObject = normalizeTimeFields({
+    ...sharedObject,
+    dbKey: key,
+    userId
+  });
+  const indexKeys = shareKey.allIndexKeysFromShare(key, persistedSharedObject);
+  const results = await Promise.all(
+    servers.map(
+      (server) => noloWriteRequest(server, { data: persistedSharedObject, customKey: key, userId, indexKeys }, state)
+    )
+  );
+  const [originPublished, ...replicaPublishResults] = results;
+  if (!originPublished) {
+    const successfulReplicaServers = replicaServers.filter(
+      (_, index) => replicaPublishResults[index]
+    );
+    await Promise.all(
+      successfulReplicaServers.map(
+        (server) => noloDeleteRequest(server, key, { type: "single" }, state)
+      )
+    );
+    throw new Error("Failed to publish share to origin server.");
+  }
+  if (!clientDb) {
+    throw new Error("Client database instance is required in shareResourceAction");
+  }
+  await clientDb.put(key, persistedSharedObject);
+  return { token, key };
+};
+
+export {
+  shareResourceAction
+};

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-6GANEXVO.js

@@ -0,0 +1,231 @@
+import {
+  DEFAULT_AGENT_BASE_POLICY,
+  DEFAULT_USER_PREFERENCE_PROFILE
+} from "./chunk-TSS3XJY4.js";
+
+// packages/ai/policy/runtimePolicy.ts
+var clampLevel = (value, fallback) => {
+  const n = Number(value);
+  if (n === 1 || n === 2 || n === 3 || n === 4) {
+    return n;
+  }
+  return fallback;
+};
+var normalizeTonePreset = (value, fallback) => {
+  switch (value) {
+    case "professional":
+    case "friendly":
+    case "direct":
+    case "pragmatic":
+    case "default":
+      return value;
+    default:
+      return fallback;
+  }
+};
+var normalizeToneResolutionMode = (value, fallback) => {
+  switch (value) {
+    case "agent_first":
+    case "user_first":
+    case "blend":
+      return value;
+    default:
+      return fallback;
+  }
+};
+var normalizeSelfEvolutionMode = (value, fallback) => {
+  switch (value) {
+    case "none":
+    case "knowledge_only":
+    case "prompt_and_refs":
+    case "full":
+      return value;
+    default:
+      return fallback;
+  }
+};
+var resolveAgentBasePolicy = (agentConfig) => {
+  const raw = agentConfig?.basePolicy ?? {};
+  return {
+    version: 1,
+    tone: {
+      preset: normalizeTonePreset(
+        raw?.tone?.preset,
+        DEFAULT_AGENT_BASE_POLICY.tone?.preset ?? "default"
+      ),
+      resolutionMode: normalizeToneResolutionMode(
+        raw?.tone?.resolutionMode,
+        DEFAULT_AGENT_BASE_POLICY.tone?.resolutionMode ?? "blend"
+      )
+    },
+    knowledgeCaptureMaxLevel: clampLevel(
+      raw?.knowledgeCaptureMaxLevel,
+      DEFAULT_AGENT_BASE_POLICY.knowledgeCaptureMaxLevel
+    ),
+    spaceContextMaxLevel: clampLevel(
+      raw?.spaceContextMaxLevel,
+      DEFAULT_AGENT_BASE_POLICY.spaceContextMaxLevel
+    ),
+    selfEvolutionMode: normalizeSelfEvolutionMode(
+      raw?.selfEvolutionMode,
+      DEFAULT_AGENT_BASE_POLICY.selfEvolutionMode
+    )
+  };
+};
+var resolveUserPreferenceProfile = (settingsRecord) => {
+  const fallbackSpaceLevel = settingsRecord?.enableReadCurrentSpace === false ? 1 : DEFAULT_USER_PREFERENCE_PROFILE.spaceContextLevel;
+  return {
+    version: 1,
+    tone: {
+      preset: normalizeTonePreset(
+        settingsRecord?.userTonePreset,
+        DEFAULT_USER_PREFERENCE_PROFILE.tone?.preset ?? "default"
+      )
+    },
+    knowledgeCaptureLevel: clampLevel(
+      settingsRecord?.knowledgeCaptureLevel,
+      DEFAULT_USER_PREFERENCE_PROFILE.knowledgeCaptureLevel
+    ),
+    spaceContextLevel: clampLevel(
+      settingsRecord?.spaceContextLevel,
+      fallbackSpaceLevel
+    )
+  };
+};
+var containsAny = (text, patterns) => patterns.some((pattern) => text.includes(pattern));
+var inferCaptureIntent = (userInput) => {
+  const normalized = userInput.toLowerCase();
+  if (containsAny(normalized, [
+    "\u4FDD\u5B58",
+    "\u5B58\u4E00\u4E0B",
+    "\u6C89\u6DC0",
+    "\u8BB0\u4F4F",
+    "\u5199\u5165\u6587\u6863",
+    "\u5EFA\u6587\u6863",
+    "\u521B\u5EFA\u6587\u6863",
+    "\u5BFC\u5165 skill",
+    "\u5BFC\u5165\u8FD9\u4E2A skill",
+    "\u786E\u8BA4\u5BFC\u5165",
+    "\u786E\u8BA4\u5BFC\u5165\u8FD9\u4E2A skill",
+    "\u5BFC\u5165\u8FD9\u4E2A\u6280\u80FD",
+    "\u786E\u8BA4\u5BFC\u5165\u8FD9\u4E2A\u6280\u80FD",
+    "\u521B\u5EFA skill",
+    "\u521B\u5EFA\u8FD9\u4E2A skill",
+    "skill \u6587\u6863",
+    "\u521B\u5EFA\u8868\u683C",
+    "createtable",
+    "addtablerow",
+    "addtablerows",
+    "\u5EFA\u8868",
+    "\u5EFA\u4E2A\u8868",
+    "\u505A\u4E2A\u8868",
+    "\u505A\u4E00\u5F20\u8868",
+    "\u5199\u8868",
+    "\u5199\u5165\u8868",
+    "\u5199\u5165\u4E00\u884C",
+    "\u5199\u5165 table",
+    "\u653E\u5230 table",
+    "\u5B58\u5230 table",
+    "\u4FDD\u5B58\u5230 table",
+    "\u8BB0\u5F55\u4E0B\u6765",
+    "\u91C7\u96C6",
+    "\u505A\u6570\u636E\u96C6",
+    "\u505A\u6210\u6570\u636E\u96C6",
+    "\u6574\u7406\u6210\u6570\u636E\u96C6",
+    "\u6574\u7406\u6210\u8868",
+    "\u6574\u7406\u6210\u4E00\u5F20\u8868",
+    "\u5EFA\u7ACB\u4E00\u4E2A\u8868",
+    "\u5EFA\u7ACB\u4E00\u5F20\u8868",
+    "\u5EFA\u7ACB\u6210\u8868",
+    "\u5EFA\u7ACB\u6210\u4E00\u5F20\u8868",
+    "\u521B\u5EFA\u8FD9\u4E2A\u8868\u683C",
+    "\u786E\u8BA4\u521B\u5EFA",
+    "\u786E\u8BA4\u521B\u5EFA\u8FD9\u5F20\u8868\u683C",
+    "create doc",
+    "import skill",
+    "confirm import",
+    "create skill",
+    "create table",
+    "write table",
+    "save to table",
+    "dataset",
+    "save this",
+    "remember this",
+    "document this"
+  ])) {
+    return "strong";
+  }
+  if (containsAny(normalized, [
+    "\u603B\u7ED3",
+    "\u65B9\u6848",
+    "\u8C03\u7814",
+    "\u89C4\u8303",
+    "\u4F1A\u8BAE\u7EAA\u8981",
+    "\u603B\u7ED3\u4E00\u4E0B",
+    "research",
+    "proposal",
+    "spec",
+    "summary"
+  ])) {
+    return "possible";
+  }
+  return "none";
+};
+var resolveTonePreset = (agentTone, userTone, mode) => {
+  if (mode === "agent_first") {
+    return agentTone === "default" ? userTone : agentTone;
+  }
+  if (mode === "user_first") {
+    return userTone === "default" ? agentTone : userTone;
+  }
+  if (userTone !== "default") return userTone;
+  return agentTone;
+};
+var preloadSummaryCountByLevel = (level) => ({ 1: 0, 2: 0, 3: 8, 4: 16 })[level];
+var preloadBudgetRatioByLevel = (level) => ({ 1: 0, 2: 0.01, 3: 0.04, 4: 0.08 })[level];
+var knowledgeCaptureLevelLabel = (level) => ({
+  1: "\u4E0D\u4E3B\u52A8\u521B\u5EFA",
+  2: "\u5148\u95EE\u518D\u521B\u5EFA",
+  3: "\u56DE\u7B54\u540E\u5EFA\u8BAE\u521B\u5EFA",
+  4: "\u9AD8\u4EF7\u503C\u7ED3\u679C\u53EF\u81EA\u52A8\u521B\u5EFA"
+})[level] ?? "\u672A\u77E5\u7EA7\u522B";
+var spaceContextLevelLabel = (level) => ({
+  1: "\u4E0D\u81EA\u52A8\u8BFB\u53D6",
+  2: "\u53EA\u770B\u7ED3\u6784\u548C\u6807\u9898",
+  3: "\u8F7B\u91CF\u8BFB\u53D6",
+  4: "\u81EA\u9002\u5E94\u8BFB\u53D6"
+})[level] ?? "\u672A\u77E5\u7EA7\u522B";
+var buildStaticUserPolicyContext = (params) => {
+  const agentBasePolicy = resolveAgentBasePolicy(params.agentConfig);
+  const userPreferenceProfile = resolveUserPreferenceProfile(params.settingsRecord);
+  const tonePreset = resolveTonePreset(
+    agentBasePolicy.tone?.preset ?? "default",
+    userPreferenceProfile.tone?.preset ?? "default",
+    agentBasePolicy.tone?.resolutionMode ?? "blend"
+  );
+  const knowledgeLevel = Math.min(
+    agentBasePolicy.knowledgeCaptureMaxLevel,
+    userPreferenceProfile.knowledgeCaptureLevel
+  );
+  const spaceLevel = Math.min(
+    agentBasePolicy.spaceContextMaxLevel,
+    userPreferenceProfile.spaceContextLevel
+  );
+  return [
+    `\u7528\u6237\u8BED\u6C14\u504F\u597D\uFF1A${tonePreset}`,
+    `\u77E5\u8BC6\u6C89\u6DC0\u7EA7\u522B\uFF1A${knowledgeLevel}\uFF08${knowledgeCaptureLevelLabel(knowledgeLevel)}\uFF09`,
+    `\u7A7A\u95F4\u4E0A\u4E0B\u6587\u7EA7\u522B\uFF1A${spaceLevel}\uFF08${spaceContextLevelLabel(spaceLevel)}\uFF09`,
+    "\u8BF7\u5C3D\u91CF\u4FDD\u7559 agent \u81EA\u8EAB\u89D2\u8272\u8BBE\u5B9A\uFF0C\u540C\u65F6\u6309\u7528\u6237\u504F\u597D\u8C03\u6574\u8868\u8FBE\u548C\u81EA\u52A8\u5316\u7A0B\u5EA6\u3002"
+  ].join("\n");
+};
+var resolveSpaceContextPreloadPlan = (level) => ({
+  preloadSummaryCount: preloadSummaryCountByLevel(level),
+  preloadBudgetRatio: preloadBudgetRatioByLevel(level),
+  includeRecentContent: level >= 3
+});
+
+export {
+  inferCaptureIntent,
+  buildStaticUserPolicyContext,
+  resolveSpaceContextPreloadPlan
+};

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
+};