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

package/chunk-QSJ3HFEF.js

@@ -0,0 +1,8 @@
+// packages/core/trimmedLowercaseString.ts
+function asTrimmedLowercaseString(value) {
+  return typeof value === "string" ? value.trim().toLowerCase() : "";
+}
+
+export {
+  asTrimmedLowercaseString
+};

package/chunk-RGIM3WLT.js

@@ -0,0 +1,113 @@
+import {
+  createSpaceKey
+} from "./chunk-UAD2WT54.js";
+import {
+  patch,
+  read
+} from "./chunk-TISCADJH.js";
+import {
+  DEVICE_LOCAL_OWNER_ID,
+  isDeviceLocalSpaceBody,
+  selectIdentityUserId
+} from "./chunk-XBROXIGL.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-RL776AGR.js

@@ -0,0 +1,190 @@
+import {
+  deleteDbRecord,
+  queryUserRecords,
+  readDbRecord
+} from "./chunk-SDJDLO5W.js";
+import {
+  mergeAndDedupUserData
+} from "./chunk-KQHGZWSV.js";
+import {
+  toErrorMessage
+} from "./chunk-HNMXYYJR.js";
+import {
+  isTombstoneRecord
+} from "./chunk-GBRG75BQ.js";
+
+// packages/cli/globalRecordOperations.ts
+async function listUserRecordsFromServers(args) {
+  const remoteResults = [];
+  const failures = [];
+  const promises = args.serverUrls.map(async (serverUrl) => {
+    try {
+      const records = await queryUserRecords({
+        authToken: args.authToken,
+        fallbackFetchImpl: args.fallbackFetchImpl,
+        fetchImpl: args.fetchImpl,
+        includeDeleted: true,
+        limit: args.limit,
+        serverUrl,
+        summary: args.summary,
+        type: args.type,
+        userId: args.userId
+      });
+      return { ok: true, serverUrl, records };
+    } catch (error) {
+      return {
+        ok: false,
+        serverUrl,
+        error: toErrorMessage(error)
+      };
+    }
+  });
+  const results = await Promise.all(promises);
+  for (const res of results) {
+    if (res.ok) {
+      remoteResults.push({
+        data: {
+          data: res.records.map((record) => ({
+            ...record,
+            serverOrigin: typeof record?.serverOrigin === "string" && record.serverOrigin.trim() ? record.serverOrigin : res.serverUrl
+          }))
+        }
+      });
+    } else {
+      failures.push({
+        serverUrl: res.serverUrl,
+        error: res.error
+      });
+    }
+  }
+  if (remoteResults.length === 0 && failures.length > 0) {
+    const label = args.label ?? "record query";
+    throw new Error(
+      `${label} failed on all candidate servers: ${failures.map((failure) => `${failure.serverUrl}: ${failure.error}`).join("; ")}`
+    );
+  }
+  const merged = mergeAndDedupUserData([], remoteResults, { includeDeleted: true });
+  return {
+    records: merged.filter((record) => !isTombstoneRecord(record)),
+    failures
+  };
+}
+async function readDbRecordFromServers(args) {
+  const failures = [];
+  for (const serverUrl of args.serverUrls) {
+    try {
+      const record = await readDbRecord({
+        authToken: args.authToken,
+        dbKey: args.dbKey,
+        fallbackFetchImpl: args.fallbackFetchImpl,
+        fetchImpl: args.fetchImpl,
+        includeDeleted: args.includeDeleted,
+        serverUrl
+      });
+      return { record, serverUrl, failures };
+    } catch (error) {
+      failures.push({
+        serverUrl,
+        error: toErrorMessage(error)
+      });
+    }
+  }
+  const label = args.label ?? `record ${args.dbKey}`;
+  throw new Error(
+    `${label} is unreadable on all candidate servers: ${failures.map((failure) => `${failure.serverUrl}: ${failure.error}`).join("; ")}`
+  );
+}
+async function readDbRecordVersionsFromServers(args) {
+  const records = [];
+  const failures = [];
+  const promises = args.serverUrls.map(async (serverUrl) => {
+    try {
+      const record = await readDbRecord({
+        authToken: args.authToken,
+        dbKey: args.dbKey,
+        fallbackFetchImpl: args.fallbackFetchImpl,
+        fetchImpl: args.fetchImpl,
+        includeDeleted: true,
+        serverUrl
+      });
+      return { ok: true, serverUrl, record };
+    } catch (error) {
+      return {
+        ok: false,
+        serverUrl,
+        error: toErrorMessage(error)
+      };
+    }
+  });
+  const results = await Promise.all(promises);
+  for (const res of results) {
+    if (res.ok) {
+      const record = res.record;
+      records.push({
+        ...record,
+        dbKey: typeof record?.dbKey === "string" && record.dbKey.trim() ? record.dbKey : args.dbKey,
+        serverOrigin: typeof record?.serverOrigin === "string" && record.serverOrigin.trim() ? record.serverOrigin : res.serverUrl
+      });
+    } else {
+      failures.push({
+        serverUrl: res.serverUrl,
+        error: res.error
+      });
+    }
+  }
+  return { records, failures };
+}
+async function readLiveDbRecordAfterTombstoneMerge(args) {
+  const result = await readDbRecordVersionsFromServers(args);
+  const merged = mergeAndDedupUserData(
+    [],
+    [{ data: { data: result.records } }],
+    { includeDeleted: true }
+  );
+  const record = merged.find((item) => item?.dbKey === args.dbKey);
+  if (record && !isTombstoneRecord(record)) {
+    return {
+      record,
+      serverUrl: typeof record.serverOrigin === "string" ? record.serverOrigin : "",
+      failures: result.failures
+    };
+  }
+  const label = args.label ?? `record ${args.dbKey}`;
+  const failureText = result.failures.length ? ` Failures: ${result.failures.map((failure) => `${failure.serverUrl}: ${failure.error}`).join("; ")}` : "";
+  throw new Error(`${label} is deleted or unreadable after global tombstone merge.${failureText}`);
+}
+async function deleteDbRecordOnServers(args) {
+  return deleteDbRecordOnTargets({
+    ...args,
+    targets: args.serverUrls.map((serverUrl) => ({ serverUrl }))
+  });
+}
+async function deleteDbRecordOnTargets(args) {
+  const promises = args.targets.map(async (target) => {
+    try {
+      const result = await deleteDbRecord({
+        authToken: target.authToken ?? args.authToken,
+        dbKey: args.dbKey,
+        deleteOptions: args.deleteOptions,
+        fallbackFetchImpl: args.fallbackFetchImpl,
+        fetchImpl: args.fetchImpl,
+        serverUrl: target.serverUrl
+      });
+      return { serverUrl: target.serverUrl, ok: true, result };
+    } catch (error) {
+      return {
+        serverUrl: target.serverUrl,
+        ok: false,
+        error: toErrorMessage(error)
+      };
+    }
+  });
+  return Promise.all(promises);
+}
+
+export {
+  listUserRecordsFromServers,
+  readDbRecordFromServers,
+  readLiveDbRecordAfterTombstoneMerge,
+  deleteDbRecordOnServers
+};

