@liujitcn/kratos-taro-app-core 0.0.1

package/README.md

@@ -0,0 +1,36 @@
+# @liujitcn/kratos-taro-app-core
+
+`@liujitcn/kratos-taro-app-core` 是 Taro 应用底座，负责模块协议、启动流程、认证请求、共享状态、动态导航、基础页面、公共静态资源和构建期页面装配。core 不依赖 UI 或业务模块。
+
+## 主要能力
+
+- 账号密码、行为验证码、微信登录、OAuth、Token 刷新和退出。
+- 统一 HTTP、上传、下载、文件预览与 RSA/AES 密码加密。
+- Zustand 用户、配置和导航状态。
+- 接口驱动的逻辑路由、访问模式、自绘 tabBar 和稳定 `viewKey`。
+- 打包静态资源公共路径解析，以及 H5 默认导航栏兼容框架。
+- 首页、登录、协议、WebView、启动/错误状态页面。
+- H5 与微信小程序共用的模块页面装配 runner。
+
+## 公开入口
+
+- `@liujitcn/kratos-taro-app-core`：启动、模块、导航、状态和常用工具，包含 `resolveBundledAsset()`。
+- `@liujitcn/kratos-taro-app-core/build`：构建期模块描述。
+- `@liujitcn/kratos-taro-app-core/runner`：Taro 构建装配入口。
+- `api/*`、`components/*`、`rpc/*`、`styles/*`、`utils/*`、`views/*`：白名单子路径。
+
+业务模块只能通过这些 exports 使用底座，不得相对引用 core 源码。RPC 由 `make -C backend ts-taro-app` 生成，不能手工编辑。
+
+## Runner 协议
+
+模块必须同时提供运行时定义和 `./build` 导出。构建入口返回模块名称、包根目录与页面清单；runner 根据宿主的静态 `module-manifest.ts` 解析模块顺序，扫描页面并创建事务。
+
+runner 支持命名导入和默认导入的模块，后注册模块可以覆盖相同物理路由。页面私有 `components` 不会成为路由，模块 static 会先合并到宿主再由 Taro 编译。H5 下，runner 根据页面 `navigationStyle` 和 `navigationBar*` 配置生成默认顶部导航栏；微信小程序继续使用原生导航栏。构建失败、正常退出和收到终止信号时都会执行恢复。
+
+## 验证
+
+```bash
+pnpm --filter @liujitcn/kratos-taro-app-core tsc
+pnpm test
+pnpm check:exports
+```

package/dist/build.mjs

@@ -0,0 +1,38 @@
+// src/build.ts
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/pages.ts
+var corePages = {
+  "pages/index/index": {
+    style: {
+      navigationStyle: "custom",
+      navigationBarTextStyle: "white",
+      navigationBarTitleText: "\u9996\u9875"
+    }
+  },
+  "pages/login/login": { style: { navigationBarTitleText: "\u767B\u5F55" } },
+  "pages/login/protocal": { style: { navigationBarTitleText: "\u534F\u8BAE\u8BE6\u60C5" } },
+  "pages/webview/webview": { style: { navigationBarTitleText: "" } },
+  "pages/status/index": {
+    style: {
+      navigationStyle: "custom",
+      navigationBarTitleText: ""
+    }
+  }
+};
+
+// src/build.ts
+function defineKratosTaroBuildModule(module) {
+  return module;
+}
+var packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+var buildModule = defineKratosTaroBuildModule({
+  name: "@liujitcn/kratos-taro-app-core",
+  root: packageRoot,
+  pages: corePages
+});
+export {
+  buildModule,
+  defineKratosTaroBuildModule
+};

package/dist/runner.mjs

