nolo-cli 0.1.26 → 0.1.30

package/server/handlers/agentRun/toolPolicyGuards.ts

@@ -0,0 +1,295 @@
+import { isBudgetedWorkspaceReadKey } from "../../../ai/policy/runtimePolicy";
+import { hasExplicitPublicShareRequest } from "../../../share/publicSharePolicy";
+
+import type { ToolExecutionContext } from "./types";
+
+export const buildPolicyLimitResult = (
+  error: string,
+  message: string,
+  policy: Record<string, any>,
+): string =>
+  JSON.stringify({
+    error,
+    message,
+    policy,
+  });
+
+const normalizeUserInput = (value: unknown): string =>
+  typeof value === "string" ? value.trim().toLowerCase() : "";
+
+const containsAny = (text: string, patterns: readonly string[]): boolean =>
+  patterns.some((pattern) => text.includes(pattern));
+
+const DESTRUCTIVE_NEGATION_PATTERNS = [
+  "别删",
+  "别删除",
+  "不要删",
+  "不要删除",
+  "别乱删",
+  "别动",
+  "不要动",
+  "不要清理",
+  "不要清空",
+  "不要重置",
+  "don't delete",
+  "do not delete",
+  "don't remove",
+  "do not remove",
+  "without deleting",
+] as const;
+
+const EXPLICIT_DESTRUCTIVE_REQUEST_PATTERNS = [
+  "删除",
+  "删掉",
+  "移除",
+  "清理",
+  "清空",
+  "重置",
+  "drop",
+  "delete",
+  "remove",
+  "erase",
+  "clean up",
+  "reset",
+] as const;
+
+const SHELL_DESTRUCTIVE_PATTERNS = [
+  /\brm\s+(-[^\n\r]*\s+)?/i,
+  /\bremove-item\b/i,
+  /\bdel\s+\/?[a-z]*\s+/i,
+  /\berase\s+/i,
+  /\brmdir\s+/i,
+  /\brd\s+\/s\b/i,
+  /\bgit\s+reset\s+(--hard\b|--merge\b|--keep\b)/i,
+  /\bgit\s+clean\s+-[^\n\r]*f/i,
+  /\bgit\s+checkout\s+--\b/i,
+  /\bgit\s+restore\s+--source=/i,
+] as const;
+
+const hasExplicitDestructivePermission = (
+  userInput: unknown,
+): boolean => {
+  const normalized = normalizeUserInput(userInput);
+  if (!normalized) return false;
+  if (containsAny(normalized, DESTRUCTIVE_NEGATION_PATTERNS)) {
+    return false;
+  }
+  return containsAny(normalized, EXPLICIT_DESTRUCTIVE_REQUEST_PATTERNS);
+};
+
+export const guardDestructiveAction = (params: {
+  context?: ToolExecutionContext;
+  target:
+    | "shell_command"
+    | "app_delete"
+    | "table_row_delete"
+    | "table_column_delete";
+  detail: string;
+}): string | null => {
+  const { context, target, detail } = params;
+  if (hasExplicitDestructivePermission(context?.userInput)) {
+    return null;
+  }
+
+  return buildPolicyLimitResult(
+    "destructive_action_requires_confirmation",
+    `当前运行默认禁止自动执行可能删除用户内容的操作（${detail}）。只有当用户在当前请求里明确要求删除/清理时，才能继续；否则请停止并先说明限制。`,
+    {
+      capability: "destructive_action",
+      target,
+      detail,
+    },
+  );
+};
+
+export const isDestructiveShellCommand = (params: {
+  command?: unknown;
+  input?: unknown;
+}): boolean => {
+  const combined = [
+    typeof params.command === "string" ? params.command : "",
+    typeof params.input === "string" ? params.input : "",
+  ]
+    .filter(Boolean)
+    .join("\n");
+
+  if (!combined.trim()) return false;
+  return SHELL_DESTRUCTIVE_PATTERNS.some((pattern) => pattern.test(combined));
+};
+
+export const guardWorkspaceRead = (
+  dbKey: unknown,
+  context?: ToolExecutionContext,
+): string | null => {
+  if (
+    !context?.policy?.spaceContext ||
+    !context.runtimeState ||
+    typeof dbKey !== "string" ||
+    !isBudgetedWorkspaceReadKey(dbKey)
+  ) {
+    return null;
+  }
+
+  const { spaceContext } = context.policy;
+  const turnReads = context.runtimeState.autoSpaceReadCountThisRun;
+  const totalReads =
+    spaceContext.currentAutoReads + context.runtimeState.autoSpaceReadCountThisRun;
+
+  if (
+    turnReads < spaceContext.maxReadCallsPerTurn &&
+    totalReads < spaceContext.maxReadCallsPerDialog
+  ) {
+    return null;
+  }
+
+  return buildPolicyLimitResult(
+    "space_read_limit_reached",
+    `当前策略下已达到自动读取上限。本轮最多自动读取 ${spaceContext.maxReadCallsPerTurn} 个对象，当前对话最多自动读取 ${spaceContext.maxReadCallsPerDialog} 个对象。请停止继续 read，改为先解释限制或询问用户。`,
+    {
+      capability: "space_context",
+      level: spaceContext.level,
+      remainingAutoReadsThisTurn: Math.max(
+        0,
+        spaceContext.maxReadCallsPerTurn - turnReads,
+      ),
+      remainingAutoReadsThisDialog: Math.max(
+        0,
+        spaceContext.maxReadCallsPerDialog - totalReads,
+      ),
+    },
+  );
+};
+
+export const recordWorkspaceRead = (
+  dbKey: unknown,
+  context?: ToolExecutionContext,
+): void => {
+  if (
+    context?.policy?.spaceContext &&
+    context.runtimeState &&
+    typeof dbKey === "string" &&
+    isBudgetedWorkspaceReadKey(dbKey)
+  ) {
+    context.runtimeState.autoSpaceReadCountThisRun += 1;
+  }
+};
+
+export const guardKnowledgeCapture = (params: {
+  context?: ToolExecutionContext;
+  target: "doc" | "table";
+}): string | null => {
+  const { context, target } = params;
+  if (!context?.policy?.knowledgeCapture || !context.runtimeState) {
+    return null;
+  }
+
+  const { knowledgeCapture } = context.policy;
+  const totalCreates =
+    knowledgeCapture.currentAutoCreates +
+    context.runtimeState.autoKnowledgeCaptureCountThisRun;
+
+  if (knowledgeCapture.explicitRequest) {
+    return null;
+  }
+
+  if (target === "table") {
+    if (
+      knowledgeCapture.mode !== "auto" ||
+      totalCreates >= knowledgeCapture.maxAutoCreatesPerDialog
+    ) {
+      return buildPolicyLimitResult(
+        "knowledge_capture_requires_confirmation",
+        "当前策略不允许直接创建表格作为知识沉淀结果。请先回答，或询问用户是否需要沉淀成表格。",
+        {
+          capability: "knowledge_capture",
+          level: knowledgeCapture.level,
+          mode: knowledgeCapture.mode,
+        },
+      );
+    }
+    return null;
+  }
+
+  if (knowledgeCapture.mode === "blocked") {
+    return buildPolicyLimitResult(
+      "knowledge_capture_blocked",
+      "当前用户/Agent 策略不允许主动创建知识文档。请先直接回答，或在需要时询问用户是否要沉淀成文档/表格。",
+      {
+        capability: "knowledge_capture",
+        level: knowledgeCapture.level,
+        mode: knowledgeCapture.mode,
+      },
+    );
+  }
+
+  if (knowledgeCapture.mode === "ask") {
+    return buildPolicyLimitResult(
+      "knowledge_capture_requires_confirmation",
+      "当前策略要求先询问用户，再创建文档/表格。请先说明你建议沉淀什么，再等待用户确认。",
+      {
+        capability: "knowledge_capture",
+        level: knowledgeCapture.level,
+        mode: knowledgeCapture.mode,
+      },
+    );
+  }
+
+  if (knowledgeCapture.mode === "suggest") {
+    return buildPolicyLimitResult(
+      "knowledge_capture_suggest_only",
+      "当前策略要求先完成回答，再建议是否沉淀为文档/表格；不要直接创建。",
+      {
+        capability: "knowledge_capture",
+        level: knowledgeCapture.level,
+        mode: knowledgeCapture.mode,
+      },
+    );
+  }
+
+  if (totalCreates >= knowledgeCapture.maxAutoCreatesPerDialog) {
+    return buildPolicyLimitResult(
+      "knowledge_capture_limit_reached",
+      `当前对话已达到自动知识沉淀上限（${knowledgeCapture.maxAutoCreatesPerDialog} 次）。如确需继续，请先询问用户。`,
+      {
+        capability: "knowledge_capture",
+        level: knowledgeCapture.level,
+        mode: knowledgeCapture.mode,
+        remainingAutoCreates: Math.max(
+          0,
+          knowledgeCapture.maxAutoCreatesPerDialog - totalCreates,
+        ),
+      },
+    );
+  }
+
+  return null;
+};
+
+export const guardPublicTableShare = (
+  context?: ToolExecutionContext
+): string | null => {
+  if (hasExplicitPublicShareRequest(context?.userInput)) {
+    return null;
+  }
+
+  return buildPolicyLimitResult(
+    "public_table_share_requires_confirmation",
+    "当前策略不允许在用户未明确要求公开/社区分享时自动发布表。请先解释限制，或等待用户明确表示要公开分享到社区。",
+    {
+      capability: "public_table_share",
+      target: "shareTable",
+    }
+  );
+};
+
+export const recordKnowledgeCapture = (
+  context?: ToolExecutionContext,
+): void => {
+  if (
+    context?.policy?.knowledgeCapture &&
+    context.runtimeState &&
+    !context.policy.knowledgeCapture.explicitRequest
+  ) {
+    context.runtimeState.autoKnowledgeCaptureCountThisRun += 1;
+  }
+};

