nolo-cli 0.7.0 → 0.8.0-alpha.11

package/machineInfo-M6KB6HZN.js

@@ -0,0 +1,10 @@
+import {
+  detectMachineInfo,
+  resolveMachineId
+} from "./chunk-6HYVJV7B.js";
+import "./chunk-JBTJAPUF.js";
+import "./chunk-4VNS5WPM.js";
+export {
+  detectMachineInfo,
+  resolveMachineId
+};

package/machineWsRunDispatch-UIP355FN.js

@@ -0,0 +1,105 @@
+import {
+  buildArtifactProgress,
+  defaultRunConnectorLocalRuntimeAgent,
+  extractMultimodalUserInput,
+  handleConnectorRunMessage,
+  hasExplicitMachinePermissions,
+  isMachineBoundLocalCustomProvider,
+  localRuntimeEnvFromPolicy,
+  requestsLocalWorkspaceRuntime,
+  runtimePolicyFromConnectorPayload,
+  runtimeWorkspacePermissionPolicy,
+  scopePermissionPolicyToRuntimeWorkspace,
+  summarizeAgentConfigForLogs
+} from "./chunk-6B7G54GE.js";
+import "./chunk-YOUZDXU7.js";
+import "./chunk-EHLHSX7R.js";
+import "./chunk-F6QQI5YI.js";
+import "./chunk-VHBWHNVT.js";
+import "./chunk-BSTNFPHD.js";
+import "./chunk-X7W4TNB4.js";
+import "./chunk-ATNTHIZI.js";
+import "./chunk-JBTJAPUF.js";
+import "./chunk-LAWBMYBC.js";
+import "./chunk-2MALU52L.js";
+import "./chunk-GGUO4FKF.js";
+import "./chunk-GAKEBQD6.js";
+import "./chunk-KQHGZWSV.js";
+import "./chunk-XKIMRZO2.js";
+import "./chunk-3LY4F7SV.js";
+import "./chunk-VP4WJWKW.js";
+import "./chunk-63W5N6P3.js";
+import "./chunk-53DNV5AT.js";
+import "./chunk-7OC5VCLW.js";
+import "./chunk-NXZGF7F7.js";
+import "./chunk-OWOHNGCN.js";
+import "./chunk-HEIIIZBX.js";
+import "./chunk-QR5IPGT3.js";
+import "./chunk-MRC4Q34M.js";
+import "./chunk-J4576WMJ.js";
+import "./chunk-CWMSB67P.js";
+import "./chunk-7YLKNMOM.js";
+import "./chunk-IYQV26RA.js";
+import "./chunk-Z4NR32XR.js";
+import "./chunk-M76ECQRD.js";
+import "./chunk-AUGHVUFE.js";
+import "./chunk-H2RMRZJE.js";
+import "./chunk-UAD2WT54.js";
+import "./chunk-USZMK5UT.js";
+import "./chunk-IDZTNRP2.js";
+import "./chunk-ISNCLGUZ.js";
+import "./chunk-OLZBQWZU.js";
+import "./chunk-2UZXR7WO.js";
+import "./chunk-ZNFJWEN4.js";
+import "./chunk-TILFE6LV.js";
+import "./chunk-SYOF5TAS.js";
+import "./chunk-XDVAYP26.js";
+import "./chunk-LM25IZBJ.js";
+import "./chunk-5MMAK75Q.js";
+import "./chunk-572EKYLF.js";
+import "./chunk-TDIQFT2F.js";
+import "./chunk-JZPBVBIY.js";
+import "./chunk-BR2WP3DF.js";
+import "./chunk-5MIDPSSK.js";
+import "./chunk-DFFIZ25G.js";
+import "./chunk-3ASDTTEI.js";
+import "./chunk-DWLEOOGR.js";
+import "./chunk-HNMXYYJR.js";
+import "./chunk-H33743XH.js";
+import "./chunk-LM6IYQ3F.js";
+import "./chunk-IAXBCTTE.js";
+import "./chunk-VEJLAVTC.js";
+import "./chunk-Y5GCAMGP.js";
+import "./chunk-G5H7RNFL.js";
+import "./chunk-AZPCASRE.js";
+import "./chunk-2EISRLRC.js";
+import "./chunk-KX6YBIHG.js";
+import "./chunk-PN7AFLOK.js";
+import "./chunk-WWC7I6TA.js";
+import "./chunk-QSJ3HFEF.js";
+import "./chunk-ELRRLDWI.js";
+import "./chunk-EYEEHCU4.js";
+import "./chunk-QYXLLLGL.js";
+import "./chunk-GBRG75BQ.js";
+import "./chunk-4SN6J65J.js";
+import "./chunk-LCBAMY2M.js";
+import "./chunk-3EUW3WEO.js";
+import "./chunk-U6VC4MU4.js";
+import "./chunk-CF7PE763.js";
+import "./chunk-G3SUCT4W.js";
+import "./chunk-KUG52IAP.js";
+import "./chunk-4VNS5WPM.js";
+export {
+  buildArtifactProgress,
+  defaultRunConnectorLocalRuntimeAgent,
+  extractMultimodalUserInput,
+  handleConnectorRunMessage,
+  hasExplicitMachinePermissions,
+  isMachineBoundLocalCustomProvider,
+  localRuntimeEnvFromPolicy,
+  requestsLocalWorkspaceRuntime,
+  runtimePolicyFromConnectorPayload,
+  runtimeWorkspacePermissionPolicy,
+  scopePermissionPolicyToRuntimeWorkspace,
+  summarizeAgentConfigForLogs
+};

