nolo-cli 0.1.23 → 0.1.29

package/share/clientTableReplication.ts

@@ -0,0 +1,160 @@
+import { noloPatchRequest, noloWriteRequest } from "../database/requests";
+
+type BootstrapArgs = {
+  shareDbKey: string;
+  shareRecord: any;
+  tableDbKey: string;
+  replicaServers: string[];
+  thunkApi: any;
+  loadOriginTableSnapshot?: (
+    tableDbKey: string
+  ) => Promise<{ tableMeta: any; rows: any[] }>;
+  loadLocalTableSnapshot?: (
+    tableDbKey: string
+  ) => Promise<{ tableMeta: any; rows: any[] }>;
+  writeToServer?: (server: string, dbKey: string, data: any) => Promise<boolean>;
+  patchShareMeta?: (changes: Record<string, unknown>) => Promise<boolean>;
+};
+
+const normalizeServer = (value: unknown): string =>
+  typeof value === "string" && value.trim().length > 0
+    ? value.trim().replace(/\/+$/, "")
+    : "";
+
+const defaultLoadOriginTableSnapshot = async (args: BootstrapArgs) => {
+  const originServer = normalizeServer(
+    args.shareRecord?.meta?.originServer ?? args.shareRecord?.data?.originServer
+  );
+  const token = args.shareDbKey.startsWith("share-")
+    ? args.shareDbKey.slice("share-".length)
+    : "";
+  if (!originServer || !token) {
+    throw new Error("Origin share bootstrap requires an originServer and share token");
+  }
+
+  const headers: Record<string, string> = {};
+  const tokenValue = args.thunkApi?.getState?.()?.auth?.currentToken;
+  if (typeof tokenValue === "string" && tokenValue.length > 0) {
+    headers.Authorization = `Bearer ${tokenValue}`;
+  }
+
+  const response = await fetch(
+    `${originServer}/api/v1/share/${encodeURIComponent(token)}/table?rowLimit=all`,
+    {
+      method: "GET",
+      headers,
+    }
+  );
+  if (!response.ok) {
+    throw new Error(`Failed to load origin table snapshot (${response.status})`);
+  }
+  const payload = await response.json();
+  return {
+    tableMeta: payload?.tableMeta ?? null,
+    rows: Array.isArray(payload?.rows) ? payload.rows : [],
+  };
+};
+
+export async function bootstrapReplicatedTable(args: BootstrapArgs): Promise<{
+  replicatedServers: string[];
+  failedServers: string[];
+  lastReplicationAt: number;
+}> {
+  const loadOriginTableSnapshot =
+    args.loadOriginTableSnapshot ??
+    args.loadLocalTableSnapshot ??
+    (() => defaultLoadOriginTableSnapshot(args));
+  const state = args.thunkApi?.getState?.() ?? {};
+  const originServer = normalizeServer(
+    args.shareRecord?.meta?.originServer ??
+      args.shareRecord?.data?.originServer
+  );
+  const writeToServer =
+    args.writeToServer ??
+    ((server: string, dbKey: string, data: any) =>
+      noloWriteRequest(
+        server,
+        {
+          data,
+          customKey: dbKey,
+          userId:
+            typeof data?.userId === "string"
+              ? data.userId
+              : typeof data?.tenantId === "string"
+                ? data.tenantId
+                : args.shareRecord?.meta?.authorId,
+        },
+        state
+      ));
+  const patchShareMeta =
+    args.patchShareMeta ??
+    (async (changes: Record<string, unknown>) => {
+      if (!originServer) return false;
+      const nextMeta = {
+        ...(args.shareRecord?.meta ?? {}),
+        ...changes,
+      };
+      const ok = await noloPatchRequest(originServer, args.shareDbKey, { meta: nextMeta }, state);
+      if (ok) {
+        args.shareRecord.meta = nextMeta;
+      }
+      return ok;
+    });
+
+  const snapshot = await loadOriginTableSnapshot(args.tableDbKey);
+  const failedServers: string[] = [];
+  const lastReplicationAt = Date.now();
+
+  if (!snapshot.tableMeta?.dbKey) {
+    await patchShareMeta({
+      replicaServers: args.replicaServers,
+      replicationDirtyAt: lastReplicationAt,
+      lastReplicationError: `bootstrap failed: missing table meta for ${args.tableDbKey}`,
+    });
+    return {
+      replicatedServers: [],
+      failedServers: [...args.replicaServers],
+      lastReplicationAt,
+    };
+  }
+
+  for (const server of args.replicaServers) {
+    const metaOk = await writeToServer(server, snapshot.tableMeta.dbKey, snapshot.tableMeta);
+    if (!metaOk) {
+      failedServers.push(server);
+      continue;
+    }
+
+    for (const row of snapshot.rows) {
+      const rowOk = await writeToServer(server, row.dbKey, row);
+      if (!rowOk) {
+        failedServers.push(server);
+        break;
+      }
+    }
+  }
+
+  await patchShareMeta(
+    failedServers.length > 0
+      ? {
+          replicaServers: args.replicaServers,
+          lastReplicationAt,
+          replicationDirtyAt: lastReplicationAt,
+          lastReplicationError: `bootstrap failed: ${failedServers.join(", ")}`,
+        }
+      : {
+          replicaServers: args.replicaServers,
+          lastReplicationAt,
+          replicationDirtyAt: null,
+          lastReplicationError: null,
+        }
+  );
+
+  return {
+    replicatedServers: args.replicaServers.filter(
+      (server) => !failedServers.includes(server)
+    ),
+    failedServers,
+    lastReplicationAt,
+  };
+}