package/server/handlers/agentRun/types.ts

@@ -0,0 +1,94 @@
+// 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 interface AgentRunRequest {
+    agentKey: string;
+    userInput:
+        | string
+        | Array<
+            | { type: "text"; text: string }
+            | {
+                type: "image_url";
+                image_url: { url: string };
+                google_native?: {
+                    inlineData: {
+                        mimeType: string;
+                        data: string;
+                    };
+                    thoughtSignature?: string;
+                };
+            }
+        >;
+    messages?: ChatMessage[]; // 历史对话，调用方自行管理（不持久化）
+    runtimeContext?: AgentRunRuntimeContext;
+    stream?: boolean;
+    maxRounds?: number; // 兼容旧客户端保留，服务端当前不再按工具轮次限制
+    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[];
+    taskRun?: {
+        rowDbKey?: string;
+        taskRunId?: string;
+        workItemId?: string;
+        artifactIds?: string[];
+    };
+    subjectRefs?: DialogSubjectRef[];
+}
+
+export interface LoopResult extends Omit<AgentRuntimeResult, "policyState"> {
+    policyState?: DialogPolicyState;
+    artifacts?: unknown;
+}
+
+export interface ToolPolicyRuntimeState {
+    autoKnowledgeCaptureCountThisRun: number;
+    autoSpaceReadCountThisRun: number;
+}
+
+export interface ToolExecutionContext {
+    policy?: ResolvedRuntimePolicy;
+    runtimeState?: ToolPolicyRuntimeState;
+    runtimeContext?: AgentRunRuntimeContext | null;
+    userId?: string | null;
+    agentKey?: string | null;
+    dialogId?: string | null;
+    currentSpaceId?: string | null;
+    userInput?: string | null;
+    imageUrls?: string[];
+}

