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

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-HNW7IJSK.js

@@ -0,0 +1,71 @@
+import {
+  createMemoryKey,
+  createMemoryOwnerIndexKey,
+  createMemorySubjectKindIndexKey,
+  ulid
+} from "./chunk-O4BU24WZ.js";
+
+// packages/ai/memory/storeShared.ts
+var createMemoryItem = (input) => {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    id: ulid(),
+    createdAt: now,
+    lastActivatedAt: now,
+    activationCount: 0,
+    ...input
+  };
+};
+var writeMemoryItemWithIndexesToDb = async (db, item) => {
+  const batch = db.batch();
+  batch.put(createMemoryKey(item.ownerType, item.ownerId, item.id), item);
+  batch.put(
+    createMemoryOwnerIndexKey(
+      item.ownerType,
+      item.ownerId,
+      item.createdAt,
+      item.id
+    ),
+    {
+      memoryKey: createMemoryKey(item.ownerType, item.ownerId, item.id),
+      ownerType: item.ownerType,
+      ownerId: item.ownerId,
+      memoryId: item.id
+    }
+  );
+  batch.put(
+    createMemorySubjectKindIndexKey(
+      item.subjectType,
+      item.subjectId,
+      item.kind,
+      item.createdAt,
+      item.id
+    ),
+    {
+      memoryKey: createMemoryKey(item.ownerType, item.ownerId, item.id),
+      subjectType: item.subjectType,
+      subjectId: item.subjectId,
+      kind: item.kind,
+      memoryId: item.id
+    }
+  );
+  await batch.write();
+};
+var touchMemoryItemsInDb = async (db, items, now = (/* @__PURE__ */ new Date()).toISOString()) => {
+  if (items.length === 0) return;
+  const batch = db.batch();
+  for (const item of items) {
+    batch.put(createMemoryKey(item.ownerType, item.ownerId, item.id), {
+      ...item,
+      lastActivatedAt: now,
+      activationCount: (item.activationCount ?? 0) + 1
+    });
+  }
+  await batch.write();
+};
+
+export {
+  createMemoryItem,
+  writeMemoryItemWithIndexesToDb,
+  touchMemoryItemsInDb
+};

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-I6XMPTMR.js

@@ -0,0 +1,113 @@
+import {
+  createSpaceKey
+} from "./chunk-UAD2WT54.js";
+import {
+  patch,
+  read
+} from "./chunk-URUUZLPA.js";
+import {
+  DEVICE_LOCAL_OWNER_ID,
+  isDeviceLocalSpaceBody,
+  selectIdentityUserId
+} from "./chunk-UTLZINAP.js";
+
+// packages/create/space/utils/permissions.ts
+var checkSpaceMembership = (spaceData, userId) => {
+  if (!spaceData) {
+    console.error("[Permission Check] Space data is missing.");
+    throw new Error("\u65E0\u6CD5\u6267\u884C\u6743\u9650\u68C0\u67E5\uFF1A\u7A7A\u95F4\u6570\u636E\u7F3A\u5931\u3002");
+  }
+  if (isDeviceLocalSpaceBody(spaceData)) {
+    return;
+  }
+  if (!userId) {
+    console.error("[Permission Check] User ID is missing.");
+    throw new Error("\u65E0\u6CD5\u6267\u884C\u6743\u9650\u68C0\u67E5\uFF1A\u7528\u6237 ID \u7F3A\u5931\u3002");
+  }
+  if (!spaceData.members || !Array.isArray(spaceData.members) || !spaceData.members.includes(userId)) {
+    console.warn(
+      `[Permission Check] User ${userId} attempt to operate on space ${spaceData.id} without membership.`
+    );
+    throw new Error("\u5F53\u524D\u7528\u6237\u4E0D\u662F\u7A7A\u95F4\u6210\u5458");
+  }
+};
+var localSpaceAuthorityPatchStamp = (spaceData) => isDeviceLocalSpaceBody(spaceData) ? { userId: DEVICE_LOCAL_OWNER_ID } : {};
+
+// packages/create/space/constants.ts
+var UNCATEGORIZED_ID = "__uncategorized_container__";
+
+// packages/create/space/content/addContentAction.ts
+var addContentAction = async (input, thunkAPI) => {
+  const {
+    spaceId,
+    title,
+    type,
+    contentKey,
+    fileCategory,
+    mimeType,
+    fileSize,
+    originalName,
+    categoryId: rawCategoryId,
+    pinned = false,
+    order,
+    triggerType,
+    skillSummary
+  } = input;
+  const { dispatch, getState } = thunkAPI;
+  const userId = selectIdentityUserId(getState());
+  if (!contentKey || typeof contentKey !== "string" || contentKey.trim() === "")
+    throw new Error("Invalid contentKey provided.");
+  if (!title || typeof title !== "string" || title.trim() === "")
+    throw new Error("Invalid or empty title provided.");
+  if (!type || typeof type !== "string")
+    throw new Error("Invalid content type provided.");
+  const spaceKey = createSpaceKey.space(spaceId);
+  const spaceData = await dispatch(read({
+    dbKey: spaceKey
+  })).unwrap();
+  checkSpaceMembership(spaceData, userId);
+  if (spaceData.contents && spaceData.contents[contentKey]) {
+    throw new Error(`\u5185\u5BB9\u952E "${contentKey}" \u5DF2\u5B58\u5728\u3002`);
+  }
+  let categoryIdForStorage;
+  if (rawCategoryId && rawCategoryId !== "" && rawCategoryId !== UNCATEGORIZED_ID) {
+    if (spaceData.categories?.[rawCategoryId]) {
+      categoryIdForStorage = rawCategoryId;
+    }
+  }
+  const now = Date.now();
+  const newSpaceContent = {
+    title: title.trim(),
+    type,
+    contentKey,
+    ...fileCategory !== void 0 ? { fileCategory } : {},
+    ...mimeType !== void 0 ? { mimeType } : {},
+    ...fileSize !== void 0 ? { fileSize } : {},
+    ...originalName !== void 0 ? { originalName } : {},
+    ...categoryIdForStorage !== void 0 && {
+      categoryId: categoryIdForStorage
+    },
+    pinned,
+    createdAt: now,
+    updatedAt: now,
+    ...order !== void 0 && typeof order === "number" && { order },
+    ...triggerType !== void 0 && { triggerType },
+    ...skillSummary !== void 0 ? { skillSummary } : {}
+  };
+  const changes = {
+    contents: { [contentKey]: newSpaceContent },
+    updatedAt: now,
+    ...localSpaceAuthorityPatchStamp(spaceData)
+  };
+  const updatedSpaceData = await dispatch(
+    patch({ dbKey: spaceKey, changes })
+  ).unwrap();
+  return { spaceId, updatedSpaceData };
+};
+
+export {
+  checkSpaceMembership,
+  localSpaceAuthorityPatchStamp,
+  UNCATEGORIZED_ID,
+  addContentAction
+};

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