nolo-cli 0.1.44 → 0.1.46

package/connector-experimental/heartbeatLoop.ts

@@ -1,22 +0,0 @@
-export type HeartbeatLoopOptions = {
-  intervalMs: number;
-  sendHeartbeat: () => Promise<void>;
-  sleep?: (ms: number) => Promise<void>;
-  signal?: AbortSignal;
-  maxBeats?: number;
-};
-
-const defaultSleep = (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms));
-
-export async function runHeartbeatLoop(options: HeartbeatLoopOptions): Promise<void> {
-  const sleep = options.sleep ?? defaultSleep;
-  let beats = 0;
-
-  while (!options.signal?.aborted) {
-    await options.sendHeartbeat();
-    beats += 1;
-    if (options.maxBeats && beats >= options.maxBeats) return;
-    if (options.signal?.aborted) return;
-    await sleep(options.intervalMs);
-  }
-}

package/connector-experimental/machineInfo.ts

@@ -1,46 +0,0 @@
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { arch, hostname, homedir, platform } from "node:os";
-import { randomUUID } from "node:crypto";
-
-import { detectRuntimeCapabilities } from "./capabilities";
-import type { MachineHeartbeat } from "./protocol";
-
-const CONNECTOR_VERSION = "0.1.0-experimental";
-
-function defaultMachineIdPath() {
-  return join(homedir(), ".nolo", "machine-id");
-}
-
-export function resolveMachineId(path = defaultMachineIdPath()) {
-  try {
-    if (existsSync(path)) {
-      const existing = readFileSync(path, "utf8").trim();
-      if (existing) return existing;
-    }
-    const next = `machine-${randomUUID()}`;
-    mkdirSync(dirname(path), { recursive: true });
-    writeFileSync(path, `${next}\n`, "utf8");
-    return next;
-  } catch {
-    return `machine-${hostname().toLowerCase()}`;
-  }
-}
-
-export function detectMachineInfo(overrides?: {
-  machineId?: string;
-  name?: string;
-  capabilities?: string[];
-  probeLaunchable?: boolean;
-}): MachineHeartbeat {
-  return {
-    machineId: overrides?.machineId ?? resolveMachineId(),
-    name: overrides?.name ?? hostname(),
-    platform: platform(),
-    arch: arch(),
-    connectorVersion: CONNECTOR_VERSION,
-    capabilities: overrides?.capabilities ?? detectRuntimeCapabilities({
-      probeLaunchable: overrides?.probeLaunchable,
-    }),
-  };
-}

package/connector-experimental/protocol.ts

@@ -1,54 +0,0 @@
-export type MachineHeartbeatInput = {
-  machineId?: unknown;
-  name?: unknown;
-  platform?: unknown;
-  arch?: unknown;
-  connectorVersion?: unknown;
-  capabilities?: unknown;
-};
-
-export type MachineHeartbeat = {
-  machineId: string;
-  name: string;
-  platform: string;
-  arch: string;
-  connectorVersion?: string;
-  capabilities: string[];
-};
-
-const normalizeRequiredString = (value: unknown, field: string) => {
-  if (typeof value !== "string" || !value.trim()) {
-    throw new Error(`${field} is required`);
-  }
-  return value.trim();
-};
-
-const normalizeOptionalString = (value: unknown) =>
-  typeof value === "string" && value.trim() ? value.trim() : undefined;
-
-export function normalizeCapabilityList(value: unknown): string[] {
-  if (!Array.isArray(value)) return [];
-  const seen = new Set<string>();
-  const result: string[] = [];
-  for (const item of value) {
-    if (typeof item !== "string") continue;
-    const normalized = item.trim();
-    if (!normalized || seen.has(normalized)) continue;
-    seen.add(normalized);
-    result.push(normalized);
-  }
-  return result;
-}
-
-export function normalizeMachineHeartbeat(input: MachineHeartbeatInput): MachineHeartbeat {
-  const heartbeat: MachineHeartbeat = {
-    machineId: normalizeRequiredString(input.machineId, "machineId"),
-    name: normalizeRequiredString(input.name, "name"),
-    platform: normalizeRequiredString(input.platform, "platform"),
-    arch: normalizeRequiredString(input.arch, "arch"),
-    capabilities: normalizeCapabilityList(input.capabilities),
-  };
-  const connectorVersion = normalizeOptionalString(input.connectorVersion);
-  if (connectorVersion) heartbeat.connectorVersion = connectorVersion;
-  return heartbeat;
-}