package/server/handlers/agentRun/workspaceLease.ts

@@ -0,0 +1,58 @@
+import type { AgentRuntimeToolPolicy } from "../../../agent-runtime";
+import type { ConnectorAgentRunResult } from "../connector/connectorConnectionRegistry";
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+function stringField(record: Record<string, unknown>, key: string) {
+  const value = record[key];
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function stringArray(value: unknown) {
+  return Array.isArray(value)
+    ? value.filter((item): item is string => typeof item === "string" && !!item.trim())
+    : [];
+}
+
+function extractConnectorArtifact(result: ConnectorAgentRunResult | null | undefined) {
+  const artifacts = result?.artifacts;
+  if (isRecord(artifacts)) return artifacts;
+  if (Array.isArray(artifacts)) {
+    return artifacts.find(isRecord);
+  }
+  return undefined;
+}
+
+export function buildWorkspaceLeaseFromConnectorResult(args: {
+  result: ConnectorAgentRunResult | null | undefined;
+  agentKey: string;
+  machineId?: string | null;
+  runtimeToolPolicySnapshot?: AgentRuntimeToolPolicy;
+  now?: () => number;
+}) {
+  const artifact = extractConnectorArtifact(args.result);
+  const workspaceRoot = artifact ? stringField(artifact, "cwd") : undefined;
+  if (!workspaceRoot) return undefined;
+  const createdAt = new Date((args.now ?? Date.now)()).toISOString();
+  const changedFiles = stringArray(artifact.changedFiles);
+  return {
+    id: `machine-${args.machineId || "unbound"}-${createdAt}`,
+    source: "machine-connector",
+    agentKey: args.agentKey,
+    ...(args.machineId ? { machineId: args.machineId } : {}),
+    workspaceRoot,
+    writableRoots: [workspaceRoot],
+    createdAt,
+    policy: args.runtimeToolPolicySnapshot,
+    evidence: {
+      artifactKind: "connector-run-artifact",
+      ...(stringField(artifact, "baseSha") ? { baseSha: stringField(artifact, "baseSha") } : {}),
+      ...(stringField(artifact, "headSha") ? { headSha: stringField(artifact, "headSha") } : {}),
+      ...(changedFiles.length > 0 ? { changedFiles } : {}),
+      ...(stringField(artifact, "statusShort") ? { statusShort: stringField(artifact, "statusShort") } : {}),
+      ...(stringField(artifact, "diffStat") ? { diffStat: stringField(artifact, "diffStat") } : {}),
+    },
+  };
+}

package/server/handlers/alphaTestRouteGuard.ts

@@ -0,0 +1,30 @@
+const ALLOWED_ALPHA_TEST_HOSTS = new Set([
+  "localhost",
+  "127.0.0.1",
+  "::1",
+  "us.nolo.chat",
+]);
+
+export function isAlphaTestHost(host: string | null | undefined): boolean {
+  const rawHost = String(host ?? "").trim().toLowerCase();
+  const normalizedHost =
+    rawHost.startsWith("[") && rawHost.includes("]")
+      ? rawHost.slice(1, rawHost.indexOf("]"))
+      : rawHost.split(":")[0];
+
+  return ALLOWED_ALPHA_TEST_HOSTS.has(normalizedHost);
+}
+
+export function createAlphaOnlyHandler(
+  handler: (req: Request) => Response | Promise<Response>,
+) {
+  return async (req: Request): Promise<Response> => {
+    const host = req.headers.get("host") || new URL(req.url).host;
+
+    if (!isAlphaTestHost(host)) {
+      return new Response("alpha test routes disabled", { status: 403 });
+    }
+
+    return handler(req);
+  };
+}

package/server/handlers/apifyActorHandler.ts

@@ -0,0 +1,170 @@
+// 文件路径: packages/server/handlers/apifyActorHandler.ts
+
+import { authenticateRequest, CORS_HEADERS_AUTH } from "../../auth/utils";
+import { getUser } from "../../auth/server/getUser";
+import { checkBasicBalance } from "../../auth/billing";
+import { chargeExternalTool } from "../../ai/token/externalToolCost";
+
+const APIFY_TOKEN = process.env.APIFY_TOKEN;
+
+type ResultType = "datasetItems" | "run" | "kvOutput";
+
+interface ApifyActorRequestBody {
+  actorId: string;
+  input: any;
+  resultType?: ResultType;
+  dialogId?: string;
+}
+
+export async function handleApifyActor(req: Request): Promise<Response> {
+  try {
+    // 1. 鉴权 + 余额检查
+    const auth = await authenticateRequest(req);
+    if (auth instanceof Response) return auth;
+
+    const { userId } = auth;
+    const { balance = 0 } = await getUser(userId);
+
+    const balanceCheck = checkBasicBalance(balance);
+    if (!balanceCheck.allowed && balanceCheck.error) {
+      return jsonError(
+        balanceCheck.error.status,
+        balanceCheck.error.message,
+        balanceCheck.error.code,
+        balanceCheck.error.details
+      );
+    }
+
+    // 2. 解析 body
+    const body = (await req
+      .json()
+      .catch(() => null)) as ApifyActorRequestBody | null;
+
+    if (!body || typeof body !== "object") {
+      return jsonError(
+        400,
+        "请求体必须是 JSON 对象，并包含 actorId 与 input 字段。",
+        "INVALID_BODY"
+      );
+    }
+
+    const { actorId, input, resultType = "datasetItems", dialogId } = body;
+
+    if (!actorId || typeof actorId !== "string") {
+      return jsonError(400, "缺少有效的 actorId（字符串）。", "INVALID_ACTOR");
+    }
+    if (!input || typeof input !== "object") {
+      return jsonError(400, "缺少有效的 input（对象）。", "INVALID_INPUT");
+    }
+
+    if (!APIFY_TOKEN) {
+      return jsonError(
+        500,
+        "后端未配置 APIFY_TOKEN 环境变量，无法调用 Apify API。",
+        "APIFY_TOKEN_MISSING"
+      );
+    }
+
+    const normalizedActorId = actorId.replace("/", "~");
+
+    let suffix: string;
+    switch (resultType) {
+      case "run":
+        suffix = "runs";
+        break;
+      case "kvOutput":
+        suffix = "run-sync";
+        break;
+      case "datasetItems":
+      default:
+        suffix = "run-sync-get-dataset-items";
+        break;
+    }
+
+    const url = `https://api.apify.com/v2/acts/${encodeURIComponent(
+      normalizedActorId
+    )}/${suffix}?token=${APIFY_TOKEN}`;
+
+    const apifyResp = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(input),
+    });
+
+    const text = await apifyResp.text();
+    let parsed: any = text;
+    try {
+      parsed = JSON.parse(text);
+    } catch {
+      // 不是 JSON 就直接原样转发
+    }
+
+    if (!apifyResp.ok) {
+      console.error("Apify 调用失败:", apifyResp.status, text);
+      return new Response(
+        JSON.stringify({
+          error: {
+            message: "调用 Apify Actor 失败",
+            status: apifyResp.status,
+            detail: parsed,
+            code: "APIFY_CALL_FAILED",
+          },
+        }),
+        {
+          status: 502,
+          headers: {
+            "Content-Type": "application/json",
+            ...CORS_HEADERS_AUTH,
+          },
+        }
+      );
+    }
+
+    // 扣费：Apify Actor 运行成功后按次收费
+    await chargeExternalTool({
+      userId,
+      toolId: "apify_actor_run",
+      dialogId,
+      reason: `apify_actor:${actorId}`,
+    });
+
+    return new Response(JSON.stringify(parsed), {
+      status: 200,
+      headers: {
+        "Content-Type": "application/json",
+        ...CORS_HEADERS_AUTH,
+      },
+    });
+  } catch (err: any) {
+    console.error("handleApifyActor 发生异常:", err);
+    return jsonError(
+      500,
+      `服务器内部错误: ${err?.message || String(err)}`,
+      "INTERNAL_ERROR"
+    );
+  }
+}
+
+function jsonError(
+  status: number,
+  message: string,
+  code: string = "APIFY_ERROR",
+  detail?: any
+): Response {
+  return new Response(
+    JSON.stringify({
+      error: {
+        message,
+        code,
+        detail,
+      },
+    }),
+    {
+      status,
+      headers: {
+        "Content-Type": "application/json",
+        ...CORS_HEADERS_AUTH,
+      },
+    }
+  );
+}