nolo-cli 0.1.23 → 0.1.29

package/create/version/appVersionReplication.ts

@@ -0,0 +1,160 @@
+import {
+  buildVersionGetRequest,
+  buildVersionListRequest,
+  buildVersionSaveRequest,
+} from "./versionApi";
+
+export interface VersionListEntry {
+  versionId: string;
+  entityId: string;
+  type: "app" | "doc" | "agent";
+  label?: string;
+  pinned?: boolean;
+  createdAt: number | string;
+  createdBy?: string;
+}
+
+interface VersionRecord extends VersionListEntry {
+  snapshot: any;
+}
+
+export const RECENT_APP_VERSION_FANOUT_LIMIT = 5;
+
+const normalizeOrigin = (origin?: string | null): string | null => {
+  if (typeof origin !== "string") return null;
+  const trimmed = origin.trim();
+  return trimmed ? trimmed.replace(/\/+$/, "") : null;
+};
+
+async function fetchVersionList(
+  server: string,
+  token: string,
+  entityId: string
+): Promise<VersionListEntry[]> {
+  const request = buildVersionListRequest(server, token, "app", entityId);
+  const res = await fetch(request.url, request.init);
+  if (!res.ok) return [];
+  const data = await res.json().catch(() => null);
+  return Array.isArray(data?.versions) ? data.versions : [];
+}
+
+async function fetchVersionRecord(
+  server: string,
+  token: string,
+  entityId: string,
+  versionId: string
+): Promise<VersionRecord | null> {
+  const request = buildVersionGetRequest(server, token, "app", entityId, versionId);
+  const res = await fetch(request.url, request.init);
+  if (!res.ok) return null;
+  const data = await res.json().catch(() => null);
+  return data?.version && typeof data.version === "object" ? (data.version as VersionRecord) : null;
+}
+
+async function saveVersionRecord(
+  server: string,
+  token: string,
+  record: VersionRecord
+): Promise<boolean> {
+  const request = buildVersionSaveRequest(
+    server,
+    token,
+    "app",
+    record.entityId,
+    record.snapshot,
+    {
+      label: record.label,
+      pinned: record.pinned,
+      versionId: record.versionId,
+      createdAt:
+        typeof record.createdAt === "number"
+          ? record.createdAt
+          : Date.parse(record.createdAt),
+    }
+  );
+  const res = await fetch(request.url, request.init);
+  return res.ok;
+}
+
+export async function ensureSpecificAppVersionLocal(args: {
+  currentServer: string;
+  sourceServer?: string | null;
+  token: string;
+  appId: string;
+  versionId: string;
+}): Promise<boolean> {
+  const currentServer = normalizeOrigin(args.currentServer);
+  const sourceServer = normalizeOrigin(args.sourceServer);
+  if (!currentServer) return false;
+
+  const localRecord = await fetchVersionRecord(currentServer, args.token, args.appId, args.versionId);
+  if (localRecord) return true;
+
+  if (!sourceServer || sourceServer === currentServer) return false;
+  const remoteRecord = await fetchVersionRecord(sourceServer, args.token, args.appId, args.versionId);
+  if (!remoteRecord) return false;
+  return saveVersionRecord(currentServer, args.token, remoteRecord);
+}
+
+export async function syncSpecificAppVersion(args: {
+  currentServer: string;
+  sourceServer?: string | null;
+  token: string;
+  appId: string;
+  versionId: string;
+}): Promise<boolean> {
+  return ensureSpecificAppVersionLocal(args);
+}
+
+export async function syncRecentAppVersions(args: {
+  currentServer: string;
+  sourceServer?: string | null;
+  token: string;
+  appId: string;
+  limit?: number;
+}): Promise<number> {
+  const currentServer = normalizeOrigin(args.currentServer);
+  const sourceServer = normalizeOrigin(args.sourceServer);
+  if (!currentServer || !sourceServer || currentServer === sourceServer) return 0;
+
+  const remoteVersions = await fetchVersionList(sourceServer, args.token, args.appId);
+  const targetVersions = remoteVersions.slice(0, args.limit ?? RECENT_APP_VERSION_FANOUT_LIMIT);
+  if (targetVersions.length === 0) return 0;
+
+  let syncedCount = 0;
+  for (const meta of targetVersions) {
+    const record = await fetchVersionRecord(sourceServer, args.token, args.appId, meta.versionId);
+    if (!record) continue;
+    const saved = await saveVersionRecord(currentServer, args.token, record);
+    if (saved) syncedCount += 1;
+  }
+  return syncedCount;
+}
+
+export async function fetchAppVersionsCurrentServerFirst(args: {
+  currentServer: string;
+  sourceServer?: string | null;
+  token: string;
+  appId: string;
+}): Promise<VersionListEntry[]> {
+  const currentServer = normalizeOrigin(args.currentServer);
+  const sourceServer = normalizeOrigin(args.sourceServer);
+  if (!currentServer) return [];
+
+  const localVersions = await fetchVersionList(currentServer, args.token, args.appId);
+  if (localVersions.length > 0 || !sourceServer || sourceServer === currentServer) {
+    return localVersions;
+  }
+
+  const remoteVersions = await fetchVersionList(sourceServer, args.token, args.appId);
+  if (remoteVersions.length === 0) return [];
+
+  void syncRecentAppVersions({
+    currentServer,
+    sourceServer,
+    token: args.token,
+    appId: args.appId,
+  });
+
+  return remoteVersions;
+}

