nolo-cli 0.1.26 → 0.1.29

package/auth/utils.ts

@@ -0,0 +1,108 @@
+// path auth/utils.ts
+import { parseToken, verifyToken } from ".//token";
+import { assertSessionTokenVersion } from ".//sessionTokenVersion";
+import serverDb from "../database/server/db";
+import { WEB_AUTH_TOKEN_COOKIE } from "./tokenCookie";
+
+export const CORS_HEADERS_AUTH = {
+  "Access-Control-Allow-Origin": "*",
+  "Access-Control-Allow-Methods": "POST, GET, OPTIONS",
+  "Access-Control-Allow-Headers": "Content-Type, Authorization",
+  "Access-Control-Max-Age": "86400",
+};
+
+export const authErrorResponse = (
+  msg: string,
+  code: string,
+  status: number = 500
+): Response =>
+  new Response(JSON.stringify({ error: { message: msg, code } }), {
+    status,
+    headers: { "Content-Type": "application/json", ...CORS_HEADERS_AUTH },
+  });
+
+const getPublicKey = async (userId: string) => {
+  try {
+    const u = await serverDb.get(`user:${userId}`);
+    if (!u?.publicKey || u.balance <= 0 || u.isDisabled) {
+      return { publicKey: null, isValid: false };
+    }
+    return { publicKey: u.publicKey, isValid: true };
+  } catch (e) {
+    return { publicKey: null, isValid: false };
+  }
+};
+
+export const authenticateRequest = async (
+  req: Request
+): Promise<
+  ({ userId: string; authToken: string } & Record<string, unknown>) | Response
+> => {
+  const authHeaderToken = req.headers.get("authorization")?.split(" ")[1];
+  const cookieHeader = req.headers.get("cookie") ?? req.headers.get("Cookie") ?? "";
+  const cookieToken = cookieHeader
+    .split(";")
+    .map((part) => part.trim())
+    .find((part) => part.startsWith(`${WEB_AUTH_TOKEN_COOKIE}=`))
+    ?.slice(`${WEB_AUTH_TOKEN_COOKIE}=`.length);
+  const token = authHeaderToken ?? (cookieToken ? decodeURIComponent(cookieToken) : undefined);
+  if (!token) {
+    return authErrorResponse(
+      "No authentication token provided.",
+      "AUTH_NO_TOKEN",
+      401
+    );
+  }
+
+  try {
+    const tokenHeaderPayload = parseToken(token);
+    const userIdFromTokenHeader = tokenHeaderPayload?.userId;
+
+    if (!userIdFromTokenHeader) {
+      return authErrorResponse(
+        "Invalid token format.",
+        "AUTH_INVALID_TOKEN",
+        401
+      );
+    }
+
+    const { publicKey, isValid } = await getPublicKey(userIdFromTokenHeader);
+    if (!isValid || !publicKey) {
+      return authErrorResponse("Invalid account.", "AUTH_ACCOUNT_INVALID", 401);
+    }
+
+    const user = await serverDb.get(`user:${userIdFromTokenHeader}`);
+    const decodedTokenData = verifyToken(token, publicKey);
+    assertSessionTokenVersion(decodedTokenData, user);
+    if (!decodedTokenData) {
+      return authErrorResponse(
+        "Invalid token signature.",
+        "AUTH_INVALID_TOKEN",
+        401
+      );
+    }
+
+    const now = Date.now();
+    if (decodedTokenData.exp && now > decodedTokenData.exp * 1000) {
+      return authErrorResponse("Token has expired.", "AUTH_TOKEN_EXPIRED", 401);
+    }
+    if (
+      decodedTokenData.nbf &&
+      now < decodedTokenData.nbf * 1000
+    ) {
+      return authErrorResponse(
+        "Token not yet active.",
+        "AUTH_TOKEN_NOT_ACTIVE",
+        401
+      );
+    }
+
+    return { ...decodedTokenData, userId: userIdFromTokenHeader, authToken: token };
+  } catch (e: any) {
+    return authErrorResponse(
+      `Authentication failed: ${e.message}.`,
+      "AUTH_VERIFICATION_FAILED",
+      401
+    );
+  }
+};