package/chunk-ROWQEJRP.js

@@ -0,0 +1,139 @@
+// packages/cli/client/profileConfig.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+
+// packages/core/noloServerUrl.ts
+function isNoloChatHostname(hostname) {
+  if (typeof hostname !== "string") return false;
+  const host = hostname.trim().toLowerCase();
+  if (!host) return false;
+  return host === "nolo.chat" || host.endsWith(".nolo.chat");
+}
+function canonicalizeNoloServerUrl(value) {
+  const normalized = value.trim().replace(/\/+$/, "");
+  if (!normalized) return normalized;
+  try {
+    const url = new URL(normalized);
+    if (url.protocol === "http:" && isNoloChatHostname(url.hostname)) {
+      url.protocol = "https:";
+      return url.toString().replace(/\/+$/, "");
+    }
+  } catch {
+    return normalized;
+  }
+  return normalized;
+}
+
+// packages/cli/client/profileConfig.ts
+var normalizeProfileServerUrl = canonicalizeNoloServerUrl;
+function getDefaultProfileConfigPath() {
+  return join(homedir(), ".nolo", "config.json");
+}
+function loadProfileConfig(path = getDefaultProfileConfigPath()) {
+  if (!existsSync(path)) return null;
+  const raw = readFileSync(path, "utf8");
+  const parsed = JSON.parse(raw);
+  if (!parsed.currentProfile || !parsed.profiles?.[parsed.currentProfile]) return null;
+  for (const profile of Object.values(parsed.profiles)) {
+    if (!profile?.serverUrl) continue;
+    profile.serverUrl = normalizeProfileServerUrl(profile.serverUrl);
+  }
+  return parsed;
+}
+function clearProfileAuthToken(path = getDefaultProfileConfigPath()) {
+  const config = loadProfileConfig(path);
+  if (!config) return false;
+  const profile = config.profiles[config.currentProfile];
+  if (!profile?.authToken?.trim()) return false;
+  delete profile.authToken;
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(config, null, 2)}
+`, "utf8");
+  return true;
+}
+function saveDefaultProfile(path, profile) {
+  const existing = loadProfileConfig(path);
+  const mergedDefault = {
+    ...existing?.profiles?.default ?? {},
+    serverUrl: normalizeProfileServerUrl(profile.serverUrl),
+    authToken: profile.authToken.trim()
+  };
+  const config = {
+    currentProfile: "default",
+    profiles: {
+      ...existing?.profiles ?? {},
+      default: mergedDefault
+    }
+  };
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(config, null, 2)}
+`, "utf8");
+  return config;
+}
+function buildEnvFromProfile(config) {
+  if (!config) return {};
+  const profile = config.profiles[config.currentProfile];
+  if (!profile) return {};
+  return {
+    NOLO_PROFILE: config.currentProfile,
+    NOLO_SERVER: profile.serverUrl,
+    ...profile.authToken?.trim() ? { AUTH_TOKEN: profile.authToken.trim() } : {},
+    ...profile.agentKey ? { NOLO_AGENT: profile.agentKey } : {},
+    ...profile.agentName ? { NOLO_AGENT_NAME: profile.agentName } : {},
+    ...profile.locale ? { NOLO_LANG: profile.locale } : {}
+  };
+}
+function buildCliRuntimeEnv(processEnv, config) {
+  const profileEnv = buildEnvFromProfile(config);
+  const explicitAuthToken = processEnv.AUTH_TOKEN || processEnv.AUTH;
+  const explicitServerUrl = processEnv.NOLO_SERVER || processEnv.NOLO_SERVER_URL || processEnv.BASE_URL;
+  return {
+    ...processEnv,
+    ...profileEnv,
+    ...explicitAuthToken ? { AUTH_TOKEN: explicitAuthToken } : {},
+    ...explicitServerUrl ? {
+      NOLO_SERVER: explicitServerUrl,
+      BASE_URL: explicitServerUrl
+    } : {}
+  };
+}
+function getCurrentProfile(config) {
+  if (!config) return null;
+  return config.profiles[config.currentProfile] ?? null;
+}
+function saveProfileLocale(locale, path = getDefaultProfileConfigPath()) {
+  const config = loadProfileConfig(path);
+  if (!config) return null;
+  const profile = config.profiles[config.currentProfile];
+  if (!profile) return null;
+  profile.locale = locale;
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(config, null, 2)}
+`, "utf8");
+  return config;
+}
+function saveProfileAgentSelection(selection, path = getDefaultProfileConfigPath()) {
+  const config = loadProfileConfig(path);
+  if (!config) return null;
+  const profile = config.profiles[config.currentProfile];
+  if (!profile) return null;
+  profile.agentKey = selection.agentKey.trim();
+  profile.agentName = selection.agentName.trim();
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(config, null, 2)}
+`, "utf8");
+  return config;
+}
+
+export {
+  getDefaultProfileConfigPath,
+  loadProfileConfig,
+  clearProfileAuthToken,
+  saveDefaultProfile,
+  buildEnvFromProfile,
+  buildCliRuntimeEnv,
+  getCurrentProfile,
+  saveProfileLocale,
+  saveProfileAgentSelection
+};