package/connectorRunArtifact.ts

@@ -1,120 +0,0 @@
-import { existsSync } from "node:fs";
-import { resolve } from "node:path";
-import type { MachineRunPermissionPolicy } from "./ai/agent/machineRunPermissions";
-
-type EnvLike = Record<string, string | undefined>;
-
-export type ConnectorRunArtifact = {
-  cwd: string;
-  exitStatus: "completed" | "failed";
-  collectedAt: string;
-  baseSha?: string | null;
-  headSha?: string | null;
-  changedFiles?: string[];
-  statusShort?: string;
-  diffStat?: string;
-  patchPreview?: string;
-  error?: string;
-  artifactError?: string;
-};
-
-const MAX_PATCH_PREVIEW_CHARS = 24_000;
-
-function normalizePath(value: string) {
-  return resolve(value.trim());
-}
-
-export function resolveConnectorRunCwd(args: {
-  env?: EnvLike;
-  policy: MachineRunPermissionPolicy;
-  fallbackCwd?: string;
-}) {
-  const explicit =
-    args.env?.NOLO_CONNECTOR_WORKDIR ||
-    args.env?.NOLO_AGENT_WORKDIR ||
-    "";
-  const candidate = explicit || args.policy.writableRoots[0] || args.fallbackCwd || process.cwd();
-  const cwd = normalizePath(candidate);
-  if (!existsSync(cwd)) {
-    throw new Error(`Connector run cwd does not exist: ${cwd}`);
-  }
-  return cwd;
-}
-
-async function runGit(
-  args: string[],
-  cwd: string,
-  options: { trim?: boolean } = {}
-): Promise<string | null> {
-  const proc = Bun.spawn(["git", ...args], {
-    cwd,
-    stdout: "pipe",
-    stderr: "pipe",
-    stdin: "ignore",
-  });
-  const [stdout, exitCode] = await Promise.all([
-    new Response(proc.stdout).text(),
-    proc.exited,
-  ]);
-  if (exitCode !== 0) return null;
-  return options.trim === false ? stdout.replace(/\r?\n$/, "") : stdout.trim();
-}
-
-export function parseStatusChangedFiles(statusShort: string | null): string[] {
-  if (!statusShort) return [];
-  return [...new Set(statusShort
-    .split(/\r?\n/)
-    .map((line) => {
-      const porcelainMatch = line.match(/^.{2} (.+)$/);
-      if (porcelainMatch?.[1]) return porcelainMatch[1].trim();
-      const trimmedMatch = line.match(/^[MADRCU?!]{1,2}\s+(.+)$/);
-      return trimmedMatch?.[1]?.trim() ?? "";
-    })
-    .map((line) => line.includes(" -> ") ? line.split(" -> ").at(-1) ?? line : line)
-    .filter(Boolean))];
-}
-
-export async function readConnectorGitHead(cwd: string): Promise<string | null> {
-  return runGit(["rev-parse", "HEAD"], cwd);
-}
-
-export async function collectConnectorRunArtifact(args: {
-  cwd: string;
-  baseSha?: string | null;
-  exitStatus: "completed" | "failed";
-  error?: string;
-}): Promise<ConnectorRunArtifact> {
-  const collectedAt = new Date().toISOString();
-  try {
-    const [headSha, statusShort, diffStat, patchText] = await Promise.all([
-      readConnectorGitHead(args.cwd),
-      runGit(["status", "--short"], args.cwd, { trim: false }),
-      runGit(["diff", "--stat"], args.cwd),
-      runGit(["diff", "--no-color", "--unified=3"], args.cwd),
-    ]);
-    const patchPreview = patchText && patchText.length > MAX_PATCH_PREVIEW_CHARS
-      ? `${patchText.slice(0, MAX_PATCH_PREVIEW_CHARS)}\n...[truncated ${patchText.length - MAX_PATCH_PREVIEW_CHARS} chars]`
-      : patchText || undefined;
-    return {
-      cwd: args.cwd,
-      exitStatus: args.exitStatus,
-      collectedAt,
-      baseSha: args.baseSha ?? null,
-      headSha,
-      changedFiles: parseStatusChangedFiles(statusShort),
-      ...(statusShort ? { statusShort } : {}),
-      ...(diffStat ? { diffStat } : {}),
-      ...(patchPreview ? { patchPreview } : {}),
-      ...(args.error ? { error: args.error } : {}),
-    };
-  } catch (error) {
-    return {
-      cwd: args.cwd,
-      exitStatus: args.exitStatus,
-      collectedAt,
-      baseSha: args.baseSha ?? null,
-      ...(args.error ? { error: args.error } : {}),
-      artifactError: error instanceof Error ? error.message : String(error),
-    };
-  }
-}