package/auth/web/bootstrapAuthState.ts

@@ -0,0 +1,60 @@
+import { parseToken } from "../token";
+import type { User } from "../types";
+import { safelyParseJSON } from "../types";
+
+export interface BootstrappedAuthState {
+  currentUser: User;
+  users: User[];
+  isLoggedIn: true;
+  currentToken: string;
+  isLoading: false;
+}
+
+const isUser = (value: unknown): value is User =>
+  typeof value === "object" &&
+  value !== null &&
+  typeof (value as { userId?: unknown }).userId === "string";
+
+export const getBootstrappedAuthState = (
+  storedTokens: string | null
+): BootstrappedAuthState | null => {
+  if (!storedTokens) return null;
+
+  const tokens = safelyParseJSON(storedTokens).filter(
+    (token): token is string => typeof token === "string" && token.length > 0
+  );
+
+  if (!tokens.length) return null;
+
+  const users: User[] = [];
+  const seenUserIds = new Set<string>();
+  let currentUser: User | null = null;
+  let currentToken: string | null = null;
+
+  for (const token of tokens) {
+    const parsedUser = parseToken(token);
+    if (!isUser(parsedUser)) continue;
+    if (seenUserIds.has(parsedUser.userId)) continue;
+    seenUserIds.add(parsedUser.userId);
+
+    users.push(parsedUser);
+    if (!currentUser) {
+      currentUser = parsedUser;
+      currentToken = token;
+    }
+  }
+
+  if (!currentUser || !currentToken) return null;
+
+  return {
+    currentUser,
+    users,
+    isLoggedIn: true,
+    currentToken,
+    isLoading: false,
+  };
+};
+
+export const readBootstrappedAuthState = (
+  storage: Pick<Storage, "getItem">
+) => getBootstrappedAuthState(storage.getItem("tokens"));

package/auth/web/tokenManager.ts

@@ -0,0 +1,61 @@
+// auth/web/tokenManager.ts
+import type { TokenManager } from "../types";
+import { safelyParseJSON } from "../types";
+import { parseToken } from "../token";
+import { WEB_AUTH_TOKEN_COOKIE } from "../tokenCookie";
+
+const PERSISTENT_AUTH_TOKEN_COOKIE_MAX_AGE_SECONDS = 10 * 365 * 24 * 3600;
+
+function writeAuthTokenCookie(token: string | null): void {
+  if (typeof document === "undefined") return;
+  if (!token) {
+    document.cookie = `${WEB_AUTH_TOKEN_COOKIE}=; Path=/; Max-Age=0; SameSite=Lax`;
+    return;
+  }
+  document.cookie =
+    `${WEB_AUTH_TOKEN_COOKIE}=${encodeURIComponent(token)}; ` +
+    `Path=/; Max-Age=${PERSISTENT_AUTH_TOKEN_COOKIE_MAX_AGE_SECONDS}; SameSite=Lax`;
+}
+
+export function syncWebAuthTokenCookie(tokens: readonly string[]): void {
+  const firstToken = typeof tokens[0] === "string" && tokens[0] ? tokens[0] : null;
+  writeAuthTokenCookie(firstToken);
+}
+
+function tokenUserId(token: string): string | null {
+  const parsed = parseToken(token);
+  return typeof parsed?.userId === "string" ? parsed.userId : null;
+}
+
+export const webTokenManager: TokenManager = {
+  async getTokens() {
+    const stored = localStorage.getItem("tokens");
+    if (!stored) return [];
+    return safelyParseJSON(stored);
+  },
+
+  async storeToken(newToken: string) {
+    const tokens = await this.getTokens();
+    const newUserId = tokenUserId(newToken);
+    const filtered = tokens.filter((token) => {
+      if (token === newToken) return false;
+      return !newUserId || tokenUserId(token) !== newUserId;
+    });
+    filtered.unshift(newToken);
+    localStorage.setItem("tokens", JSON.stringify(filtered));
+    syncWebAuthTokenCookie(filtered);
+  },
+
+  async removeToken(tokenToRemove: string) {
+    const tokens = await this.getTokens();
+    const filtered = tokens.filter((t) => t !== tokenToRemove);
+    localStorage.setItem("tokens", JSON.stringify(filtered));
+    syncWebAuthTokenCookie(filtered);
+  },
+
+  async initTokens() {
+    const tokens = await this.getTokens();
+    syncWebAuthTokenCookie(tokens);
+    return tokens;
+  },
+};