package/create/version/versionApi.ts

@@ -0,0 +1,142 @@
+import type { VersionEntityType } from "./VersionHistoryPanel";
+
+type JsonHeaders = Record<string, string>;
+
+const buildAuthHeaders = (token: string, includeJson = true): JsonHeaders => ({
+  Authorization: `Bearer ${token}`,
+  ...(includeJson ? { "Content-Type": "application/json" } : {}),
+});
+
+export function buildVersionListRequest(
+  server: string,
+  token: string,
+  type: VersionEntityType,
+  entityId: string
+) {
+  const params = new URLSearchParams({ type, entityId });
+  return {
+    url: `${server}/api/version/list?${params}`,
+    init: {
+      method: "GET",
+      headers: buildAuthHeaders(token, false),
+    } satisfies RequestInit,
+  };
+}
+
+export function buildVersionGetRequest(
+  server: string,
+  token: string,
+  type: VersionEntityType,
+  entityId: string,
+  versionId: string
+) {
+  const params = new URLSearchParams({ type, entityId, versionId });
+  return {
+    url: `${server}/api/version/get?${params}`,
+    init: {
+      method: "GET",
+      headers: buildAuthHeaders(token, false),
+    } satisfies RequestInit,
+  };
+}
+
+export function buildVersionSaveRequest(
+  server: string,
+  token: string,
+  type: VersionEntityType,
+  entityId: string,
+  snapshot: unknown,
+  options: {
+    label?: string;
+    pinned?: boolean;
+    versionId?: string;
+    createdAt?: number;
+  } = {}
+) {
+  return {
+    url: `${server}/api/version/save`,
+    init: {
+      method: "POST",
+      headers: buildAuthHeaders(token),
+      body: JSON.stringify({
+        type,
+        entityId,
+        snapshot,
+        label: options.label,
+        pinned: options.pinned,
+        versionId: options.versionId,
+        createdAt: options.createdAt,
+      }),
+    } satisfies RequestInit,
+  };
+}
+
+export function buildVersionPinRequest(
+  server: string,
+  token: string,
+  type: VersionEntityType,
+  entityId: string,
+  versionId: string,
+  pinned: boolean
+) {
+  return {
+    url: `${server}/api/version/pin`,
+    init: {
+      method: "POST",
+      headers: buildAuthHeaders(token),
+      body: JSON.stringify({ type, entityId, versionId, pinned }),
+    } satisfies RequestInit,
+  };
+}
+
+export function buildVersionRestoreRequest(
+  server: string,
+  token: string,
+  type: VersionEntityType,
+  entityId: string,
+  versionId: string
+) {
+  return {
+    url: `${server}/api/version/restore`,
+    init: {
+      method: "POST",
+      headers: buildAuthHeaders(token),
+      body: JSON.stringify({ type, entityId, versionId }),
+    } satisfies RequestInit,
+  };
+}
+
+export function buildVersionDeleteRequest(
+  server: string,
+  token: string,
+  type: VersionEntityType,
+  entityId: string,
+  versionId: string
+) {
+  return {
+    url: `${server}/api/version/delete`,
+    init: {
+      method: "DELETE",
+      headers: buildAuthHeaders(token),
+      body: JSON.stringify({ type, entityId, versionId }),
+    } satisfies RequestInit,
+  };
+}
+
+export function buildVersionLabelRequest(
+  server: string,
+  token: string,
+  type: VersionEntityType,
+  entityId: string,
+  versionId: string,
+  label: string
+) {
+  return {
+    url: `${server}/api/version/label`,
+    init: {
+      method: "PATCH",
+      headers: buildAuthHeaders(token),
+      body: JSON.stringify({ type, entityId, versionId, label }),
+    } satisfies RequestInit,
+  };
+}