package/chunk-S7Z2HMCN.js

@@ -0,0 +1,25 @@
+// packages/cli/secretScan.ts
+var SECRET_PATTERNS = [
+  { label: "password", pattern: /\bpassword\s*[:=]\s*["']?[^"',\s#]{8,}/i },
+  { label: "psk", pattern: /\bpsk\s*[:=]\s*["']?[^"',\s#]{8,}/i },
+  { label: "api key", pattern: /\b(api[_-]?key|apikey)\s*[:=]\s*["']?[^"',\s#]{12,}/i },
+  { label: "token", pattern: /\b(token|secret)\s*[:=]\s*["']?[^"',\s#]{12,}/i },
+  { label: "private key", pattern: /-----BEGIN [A-Z ]*PRIVATE KEY-----/ }
+];
+function findPotentialSecrets(text) {
+  return text.split(/\r?\n/).flatMap(
+    (line, index) => SECRET_PATTERNS.filter(({ pattern }) => pattern.test(line)).map(({ label }) => ({
+      label,
+      line: index + 1,
+      preview: line.length > 120 ? `${line.slice(0, 117)}...` : line
+    }))
+  );
+}
+function formatSecretFindings(findings) {
+  return findings.map((finding) => `  line ${finding.line} (${finding.label}): ${finding.preview}`).join("\n");
+}
+
+export {
+  findPotentialSecrets,
+  formatSecretFindings
+};