package/auth/web/useRegister.ts

@@ -0,0 +1,70 @@
+import { useState } from "react";
+import { useAppDispatch } from "../../app/store";
+import { startPersonalizationDialog } from "../../ai/policy/personalizationDialog";
+import { signUp } from "../authSlice";
+import { useNavigate } from "react-router-dom";
+import { useTranslation } from "react-i18next";
+import { resolvePreferredAuthLocale } from "../locale";
+
+/**
+ * 定义注册时需要提交的数据结构
+ */
+interface RegisterData {
+  username: string;
+  password: string;
+  email?: string;
+  inviter?: string;
+  inviterCode?: string;
+}
+
+/**
+ * 处理用户注册逻辑的自定义 Hook
+ */
+const useRegister = () => {
+  const navigate = useNavigate();
+  const dispatch = useAppDispatch();
+  const { t, i18n } = useTranslation();
+  const [error, setError] = useState<string | null>(null);
+
+  /**
+   * 异步处理注册请求
+   * @param {RegisterData} data - 用户注册表单数据
+   */
+  const handleRegister = async (data: RegisterData) => {
+    // 每次尝试注册时先清空之前的错误信息
+    setError(null);
+    try {
+      const locale = resolvePreferredAuthLocale(navigator.language, [i18n.language]);
+      const result = await dispatch(signUp({ ...data, locale })).unwrap();
+
+      // 注册成功后，直接用对话完成第一轮偏好 onboarding。
+      if (result.token) {
+        try {
+          await startPersonalizationDialog({
+            dispatch,
+            navigate,
+            language: i18n.language || locale,
+            source: "signup",
+          });
+        } catch (startupError) {
+          console.error(
+            "Failed to start personalization dialog after signup:",
+            startupError
+          );
+          navigate("/");
+        }
+      }
+    } catch (err: any) {
+      console.error("Register error:", err);
+      // 从 unwrap() 抛出的错误中提取 message 属性，如果不存在则使用通用错误提示
+      const errorMessage = err?.message || err;
+      setError(
+        typeof errorMessage === "string" ? errorMessage : t("networkError")
+      );
+    }
+  };
+
+  return { handleRegister, error };
+};
+
+export default useRegister;

package/build.ts

@@ -0,0 +1,16 @@
+#!/usr/bin/env bun
+
+import { buildPublishArtifact } from "./buildPublish";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const CLI_DIR = dirname(fileURLToPath(import.meta.url));
+const DIST_DIR = join(CLI_DIR, "dist");
+
+console.log("Building publish artifact...");
+console.log("Source:", CLI_DIR);
+console.log("Dist:", DIST_DIR);
+
+await buildPublishArtifact(CLI_DIR, DIST_DIR);
+
+console.log("Build complete! Artifact at:", DIST_DIR);

package/buildPublish.ts