package/customCodingAgentFlow.ts

@@ -0,0 +1,208 @@
+export type CodingAgentServerEntry = {
+  baseUrl: string;
+  userId: string;
+  authToken: string;
+};
+
+export type CodingAgentWriteResult = {
+  privateKey: string;
+  contentKey: string;
+};
+
+export type CodingAgentVerifyResult = {
+  dialogId: string;
+  content: string;
+};
+
+export type CodingAgentFlowDeps = {
+  ensureAccess: (args: {
+    baseUrl: string;
+    seed: string;
+    username: string;
+    locale: string;
+  }) => Promise<{ userId: string; authToken: string }>;
+  ensureAccessOnBases: (args: {
+    baseUrl: string;
+    seed: string;
+    username: string;
+    locale: string;
+  }) => Promise<CodingAgentServerEntry[]>;
+  upsertAgentRecordOnBases: (args: {
+    serverEntries: CodingAgentServerEntry[];
+    agentRecord: Record<string, any>;
+  }) => Promise<CodingAgentWriteResult[]>;
+  attachAgentToSpace: (args: {
+    baseUrl: string;
+    userId: string;
+    authToken: string;
+    spaceId: string;
+    contentKey: string;
+    title: string;
+  }) => Promise<void>;
+  verifyAgentResponse: (args: {
+    baseUrl: string;
+    authToken: string;
+    agentKey: string;
+    prompt: string;
+    expected: string;
+    maxRounds: number;
+  }) => Promise<CodingAgentVerifyResult>;
+  resolveTargetSpaceId: (spaceId?: string) => string | undefined;
+  now?: () => number;
+};
+
+export type CreateCodingAgentFromRecordOptions = {
+  baseUrl: string;
+  spaceId?: string;
+  localCoreBaseUrl?: string;
+  seed?: string;
+  username?: string;
+  locale?: string;
+  agentId: string;
+  skipVerify?: boolean;
+  verifyPrompt?: string;
+  expectedResponse?: string;
+  verifyRounds?: number;
+  syncAllBases?: boolean;
+  buildRecord: (args: {
+    userId: string;
+    now: number;
+    agentId: string;
+  }) => Record<string, any>;
+};
+
+export function normalizeCodingAgentBaseUrl(baseUrl: string): string {
+  return baseUrl.replace(/\/+$/, "");
+}
+
+export function splitCodingAgentServerEntries(
+  serverEntries: CodingAgentServerEntry[],
+  attachBaseUrl: string
+) {
+  const normalizedAttachBaseUrl = normalizeCodingAgentBaseUrl(attachBaseUrl);
+  const runtimeEntries = serverEntries.map((entry) => ({
+    ...entry,
+    baseUrl: normalizeCodingAgentBaseUrl(entry.baseUrl),
+  }));
+  const attachEntries = runtimeEntries.filter(
+    (entry) => entry.baseUrl === normalizedAttachBaseUrl
+  );
+
+  return {
+    runtimeEntries,
+    attachEntries,
+    needsAttachLogin: attachEntries.length === 0,
+  };
+}
+
+export async function createCodingAgentFromRecord(
+  options: CreateCodingAgentFromRecordOptions,
+  deps: CodingAgentFlowDeps
+) {
+  const {
+    baseUrl,
+    spaceId,
+    localCoreBaseUrl,
+    seed = process.env.AGENT_SEED ?? "nolo-platform-demo-account-v1",
+    username = process.env.AGENT_USER ?? "platform-demo",
+    locale = process.env.AGENT_LOCALE ?? "zh-CN",
+    agentId,
+    skipVerify = false,
+    verifyPrompt = "只回复 OK",
+    expectedResponse = "OK",
+    verifyRounds = 2,
+    syncAllBases = true,
+    buildRecord,
+  } = options;
+
+  const attachSpaceId = deps.resolveTargetSpaceId(spaceId);
+  const attachBaseUrl = normalizeCodingAgentBaseUrl(localCoreBaseUrl ?? baseUrl);
+  const serverEntries = syncAllBases
+    ? await deps.ensureAccessOnBases({
+        baseUrl,
+        seed,
+        username,
+        locale,
+      })
+    : [
+        {
+          baseUrl,
+          ...(await deps.ensureAccess({
+            baseUrl,
+            seed,
+            username,
+            locale,
+          })),
+        },
+      ];
+  const entryPlan = splitCodingAgentServerEntries(serverEntries, attachBaseUrl);
+  const attachEntries = entryPlan.needsAttachLogin
+    ? [
+        {
+          baseUrl: attachBaseUrl,
+          ...(await deps.ensureAccess({
+            baseUrl: attachBaseUrl,
+            seed,
+            username,
+            locale,
+          })),
+        },
+      ]
+    : entryPlan.attachEntries;
+  const allEntries = [
+    ...entryPlan.runtimeEntries,
+    ...attachEntries.filter(
+      (attachEntry) =>
+        !entryPlan.runtimeEntries.some((runtimeEntry) => runtimeEntry.baseUrl === attachEntry.baseUrl)
+    ),
+  ];
+  const primaryEntry = allEntries[0];
+  const { userId, authToken } = primaryEntry;
+  const now = deps.now?.() ?? Date.now();
+  const agentRecord = buildRecord({
+    userId,
+    now,
+    agentId,
+  });
+
+  const [{ privateKey, contentKey }] = await deps.upsertAgentRecordOnBases({
+    serverEntries: allEntries,
+    agentRecord,
+  });
+  if (attachSpaceId) {
+    for (const entry of attachEntries) {
+      await deps.attachAgentToSpace({
+        baseUrl: entry.baseUrl,
+        userId,
+        authToken: entry.authToken,
+        spaceId: attachSpaceId,
+        contentKey,
+        title: agentRecord.name ?? agentId,
+      });
+    }
+  }
+
+  const verify = skipVerify
+    ? { dialogId: "", content: "SKIPPED" }
+    : await deps.verifyAgentResponse({
+        baseUrl: primaryEntry.baseUrl,
+        authToken,
+        agentKey: privateKey,
+        prompt: verifyPrompt,
+        expected: expectedResponse,
+        maxRounds: verifyRounds,
+      });
+
+  return {
+    userId,
+    authToken,
+    agentId,
+    privateKey,
+    agentUrl: `${primaryEntry.baseUrl}/${privateKey}`,
+    spaceId: attachSpaceId,
+    verify,
+    replicatedBases: allEntries.map((entry) => entry.baseUrl),
+    verifiedBase: primaryEntry.baseUrl,
+    agentRecord,
+  };
+}