@@ -0,0 +1,321 @@
+// src/runner.ts
+import {
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  rmdirSync,
+  statSync,
+  unlinkSync,
+  writeFileSync
+} from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, relative, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { spawn } from "node:child_process";
+import ts from "typescript";
+async function main() {
+  const options = parseArguments(process.argv.slice(2));
+  const hostRoot = process.cwd();
+  const inputDir = resolve(hostRoot, "src");
+  const appConfigFile = resolve(inputDir, "app.config.ts");
+  const baseConfigFile = resolve(inputDir, "app.config.base.json");
+  const transactionFile = resolve(hostRoot, ".kratos-taro-app-pages-state.json");
+  recoverBuildTransaction(transactionFile, inputDir, appConfigFile);
+  const originalAppConfig = readFileSync(appConfigFile, "utf8");
+  const manifest = JSON.parse(readFileSync(baseConfigFile, "utf8"));
+  const modules = await loadBuildModules(hostRoot, resolve(inputDir, "module-manifest.ts"));
+  const pageMap = /* @__PURE__ */ new Map();
+  modules.forEach((module) => {
+    scanViews(resolve(module.root, "src/views")).forEach((page) => {
+      const config = module.pages[page.route] ?? {};
+      const route = normalizeRoute(config.route ?? page.route);
+      pageMap.set(route, {
+        route,
+        source: `${module.name}/views/${page.route}`,
+        style: config.style
+      });
+    });
+  });
+  const generatedFiles = [...pageMap.values()].flatMap((page) => {
+    const pageFile = resolve(inputDir, `${page.route}.tsx`);
+    const configFile = resolve(inputDir, `${page.route}.config.ts`);
+    return [pageFile, configFile].filter((file) => !existsSync(file));
+  });
+  const staticRoot = resolve(inputDir, "static");
+  const staticFiles = collectModuleStaticFiles(
+    modules.map((module) => resolve(module.root, "src/static")),
+    staticRoot
+  );
+  const generatedStaticFiles = staticFiles.map(({ target }) => target);
+  const transaction = {
+    inputDir,
+    appConfigFile,
+    originalAppConfig,
+    generatedFiles,
+    generatedStaticFiles,
+    ownerPid: process.pid
+  };
+  writeFileSync(transactionFile, `${JSON.stringify(transaction, null, 2)}
+`, { flag: "wx" });
+  let cleaned = false;
+  const cleanup = () => {
+    if (cleaned) return;
+    cleaned = true;
+    cleanupTransaction(transaction);
+    if (existsSync(transactionFile)) unlinkSync(transactionFile);
+  };
+  const handleSignal = (signal) => {
+    child?.kill(signal);
+  };
+  let child;
+  process.once("SIGINT", () => handleSignal("SIGINT"));
+  process.once("SIGTERM", () => handleSignal("SIGTERM"));
+  try {
+    pageMap.forEach((page) => {
+      appendPage(manifest, page.route);
+      const pageFile = resolve(inputDir, `${page.route}.tsx`);
+      const configFile = resolve(inputDir, `${page.route}.config.ts`);
+      if (!existsSync(pageFile)) {
+        mkdirSync(dirname(pageFile), { recursive: true });
+        writeFileSync(pageFile, createPageWrapper(page));
+      }
+      if (!existsSync(configFile)) {
+        writeFileSync(configFile, createPageConfig(page));
+      }
+    });
+    staticFiles.forEach(({ source, target }) => {
+      mkdirSync(dirname(target), { recursive: true });
+      copyFileSync(source, target);
+    });
+    writeFileSync(
+      appConfigFile,
+      `export default defineAppConfig(${JSON.stringify(manifest, null, 2)})
+`
+    );
+    const args = ["exec", "taro", "build", "--type", options.type, "--mode", options.mode];
+    if (options.watch) args.push("--watch");
+    child = spawn(process.platform === "win32" ? "pnpm.cmd" : "pnpm", args, {
+      cwd: hostRoot,
+      env: {
+        ...process.env,
+        NODE_ENV: options.mode === "development" ? "development" : "production"
+      },
+      stdio: "inherit"
+    });
+    const exitCode = await new Promise((complete, reject) => {
+      child?.once("error", reject);
+      child?.once("exit", (code, signal) => {
+        if (signal) {
+          complete(signal === "SIGINT" ? 130 : 143);
+          return;
+        }
+        complete(code ?? 1);
+      });
+    });
+    if (exitCode !== 0) process.exitCode = exitCode;
+  } finally {
+    cleanup();
+  }
+}
+function parseArguments(args) {
+  let type;
+  let mode = "production";
+  let watch = false;
+  for (let index = 0; index < args.length; index += 1) {
+    const argument = args[index];
+    if (argument === "--type") {
+      const value = args[++index];
+      if (value !== "h5" && value !== "weapp") throw new Error(`\u4E0D\u652F\u6301\u7684 Taro \u7C7B\u578B\uFF1A${value}`);
+      type = value;
+    } else if (argument === "--mode") {
+      mode = args[++index] || mode;
+    } else if (argument === "--watch") {
+      watch = true;
+    } else {
+      throw new Error(`\u672A\u77E5\u53C2\u6570\uFF1A${argument}`);
+    }
+  }
+  if (!type) throw new Error("\u7F3A\u5C11 --type h5|weapp");
+  return { type, mode, watch };
+}
+async function loadBuildModules(hostRoot, manifestFile) {
+  const source = readFileSync(manifestFile, "utf8");
+  const sourceFile = ts.createSourceFile(
+    manifestFile,
+    source,
+    ts.ScriptTarget.Latest,
+    true,
+    ts.ScriptKind.TS
+  );
+  const imports = /* @__PURE__ */ new Map();
+  let moduleNames = [];
+  sourceFile.forEachChild((node) => {
+    if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) {
+      const importClause = node.importClause;
+      const bindings = node.importClause?.namedBindings;
+      const packageName = node.moduleSpecifier.text;
+      if (importClause?.name) imports.set(importClause.name.text, packageName);
+      if (bindings && ts.isNamedImports(bindings)) {
+        bindings.elements.forEach((element) => {
+          imports.set(element.name.text, packageName);
+        });
+      }
+      return;
+    }
+    if (!ts.isVariableStatement(node)) return;
+    node.declarationList.declarations.forEach((declaration) => {
+      if (ts.isIdentifier(declaration.name) && declaration.name.text === "moduleManifest" && declaration.initializer && ts.isArrayLiteralExpression(declaration.initializer)) {
+        moduleNames = declaration.initializer.elements.filter(ts.isIdentifier).map((element) => element.text);
+      }
+    });
+  });
+  if (!moduleNames.length) throw new Error(`\u6A21\u5757\u6E05\u5355\u672A\u5BFC\u51FA moduleManifest\uFF1A${manifestFile}`);
+  const hostRequire = createRequire(resolve(hostRoot, "package.json"));
+  return Promise.all(
+    moduleNames.map(async (name) => {
+      const packageName = imports.get(name);
+      if (!packageName) throw new Error(`\u6A21\u5757 ${name} \u7F3A\u5C11\u9759\u6001 import`);
+      const buildEntry = hostRequire.resolve(`${packageName}/build`);
+      const loaded = await import(pathToFileURL(buildEntry).href);
+      if (!loaded.buildModule) throw new Error(`${packageName}/build \u672A\u5BFC\u51FA buildModule`);
+      return loaded.buildModule;
+    })
+  );
+}
+function recoverBuildTransaction(transactionFile, inputDir, appConfigFile) {
+  if (!existsSync(transactionFile)) return;
+  const transaction = JSON.parse(readFileSync(transactionFile, "utf8"));
+  if (transaction.inputDir !== inputDir || transaction.appConfigFile !== appConfigFile) {
+    throw new Error(`Taro \u6784\u5EFA\u4E8B\u52A1\u76EE\u5F55\u4E0D\u5339\u914D\uFF1A${transactionFile}`);
+  }
+  if (transaction.ownerPid !== process.pid && isProcessRunning(transaction.ownerPid)) {
+    throw new Error(
+      `\u9875\u9762\u88C5\u914D\u5DF2\u7531\u8FDB\u7A0B ${transaction.ownerPid} \u4F7F\u7528\uFF0C\u8BF7\u5148\u505C\u6B62\u53E6\u4E00\u4E2A H5 \u6216\u5C0F\u7A0B\u5E8F\u5F00\u53D1\u8FDB\u7A0B`
+    );
+  }
+  cleanupTransaction(transaction);
+  unlinkSync(transactionFile);
+}
+function cleanupTransaction(transaction) {
+  for (const file of [...transaction.generatedFiles].reverse()) {
+    if (existsSync(file)) unlinkSync(file);
+    removeEmptyParents(dirname(file), transaction.inputDir);
+  }
+  removeGeneratedStaticFiles(transaction.generatedStaticFiles, resolve(transaction.inputDir, "static"));
+  writeFileSync(transaction.appConfigFile, transaction.originalAppConfig);
+}
+function isProcessRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function scanViews(root) {
+  if (!existsSync(root)) return [];
+  const files = [];
+  const visit = (directory) => {
+    readdirSync(directory).forEach((entry) => {
+      const path = resolve(directory, entry);
+      if (statSync(path).isDirectory()) {
+        if (entry !== "components") visit(path);
+      } else if (entry.endsWith(".tsx")) {
+        files.push(path);
+      }
+    });
+  };
+  visit(root);
+  return files.map((source) => ({
+    route: normalizeRoute(relative(root, source)),
+    source
+  }));
+}
+function collectModuleStaticFiles(sourceRoots, targetRoot) {
+  const fileMap = /* @__PURE__ */ new Map();
+  sourceRoots.forEach((sourceRoot) => {
+    scanFiles(sourceRoot).forEach((source) => {
+      const target = resolve(targetRoot, relative(sourceRoot, source));
+      if (!existsSync(target)) fileMap.set(target, { source, target });
+    });
+  });
+  return [...fileMap.values()];
+}
+function scanFiles(root) {
+  if (!existsSync(root)) return [];
+  const files = [];
+  const visit = (directory) => {
+    readdirSync(directory).forEach((entry) => {
+      const path = resolve(directory, entry);
+      if (statSync(path).isDirectory()) visit(path);
+      else files.push(path);
+    });
+  };
+  visit(root);
+  return files;
+}
+function appendPage(manifest, route) {
+  const [first, ...rest] = route.split("/");
+  if (!first.startsWith("pages") || first === "pages") {
+    if (!manifest.pages.includes(route)) manifest.pages.push(route);
+    return;
+  }
+  manifest.subpackages ??= [];
+  let subpackage = manifest.subpackages.find((item) => item.root === first);
+  if (!subpackage) {
+    subpackage = { root: first, pages: [] };
+    manifest.subpackages.push(subpackage);
+  }
+  const subRoute = rest.join("/");
+  if (!subpackage.pages.includes(subRoute)) subpackage.pages.push(subRoute);
+}
+function createPageWrapper(page) {
+  return `import KratosPage from ${JSON.stringify(page.source)}
+import { KratosPageFrame } from '@liujitcn/kratos-taro-app-core/components/KratosPageFrame'
+import { KratosTabBar } from '@liujitcn/kratos-taro-app-core/components/KratosTabBar'
+
+/** \u81EA\u52A8\u751F\u6210\u7684\u6A21\u5757\u9875\u9762\u5305\u88C5\u5668\u3002 */
+export default function KratosPageWrapper() {
+  return (
+    <>
+      <KratosPageFrame
+        navigationStyle=${JSON.stringify(page.style?.navigationStyle ?? "default")}
+        navigationBarTitleText=${JSON.stringify(page.style?.navigationBarTitleText ?? "")}
+        navigationBarBackgroundColor=${JSON.stringify(page.style?.navigationBarBackgroundColor ?? "#f8f8f8")}
+        navigationBarTextStyle=${JSON.stringify(page.style?.navigationBarTextStyle ?? "black")}
+      >
+        <KratosPage />
+      </KratosPageFrame>
+      <KratosTabBar route=${JSON.stringify(page.route)} />
+    </>
+  )
+}
+`;
+}
+function createPageConfig(page) {
+  return `export default definePageConfig(${JSON.stringify(page.style ?? {}, null, 2)})
+`;
+}
+function normalizeRoute(route) {
+  return route.replace(/\\/g, "/").replace(/^\/+/, "").replace(/\.tsx$/, "");
+}
+function removeGeneratedStaticFiles(files, staticRoot) {
+  for (const file of [...files].reverse()) {
+    if (existsSync(file)) unlinkSync(file);
+    removeEmptyParents(dirname(file), staticRoot);
+  }
+}
+function removeEmptyParents(directory, boundary) {
+  let current = directory;
+  while (current !== boundary && current.startsWith(boundary) && existsSync(current)) {
+    if (readdirSync(current).length) return;
+    rmdirSync(current);
+    current = dirname(current);
+  }
+}
+void main().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@liujitcn/kratos-taro-app-core",
+  "description": "Runtime, navigation, authentication, and build foundation for Kratos Taro apps.",
+  "version": "0.0.1",
+  "type": "module",
+  "files": [
+    "dist",
+    "src",
+    "README.md"
+  ],
+  "exports": {
+    ".": "./src/index.ts",
+    "./build": {
+      "types": "./src/build.ts",
+      "import": "./dist/build.mjs",
+      "default": "./dist/build.mjs"
+    },
+    "./runner": "./dist/runner.mjs",
+    "./api/*": "./src/api/*.ts",
+    "./components/*": "./src/components/*.tsx",
+    "./navigation": "./src/navigation.ts",
+    "./module": "./src/module.ts",
+    "./rpc/*": "./src/rpc/*.ts",
+    "./stores": "./src/stores/index.ts",
+    "./static/*": "./src/static/*",
+    "./styles/*": "./src/styles/*",
+    "./utils/*": "./src/utils/*.ts",
+    "./views/*": "./src/views/*",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@tarojs/components": "4.2.1",
+    "@tarojs/taro": "4.2.1",
+    "asmcrypto.js": "2.3.2",
+    "go-captcha-react": "1.0.5",
+    "react": "18.3.1",
+    "typescript": "5.8.3",
+    "zustand": "5.0.6"
+  },
+  "devDependencies": {
+    "@types/react": "18.3.23"
+  },
+  "scripts": {
+    "build": "pnpm run build:entries && pnpm pack --pack-destination ../../dist/npm",
+    "build:entries": "esbuild src/build.ts --bundle --platform=node --format=esm --packages=external --outfile=dist/build.mjs && esbuild src/runner.ts --bundle --platform=node --format=esm --packages=external --outfile=dist/runner.mjs",
+    "tsc": "tsc --noEmit -p tsconfig.json"
+  }
+}

