nolo-cli 0.1.40 → 0.1.42

package/secretScan.ts

@@ -0,0 +1,31 @@
+export type SecretFinding = {
+  label: string;
+  line: number;
+  preview: string;
+};
+
+const SECRET_PATTERNS: Array<{ label: string; pattern: RegExp }> = [
+  { 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-----/ },
+];
+
+export function findPotentialSecrets(text: string): SecretFinding[] {
+  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,
+      }))
+    );
+}
+
+export function formatSecretFindings(findings: SecretFinding[]) {
+  return findings
+    .map((finding) => `  line ${finding.line} (${finding.label}): ${finding.preview}`)
+    .join("\n");
+}

package/server/handlers/agentRun/types.ts

@@ -0,0 +1,105 @@
+// packages/server/handlers/agentRun/types.ts
+
+import type {
+    DialogPolicyState,
+} from "../../../ai/policy/types";
+import type { ResolvedRuntimePolicy } from "../../../ai/policy/runtimePolicy";
+import type { DialogRuntimeProfile } from "../../../app/types";
+import type { DialogSubjectRef } from "../../../app/types";
+import type {
+    AgentRuntimeChatMessage,
+    AgentRuntimeResult,
+    AgentRuntimeToolCall,
+} from "../../../agent-runtime/types";
+import type { AgentRuntimeOptions } from "../../../ai/agent/types";
+
+export type ChatMessage = AgentRuntimeChatMessage;
+
+export type AssistantToolCall = AgentRuntimeToolCall;
+
+export type AgentRunUserInputReferencePart = {
+    type: string;
+    name?: string;
+    pageKey?: string;
+    dialogKey?: string;
+};
+
+export type AgentRunUserInputPart =
+    | { type: "text"; text: string }
+    | {
+        type: "image_url";
+        image_url: { url: string };
+        google_native?: {
+            inlineData?: {
+                mimeType: string;
+                data: string;
+            };
+            thoughtSignature?: string;
+        };
+    }
+    | AgentRunUserInputReferencePart;
+
+export interface AgentRunRequest {
+    agentKey: string;
+    userInput: string | AgentRunUserInputPart[];
+    messages?: ChatMessage[]; // 历史对话，调用方自行管理（不持久化）
+    runtimeContext?: AgentRunRuntimeContext;
+    stream?: boolean;
+    timeoutMs?: number; // 可选：调用方为本次 agent run 传入的任务级超时预算
+    background?: boolean;
+    spaceId?: string;
+    category?: string;
+    inheritedFromDialogKey?: string;
+    parentDialogId?: string;
+    runtimeProfile?: DialogRuntimeProfile;
+    runtimeOptions?: AgentRuntimeOptions;
+    debugContextLayers?: boolean;
+    /** 传入已有 dialogId 时，新消息追加到该对话而不是新建 */
+    continueDialogId?: string;
+    /** UI 已自行管理消息持久化时，设为 false 避免 agent/run 额外创建运行对话 */
+    persistDialog?: boolean;
+    /** persistDialog=false 时用于工具上下文和计费归属的已有 UI dialogId */
+    clientDialogId?: string;
+}
+
+export interface AgentRunRuntimeContext {
+    surface?: "web" | "electron" | "electron-bun" | "cli" | "server-script" | "backend-script" | "react-native" | string;
+    host?: string;
+    runtime?: string;
+    entrypoint?: string;
+    capabilities?: string[];
+    subjectRefs?: DialogSubjectRef[];
+}
+
+export interface LoopResult extends Omit<AgentRuntimeResult, "policyState"> {
+    policyState?: DialogPolicyState;
+    artifacts?: unknown;
+    activeAgentKey?: string;
+    threadMetadata?: {
+        threadKind?: AgentRunRuntimeContext["threadKind"];
+        presentationIntent?: AgentRunRuntimeContext["presentationIntent"];
+    };
+}
+
+export interface ToolPolicyRuntimeState {
+    autoKnowledgeCaptureCountThisRun: number;
+    autoSpaceReadCountThisRun: number;
+}
+
+export interface ToolExecutionContext {
+    policy?: ResolvedRuntimePolicy;
+    runtimeState?: ToolPolicyRuntimeState;
+    runtimeToolSurface?: {
+        finalToolNames?: unknown;
+        explicitToolNames?: unknown;
+        injectedToolNames?: unknown;
+        auditReason?: unknown;
+    } | null;
+    runtimeContext?: AgentRunRuntimeContext | null;
+    userId?: string | null;
+    agentKey?: string | null;
+    dialogId?: string | null;
+    currentSpaceId?: string | null;
+    userInput?: string | null;
+    imageUrls?: string[];
+}