@@ -0,0 +1,133 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import {
+  buildPublishArtifactAssembly,
+  inlineWorkspaceDependencies,
+} from "./buildPublishArtifactAssembly";
+import {
+  collectTypeScriptSourceFiles,
+  collectWorkspaceDependencies,
+  extractExternalImports,
+  rewriteCrossPackageImports,
+} from "./buildPublishImportAnalysis";
+import { buildPublishManifest } from "./publishPackage";
+
+/**
+ * Build a publish-safe CLI artifact in the dist directory.
+ *
+ * This function:
+ * 1. Creates a dist directory
+ * 2. Copies source files specified in package.json "files" array
+ * 3. Generates a publish-safe package.json (no workspace deps)
+ * 4. Inlines workspace dependencies from monorepo packages
+ *
+ * The output can be published to npm and installed outside the monorepo.
+ *
+ * @param sourceDir - The CLI package source directory (packages/cli)
+ * @param distDir - The output directory (packages/cli/dist)
+ */
+export async function buildPublishArtifact(
+  sourceDir: string,
+  distDir: string
+): Promise<void> {
+  const pkgPath = join(sourceDir, "package.json");
+  if (!existsSync(pkgPath)) {
+    throw new Error(`package.json not found at ${pkgPath}`);
+  }
+
+  const sourceManifest = JSON.parse(readFileSync(pkgPath, "utf8"));
+  const filesToCopy = sourceManifest.files || [];
+  const warn = (message: string, error?: unknown): void => {
+    if (error === undefined) {
+      console.warn(message);
+      return;
+    }
+    console.warn(message, error);
+  };
+
+  const {
+    resolvedFilesToCopy,
+    inlinedDeps,
+    externalDeps,
+  } = await buildPublishArtifactAssembly({
+    sourceDir,
+    distDir,
+    filesToCopy,
+    extractExternalImports,
+    rewriteCrossPackageImports,
+    collectWorkspaceDependencies: (entrySourceDir, resolvedFiles) =>
+      collectWorkspaceDependencies(entrySourceDir, sourceManifest, resolvedFiles),
+    inlineWorkspaceDependencies,
+    warn,
+  });
+
+  const publishManifest = buildPublishManifest(sourceManifest);
+  const repoRoot = join(sourceDir, "..", "..");
+  const rootManifest = existsSync(join(repoRoot, "package.json"))
+    ? JSON.parse(readFileSync(join(repoRoot, "package.json"), "utf8"))
+    : {};
+  const cliExternalDeps = discoverExternalImportsFromCliSourceFiles(
+    sourceDir,
+    resolvedFilesToCopy,
+    rootManifest
+  );
+
+  if (inlinedDeps.length > 0) {
+    publishManifest.files = publishManifest.files || [];
+    for (const dep of inlinedDeps) {
+      publishManifest.files.push(`${dep}/**/*.ts`);
+    }
+  }
+
+  if (Object.keys(externalDeps).length > 0) {
+    publishManifest.dependencies = publishManifest.dependencies || {};
+    for (const [name, version] of Object.entries(externalDeps)) {
+      if (!publishManifest.dependencies[name]) {
+        publishManifest.dependencies[name] = version;
+      }
+    }
+  }
+
+  if (Object.keys(cliExternalDeps).length > 0) {
+    publishManifest.dependencies = publishManifest.dependencies || {};
+    for (const [name, version] of Object.entries(cliExternalDeps)) {
+      if (!publishManifest.dependencies[name]) {
+        publishManifest.dependencies[name] = version;
+      }
+    }
+  }
+
+  writeFileSync(
+    join(distDir, "package.json"),
+    JSON.stringify(publishManifest, null, 2) + "\n"
+  );
+}
+
+function discoverExternalImportsFromCliSourceFiles(
+  sourceDir: string,
+  filesToCopy: string[],
+  rootManifest: Record<string, any>
+): Record<string, string> {
+  const rootDeps: Record<string, string> = {};
+  if (rootManifest.dependencies) {
+    for (const [name, version] of Object.entries(rootManifest.dependencies)) {
+      if (typeof version === "string" && !version.startsWith("workspace:")) {
+        rootDeps[name] = version;
+      }
+    }
+  }
+
+  const externalDeps: Record<string, string> = {};
+  for (const filePath of collectTypeScriptSourceFiles(sourceDir, filesToCopy)) {
+    const content = readFileSync(filePath, "utf8");
+    for (const importName of extractExternalImports(content)) {
+      if (rootDeps[importName]) {
+        externalDeps[importName] = rootDeps[importName];
+      }
+    }
+  }
+
+  return externalDeps;
+}
+
+export { rewriteCrossPackageImports } from "./buildPublishImportAnalysis";