package/src/api/base/config.ts

@@ -0,0 +1,20 @@
+import { http } from '../../utils/http'
+import type { ConfigService, GetConfigRequest, GetConfigResponse } from '../../rpc/base/v1/config'
+
+const CONFIG_URL = '/v1/base/config'
+
+/** 系统配置公共服务 */
+export class ConfigServiceImpl implements ConfigService {
+  /** 获取系统配置 */
+  GetConfig(request: GetConfigRequest): Promise<GetConfigResponse> {
+    return http<GetConfigResponse>({
+      url: `${CONFIG_URL}`,
+      method: 'GET',
+      authMode: 'none',
+      data: request,
+      header: { Authorization: 'no-auth' },
+    })
+  }
+}
+
+export const defConfigService = new ConfigServiceImpl()

package/src/api/base/file.ts

@@ -0,0 +1,57 @@
+import Taro from '@tarojs/taro'
+import type {
+  DownloadFileRequest,
+  FileInfo,
+  MultiUploadFileResponse,
+} from '../../rpc/base/v1/file'
+import { uploadFile, uploadFileList } from '../../utils/file'
+import { getRequestAccessToken, requestBaseURL } from '../../utils/http'
+
+const FILE_URL = '/v1/base/file'
+
+/** 文件服务。 */
+export class FileServiceImpl {
+  /** 上传多个浏览器文件。 */
+  async MultiUploadFile(files: File[], fileType: string): Promise<MultiUploadFileResponse> {
+    if (process.env.TARO_ENV !== 'h5') {
+      throw new Error('小程序端请使用文件临时路径上传')
+    }
+    const paths = files.map((file) => URL.createObjectURL(file))
+    try {
+      return { files: await uploadFileList(fileType, paths) }
+    } finally {
+      paths.forEach((path) => URL.revokeObjectURL(path))
+    }
+  }
+
+  /** 上传单个浏览器文件。 */
+  async UploadFile(file: File, fileType: string): Promise<FileInfo> {
+    if (process.env.TARO_ENV !== 'h5') {
+      throw new Error('小程序端请使用文件临时路径上传')
+    }
+    const path = URL.createObjectURL(file)
+    try {
+      return await uploadFile(fileType, path)
+    } finally {
+      URL.revokeObjectURL(path)
+    }
+  }
+
+  /** 下载并打开后端文件。 */
+  async DownloadFile(file: string, fileName: string): Promise<void> {
+    const request: DownloadFileRequest = { name: fileName, path: file }
+    const query = Object.entries(request)
+      .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`)
+      .join('&')
+    const token = await getRequestAccessToken()
+    const response = await Taro.downloadFile({
+      url: `${requestBaseURL}${FILE_URL}?${query}`,
+      header: { Authorization: token, 'source-client': 'miniapp' },
+    })
+    if (response.statusCode !== 200) throw new Error('下载失败')
+    await Taro.openDocument({ filePath: response.tempFilePath, showMenu: true })
+  }
+}
+
+/** 默认文件服务。 */
+export const defFileService = new FileServiceImpl()

package/src/api/base/login.ts

@@ -0,0 +1,87 @@
+import { http } from '../../utils/http'
+import type {
+  CaptchaRequest,
+  CaptchaResponse,
+  LogoutRequest,
+  LoginRequest,
+  LoginResponse,
+  PasswordPublicKeyRequest,
+  PasswordPublicKeyResponse,
+  RefreshTokenRequest,
+  RefreshTokenResponse,
+  VerifyCaptchaRequest,
+  VerifyCaptchaResponse,
+  LoginService,
+} from '../../rpc/base/v1/login'
+import type { Empty } from '../../rpc/google/protobuf/empty'
+
+const CAPTCHA_URL = '/v1/base/captcha'
+const CAPTCHA_VERIFY_URL = '/v1/base/captcha/verify'
+const PASSWORD_PUBLIC_KEY_URL = '/v1/base/password-public-key'
+const SESSION_URL = '/v1/base/session'
+const TOKEN_URL = '/v1/base/token'
+
+/** 登录公共服务 */
+export class LoginServiceImpl implements LoginService {
+  /** 验证码 */
+  Captcha(request: CaptchaRequest): Promise<CaptchaResponse> {
+    return http<CaptchaResponse>({
+      url: `${CAPTCHA_URL}`,
+      method: 'GET',
+      authMode: 'none',
+      data: request,
+      header: { Authorization: 'no-auth' },
+    })
+  }
+  /** 验证码预校验 */
+  VerifyCaptcha(request: VerifyCaptchaRequest): Promise<VerifyCaptchaResponse> {
+    return http<VerifyCaptchaResponse>({
+      url: `${CAPTCHA_VERIFY_URL}`,
+      method: 'POST',
+      authMode: 'none',
+      data: request,
+      header: { Authorization: 'no-auth' },
+    })
+  }
+  /** 获取密码临时公钥 */
+  PasswordPublicKey(request: PasswordPublicKeyRequest): Promise<PasswordPublicKeyResponse> {
+    return http<PasswordPublicKeyResponse>({
+      url: `${PASSWORD_PUBLIC_KEY_URL}`,
+      method: 'GET',
+      authMode: 'none',
+      data: request,
+      header: { Authorization: 'no-auth' },
+    })
+  }
+  /** 登出 */
+  Logout(request: LogoutRequest): Promise<Empty> {
+    return http<Empty>({
+      url: `${SESSION_URL}`,
+      method: 'DELETE',
+      authMode: 'required',
+      data: request,
+    })
+  }
+  /** 刷新认证令牌 */
+  RefreshToken(request: RefreshTokenRequest): Promise<RefreshTokenResponse> {
+    return http<RefreshTokenResponse>({
+      url: `${TOKEN_URL}`,
+      method: 'POST',
+      authMode: 'none',
+      data: request,
+      header: { Authorization: 'no-auth' },
+    })
+  }
+  /** 登录 */
+  Login(request: LoginRequest): Promise<LoginResponse> {
+    return http<LoginResponse>({
+      url: `${SESSION_URL}`,
+      method: 'POST',
+      authMode: 'none',
+      data: request,
+      header: { Authorization: 'no-auth' },
+    })
+  }
+}
+
+export const defLoginService = new LoginServiceImpl()

package/src/api/base/menu.ts

@@ -0,0 +1,17 @@
+import { http } from '../../utils/http'
+import type { ListBaseMenuResponse } from '../../rpc/system/app/v1/base_menu'
+
+/** 远端移动菜单服务。 */
+export class BaseMenuServiceImpl {
+  /** 获取扁平移动菜单配置。 */
+  ListBaseMenu(): Promise<ListBaseMenuResponse> {
+    return http<ListBaseMenuResponse>({
+      url: '/v1/app/base/menu',
+      method: 'GET',
+      authMode: 'optional',
+    })
+  }
+}
+
+/** 默认移动菜单服务。 */
+export const defBaseMenuService = new BaseMenuServiceImpl()