package/connectorWebSocketTarget.ts

@@ -1,112 +0,0 @@
-export class ConnectorWebSocketAuthError extends Error {
-  code: string;
-
-  constructor(message: string, code = "CONNECTOR_AUTH_FAILED") {
-    super(message);
-    this.name = "ConnectorWebSocketAuthError";
-    this.code = code;
-  }
-}
-
-export function isConnectorWebSocketAuthError(error: unknown): error is ConnectorWebSocketAuthError {
-  return error instanceof ConnectorWebSocketAuthError;
-}
-
-export class ConnectorWebSocketRetryableError extends Error {
-  reason: string;
-  retryAfterMs?: number;
-
-  constructor(message: string, options: { reason?: string; retryAfterMs?: number } = {}) {
-    super(message);
-    this.name = "ConnectorWebSocketRetryableError";
-    this.reason = options.reason ?? "retryable";
-    this.retryAfterMs = options.retryAfterMs;
-  }
-}
-
-export function isConnectorWebSocketRetryableError(
-  error: unknown
-): error is ConnectorWebSocketRetryableError {
-  return error instanceof ConnectorWebSocketRetryableError;
-}
-
-function parseRetryAfterMs(response: Response, bodyRetryAfterMs?: unknown) {
-  const headerValue = response.headers.get("Retry-After");
-  if (typeof headerValue === "string" && headerValue.trim()) {
-    const asSeconds = Number(headerValue.trim());
-    if (Number.isFinite(asSeconds) && asSeconds >= 0) {
-      return Math.round(asSeconds * 1_000);
-    }
-    const asDateMs = Date.parse(headerValue.trim());
-    if (Number.isFinite(asDateMs)) {
-      return Math.max(0, asDateMs - Date.now());
-    }
-  }
-  const parsed = Number(bodyRetryAfterMs);
-  return Number.isFinite(parsed) && parsed >= 0 ? Math.round(parsed) : undefined;
-}
-
-export async function resolveConnectorWebSocketTarget(input: {
-  serverUrl: string;
-  machineId: string;
-  connectorSurface?: string;
-  headers: Record<string, string>;
-  fetchImpl?: typeof fetch;
-}) {
-  const directWsUrl = new URL(input.serverUrl);
-  directWsUrl.protocol = directWsUrl.protocol === "https:" ? "wss:" : "ws:";
-  directWsUrl.pathname = "/api/connector/ws";
-  directWsUrl.search = "";
-  directWsUrl.searchParams.set("machineId", input.machineId);
-  if (input.connectorSurface?.trim()) {
-    directWsUrl.searchParams.set(
-      "connectorSurface",
-      input.connectorSurface.trim().toLowerCase()
-    );
-  }
-
-  const probeUrl = new URL(input.serverUrl);
-  probeUrl.pathname = "/api/connector/ws";
-  probeUrl.search = directWsUrl.search;
-
-  const response = await (input.fetchImpl ?? fetch)(probeUrl, {
-    headers: input.headers,
-  }).catch(() => null);
-
-  if (response && (response.status === 401 || response.status === 403)) {
-    const json = await response.json().catch(() => null);
-    const code = typeof json?.code === "string" ? json.code : "CONNECTOR_AUTH_FAILED";
-    const message = typeof json?.error === "string" ? json.error : `Connector auth failed with HTTP ${response.status}`;
-    throw new ConnectorWebSocketAuthError(`${code}: ${message}`, code);
-  }
-
-  if (response && !response.ok) {
-    const json = await response.clone().json().catch(() => null);
-    const retryable =
-      json?.retryable === true ||
-      json?.reason === "core_draining" ||
-      response.status === 502 ||
-      response.status === 503 ||
-      response.status === 504;
-    if (retryable) {
-      const reason = typeof json?.reason === "string" ? json.reason : "retryable";
-      const message =
-        typeof json?.error === "string"
-          ? json.error
-          : `Connector websocket unavailable with HTTP ${response.status}`;
-      throw new ConnectorWebSocketRetryableError(message, {
-        reason,
-        retryAfterMs: parseRetryAfterMs(response, json?.retryAfterMs),
-      });
-    }
-  }
-
-  if (!response || !response.ok) {
-    return directWsUrl.toString();
-  }
-
-  const json = await response.json().catch(() => null);
-  return typeof json?.wsUrl === "string" && json.wsUrl
-    ? json.wsUrl
-    : directWsUrl.toString();
-}