package/share/helpers.ts

@@ -0,0 +1,302 @@
+import {
+  createAgentKey,
+  createCybotKey,
+  isAgentKey,
+  splitKey,
+} from "../database/keys";
+import { DataType } from "../create/types";
+import type { ShareType } from "./types";
+
+// ── String normalization ────────────────────────────────────────────
+
+export const toSafeString = (value: unknown): string =>
+  typeof value === "string" ? value.trim() : "";
+
+export const toNonEmptyString = (value: unknown): string | undefined => {
+  const text = toSafeString(value);
+  return text || undefined;
+};
+
+export const normalizeUserId = (value: unknown): string => {
+  const text = toSafeString(value);
+  return text.startsWith("user:") ? text.slice(5) : text;
+};
+
+export const normalizeAuthorName = (value: unknown): string => {
+  const text = toSafeString(value);
+  if (!text) return "";
+  const lower = text.toLowerCase();
+  if (lower === "unknown" || lower === "unknown user") return "";
+  return text;
+};
+
+export const toSafeAgentKey = (value: unknown): string => {
+  const text = toSafeString(value);
+  return text && isAgentKey(text) ? text : "";
+};
+
+// ── Time helpers ────────────────────────────────────────────────────
+
+export const toSafeTimestamp = (value: unknown): number => {
+  const num = Number(value);
+  if (Number.isFinite(num) && num > 0) return num;
+  if (typeof value !== "string") return 0;
+  const parsed = Date.parse(value);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : 0;
+};
+
+const SHARE_TIME_FORMATTER = new Intl.DateTimeFormat("zh-CN", {
+  timeZone: "Asia/Shanghai",
+  year: "numeric",
+  month: "2-digit",
+  day: "2-digit",
+  hour: "2-digit",
+  minute: "2-digit",
+  second: "2-digit",
+  hour12: false,
+});
+
+export const formatShareTime = (timestamp: number): string => {
+  if (!timestamp) return "时间未知";
+  const date = new Date(timestamp);
+  return Number.isFinite(date.getTime()) ? SHARE_TIME_FORMATTER.format(date) : "时间未知";
+};
+
+// ── Agent extraction ────────────────────────────────────────────────
+
+const findAgentKeyInMessages = (messages: unknown[]): string => {
+  for (const raw of messages) {
+    if (!raw || typeof raw !== "object") continue;
+    const key = toSafeAgentKey((raw as Record<string, unknown>).cybotKey);
+    if (key) return key;
+  }
+  return "";
+};
+
+const findAgentKeyInArray = (items: unknown[]): string => {
+  for (const raw of items) {
+    const direct = toSafeAgentKey(raw);
+    if (direct) return direct;
+    if (!raw || typeof raw !== "object") continue;
+    const item = raw as Record<string, unknown>;
+    const key = toSafeAgentKey(item.dbKey) || toSafeAgentKey(item.id);
+    if (key) return key;
+  }
+  return "";
+};
+
+const findAgentNameInMessages = (messages: unknown[]): string => {
+  for (const raw of messages) {
+    if (!raw || typeof raw !== "object") continue;
+    const msg = raw as Record<string, unknown>;
+    const name =
+      toSafeString(msg.agentName) ||
+      toSafeString(msg.cybotName) ||
+      toSafeString(msg.sourceAgentName);
+    if (name) return name;
+  }
+  return "";
+};
+
+const findAgentNameInArray = (items: unknown[]): string => {
+  for (const raw of items) {
+    if (!raw || typeof raw !== "object") continue;
+    const item = raw as Record<string, unknown>;
+    const name =
+      toSafeString(item.name) ||
+      toSafeString(item.agentName) ||
+      toSafeString(item.cybotName) ||
+      toSafeString(item.sourceAgentName);
+    if (name) return name;
+  }
+  return "";
+};
+
+export const extractAgentInfo = (
+  type: ShareType,
+  data: Record<string, unknown>
+): { sourceAgentKey?: string; sourceAgentName?: string } => {
+  const meta = data.meta as Record<string, unknown> | undefined;
+
+  // Candidate keys in priority order
+  const keyCandidates: unknown[] = [
+    meta?.sourceAgentKey,
+    meta?.agentKey,
+    data.sourceAgentKey,
+    data.agentKey,
+    data.cybotKey,
+    type === DataType.CYBOT ? (data.dbKey ?? data.id) : undefined,
+  ];
+
+  let agentKey = "";
+  for (const candidate of keyCandidates) {
+    agentKey = toSafeAgentKey(candidate);
+    if (agentKey) break;
+  }
+
+  // Fallback: search in arrays
+  if (!agentKey && Array.isArray(data.cybots)) {
+    agentKey = findAgentKeyInArray(data.cybots);
+  }
+  if (!agentKey && Array.isArray(data.messages)) {
+    agentKey = findAgentKeyInMessages(data.messages as unknown[]);
+  }
+  if (!agentKey && Array.isArray(data.history)) {
+    agentKey = findAgentKeyInMessages(data.history as unknown[]);
+  }
+
+  // Agent name
+  const nameCandidates: unknown[] = [
+    meta?.sourceAgentName,
+    meta?.agentName,
+    meta?.cybotName,
+    data.sourceAgentName,
+    data.agentName,
+    data.cybotName,
+    type === DataType.CYBOT ? data.name : undefined,
+  ];
+
+  let agentName = "";
+  for (const candidate of nameCandidates) {
+    agentName = toSafeString(candidate);
+    if (agentName) break;
+  }
+  if (!agentName && Array.isArray(data.cybots)) {
+    agentName = findAgentNameInArray(data.cybots);
+  }
+  if (!agentName && Array.isArray(data.messages)) {
+    agentName = findAgentNameInMessages(data.messages as unknown[]);
+  }
+  if (!agentName && Array.isArray(data.history)) {
+    agentName = findAgentNameInMessages(data.history as unknown[]);
+  }
+
+  return {
+    ...(agentKey ? { sourceAgentKey: agentKey } : {}),
+    ...(agentName ? { sourceAgentName: agentName } : {}),
+  };
+};
+
+// ── Cover image extraction ──────────────────────────────────────────
+
+const extractImageFromContent = (content: unknown): string | undefined => {
+  if (Array.isArray(content)) {
+    const part = content.find(
+      (p: any) => p?.type === "image_url" && typeof p?.image_url?.url === "string"
+    );
+    if (part?.image_url?.url) return part.image_url.url;
+  }
+  if (typeof content === "string") {
+    const match = content.match(/!\[.*?\]\((.*?)\)/);
+    if (match?.[1]) return match[1];
+  }
+  return undefined;
+};
+
+export const extractCoverImage = (
+  type: ShareType,
+  data: Record<string, unknown>
+): string | undefined => {
+  if (type === DataType.IMAGE) {
+    return toNonEmptyString(data.url);
+  }
+  if (type === DataType.APP) {
+    return toNonEmptyString(data.coverImage);
+  }
+  if (type !== DataType.DIALOG) return undefined;
+
+  const messages = (Array.isArray(data.messages)
+    ? data.messages
+    : Array.isArray(data.history)
+      ? data.history
+      : []) as Record<string, unknown>[];
+
+  for (const msg of messages) {
+    const fromContent = extractImageFromContent(msg.content);
+    if (fromContent) return fromContent;
+
+    const image = toNonEmptyString(msg.image);
+    if (image) return image;
+
+    if (Array.isArray(msg.images)) {
+      const first = (msg.images as unknown[]).find(
+        (u) => typeof u === "string" && u.trim().length > 0
+      );
+      if (first) return first as string;
+    }
+  }
+  return undefined;
+};
+
+// ── Author extraction ────────────────────────────────────────────────
+
+export const toPublicAgentKey = (value: unknown): string => {
+  const key = toSafeAgentKey(value);
+  if (!key) return "";
+
+  const parts = splitKey(key);
+  if (parts.length < 3) return "";
+
+  const [type, owner] = parts;
+  const agentId = parts[parts.length - 1];
+  if (!agentId) return "";
+  if (owner === "pub") return key;
+
+  if (type === DataType.AGENT) {
+    return createAgentKey.public(agentId);
+  }
+  if (type === DataType.CYBOT) {
+    return createCybotKey.public(agentId);
+  }
+  return "";
+};
+
+export const resolveShareAuthorIdentity = (args: {
+  user?: Record<string, unknown> | null;
+  profile?: Record<string, unknown> | null;
+  fallbackName?: unknown;
+  fallbackAvatar?: unknown;
+}): { authorName?: string; authorAvatar?: string } => {
+  const authorName =
+    toNonEmptyString(args.profile?.nickname) ??
+    toNonEmptyString(args.user?.name) ??
+    toNonEmptyString(args.user?.nickname) ??
+    toNonEmptyString(args.user?.username) ??
+    toNonEmptyString(args.fallbackName);
+  const authorAvatar =
+    toNonEmptyString(args.profile?.avatar) ??
+    toNonEmptyString(args.user?.avatar) ??
+    toNonEmptyString(args.fallbackAvatar);
+
+  return {
+    ...(authorName ? { authorName } : {}),
+    ...(authorAvatar ? { authorAvatar } : {}),
+  };
+};
+
+// ── Error helpers ───────────────────────────────────────────────────
+
+export const isLevelNotFoundError = (error: unknown): boolean => {
+  if (!error || typeof error !== "object") return false;
+  const e = error as Record<string, unknown>;
+  return (
+    e.notFound === true ||
+    e.name === "NotFoundError" ||
+    e.code === "LEVEL_NOT_FOUND" ||
+    e.code === "LEVEL_NOT_FOUND_ERROR"
+  );
+};
+
+// ── Sanitization ────────────────────────────────────────────────────
+
+const SENSITIVE_FIELDS = ["apiKey", "secret", "password"] as const;
+
+export const sanitizeShareData = (
+  data: Record<string, unknown>
+): Record<string, unknown> => {
+  const snapshot = { ...data };
+  for (const field of SENSITIVE_FIELDS) {
+    delete snapshot[field];
+  }
+  return snapshot;
+};