package/customCodingAgentRecord.ts

@@ -0,0 +1,179 @@
+export const DEFAULT_CODING_AGENT_PROMPT = [
+  "你是空间里的私有代码助理。",
+  "底层模型来自 OpenAI 兼容接口。",
+  "默认输出中文，代码、路径和命令保持英文。",
+  "执行命令前先判断当前环境；环境不明确时先调用 checkEnv({check:'context'})。",
+  "Windows 默认使用 PowerShell 语法，Linux/macOS 默认使用 bash 语法。",
+  "开始动手前先理解需求和上下文，避免无关改动。",
+  "优先做可验证、可落地的修改，必要时先读取文件和环境。",
+  "涉及代码改动时，尽量给出最小但完整的实现，并说明验证方式。",
+].join("\n");
+
+export type BuildCodingAgentRecordOptions = {
+  userId: string;
+  now: number;
+  agentId: string;
+  name: string;
+  provider: string;
+  model: string;
+  apiSource: "custom" | "platform";
+  tools: string[];
+  tags: string[];
+  introduction?: string;
+  greeting?: string;
+  prompt?: string;
+  providerUrl?: string;
+  apiKey?: string;
+  apiKeyHeader?: string;
+};
+
+export type CustomCodingAgentRecordPlanOptions = {
+  agentId?: string;
+  apiKey: string;
+  apiKeyHeader?: string;
+  providerUrl: string;
+  model: string;
+  name: string;
+  providerTag?: string;
+  introduction?: string;
+  greeting?: string;
+  prompt?: string;
+  tags?: string[];
+  tools: string[];
+};
+
+export type CustomCodingAgentRecordPlan = {
+  agentId: string;
+  normalizedProviderUrl: string;
+  normalizedApiKey: string;
+  buildRecord: (args: { userId: string; now: number }) => Record<string, any>;
+};
+
+export function deterministicId(prefix: string, seed: string): string {
+  let hash = 0x811c9dc5;
+  for (let index = 0; index < seed.length; index++) {
+    hash ^= seed.charCodeAt(index);
+    hash = (hash * 0x01000193) >>> 0;
+  }
+  const suffix = hash.toString(36).toUpperCase().padStart(14, "0");
+  return (prefix + suffix).slice(0, 26);
+}
+
+export function inferHostTag(providerUrl: string): string {
+  try {
+    return new URL(providerUrl).hostname.replace(/^www\./, "").replace(/\./g, "-");
+  } catch {
+    return "custom";
+  }
+}
+
+function isLocalProviderUrl(providerUrl: string | undefined): boolean {
+  if (!providerUrl) return false;
+  try {
+    const hostname = new URL(providerUrl).hostname.toLowerCase();
+    return hostname === "127.0.0.1" || hostname === "localhost" || hostname === "::1";
+  } catch {
+    return false;
+  }
+}
+
+export function buildCodingAgentRecord(options: BuildCodingAgentRecordOptions) {
+  const normalizedProviderUrl = options.providerUrl?.trim().replace(/\/+$/, "");
+  return {
+    type: "agent",
+    id: options.agentId,
+    userId: options.userId,
+    name: options.name.trim(),
+    introduction: options.introduction ?? `使用 ${options.provider} 的私有代码助理。`,
+    greeting:
+      options.greeting ??
+      `你好，我是 ${options.name}。你可以直接让我读项目、改代码、查环境、写脚本。`,
+    prompt: options.prompt ?? DEFAULT_CODING_AGENT_PROMPT,
+    apiSource: options.apiSource,
+    provider: options.provider,
+    model: options.model.trim(),
+    ...(normalizedProviderUrl ? { customProviderUrl: normalizedProviderUrl } : {}),
+    ...(options.apiKey?.trim() ? { apiKey: options.apiKey.trim() } : {}),
+    ...(options.apiKeyHeader?.trim() ? { apiKeyHeader: options.apiKeyHeader.trim() } : {}),
+    useServerProxy: true,
+    hasVision: false,
+    inputPrice: 0,
+    outputPrice: 0,
+    isPublic: false,
+    tools: [...options.tools],
+    tags: [...new Set(options.tags.filter(Boolean))],
+    ...(isLocalProviderUrl(normalizedProviderUrl)
+      ? {
+          runtimeBinding: {
+            kind: "desktop-local-provider",
+            providerUrl: normalizedProviderUrl,
+          },
+        }
+      : {}),
+    whitelist: [],
+    createdAt: options.now,
+    updatedAt: options.now,
+  };
+}
+
+export function resolveCustomCodingAgentRecordPlan(
+  options: CustomCodingAgentRecordPlanOptions
+): CustomCodingAgentRecordPlan {
+  const providerTag = options.providerTag ?? "custom";
+  const normalizedProviderUrl = options.providerUrl.trim().replace(/\/+$/, "");
+  const normalizedApiKey = options.apiKey.trim();
+  const model = options.model.trim();
+  const name = options.name.trim();
+
+  if (!normalizedApiKey) {
+    throw new Error("缺少 API key。");
+  }
+  if (!normalizedProviderUrl) {
+    throw new Error("缺少 provider url。");
+  }
+  if (!model) {
+    throw new Error("缺少 model。");
+  }
+  if (!name) {
+    throw new Error("缺少 agent 名称。");
+  }
+
+  const agentId =
+    options.agentId ??
+    deterministicId(
+      "01CUSTOMCODEA",
+      `custom-coding-agent:${normalizedProviderUrl}:${model}:${name}`
+    );
+  const introduction =
+    options.introduction ??
+    `使用 ${providerTag} 提供的 OpenAI 兼容接口的私有代码助理，适合代码阅读、修改、命令执行与开发协作。`;
+  const greeting =
+    options.greeting ??
+    `你好，我是 ${name}。你可以直接让我读项目、改代码、查环境、写脚本。`;
+  const prompt = options.prompt ?? DEFAULT_CODING_AGENT_PROMPT;
+  const tags = options.tags ?? [providerTag, inferHostTag(normalizedProviderUrl), "coding"];
+
+  return {
+    agentId,
+    normalizedProviderUrl,
+    normalizedApiKey,
+    buildRecord: ({ userId, now }) =>
+      buildCodingAgentRecord({
+        userId,
+        now,
+        agentId,
+        name,
+        introduction,
+        greeting,
+        prompt,
+        apiSource: "custom",
+        provider: "custom",
+        model,
+        providerUrl: normalizedProviderUrl,
+        apiKey: normalizedApiKey,
+        apiKeyHeader: options.apiKeyHeader,
+        tools: options.tools,
+        tags,
+      }),
+  };
+}