package/core/builtinAgents.ts

@@ -1,209 +0,0 @@
-import { APP_BUILDER_PRESET } from "../ai/tools/agent/presets/appBuilderPreset";
-import { FIREWORKS_KIMI_LATEST_MODEL } from "../ai/llm/kimi";
-
-export const BUILTIN_NOLO_AGENT_KEY = "agent-pub-01NOLOAPPBLD000000019KCKT0";
-export const BUILTIN_APP_BUILDER_AGENT_KEY =
-  "agent-pub-01APPBUILDER00000001YAII3I";
-export const BUILTIN_ECOMMERCE_AGENT_KEY =
-  "agent-pub-01ECOMMERCEAG00000001PYQ2J";
-export const BUILTIN_AGENT_CREATOR_AGENT_KEY =
-  "agent-pub-01NOLOAGENTCRT000000000001";
-export const BUILTIN_NOLO_AGENT_ID = "01NOLOAPPBLD000000019KCKT0";
-export const BUILTIN_APP_BUILDER_AGENT_ID = "01APPBUILDER00000001YAII3I";
-export const BUILTIN_ECOMMERCE_AGENT_ID = "01ECOMMERCEAG00000001PYQ2J";
-export const BUILTIN_AGENT_CREATOR_AGENT_ID = "01NOLOAGENTCRT000000000001";
-
-const BUILTIN_PUBLIC_RUNTIME_SERVER_BASE = "https://nolo.chat";
-
-const buildBuiltinBaseAgent = (overrides: Record<string, unknown>) => {
-  const timestamp = Date.now();
-  return {
-    type: "agent",
-    isPublic: true,
-    userId: "builtin",
-    createdAt: timestamp,
-    updatedAt: timestamp,
-    references: [],
-    ...overrides,
-  };
-};
-
-const BUILTIN_NOLO_PROMPT = [
-  "你是 nolo，负责帮助刚进入产品的用户理解现在能做什么，并把他们带到合适的下一步。",
-  "优先直接回答、解释入口、帮用户开始对话、创建 AI、创建文档，或把任务交给更合适的 agent。",
-  "用户只是泛泛提问时，先收敛问题，不要立刻切换到重型流程。",
-  `当用户明确要创建、定制或发布 AI / Agent / 智能体时，调用 runStreamingAgent 转交给 AI 创建助手，agentKey 是 ${BUILTIN_AGENT_CREATOR_AGENT_KEY}。`,
-  "不要自己调用 prepareAgentDraft 或 createAgent；AI 创建助手负责草稿预览、用户确认和最终创建。",
-  "不要调用 deleteSpaces 这类高风险能力。",
-].join("\n");
-
-export const BUILTIN_AGENT_CREATOR_PROMPT = [
-  "你是 Nolo 的 AI 创建助手，只负责通过对话帮助用户创建或调整一个新的 Agent。",
-  "先理解用户想让这个 AI 服务谁、完成什么任务、使用什么语气、需要哪些能力、是否需要知识引用，以及是否适合公开。",
-  "当信息足够形成初版配置时，先调用 prepareAgentDraft，生成可预览草稿；信息不足时每次只问一个关键问题。",
-  "prepareAgentDraft 只生成草稿，不代表已经创建真实 Agent。",
-  "草稿展示后，等待用户明确确认，例如“确认创建”“就按这个创建”“创建这个 AI”。",
-  "只有得到明确确认后，才调用 createAgent 创建真实 Agent。",
-  "用户只是讨论、补充、修改或说“先看看”时，不要调用 createAgent。",
-  "默认模型使用 provider=fireworks, model=accounts/fireworks/models/kimi-latest；除非用户明确要求且平台已知支持，不要选择 Claude/Anthropic 等当前 runtime 不支持的 provider。",
-  "公开状态保持保守：你可以建议公开，但只有用户明确要求公开发布时，createAgent 的 isPublic 才能为 true。",
-  "如果用户想手动微调模型、工具、知识引用或发布状态，可以引导用户进入 /create/agent 高级编辑页。",
-].join("\n");
-
-export const buildBuiltinNoloRecord = () =>
-  buildBuiltinBaseAgent({
-    dbKey: BUILTIN_NOLO_AGENT_KEY,
-    id: BUILTIN_NOLO_AGENT_ID,
-    name: "nolo",
-    introduction:
-      "专门用来引导用户理解 Nolo 能做什么，并把问题带到正确入口或更合适的 Agent。",
-    greeting:
-      "你好，我是 nolo。你可以直接说你想做什么，我会帮你开始、解释入口，或把任务交给更合适的能力。",
-    provider: "fireworks",
-    model: FIREWORKS_KIMI_LATEST_MODEL,
-    useServerProxy: true,
-    apiSource: "platform",
-    runtimeServerBase: BUILTIN_PUBLIC_RUNTIME_SERVER_BASE,
-    inputPrice: 0.95 * 8,
-    outputPrice: 4 * 8,
-    hasVision: true,
-    tags: ["nolo", "引导", "分发"],
-    tools: ["fetchWebpage", "runStreamingAgent"],
-    prompt: BUILTIN_NOLO_PROMPT,
-  });
-
-export const buildBuiltinAppBuilderRecord = () =>
-  buildBuiltinBaseAgent({
-    ...APP_BUILDER_PRESET,
-    dbKey: BUILTIN_APP_BUILDER_AGENT_KEY,
-    id: BUILTIN_APP_BUILDER_AGENT_ID,
-    runtimeServerBase: BUILTIN_PUBLIC_RUNTIME_SERVER_BASE,
-    tags: ["应用构建", "App Builder", "无代码"],
-  });
-
-export const buildBuiltinEcommerceAgentRecord = () =>
-  buildBuiltinBaseAgent({
-    dbKey: BUILTIN_ECOMMERCE_AGENT_KEY,
-    id: BUILTIN_ECOMMERCE_AGENT_ID,
-    name: "电商商品参数助手",
-    introduction:
-      "专门获取淘宝、天猫、京东等电商商品真实参数、SKU、价格、库存和店铺信息，并做结构化对比。",
-    greeting: "发给我淘宝、天猫或京东商品链接，我会尽量获取真实商品参数。",
-    provider: "fireworks",
-    model: FIREWORKS_KIMI_LATEST_MODEL,
-    useServerProxy: true,
-    apiSource: "platform",
-    runtimeServerBase: BUILTIN_PUBLIC_RUNTIME_SERVER_BASE,
-    inputPrice: 0.95 * 8,
-    outputPrice: 4 * 8,
-    hasVision: false,
-    tags: ["电商", "商品参数", "数据抓取"],
-    tools: ["taobaoTmallProductScraper", "jdProductScraper"],
-    prompt: [
-      "你是电商商品参数助手，只负责获取和整理电商商品真实数据。",
-      "当用户给淘宝/天猫链接或商品 ID 时，先提取数字 itemId，再调用 taobaoTmallProductScraper。",
-      "当用户给京东链接或 SKU 时，先提取数字 skuId，再调用 jdProductScraper。",
-      "输出要结构化：商品标题、品牌、型号、店铺、价格、SKU/规格、库存、尺寸重量、质保、数据来源和缺失项。",
-      "用户问参数或详情时，必须展开工具返回的详细参数，不要只摘要基础字段。",
-      "只输出用户请求的数据结果；不要输出寒暄、确认、过渡句或结尾追问。",
-      "如果用户给多个商品，逐个调用对应工具后再做对比表。",
-      "如果工具返回缺失字段，如实说明缺失；不要编造参数，也不要要求用户手抄页面。",
-    ].join("\n"),
-  });
-
-export const buildBuiltinAgentCreatorRecord = () =>
-  buildBuiltinBaseAgent({
-    dbKey: BUILTIN_AGENT_CREATOR_AGENT_KEY,
-    id: BUILTIN_AGENT_CREATOR_AGENT_ID,
-    name: "AI 创建助手",
-    introduction:
-      "通过对话帮你整理专属 AI 的用途、能力、Prompt、知识引用和发布建议，并在确认后创建。",
-    greeting:
-      "告诉我你想创建一个什么样的 AI：它要帮谁、完成什么、需要哪些能力或资料？",
-    provider: "fireworks",
-    model: "accounts/fireworks/models/kimi-latest",
-    useServerProxy: true,
-    apiSource: "platform",
-    runtimeServerBase: BUILTIN_PUBLIC_RUNTIME_SERVER_BASE,
-    inputPrice: 0.95 * 8,
-    outputPrice: 4 * 8,
-    hasVision: false,
-    tags: ["AI 创建", "Agent 创建", "配置助手"],
-    tools: ["prepareAgentDraft", "createAgent"],
-    prompt: BUILTIN_AGENT_CREATOR_PROMPT,
-  });
-
-export const normalizeBuiltinPublicAgentRecord = <T extends Record<string, any>>(
-  agent: T,
-): T => {
-  if (!agent || typeof agent !== "object") return agent;
-  const key = typeof agent.dbKey === "string" ? agent.dbKey : "";
-  const id = typeof agent.id === "string" ? agent.id : "";
-  const isBuiltinCreator =
-    key === BUILTIN_AGENT_CREATOR_AGENT_KEY || id === BUILTIN_AGENT_CREATOR_AGENT_ID;
-
-  if (!isBuiltinCreator) return agent;
-
-  const builtin = buildBuiltinAgentCreatorRecord();
-  return {
-    ...agent,
-    name: builtin.name,
-    introduction: builtin.introduction,
-    greeting: builtin.greeting,
-    provider: builtin.provider,
-    model: builtin.model,
-    useServerProxy: builtin.useServerProxy,
-    apiSource: builtin.apiSource,
-    runtimeServerBase: builtin.runtimeServerBase,
-    inputPrice: builtin.inputPrice,
-    outputPrice: builtin.outputPrice,
-    hasVision: builtin.hasVision,
-    references: builtin.references,
-    tags: builtin.tags,
-    tools: builtin.tools,
-    prompt: builtin.prompt,
-  };
-};
-
-export const BUILTIN_PLATFORM_AGENT_KEYS = [
-  BUILTIN_NOLO_AGENT_KEY,
-  BUILTIN_APP_BUILDER_AGENT_KEY,
-  BUILTIN_ECOMMERCE_AGENT_KEY,
-  BUILTIN_AGENT_CREATOR_AGENT_KEY,
-] as const;
-
-const BUILTIN_PLATFORM_AGENT_KEY_SET = new Set<string>(BUILTIN_PLATFORM_AGENT_KEYS);
-
-export const isBuiltinPlatformAgentRecord = (agent: {
-  dbKey?: string | null;
-  id?: string | null;
-}): boolean => {
-  const dbKey = typeof agent?.dbKey === "string" ? agent.dbKey : "";
-  if (dbKey && BUILTIN_PLATFORM_AGENT_KEY_SET.has(dbKey)) return true;
-
-  const id = typeof agent?.id === "string" ? agent.id : "";
-  if (!id) return false;
-
-  return BUILTIN_PLATFORM_AGENT_KEYS.some((key) => key.endsWith(id));
-};
-
-export const shouldHideBuiltinAgentFromPublicPlaza = (agent: {
-  dbKey?: string | null;
-  id?: string | null;
-}): boolean => isBuiltinPlatformAgentRecord(agent);
-
-export const buildBuiltinPlatformAgentRecord = (dbKey: string) => {
-  if (dbKey === BUILTIN_NOLO_AGENT_KEY) {
-    return buildBuiltinNoloRecord();
-  }
-  if (dbKey === BUILTIN_APP_BUILDER_AGENT_KEY) {
-    return buildBuiltinAppBuilderRecord();
-  }
-  if (dbKey === BUILTIN_ECOMMERCE_AGENT_KEY) {
-    return buildBuiltinEcommerceAgentRecord();
-  }
-  if (dbKey === BUILTIN_AGENT_CREATOR_AGENT_KEY) {
-    return buildBuiltinAgentCreatorRecord();
-  }
-  return null;
-};