package/share/keys.ts

@@ -0,0 +1,243 @@
+import { createKey, splitKey, isAgentKey } from "../database/keys";
+import { DataType } from "../create/types";
+import { toSafeAgentKey } from "./helpers";
+
+const SHARE_PREFIX = "share";
+const SHARE_INDEX_PREFIX = "shareidx";
+const TIMESTAMP_MAX = 9_999_999_999_999;
+
+// ── Normalization ───────────────────────────────────────────────────
+
+const normalizeUserId = (value: unknown): string => {
+  const text = String(value || "").trim();
+  return text.startsWith("user:") ? text.slice(5) : text;
+};
+
+const normalizeToken = (value: unknown): string =>
+  String(value || "").trim();
+
+const normalizeCreatedAt = (value: unknown): number => {
+  const parsed = Math.floor(Number(value));
+  if (!Number.isFinite(parsed) || parsed < 0) return 0;
+  return Math.min(parsed, TIMESTAMP_MAX);
+};
+
+const toInvertedTimestamp = (value: unknown): string =>
+  String(TIMESTAMP_MAX - normalizeCreatedAt(value)).padStart(13, "0");
+
+// ── Community index builders ────────────────────────────────────────
+
+type CommunityDimension = "creator" | "agent";
+
+const normalizeDimensionValue = (dim: CommunityDimension, raw: unknown): string =>
+  dim === "creator" ? normalizeUserId(raw) : toSafeAgentKey(raw);
+
+const createCommunityIndex = (
+  dim: CommunityDimension,
+  rawValue: unknown,
+  createdAt: unknown,
+  token: unknown
+): string => {
+  const value = normalizeDimensionValue(dim, rawValue);
+  const normalizedToken = normalizeToken(token);
+  if (!value || !normalizedToken) return "";
+  return createKey(SHARE_INDEX_PREFIX, "community", dim, value, toInvertedTimestamp(createdAt), normalizedToken);
+};
+
+const createCommunityRange = (dim: CommunityDimension, rawValue: unknown) => {
+  const value = normalizeDimensionValue(dim, rawValue);
+  if (!value) return { start: "", end: "" };
+  const start = createKey(SHARE_INDEX_PREFIX, "community", dim, value, "");
+  return { start, end: start + "\uffff" };
+};
+
+// ── Global community index (all community shares, time-ordered) ─────
+
+const createCommunityAllIndex = (
+  createdAt: unknown,
+  token: unknown
+): string => {
+  const normalizedToken = normalizeToken(token);
+  if (!normalizedToken) return "";
+  return createKey(SHARE_INDEX_PREFIX, "community", "all", toInvertedTimestamp(createdAt), normalizedToken);
+};
+
+const createCommunityAllRange = () => {
+  const start = createKey(SHARE_INDEX_PREFIX, "community", "all", "");
+  return { start, end: start + "\uffff" };
+};
+
+// ── Owner index (all shares regardless of visibility) ───────────────
+
+const createOwnerIndex = (
+  rawUserId: unknown,
+  createdAt: unknown,
+  token: unknown
+): string => {
+  const userId = normalizeUserId(rawUserId);
+  const normalizedToken = normalizeToken(token);
+  if (!userId || !normalizedToken) return "";
+  return createKey(SHARE_INDEX_PREFIX, "owner", userId, toInvertedTimestamp(createdAt), normalizedToken);
+};
+
+const createOwnerRange = (rawUserId: unknown) => {
+  const userId = normalizeUserId(rawUserId);
+  if (!userId) return { start: "", end: "" };
+  const start = createKey(SHARE_INDEX_PREFIX, "owner", userId, "");
+  return { start, end: start + "\uffff" };
+};
+
+// ── Agent key resolution from payload ───────────────────────────────
+
+const findAgentKeyInArray = (arr: unknown[]): string => {
+  for (const item of arr) {
+    const key = toSafeAgentKey(item);
+    if (key) return key;
+  }
+  return "";
+};
+
+const findAgentKeyInMessages = (messages: unknown[]): string => {
+  for (const raw of messages) {
+    if (!raw || typeof raw !== "object") continue;
+    const key = toSafeAgentKey((raw as Record<string, unknown>).cybotKey);
+    if (key) return key;
+  }
+  return "";
+};
+
+const resolveAgentKeyFromPayload = (data: any): string => {
+  if (!data || typeof data !== "object") return "";
+
+  const meta = data?.meta;
+  const payload = data?.data;
+
+  const directCandidates: unknown[] = [
+    meta?.sourceAgentKey, meta?.agentKey,
+    data?.sourceAgentKey, data?.agentKey, data?.cybotKey,
+    data?.type === DataType.CYBOT ? (data?.dbKey ?? data?.id) : "",
+  ];
+
+  for (const c of directCandidates) {
+    const key = toSafeAgentKey(c);
+    if (key) return key;
+  }
+
+  if (payload && typeof payload === "object") {
+    const payloadCandidates: unknown[] = [
+      payload?.sourceAgentKey, payload?.agentKey, payload?.cybotKey,
+      payload?.meta?.sourceAgentKey, payload?.meta?.agentKey,
+      data?.type === DataType.CYBOT ? (payload?.dbKey ?? payload?.id) : "",
+    ];
+    for (const c of payloadCandidates) {
+      const key = toSafeAgentKey(c);
+      if (key) return key;
+    }
+
+    if (Array.isArray(payload?.cybots)) {
+      const key = findAgentKeyInArray(payload.cybots);
+      if (key) return key;
+    }
+    if (Array.isArray(payload?.messages)) {
+      const key = findAgentKeyInMessages(payload.messages);
+      if (key) return key;
+    }
+    if (Array.isArray(payload?.history)) {
+      const key = findAgentKeyInMessages(payload.history);
+      if (key) return key;
+    }
+  }
+
+  return "";
+};
+
+// ── Public API ──────────────────────────────────────────────────────
+
+export const shareKey = {
+  create: (token: string) => createKey(SHARE_PREFIX, token),
+
+  range: () => {
+    const start = createKey(SHARE_PREFIX, "");
+    return { start, end: start + "\uffff" };
+  },
+
+  isShareKey: (key: string) => {
+    const parts = splitKey(key);
+    return parts.length >= 2 && parts[0] === SHARE_PREFIX;
+  },
+
+  tokenFromKey: (key: string) => {
+    if (!shareKey.isShareKey(key)) return "";
+    return key.slice(`${SHARE_PREFIX}-`.length).trim();
+  },
+
+  // Creator dimension
+  communityCreatorIndex: (authorId: string, createdAt: number, token: string) =>
+    createCommunityIndex("creator", authorId, createdAt, token),
+
+  communityCreatorRange: (authorId: string) =>
+    createCommunityRange("creator", authorId),
+
+  // Agent dimension
+  communityAgentIndex: (agentKey: string, createdAt: number, token: string) =>
+    createCommunityIndex("agent", agentKey, createdAt, token),
+
+  communityAgentRange: (agentKey: string) =>
+    createCommunityRange("agent", agentKey),
+
+  // Owner dimension (all shares, for "My Shares")
+  ownerIndex: (userId: string, createdAt: number, token: string) =>
+    createOwnerIndex(userId, createdAt, token),
+
+  ownerRange: (userId: string) =>
+    createOwnerRange(userId),
+
+  // Global community feed (all community shares, time-ordered)
+  communityAllIndex: (createdAt: number, token: string) =>
+    createCommunityAllIndex(createdAt, token),
+
+  communityAllRange: () =>
+    createCommunityAllRange(),
+
+  // From existing share data → index keys
+  communityCreatorIndexFromShare: (dbKey: string, data: any) => {
+    if (!shareKey.isShareKey(dbKey)) return "";
+    if (data?.meta?.visibility !== "community") return "";
+    const token = shareKey.tokenFromKey(dbKey);
+    return shareKey.communityCreatorIndex(data?.meta?.authorId, data?.meta?.createdAt, token);
+  },
+
+  communityAgentIndexFromShare: (dbKey: string, data: any) => {
+    if (!shareKey.isShareKey(dbKey)) return "";
+    if (data?.meta?.visibility !== "community") return "";
+    const token = shareKey.tokenFromKey(dbKey);
+    const agentKey = resolveAgentKeyFromPayload(data);
+    return shareKey.communityAgentIndex(agentKey, data?.meta?.createdAt, token);
+  },
+
+  ownerIndexFromShare: (dbKey: string, data: any) => {
+    if (!shareKey.isShareKey(dbKey)) return "";
+    const token = shareKey.tokenFromKey(dbKey);
+    return shareKey.ownerIndex(data?.meta?.authorId, data?.meta?.createdAt, token);
+  },
+
+  communityAllIndexFromShare: (dbKey: string, data: any) => {
+    if (!shareKey.isShareKey(dbKey)) return "";
+    if (data?.meta?.visibility !== "community") return "";
+    const token = shareKey.tokenFromKey(dbKey);
+    return shareKey.communityAllIndex(data?.meta?.createdAt, token);
+  },
+
+  communityIndexKeysFromShare: (dbKey: string, data: any): string[] => {
+    const all = shareKey.communityAllIndexFromShare(dbKey, data);
+    const creator = shareKey.communityCreatorIndexFromShare(dbKey, data);
+    const agent = shareKey.communityAgentIndexFromShare(dbKey, data);
+    return Array.from(new Set([all, creator, agent].filter(Boolean)));
+  },
+
+  allIndexKeysFromShare: (dbKey: string, data: any): string[] => {
+    const owner = shareKey.ownerIndexFromShare(dbKey, data);
+    const community = shareKey.communityIndexKeysFromShare(dbKey, data);
+    return Array.from(new Set([owner, ...community].filter(Boolean)));
+  },
+};