package/memoryCommands-O4MIPIWQ.js

@@ -0,0 +1,476 @@
+import {
+  readOption,
+  resolveAuthToken,
+  resolveServerCandidates,
+  resolveServerUrl
+} from "./chunk-ISNCLGUZ.js";
+import "./chunk-OLZBQWZU.js";
+import {
+  toErrorMessage
+} from "./chunk-HNMXYYJR.js";
+import "./chunk-4SN6J65J.js";
+import "./chunk-LCBAMY2M.js";
+import "./chunk-CF7PE763.js";
+import {
+  asOptionalTrimmedString
+} from "./chunk-G3SUCT4W.js";
+import "./chunk-4VNS5WPM.js";
+
+// packages/cli/memoryCommands.ts
+var VALUE_FLAGS = /* @__PURE__ */ new Set([
+  "--content",
+  "--cursor",
+  "--dialog-id",
+  "--facet",
+  "--id",
+  "--ids",
+  "--kind",
+  "--limit",
+  "--pattern-prefix",
+  "--scope",
+  "--server",
+  "--server-url",
+  "--space",
+  "--source-dialog",
+  "--subject",
+  "--subject-id",
+  "--subject-type",
+  "--tag",
+  "--token"
+]);
+function hasFlag(args, flag) {
+  return args.includes(flag);
+}
+function printMemoryDeleteUsage(output) {
+  output.write(`Usage:
+  nolo memory delete --source-dialog <dialogId> --yes [--json]
+  nolo memory delete --tag <tag> --kind <kind> --yes
+  nolo memory delete --pattern-prefix <prefix> --limit <n> --yes
+
+Options:
+  --id <memoryId>            Delete a specific memory id. Repeatable.
+  --ids <a,b,c>              Delete specific memory ids.
+  --source-dialog <dialogId> Delete memories created from one dialog.
+  --tag <tag>                Require a tag. Repeatable.
+  --kind <kind>              Filter episodic / semantic / procedural. Repeatable.
+  --facet <facet>            Filter preference / tension / unfinished / goal / style. Repeatable.
+  --subject-type <type>      Filter user / agent / space / project / system.
+  --subject <subjectId>      Filter subjectId.
+  --pattern-prefix <prefix>  Filter patternKey prefix.
+  --limit <n>                Maximum memories to delete.
+  --yes                      Actually delete. Without this, command is a dry-run.
+  --json                     Print machine-readable JSON.
+  --server <url>             Prefer this server and include known Nolo peers.
+  --token <jwt>              Override AUTH_TOKEN.
+
+At least one filter is required; this command will not delete all memory implicitly.
+`);
+}
+function readRepeated(args, flag) {
+  const values = [];
+  for (let index = 0; index < args.length; index += 1) {
+    if (args[index] !== flag) continue;
+    const value = args[index + 1];
+    const trimmed = asOptionalTrimmedString(value);
+    if (trimmed) values.push(trimmed);
+  }
+  return values;
+}
+function readCsvValues(args, flag) {
+  const raw = readRepeated(args, flag).join(",");
+  return raw.split(",").map((value) => value.trim()).filter(Boolean);
+}
+function readLimit(args) {
+  const raw = readOption(args, "--limit");
+  if (!raw) return void 0;
+  if (!/^\d+$/.test(raw)) throw new Error(`invalid --limit: ${raw}`);
+  const parsed = Number(raw);
+  return parsed > 0 ? parsed : void 0;
+}
+function assertNoUnknownFlags(args) {
+  for (let index = 0; index < args.length; index += 1) {
+    const value = args[index];
+    if (!value.startsWith("-")) continue;
+    if (value === "--help" || value === "-h" || value === "--yes" || value === "--json") continue;
+    if (VALUE_FLAGS.has(value)) {
+      index += 1;
+      continue;
+    }
+    throw new Error(`unknown option: ${value}`);
+  }
+}
+function buildDeleteBody(args) {
+  const ids = [...readRepeated(args, "--id"), ...readCsvValues(args, "--ids")];
+  const kinds = readRepeated(args, "--kind");
+  const facets = readRepeated(args, "--facet");
+  const tags = readRepeated(args, "--tag");
+  const sourceDialogId = readOption(args, "--source-dialog")?.trim();
+  const subjectType = readOption(args, "--subject-type")?.trim();
+  const subjectId = (readOption(args, "--subject") ?? readOption(args, "--subject-id"))?.trim();
+  const patternKeyPrefix = readOption(args, "--pattern-prefix")?.trim();
+  const limit = readLimit(args);
+  const body = {};
+  if (ids.length) body.ids = [...new Set(ids)];
+  if (kinds.length) body.kinds = [...new Set(kinds)];
+  if (facets.length) body.facets = [...new Set(facets)];
+  if (tags.length) body.tags = [...new Set(tags)];
+  if (sourceDialogId) body.sourceDialogId = sourceDialogId;
+  if (subjectType) body.subjectType = subjectType;
+  if (subjectId) body.subjectId = subjectId;
+  if (patternKeyPrefix) body.patternKeyPrefix = patternKeyPrefix;
+  if (typeof limit === "number") body.limit = limit;
+  return body;
+}
+function hasDeleteFilter(body) {
+  return Object.keys(body).some((key) => key !== "limit");
+}
+async function postMemoryDelete(args) {
+  const res = await args.fetchImpl(`${args.serverUrl}/api/memory/delete`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${args.authToken}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(args.body)
+  });
+  const text = await res.text();
+  let payload = null;
+  try {
+    payload = text ? JSON.parse(text) : null;
+  } catch {
+    payload = { raw: text };
+  }
+  if (!res.ok || payload?.error) {
+    const message = payload?.error?.message ?? payload?.message ?? payload?.error ?? `HTTP ${res.status}`;
+    throw new Error(`${message}`);
+  }
+  return payload;
+}
+async function runMemoryDeleteCommand(args, deps = {}) {
+  const env = deps.env ?? process.env;
+  const output = deps.output ?? process.stdout;
+  if (hasFlag(args, "--help") || hasFlag(args, "-h")) {
+    printMemoryDeleteUsage(output);
+    return 0;
+  }
+  try {
+    assertNoUnknownFlags(args);
+    const authToken = resolveAuthToken(args, env);
+    if (!authToken) {
+      output.write("[nolo] memory delete requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n");
+      return 1;
+    }
+    const body = buildDeleteBody(args);
+    if (!hasDeleteFilter(body)) {
+      output.write("[nolo] memory delete requires at least one filter; use --help for examples.\n");
+      return 1;
+    }
+    const shouldDelete = hasFlag(args, "--yes");
+    const wantJson = hasFlag(args, "--json");
+    const fetchImpl = deps.fetchImpl ?? fetch;
+    const serverUrl = resolveServerUrl(args, env);
+    const serverUrls = resolveServerCandidates(args, env, serverUrl);
+    if (!shouldDelete) {
+      const payload2 = {
+        dryRun: true,
+        deleted: false,
+        targetServers: serverUrls,
+        request: body,
+        nextStep: "rerun with --yes to delete matching memories"
+      };
+      if (wantJson) {
+        output.write(`${JSON.stringify(payload2, null, 2)}
+`);
+      } else {
+        output.write("dryRun: true\n");
+        output.write(`targetServers: ${serverUrls.join(", ")}
+`);
+        output.write(`request: ${JSON.stringify(body)}
+`);
+        output.write("rerun with --yes to delete matching memories\n");
+      }
+      return 0;
+    }
+    const promises = serverUrls.map(async (target) => {
+      try {
+        const result = await postMemoryDelete({
+          authToken,
+          body,
+          fetchImpl,
+          serverUrl: target
+        });
+        return { serverUrl: target, ok: true, result };
+      } catch (error) {
+        return {
+          serverUrl: target,
+          ok: false,
+          error: toErrorMessage(error)
+        };
+      }
+    });
+    const deleteResults = await Promise.all(promises);
+    const deletedCount = deleteResults.reduce(
+      (sum, item) => sum + (item.ok ? Number(item.result?.deletedCount ?? 0) : 0),
+      0
+    );
+    const payload = {
+      dryRun: false,
+      deleted: true,
+      deletedCount,
+      request: body,
+      targetServers: serverUrls,
+      deleteResults
+    };
+    if (wantJson) {
+      output.write(`${JSON.stringify(payload, null, 2)}
+`);
+    } else {
+      output.write(`deletedCount: ${deletedCount}
+`);
+      for (const result of deleteResults) {
+        output.write(
+          result.ok ? `${result.serverUrl}: ok deleted=${result.result?.deletedCount ?? 0}
+` : `${result.serverUrl}: failed ${result.error}
+`
+        );
+      }
+    }
+    return deleteResults.some((result) => result.ok) ? 0 : 1;
+  } catch (error) {
+    output.write(`[nolo] memory delete failed: ${toErrorMessage(error)}
+`);
+    return 1;
+  }
+}
+function printMemoryListUsage(output) {
+  output.write(`Usage:
+  nolo memory list [--limit 50] [--kind episodic] [--subject-type agent]
+  nolo memory list --subject-type agent --subject <subjectId> --json
+
+Options:
+  --limit <n>               Page size (1-200, default 50).
+  --cursor <cursor>         Continue from a previous page's nextCursor.
+  --kind <kind>             Filter episodic / semantic / procedural.
+  --subject-type <type>     Filter user / agent / space / project / system.
+  --subject <subjectId>    Filter subjectId (requires --subject-type).
+  --json                    Print machine-readable JSON.
+  --server <url>            Prefer this server and include known Nolo peers.
+  --token <jwt>             Override AUTH_TOKEN.
+
+Listing is scoped to the authenticated user's memories.
+`);
+}
+function buildListBody(args) {
+  const body = {};
+  const limit = readLimit(args);
+  if (typeof limit === "number") body.limit = limit;
+  const cursor = readOption(args, "--cursor")?.trim();
+  if (cursor) body.cursor = cursor;
+  const kind = readOption(args, "--kind")?.trim();
+  if (kind) body.kind = kind;
+  const subjectType = readOption(args, "--subject-type")?.trim();
+  if (subjectType) body.subjectType = subjectType;
+  const subjectId = (readOption(args, "--subject") ?? readOption(args, "--subject-id"))?.trim();
+  if (subjectId) body.subjectId = subjectId;
+  return body;
+}
+function parseMemoryResponse(text) {
+  if (!text) return { result: null, errorMessage: void 0 };
+  try {
+    const parsed = JSON.parse(text);
+    if (typeof parsed === "object" && parsed !== null && "error" in parsed) {
+      const err = parsed.error;
+      const message = typeof err === "object" && err !== null && "message" in err ? String(err.message ?? "") : "";
+      return { result: parsed, errorMessage: message || parsed.message };
+    }
+    return { result: parsed, errorMessage: void 0 };
+  } catch {
+    return { result: { raw: text }, errorMessage: void 0 };
+  }
+}
+async function postMemoryList(args) {
+  const res = await args.fetchImpl(`${args.serverUrl}/api/memory/list`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${args.authToken}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(args.body)
+  });
+  const text = await res.text();
+  const parsed = parseMemoryResponse(text);
+  if (!res.ok) {
+    throw new Error(parsed.errorMessage ?? `HTTP ${res.status}`);
+  }
+  if (parsed.errorMessage) {
+    throw new Error(parsed.errorMessage);
+  }
+  return parsed.result;
+}
+function renderMemoryItem(item) {
+  if (typeof item !== "object" || item === null) return String(item);
+  const record = item;
+  const parts = [];
+  if (record.id) parts.push(record.id);
+  if (record.kind) parts.push(`kind=${record.kind}`);
+  if (record.subjectType) parts.push(`subject=${record.subjectType}${record.subjectId ? `:${record.subjectId}` : ""}`);
+  if (record.scope) parts.push(`scope=${record.scope}`);
+  const content = record.content ? record.content.length > 80 ? `${record.content.slice(0, 80)}\u2026` : record.content : "";
+  return [parts.join("  "), content].filter(Boolean).join("\n    ");
+}
+async function runMemoryListCommand(args, deps = {}) {
+  const env = deps.env ?? process.env;
+  const output = deps.output ?? process.stdout;
+  if (hasFlag(args, "--help") || hasFlag(args, "-h")) {
+    printMemoryListUsage(output);
+    return 0;
+  }
+  try {
+    assertNoUnknownFlags(args);
+    const authToken = resolveAuthToken(args, env);
+    if (!authToken) {
+      output.write("[nolo] memory list requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n");
+      return 1;
+    }
+    const body = buildListBody(args);
+    const wantJson = hasFlag(args, "--json");
+    const fetchImpl = deps.fetchImpl ?? fetch;
+    const serverUrl = resolveServerUrl(args, env);
+    const serverUrls = resolveServerCandidates(args, env, serverUrl);
+    const target = serverUrls[0] ?? serverUrl;
+    try {
+      const result = await postMemoryList({ authToken, body, fetchImpl, serverUrl: target });
+      const items = Array.isArray(result.items) ? result.items : [];
+      if (wantJson) {
+        output.write(`${JSON.stringify({ items, nextCursor: result.nextCursor, truncated: result.truncated }, null, 2)}
+`);
+      } else {
+        output.write(`${target}: ${items.length} memor${items.length === 1 ? "y" : "ies"}
+`);
+        for (const item of items) {
+          output.write(`  ${renderMemoryItem(item)}
+`);
+        }
+        if (result.nextCursor) {
+          output.write(`nextCursor: ${result.nextCursor}
+`);
+        }
+        if (result.truncated) {
+          output.write("truncated: true (more entries may exist; page with --cursor)\n");
+        }
+      }
+      return 0;
+    } catch (error) {
+      output.write(`[nolo] memory list failed: ${toErrorMessage(error)}
+`);
+      return 1;
+    }
+  } catch (error) {
+    output.write(`[nolo] memory list failed: ${toErrorMessage(error)}
+`);
+    return 1;
+  }
+}
+function printMemoryRememberUsage(output) {
+  output.write(`Usage:
+  nolo memory remember --content "\u7528\u6237\u504F\u597D\u5148\u770B\u7ED3\u8BBA" --kind semantic
+  nolo memory remember --content "..." --kind episodic --scope auto --dialog-id <id>
+
+Options:
+  --content <text>         The memory text to store (required).
+  --kind <kind>            episodic / semantic / procedural (required).
+  --scope <scope>          auto / user / space (default auto).
+  --dialog-id <id>         Attach to a dialog.
+  --space <spaceId>        Store under a space (requires space membership).
+  --json                    Print machine-readable JSON.
+  --server <url>            Prefer this server and include known Nolo peers.
+  --token <jwt>             Override AUTH_TOKEN.
+`);
+}
+function buildRememberBody(args) {
+  const content = readOption(args, "--content")?.trim();
+  const kind = readOption(args, "--kind")?.trim();
+  const scope = readOption(args, "--scope")?.trim();
+  const dialogId = readOption(args, "--dialog-id")?.trim();
+  const spaceId = readOption(args, "--space")?.trim();
+  return { content, kind, scope, dialogId, spaceId };
+}
+async function postMemoryRemember(args) {
+  const res = await args.fetchImpl(`${args.serverUrl}/api/memory/remember`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${args.authToken}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(args.body)
+  });
+  const text = await res.text();
+  const parsed = parseMemoryResponse(text);
+  if (!res.ok) {
+    throw new Error(parsed.errorMessage ?? `HTTP ${res.status}`);
+  }
+  if (parsed.errorMessage) {
+    throw new Error(parsed.errorMessage);
+  }
+  return parsed.result;
+}
+var REMEMBER_KINDS = /* @__PURE__ */ new Set(["episodic", "semantic", "procedural"]);
+var REMEMBER_SCOPES = /* @__PURE__ */ new Set(["auto", "user", "space"]);
+async function runMemoryRememberCommand(args, deps = {}) {
+  const env = deps.env ?? process.env;
+  const output = deps.output ?? process.stdout;
+  if (hasFlag(args, "--help") || hasFlag(args, "-h")) {
+    printMemoryRememberUsage(output);
+    return 0;
+  }
+  try {
+    assertNoUnknownFlags(args);
+    const authToken = resolveAuthToken(args, env);
+    if (!authToken) {
+      output.write("[nolo] memory remember requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n");
+      return 1;
+    }
+    const { content, kind, scope, dialogId, spaceId } = buildRememberBody(args);
+    if (!content) {
+      output.write("[nolo] memory remember requires --content <text>; use --help for examples.\n");
+      return 1;
+    }
+    if (!kind || !REMEMBER_KINDS.has(kind)) {
+      output.write("[nolo] memory remember requires --kind <episodic|semantic|procedural>.\n");
+      return 1;
+    }
+    const normalizedScope = scope && REMEMBER_SCOPES.has(scope) ? scope : "auto";
+    const body = { content, kind, scope: normalizedScope };
+    if (dialogId) body.dialogId = dialogId;
+    if (spaceId) body.spaceId = spaceId;
+    const wantJson = hasFlag(args, "--json");
+    const fetchImpl = deps.fetchImpl ?? fetch;
+    const serverUrl = resolveServerUrl(args, env);
+    const serverUrls = resolveServerCandidates(args, env, serverUrl);
+    const target = serverUrls[0] ?? serverUrl;
+    try {
+      const result = await postMemoryRemember({ authToken, body, fetchImpl, serverUrl: target });
+      if (wantJson) {
+        output.write(`${JSON.stringify(result, null, 2)}
+`);
+      } else {
+        output.write(`${target}: remembered ${kind}
+`);
+      }
+      return 0;
+    } catch (error) {
+      output.write(`[nolo] memory remember failed: ${toErrorMessage(error)}
+`);
+      return 1;
+    }
+  } catch (error) {
+    output.write(`[nolo] memory remember failed: ${toErrorMessage(error)}
+`);
+    return 1;
+  }
+}
+export {
+  runMemoryDeleteCommand,
+  runMemoryListCommand,
+  runMemoryRememberCommand
+};

package/models-XLEOET3E.js

@@ -0,0 +1,9 @@
+import {
+  ALL_MODELS
+} from "./chunk-USZMK5UT.js";
+import "./chunk-BR2WP3DF.js";
+import "./chunk-QSJ3HFEF.js";
+import "./chunk-4VNS5WPM.js";
+export {
+  ALL_MODELS
+};