package/core/config.ts

@@ -1,15 +0,0 @@
-const providerName = "nolotus";
-
-const slogonforYou =
-  "The goodness or badness of this world concerns every individual.";
-
-// be cart  CryptoJS.PBKDF2  keySize: 256 / AUTH_VERSION[1].keylen,
-// even keylen same ,maybe error rn with web version
-export const AUTH_VERSION = {
-  "1": {
-    iterations: 10000,
-    salt: providerName + slogonforYou,
-    keylen: 32,
-  },
-};
-export const SALT = AUTH_VERSION[1].salt;

package/core/crypto.ts

@@ -1,51 +0,0 @@
-import nacl from "tweetnacl";
-import { Base64 } from "js-base64";
-
-export const signMessage = (
-  message: string,
-  secretKeyBase64: string
-): string => {
-  const messageUint8 = new TextEncoder().encode(message);
-  const signedMessage = nacl.sign(
-    messageUint8,
-    Base64.toUint8Array(secretKeyBase64)
-  );
-  return Base64.fromUint8Array(signedMessage);
-};
-
-export const verifySignedMessage = (
-  signedMessageBase64: string,
-  publicKeyBase64: string
-): string => {
-  const message = nacl.sign.open(
-    Base64.toUint8Array(signedMessageBase64),
-    Base64.toUint8Array(publicKeyBase64)
-  );
-
-  if (!message) throw new Error("Decoding failed");
-  return new TextDecoder().decode(message);
-};
-
-export const detachedSign = (message: string, secretKeyBase64: string) => {
-  const signature = nacl.sign.detached(
-    new TextEncoder().encode(message),
-    Base64.toUint8Array(secretKeyBase64)
-  );
-  return Base64.fromUint8Array(signature, true);
-};
-
-export const verifyDetachedSignature = (
-  message: string,
-  signatureBase64: string,
-  publicKeyBase64: string
-): boolean => {
-  try {
-    return nacl.sign.detached.verify(
-      new TextEncoder().encode(message),
-      Base64.toUint8Array(signatureBase64),
-      Base64.toUint8Array(publicKeyBase64)
-    );
-  } catch {
-    return false;
-  }
-};