package/share/action.ts

@@ -0,0 +1,225 @@
+import type { AppThunkApi } from "../app/store";
+import { selectCurrentUser, selectUserId } from "../auth/authSlice";
+import {
+  selectCurrentServer,
+  selectRemoteServers,
+} from "../app/settings/settingSlice";
+import { normalizeTimeFields } from "../database/actions/common";
+import { createUserKey } from "../database/keys";
+import { noloDeleteRequest, noloWriteRequest } from "../database/requests";
+
+import type { SharedObject, ShareType } from "./types";
+import { shareKey } from "./keys";
+import {
+  toNonEmptyString,
+  sanitizeShareData,
+  extractCoverImage,
+  extractAgentInfo,
+  resolveShareAuthorIdentity,
+} from "./helpers";
+
+const generateToken = (): string => {
+  const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
+  const charsLen = chars.length; // 36
+  const maxValid = 252; // 252 = 36 * 7, largest multiple of 36 ≤ 255
+  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;
+};
+
+export interface ShareActionConfig {
+  type: ShareType;
+  data: Record<string, unknown>;
+  title: string;
+  description?: string;
+  visibility?: "private" | "community";
+}
+
+const assertDialogShareMessagesPresent = (
+  type: ShareType,
+  data: Record<string, unknown>
+) => {
+  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.");
+};
+
+const resolveTableSharePayload = (
+  type: ShareType,
+  data: Record<string, unknown>,
+  userId: string,
+  originServer: string
+): Record<string, unknown> => {
+  if (type !== "table") return sanitizeShareData(data);
+
+  const tableDbKey =
+    typeof data.dbKey === "string" && data.dbKey.trim().length > 0
+      ? data.dbKey
+      : undefined;
+  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,
+  };
+};
+
+export const shareResourceAction = async (
+  config: ShareActionConfig,
+  thunkApi: AppThunkApi
+): Promise<{ token: string; key: string }> => {
+  const state = thunkApi.getState();
+  const userId = selectUserId(state);
+  const currentUser = selectCurrentUser(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: Record<string, unknown> | null = null;
+
+  if (clientDb) {
+    try {
+      authorProfile = await clientDb.get(createUserKey.profile(userId));
+    } catch {
+      authorProfile = null;
+    }
+  }
+
+  const { authorName, authorAvatar } = resolveShareAuthorIdentity({
+    user: currentUser as Record<string, unknown> | null,
+    profile: authorProfile,
+  });
+
+  // Resolve agent name from local DB if we have a key but no name
+  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 { /* agent lookup is best-effort */ }
+    }
+  }
+
+  const sharedObject: 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) as string | undefined,
+      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
+          : undefined,
+      tableOwnerId:
+        typeof sharedObject.data.tableOwnerId === "string"
+          ? sharedObject.data.tableOwnerId
+          : undefined,
+      originServer: currentServer,
+      replicaServers,
+    };
+  }
+
+  const persistedSharedObject = normalizeTimeFields({
+    ...sharedObject,
+    dbKey: key,
+    userId,
+  });
+
+  // Compute index keys on the frontend — server just stores them
+  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 };
+};

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