nolo-cli 0.1.19 → 0.1.21

package/database/server/dataHandlers.ts

@@ -1,50 +1,48 @@
 import { pino } from "pino";
 import serverDb from "./db";
+import { chargeTokenUsageWithLedger } from "auth/server/tokenUsageBilling";
 
 const logger = pino({ name: "dataHandlers" });
 
-// 依赖注入：扣费函数类型，由调用方传入，避免 database → auth 循环依赖
-type DeductBalanceFn = (userId: string, amount: number, reason: string, txId?: string) => Promise<{ success: boolean; error?: string }>;
-
 export const handleToken = async (
   data: any,
   res: any,
   userId?: string,
   customKey?: string,
   actionUserId?: string,
-  deductBalance?: DeductBalanceFn,
 ) => {
   const isStatsKey = customKey.includes("token-stats");
   await serverDb.put(customKey, data);
 
-  if (!isStatsKey && data.cost && data.cost > 0 && deductBalance) {
+  if (!isStatsKey && data.cost && data.cost > 0) {
     try {
-      //must change
       const txId = `token-${customKey}`;
       logger.info({
-        event: "token_deduct_start",
+        event: "token_split_ledger_charge_start",
         userId: data.userId,
         cost: data.cost,
         txId,
       });
-      const deductResult = await deductBalance(
-        data.userId,
-        data.cost,
-        `Token generation cost: ${customKey}`,
-        txId
-      );
+      const chargeResult = await chargeTokenUsageWithLedger({
+        store: serverDb,
+        userId: data.userId,
+        tokenKey: customKey,
+        tokenRecord: data,
+        reason: `Token generation cost: ${customKey}`,
+        txId,
+      });
       logger.info({
-        event: "token_deduct_result",
+        event: "token_split_ledger_charge_result",
         userId: data.userId,
         cost: data.cost,
         txId,
-        deductResult,
+        chargeResult,
       });
 
-      if (!deductResult.success) {
+      if (!chargeResult.success) {
         logger.warn({
-          event: "token_deduct_failed",
-          error: deductResult.error,
+          event: "token_split_ledger_charge_failed",
+          error: chargeResult.error,
           userId: data.userId,
           cost: data.cost,
           txId,
@@ -52,12 +50,12 @@ export const handleToken = async (
         // next todo fix it
         return res.status(402).json({
           message: "Token usage recorded but payment failed",
-          error: deductResult.error,
+          error: chargeResult.error,
         });
       }
     } catch (error) {
       logger.error({
-        event: "token_deduct_error",
+        event: "token_split_ledger_charge_error",
         error: error.message,
         userId: data.userId,
         dbKey: customKey,

package/database/server/emailRepository.ts

@@ -406,9 +406,9 @@ const ensureCloudflareEmailRoutingRule = async (
   const config = resolveCloudflareEmailRoutingConfig();
   if (!config) return;
 
-  const url = `${config.apiBaseUrl.replace(/\/+$/, "")}/zones/${encodeURIComponent(
-    config.zoneId
-  )}/email/routing/rules`;
+  const url = `${config.apiBaseUrl.replace(/\/+$/, "")}/zones/${encodeURIComponent(
+    config.zoneId
+  )}/email/routing/rules?per_page=100`;
   const headers = {
     Authorization: `Bearer ${config.apiToken}`,
     "Content-Type": "application/json",

package/database/server/patch.ts

@@ -8,8 +8,9 @@ import {
   isCybotReadOnlyMutation,
 } from "./cybotReadonly";
 import { invalidatePublicAgentsCache } from "ai/agent/server/fetchPublicAgents";
-import { resolveWriteAuthority } from "./writeAuthority";
-import {
+import { resolveWriteAuthority } from "./writeAuthority";
+import { findIdentityPatchField } from "./recordIdentity";
+import {
   findActiveLiveShareByTable,
   patchShareMeta,
   reconcileReplicaTable,
@@ -96,14 +97,21 @@ export const handlePatch = async (req, res) => {
       .json({ message: "Bad Request: Missing or invalid changes in body" });
   }
 
-  if (isCybotReadOnlyMutation({ dbKey, dataType: changes?.type })) {
-    return res.status(403).json({
-      message: CYBOT_READONLY_MESSAGE,
-      error: "cybot_readonly",
-    });
-  }
-
-  try {
+  if (isCybotReadOnlyMutation({ dbKey, dataType: changes?.type })) {
+    return res.status(403).json({
+      message: CYBOT_READONLY_MESSAGE,
+      error: "cybot_readonly",
+    });
+  }
+
+  const identityPatchField = findIdentityPatchField(dbKey, changes);
+  if (identityPatchField) {
+    return res.status(400).json({
+      message: `Bad Request: identity field '${identityPatchField}' cannot be patched`,
+    });
+  }
+
+  try {
     // --- 修改：使用 dbKey 变量与数据库交互 ---
     const exist = await serverDb.get(dbKey);
     if (!exist) {

package/database/server/query.ts

@@ -61,6 +61,42 @@ const getComparableTimestamp = (item: BaseItem): number => {
   return 0;
 };
 
+const SUMMARY_FIELDS = [
+  "dbKey",
+  "id",
+  "type",
+  "userId",
+  "contentKey",
+  "appKey",
+  "appId",
+  "name",
+  "title",
+  "displayName",
+  "createdAt",
+  "updatedAt",
+  "created",
+  "updated_at",
+  "deletedAt",
+  "pinned",
+  "spaceId",
+  "fileCategory",
+  "mimeType",
+  "fileSize",
+  "originalName",
+  "serverOrigin",
+  "customUrl",
+  "visibility",
+  "deployMode",
+] as const;
+
+const toSummaryRecord = (item: BaseItem): BaseItem => {
+  const summary: Record<string, unknown> = {};
+  for (const field of SUMMARY_FIELDS) {
+    if (field in item) summary[field] = item[field];
+  }
+  return summary as BaseItem;
+};
+
 async function fetchUserData(
   types: string | string[],
   userId: string,
@@ -97,9 +133,10 @@ export const handleQuery = async (req: any, res: any) => {
   ) {
     return res.status(400).json({ error: "UserId is invalid or missing" });
   }
-  const { type, includeDeleted } = req.body as {
+  const { type, includeDeleted, summary } = req.body as {
     type?: string | string[];
     includeDeleted?: boolean;
+    summary?: boolean;
   };
   const requestedTypes = normalizeQueryTypes(type);
   if (requestedTypes.length === 0) {
@@ -117,6 +154,7 @@ export const handleQuery = async (req: any, res: any) => {
       (left, right) => getComparableTimestamp(right) - getComparableTimestamp(left)
     );
     const result = limit ? sortedData.slice(0, limit) : sortedData;
+    const responseData = summary === true ? result.map(toSummaryRecord) : result;
     if (shouldDebugQuery) {
       console.log("[db/query]", {
         userId,
@@ -124,13 +162,14 @@ export const handleQuery = async (req: any, res: any) => {
         includeDeleted: includeDeleted === true,
         limit: limit ?? null,
         total: data.length,
-        returned: result.length,
-        sampleKeys: result.slice(0, 10).map((item) =>
+        returned: responseData.length,
+        summary: summary === true,
+        sampleKeys: responseData.slice(0, 10).map((item) =>
           item.dbKey ?? item.contentKey ?? item.appKey ?? item.appId ?? item.id ?? "unknown"
         ),
       });
     }
-    return res.status(200).json({ data: { data: result } });
+    return res.status(200).json({ data: { data: responseData } });
   } catch (err) {
     const message = err instanceof Error ? err.message : "Unknown error";
     return res.status(500).json({ error: message });

package/database/server/read.ts

@@ -2,11 +2,15 @@
 
 import serverDb, { ensureServerDbOpen } from "./db";
 import { DB_PREFIX, shareKey } from "database/keys";
-import { parseToken, verifyToken } from "auth/token";
-import { assertSessionTokenVersion } from "auth/sessionTokenVersion";
-import { isTombstoneRecord } from "database/tombstones";
-import { userActor } from "auth/actor";
-import { authorizeActorRecordAccess } from "./actorAccess";
+import { parseToken, verifyToken } from "auth/token";
+import { assertSessionTokenVersion } from "auth/sessionTokenVersion";
+import { hasActiveEntitlement } from "../../auth/server/productEntitlements";
+import { isTombstoneRecord } from "database/tombstones";
+import { userActor } from "auth/actor";
+import { authorizeActorRecordAccess } from "./actorAccess";
+import {
+  resolveSharePaidAccess,
+} from "../../share/paidAccess";
 
 const isLevelNotFoundError = (error: any): boolean => {
   const code = error?.code;
@@ -68,20 +72,11 @@ const getAuthorizedUserId = async (req: any): Promise<string | null> => {
   }
 };
 
-const purchaseRecordKey = (buyerId: string, shareToken: string) =>
-  `doc-purchase-${buyerId}-${shareToken}`;
+const isCommunityShare = (share: any): boolean =>
+  share?.meta?.visibility === "community";
 
-const extractShareTokenFromDbKey = (dbKey: string): string | null =>
-  dbKey.startsWith("share-") ? dbKey.slice("share-".length) : null;
-
-const isCommunityShare = (share: any): boolean =>
-  share?.meta?.visibility === "community";
-
-const isShareOwner = (share: any, userId: string | null): boolean =>
-  Boolean(userId && share?.meta?.authorId === userId);
-
-const isPaidShare = (share: any): boolean =>
-  typeof share?.meta?.price === "number" && share.meta.price > 0;
+const isShareOwner = (share: any, userId: string | null): boolean =>
+  Boolean(userId && share?.meta?.authorId === userId);
 
 const redactSharePayload = (share: any) => ({
   ...share,
@@ -93,20 +88,7 @@ const redactSharePayload = (share: any) => ({
   },
 });
 
-const hasPurchasedShare = async (
-  userId: string | null,
-  shareToken: string | null
-): Promise<boolean> => {
-  if (!userId || !shareToken) return false;
-  try {
-    await serverDb.get(purchaseRecordKey(userId, shareToken));
-    return true;
-  } catch {
-    return false;
-  }
-};
-
-const toPublicProfile = (profile: any, user: any) => ({
+const toPublicProfile = (profile: any, user: any) => ({
   nickname:
     typeof profile?.nickname === "string" && profile.nickname.trim()
       ? profile.nickname
@@ -251,12 +233,16 @@ export const handleReadSingle = async (req: any) => {
         );
       }
 
-      if (isPaidShare(result) && !owner) {
-        const shareToken = extractShareTokenFromDbKey(dbKey);
-        const purchased = await hasPurchasedShare(authedUserId, shareToken);
-        if (!purchased) {
-          return new Response(JSON.stringify(redactSharePayload(result)), {
-            status: 200,
+      const paidAccess = resolveSharePaidAccess(result);
+      if (paidAccess.mode === "product" && !owner) {
+        const purchased = await hasActiveEntitlement({
+          store: serverDb,
+          userId: authedUserId,
+          productId: paidAccess.productId,
+        });
+        if (!purchased) {
+          return new Response(JSON.stringify(redactSharePayload(result)), {
+            status: 200,
             headers: corsHeaders,
           });
         }

package/database/server/recordIdentity.ts

@@ -0,0 +1,100 @@
+const SPACE_MEMBER_PREFIX = "space-member-";
+
+const RESERVED_IDENTITY_PATCH_FIELDS = new Set([
+  "dbKey",
+  "ownerId",
+  "tenantId",
+  "userId",
+]);
+
+const parseSpaceMemberKey = (
+  dbKey: string
+): { userId: string; spaceId: string } | null => {
+  if (typeof dbKey !== "string" || !dbKey.startsWith(SPACE_MEMBER_PREFIX)) {
+    return null;
+  }
+
+  const rest = dbKey.slice(SPACE_MEMBER_PREFIX.length);
+  const lastDash = rest.lastIndexOf("-");
+  if (lastDash <= 0 || lastDash === rest.length - 1) {
+    return null;
+  }
+
+  return {
+    userId: rest.slice(0, lastDash),
+    spaceId: rest.slice(lastDash + 1),
+  };
+};
+
+const parseOwnerFromSegmentedKey = (
+  dbKey: string,
+  prefixA: string,
+  prefixB: string
+): string | null => {
+  const parts = dbKey.split("-");
+  if (parts[0] !== prefixA || parts[1] !== prefixB || parts.length < 4) {
+    return null;
+  }
+  return parts[2] || null;
+};
+
+export const normalizeRecordIdentityForWrite = <T>(dbKey: string, data: T): T => {
+  if (!data || typeof data !== "object") {
+    return data;
+  }
+
+  const record = { ...(data as Record<string, any>) };
+  const spaceMember = parseSpaceMemberKey(dbKey);
+  if (spaceMember) {
+    return {
+      ...record,
+      userId: spaceMember.userId,
+      spaceId: spaceMember.spaceId,
+    } as T;
+  }
+
+  const spaceSettingUserId = parseOwnerFromSegmentedKey(
+    dbKey,
+    "space",
+    "setting"
+  );
+  if (spaceSettingUserId) {
+    return {
+      ...record,
+      userId: spaceSettingUserId,
+    } as T;
+  }
+
+  const userPrefOwnerId = parseOwnerFromSegmentedKey(dbKey, "user", "pref");
+  if (userPrefOwnerId) {
+    return {
+      ...record,
+      userId: userPrefOwnerId,
+      ownerId: userPrefOwnerId,
+    } as T;
+  }
+
+  return data;
+};
+
+export const findIdentityPatchField = (
+  dbKey: string,
+  changes: unknown
+): string | null => {
+  if (!changes || typeof changes !== "object") {
+    return null;
+  }
+
+  const fields = new Set(RESERVED_IDENTITY_PATCH_FIELDS);
+  if (parseSpaceMemberKey(dbKey)) {
+    fields.add("spaceId");
+  }
+
+  for (const field of fields) {
+    if (Object.prototype.hasOwnProperty.call(changes, field)) {
+      return field;
+    }
+  }
+
+  return null;
+};

package/database/server/write.ts

@@ -1,8 +1,7 @@
 // 文件路径: packages/database/server/write.ts
 
-import { logger } from "auth/server/shared";
-import { deductUserBalance } from "auth/server/deduct";
-import { DataType } from "create/types";
+import { logger } from "auth/server/shared";
+import { DataType } from "create/types";
 import serverDb, { ensureServerDbOpen } from "./db";
 import { handleToken, handleCybot } from "./dataHandlers";
 import { handleTransaction } from "./handleTransaction";
@@ -13,9 +12,10 @@ import {
 } from "./cybotReadonly";
 import { invalidatePublicAgentsCache } from "ai/agent/server/fetchPublicAgents";
 import { emitSpaceMemberAddedNotification } from "server/handlers/notificationEmitter";
-import { canWriteRecord } from "./writeAuthority";
-import { canWriteSpaceMemberRecord, parseSpaceMemberKey } from "./spaceMemberAuthority";
-import {
+import { canWriteRecord } from "./writeAuthority";
+import { canWriteSpaceMemberRecord, parseSpaceMemberKey } from "./spaceMemberAuthority";
+import { normalizeRecordIdentityForWrite } from "./recordIdentity";
+import {
   bootstrapReplicatedTable,
   findActiveLiveShareByTable,
   patchShareMeta,
@@ -144,7 +144,8 @@ export const handleWrite = async (req: any, res: any) => {
   const { user } = req;
   const actionUserId = user?.userId;
 
-  const { userId, data, customKey, indexKeys } = req.body ?? {};
+  const { userId, customKey, indexKeys } = req.body ?? {};
+  let { data } = req.body ?? {};
 
   // 基本参数校验
   if (!data || !customKey) {
@@ -158,7 +159,7 @@ export const handleWrite = async (req: any, res: any) => {
     });
   }
 
-  if (isCybotReadOnlyMutation({ dbKey: customKey, dataType: data.type })) {
+  if (isCybotReadOnlyMutation({ dbKey: customKey, dataType: data.type })) {
     logger.warn({
       event: "cybot_write_blocked",
       actionUserId,
@@ -167,11 +168,13 @@ export const handleWrite = async (req: any, res: any) => {
     });
     return res.status(403).json({
       message: CYBOT_READONLY_MESSAGE,
-      error: "cybot_readonly",
-    });
-  }
-
-  const saveUserId = userId || data.userId;
+      error: "cybot_readonly",
+    });
+  }
+
+  data = normalizeRecordIdentityForWrite(customKey, data);
+
+  const saveUserId = userId || data.userId;
   const writeAuthority = canWriteRecord({
     dbKey: customKey,
     actionUserId,
@@ -246,10 +249,10 @@ export const handleWrite = async (req: any, res: any) => {
         break;
       }
 
-      case DataType.TOKEN: {
-        result = await handleToken(data, res, userId, customKey, actionUserId, deductUserBalance);
-        break;
-      }
+      case DataType.TOKEN: {
+        result = await handleToken(data, res, userId, customKey, actionUserId);
+        break;
+      }
 
       case DataType.CYBOT: {
         result = await handleCybot(data, res, customKey);
@@ -276,14 +279,7 @@ export const handleWrite = async (req: any, res: any) => {
             console.log("Creating space with key:", customKey);
           }
 
-          if (isSpaceMemberWrite && !data.userId) {
-            const parsedMemberKey = parseSpaceMemberKey(customKey);
-            if (parsedMemberKey) {
-              data.userId = parsedMemberKey.memberUserId;
-            }
-          }
-
-          // Generic author enrichment (fallback if frontend didn't provide)
+          // Generic author enrichment (fallback if frontend didn't provide)
           if (user) {
             if (!data.authorName) data.authorName = user.name || user.username || "Anonymous";
             if (!data.authorAvatar) data.authorAvatar = user.avatar;

package/index.ts

@@ -7,6 +7,7 @@ import { renderHelpText, resolveCommand } from "./commandRegistry";
 import { runLoginCommand, runLogoutCommand, runWhoamiCommand } from "./authCommands";
 import {
   runAgentBindCurrentCommand,
+  runAgentReadCommand,
   runAgentRuntimeDoctorCommand,
   runAgentSmokeCurrentCommand,
   runDoctorRuntimeCommand,
@@ -15,10 +16,12 @@ import { runAgentRunCommand } from "./agentRunCommand";
 import { runAgentPullCommand } from "./agentPullCommand";
 import { buildEnvFromProfile, loadProfileConfig } from "./client/profileConfig";
 import { resolveTuiLaunchMode } from "./runtimeModeArgs";
-import {
-  runMachineConnectCommand,
-  runMachineStatusCommand,
-} from "./machineCommands";
+import {
+  runMachineConnectCommand,
+  runMachineStatusCommand,
+} from "./machineCommands";
+import { runTaskRunCommand } from "./taskRunCommand";
+import { runTableQueryCommand } from "./tableCommands";
 import { startTuiWorkspace } from "./tui/readlineWorkspace";
 import {
   buildCliDoctorText,
@@ -46,13 +49,15 @@ async function runScript(script: string, forwardedArgs: string[], env: NodeJS.Pr
   process.exit(exitCode);
 }
 
-const args = process.argv.slice(2);
-const profileEnv = buildEnvFromProfile(loadProfileConfig());
-const runtimeEnv = {
-  ...profileEnv,
-  ...process.env,
-  NOLO_CLI_VERSION: packageInfo.version,
-};
+const args = process.argv.slice(2);
+const profileEnv = buildEnvFromProfile(loadProfileConfig());
+const explicitServerUrl = process.env.NOLO_SERVER || process.env.NOLO_SERVER_URL || process.env.BASE_URL;
+const runtimeEnv = {
+  ...profileEnv,
+  ...process.env,
+  ...(explicitServerUrl ? { NOLO_SERVER: explicitServerUrl, BASE_URL: explicitServerUrl } : {}),
+  NOLO_CLI_VERSION: packageInfo.version,
+};
 
 function readOption(args: string[], flag: string) {
   const index = args.indexOf(flag);
@@ -103,20 +108,34 @@ if (args[0] === "logout") {
   process.exit(runLogoutCommand());
 }
 
-if (args[0] === "connect") {
-  process.exit(await runMachineConnectCommand(args.slice(1), { env: runtimeEnv }));
-}
-
-if (args[0] === "daemon" || looksLikeDaemonShortcut(args)) {
-  const daemonArgs = args[0] === "daemon" ? args.slice(1) : args;
-  process.exit(await runMachineConnectCommand(["--ws"], { env: buildDaemonEnv(daemonArgs) }));
-}
-
-if (args[0] === "machine" && args[1] === "status") {
-  process.exit(await runMachineStatusCommand(args.slice(2), { env: runtimeEnv }));
-}
+if (args[0] === "connect") {
+  process.exit(await runMachineConnectCommand(args.slice(1), {
+    env: runtimeEnv,
+    cliEntrypointPath: fileURLToPath(import.meta.url),
+  }));
+}
+
+if (args[0] === "task-run") {
+  process.exit(await runTaskRunCommand(args.slice(1), { env: runtimeEnv }));
+}
+
+if (args[0] === "table" && args[1] === "query") {
+  process.exit(await runTableQueryCommand(args.slice(2), { env: runtimeEnv }));
+}
+
+if (args[0] === "daemon" || looksLikeDaemonShortcut(args)) {
+  const daemonArgs = args[0] === "daemon" ? args.slice(1) : args;
+  process.exit(await runMachineConnectCommand(["--ws"], {
+    env: buildDaemonEnv(daemonArgs),
+    cliEntrypointPath: fileURLToPath(import.meta.url),
+  }));
+}
 
-if (args[0] === "agent" && args[1] === "bind-current") {
+if (args[0] === "machine" && args[1] === "status") {
+  process.exit(await runMachineStatusCommand(args.slice(2), { env: runtimeEnv }));
+}
+
+if (args[0] === "agent" && args[1] === "bind-current") {
   process.exit(await runAgentBindCurrentCommand(args.slice(2), { env: runtimeEnv }));
 }
 
@@ -131,10 +150,28 @@ if (args[0] === "agent" && args[1] === "run") {
   }));
 }
 
+if (args[0] === "agent" && args[1] === "chat") {
+  process.exit(await runAgentRunCommand(args.slice(2), {
+    env: runtimeEnv,
+    scriptDir: SCRIPT_DIR,
+  }));
+}
+
+if (args[0] === "chat") {
+  process.exit(await runAgentRunCommand(args.slice(1), {
+    env: runtimeEnv,
+    scriptDir: SCRIPT_DIR,
+  }));
+}
+
 if (args[0] === "agent" && args[1] === "pull") {
   process.exit(await runAgentPullCommand(args.slice(2), { env: runtimeEnv }));
 }
 
+if (args[0] === "agent" && args[1] === "read") {
+  process.exit(await runAgentReadCommand(args.slice(2), { env: runtimeEnv }));
+}
+
 if (args[0] === "agent" && args[1] === "runtime-doctor") {
   process.exit(await runAgentRuntimeDoctorCommand(args.slice(2), { env: runtimeEnv }));
 }
@@ -170,13 +207,13 @@ if (args[0] === "--help" || args[0] === "-h") {
   process.exit(0);
 }
 
-const command = resolveCommand(args);
-if (!command) {
-  console.error(`Unknown command: ${args.join(" ")}`);
-  console.error("");
-  console.log(renderHelpText());
+const command = resolveCommand(args);
+if (!command) {
+  console.error(`Unknown command: ${args.join(" ")}`);
+  console.error("");
+  console.log(renderHelpText());
   process.exit(1);
-}
-
-const forwardedArgs = args.slice(command.path.length);
-await runScript(command.script, forwardedArgs, runtimeEnv);
+}
+
+const forwardedArgs = [...(command.fixedArgs ?? []), ...args.slice(command.path.length)];
+await runScript(command.script, forwardedArgs, runtimeEnv);