package/core/generateKeyPairFromSeedV1.ts

@@ -1,15 +0,0 @@
-// keypair.ts
-import nacl from "tweetnacl";
-import { Base64 } from "js-base64";
-
-export const generateKeyPairFromSeedV1 = (seedData: string) => {
-  const seed = new TextEncoder().encode(seedData);
-  const hashSeed = nacl.hash(seed);
-  const seed32 = hashSeed.slice(0, 32);
-  const keyPair = nacl.sign.keyPair.fromSeed(seed32);
-
-  return {
-    publicKey: Base64.fromUint8Array(keyPair.publicKey, true),
-    secretKey: Base64.fromUint8Array(keyPair.secretKey, true),
-  };
-};

package/core/generateMainKey.ts

@@ -1,22 +0,0 @@
-import nacl from "tweetnacl";
-
-export const generateUserIdV1 = (
-  publicKey: string,
-  username: string,
-  language: string,
-  extra: string = ""
-) => {
-  const text = publicKey + username + language + extra;
-  const encodedText = new TextEncoder().encode(text);
-  const hash = nacl.hash(encodedText);
-
-  // 方案1：使用Array.from和map
-  const hexString = Array.from(hash)
-    .map((b) => b.toString(16).padStart(2, "0"))
-    .join("");
-
-  // 方案2：更简洁的写法，用Uint8Array直接转
-  // const hexString = [...hash].map(x => x.toString(16).padStart(2,'0')).join('');
-
-  return hexString.slice(0, 10);
-};