update add ASR MODEL

.env.example

@@ -0,0 +1,9 @@
+POSTGRES_HOST=localhost
+POSTGRES_PORT=5432
+POSTGRES_USER=postgres
+POSTGRES_PASSWORD=
+POSTGRES_DB=postgres
+
+REDIS_HOST=localhost
+REDIS_PORT=6379
+REDIS_PASSWORD=

.gitignore

@@ -17,3 +17,9 @@ release/*
 !release/.gitkeep
 
 .turbo
+
+.env*
+!.env.example
+
+pack-dist
+app.config.json5.envision

.gitmodules

@@ -1,9 +0,0 @@
-[submodule "submodules/code-center-module"]
-    path = submodules/code-center-module
-    url = git@git.xiongxiao.me:kevisual/code-center-module.git
-[submodule "submodules/permission"]
-	path = submodules/permission
-	url = git@git.xiongxiao.me:kevisual/kevsiual-permission.git
-[submodule "submodules/oss"]
-	path = submodules/oss
-	url = git@git.xiongxiao.me:kevisual/kevisual-oss.git

app.config.json5.example

@@ -1,23 +0,0 @@
-{
-  port: 4005, // 端口
-  tokenSecret: '<TOKEN_SECRET>',
-  appPath: 'apps',
-  appName: 'codeflow',
-  domain: '*',
-  mainApp: 'https://kevisual.xiongxiao.me',
-  postgres: {
-    username: 'root',
-    host: 'localhost',
-    database: 'postgres',
-    password: '*****',
-    port: 5432,
-  },
-  redis: {},
-  minio: {
-    endPoint: 'minio.xiongxiao.me',
-    bucketName: 'resources',
-    useSSL: false,
-    accessKey: 'username',
-    secretKey: 'password',
-  },
-}

bun.config.mjs

@@ -0,0 +1,37 @@
+// @ts-check
+import { resolvePath } from '@kevisual/use-config';
+import { execSync } from 'node:child_process';
+
+const entry = 'src/index.ts';
+const naming = 'app';
+const external = ['sequelize', 'pg', 'sqlite3', 'ioredis', 'pm2'];
+/**
+ * @type {import('bun').BuildConfig}
+ */
+await Bun.build({
+  target: 'node',
+  format: 'esm',
+  entrypoints: [resolvePath(entry, { meta: import.meta })],
+  outdir: resolvePath('./dist', { meta: import.meta }),
+  naming: {
+    entry: `${naming}.js`,
+  },
+  external,
+  env: 'KEVISUAL_*',
+});
+
+// const cmd = `dts -i src/index.ts -o app.d.ts`;
+// const cmd = `dts -i ${entry} -o ${naming}.d.ts`;
+// execSync(cmd, { stdio: 'inherit' });
+
+await Bun.build({
+  target: 'node',
+  format: 'esm',
+  entrypoints: [resolvePath('./src/run.ts', { meta: import.meta })],
+  outdir: resolvePath('./dist', { meta: import.meta }),
+  naming: {
+    entry: `${'run'}.js`,
+  },
+  external,
+  env: 'KEVISUAL_*',
+});

config/pacage6/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "codecenter",
+  "version": "1.0.0",
+  "author": "abearxiong",
+  "basename": "/root/code-center",
+  "app": {
+    "type": "pm2-system-app",
+    "key": "code-center",
+    "entry": "./dist/app.mjs"
+  },
+  "scripts": {
+    "start": "pm2 start apps/code-center/dist/app.mjs --name code-center"
+  },
+  "dependencies": {
+    "@kevisual/router": "^0.0.20",
+    "@kevisual/use-config": "^1.0.17",
+    "ioredis": "^5.6.1",
+    "minio": "^8.0.5",
+    "pg": "^8.16.0",
+    "sequelize": "^6.37.7",
+    "sqlite3": "^5.1.7",
+    "socket.io": "^4.8.1",
+    "pm2": "^6.0.6",
+    "dotenv": "^16.5.0"
+  }
+}

config/package/index.mjs

@@ -1,34 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-
-const currentPath = process.cwd();
-const packagePath = path.join(currentPath, 'script/package/package.json');
-
-fs.writeFileSync(
-  packagePath,
-  JSON.stringify(
-    {
-      name: 'codecenter',
-      version: '1.0.0',
-      scripts: {
-        start: 'pm2 start dist/app.mjs --name codecenter',
-      },
-      dependencies: {
-        '@kevisual/router': '^0.0.6-alpha-5',
-        '@kevisual/use-config': '^1.0.7',
-        ioredis: '^5.5.0',
-        minio: '^8.0.4',
-        pg: '^8.13.3',
-        sequelize: '^6.37.5',
-        sqlite3: '^5.1.7',
-        'socket.io': '^4.8.1',
-        '@msgpack/msgpack': '3.0.1',
-        pino: '^9.6.0',
-        'pino-pretty': '^13.0.0',
-      },
-    },
-    null,
-    2,
-  ),
-  'utf-8',
-);

config/package/package.json

@@ -1,20 +0,0 @@
-{
-  "name": "codecenter",
-  "version": "1.0.0",
-  "scripts": {
-    "start": "pm2 start dist/app.mjs --name codecenter"
-  },
-  "dependencies": {
-    "@kevisual/router": "^0.0.6-alpha-5",
-    "@kevisual/use-config": "^1.0.7",
-    "ioredis": "^5.5.0",
-    "minio": "^8.0.4",
-    "pg": "^8.13.3",
-    "sequelize": "^6.37.5",
-    "sqlite3": "^5.1.7",
-    "socket.io": "^4.8.1",
-    "@msgpack/msgpack": "3.0.1",
-    "pino": "^9.6.0",
-    "pino-pretty": "^13.0.0"
-  }
-}

dockerfile

@@ -1,27 +0,0 @@
-# 使用官方 Node.js 运行时镜像作为基础镜像
-FROM node:22-alpine
-
-# 设置工作目录
-WORKDIR /app
-
-COPY script/package/package.json ./
-# 复制 package.json 和 package-lock.json
-# COPY package*.json ./
-
-# 复制 dist 文件夹
-COPY dist ./dist
-COPY app.config.json5 ./app.config.json5
-COPY .npmrc .
-
-# 安装依赖
-RUN npm install --production --registry=https://registry.npmmirror.com/
-
-# 如果有其他静态资源文件夹，也可以一并复制
-# COPY public ./public
-
-# 暴露应用运行的端口（假设应用运行在 3000 端口）
-EXPOSE 4000
-
-# 启动应用
-CMD ["node", "dist/app.cjs"]
-# CMD ["tail", "-f", "/dev/null"]

ecosystem.config.cjs

@@ -1,18 +0,0 @@
-module.exports = {
-  apps: [
-    {
-      name: 'codecenter', // 应用名称
-      script: './dist/app.mjs', // 入口文件
-      // cwd: '.', // 设置当前工作目录
-      output: './logs/codflow.log',
-      error: './logs/codflow.log',
-      log_date_format: 'YYYY-MM-DD HH:mm:ss',
-      // watch: true, // 自动监控文件变化
-      watch: ['dist'], // 监控的文件夹
-      ignore_watch: ['node_modules', 'logs'], // 忽略的文件夹
-      env: {
-        NODE_ENV: 'development'
-      }
-    }
-  ]
-}

package.json

@@ -1,102 +1,112 @@
 {
   "name": "@kevisual/code-center",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "description": "code center",
   "type": "module",
   "main": "index.js",
   "author": "abearxiong",
+  "basename": "/root/code-center",
+  "app": {
+    "type": "pm2-system-app",
+    "key": "code-center",
+    "entry": "./dist/app.js",
+    "engine": "bun",
+    "runtime": [
+      "client"
+    ]
+  },
   "scripts": {
-    "watch": "rollup -c rollup.config.mjs -w",
-    "dev": "cross-env NODE_ENV=development nodemon --delay 2.5 -e js,cjs,mjs --exec node dist/app.mjs",
     "test": "tsx  test/**/*.ts",
-    "dev:watch": "cross-env NODE_ENV=development concurrently -n \"Watch,Dev\" -c \"green,blue\" \"npm run watch\" \"sleep 1 && npm run dev\" ",
+    "dev": "bun run --watch --hot src/index.ts",
-    "build": "rimraf dist && rollup -c rollup.config.mjs",
+    "dev:inspect": "bun run --watch --hot --inspect src/index.ts",
-    "deploy": "rsync -avz --delete ./dist/ --exclude='app.config.json5' light:~/apps/codecenter/dist",
+    "cmd": "bun run src/run.ts ",
-    "deploy:sky": "rsync -avz --delete ./dist/ --exclude='app.config.json5' sky:~/kevisual/dist",
+    "prebuild": "rimraf dist",
+    "build": "NODE_ENV=production bun bun.config.mjs",
+    "deploy": "rsync -avz --delete ./dist/  light:/root/kevisual/assistant-app/apps/code-center/dist",
+    "deploy:envision": "rsync -avz --delete ./dist/  envision:~/kevisual/assistant-app/apps/code-center/dist",
     "clean": "rm -rf dist",
-    "reload": "ssh light pm2 restart codecenter",
+    "reload": "ssh light pm2 restart code-center",
-    "reload:sky": "ssh sky pm2 restart codecenter",
+    "reload:envision": "ssh envision pm2 restart code-center",
     "pub:me": "npm run build && npm run deploy && npm run reload",
-    "pub:sky": "npm run build && npm run deploy:sky && npm run reload:sky",
+    "pub:envision": "npm run build && npm run deploy:envision && npm run reload:envision",
-    "start": "pm2 start dist/app.mjs --name codecenter",
+    "start": "pm2 start dist/app.js --name code-center",
-    "release": "node ./config/release/index.mjs",
+    "client:start": "pm2 start apps/code-center/dist/app.js --name code-center",
-    "pub": "envision pack -p -u",
+    "ssl": "ssh -L 5432:localhost:5432 light",
-    "ssh": "ssh -L 6379:localhost:6379 light ",
+    "pub": "envision pack -p -u -c"
-    "ssh:sky": "ssh -L 6379:172.21.32.13:6379 sky",
-    "dev:lib": "turbo run dev:lib"
   },
   "keywords": [],
   "types": "types/index.d.ts",
   "files": [
-    "types",
+    "dist"
-    "dist",
-    "src"
   ],
   "license": "UNLICENSED",
   "dependencies": {
-    "@kevisual/local-app-manager": "0.1.9",
+    "commander": "^14.0.1",
-    "@kevisual/router": "0.0.9",
+    "cookie": "^1.0.2",
-    "@kevisual/use-config": "^1.0.9",
+    "ioredis": "^5.8.1",
-    "@types/semver": "^7.5.8",
+    "minio": "^8.0.6",
-    "archiver": "^7.0.1",
+    "pg": "^8.16.3",
-    "crypto-js": "^4.2.0",
+    "pm2": "^6.0.13",
-    "dayjs": "^1.11.13",
+    "sequelize": "^6.37.7"
-    "formidable": "^3.5.2",
-    "ioredis": "^5.6.0",
-    "json5": "^2.2.3",
-    "jsonwebtoken": "^9.0.2",
-    "lodash-es": "^4.17.21",
-    "minio": "^8.0.5",
-    "nanoid": "^5.1.5",
-    "node-fetch": "^3.3.2",
-    "p-queue": "^8.1.0",
-    "pg": "^8.14.1",
-    "pm2": "^6.0.5",
-    "rollup-plugin-esbuild": "^6.2.1",
-    "semver": "^7.7.1",
-    "sequelize": "^6.37.6",
-    "socket.io": "^4.8.1",
-    "strip-ansi": "^7.1.0",
-    "tar": "^7.4.3",
-    "uuid": "^11.1.0",
-    "zod": "^3.24.2"
   },
   "devDependencies": {
-    "@kevisual/code-center-module": "workspace:*",
+    "@kevisual/code-center-module": "0.0.24",
-    "@kevisual/permission": "workspace:*",
+    "@kevisual/context": "^0.0.4",
-    "@kevisual/oss": "workspace:*",
+    "@kevisual/file-listener": "^0.0.2",
-    "@kevisual/types": "^0.0.6",
+    "@kevisual/local-app-manager": "0.1.22",
-    "@rollup/plugin-alias": "^5.1.1",
+    "@kevisual/logger": "^0.0.4",
-    "@rollup/plugin-commonjs": "^28.0.3",
+    "@kevisual/oss": "0.0.12",
-    "@rollup/plugin-json": "^6.1.0",
+    "@kevisual/permission": "^0.0.3",
-    "@rollup/plugin-node-resolve": "^16.0.1",
+    "@kevisual/router": "0.0.28",
-    "@rollup/plugin-replace": "^6.0.2",
+    "@kevisual/types": "^0.0.10",
-    "@rollup/plugin-typescript": "^12.1.2",
+    "@kevisual/use-config": "^1.0.19",
     "@types/archiver": "^6.0.3",
     "@types/crypto-js": "^4.2.2",
-    "@types/formidable": "^3.4.5",
+    "@types/formidable": "^3.4.6",
-    "@types/jsonwebtoken": "^9.0.9",
+    "@types/jsonwebtoken": "^9.0.10",
     "@types/lodash-es": "^4.17.12",
-    "@types/node": "^22.13.11",
+    "@types/node": "^24.7.2",
-    "@types/react": "^19.0.12",
+    "@types/react": "^19.2.2",
-    "@types/uuid": "^10.0.0",
+    "@types/semver": "^7.7.1",
-    "concurrently": "^9.1.2",
+    "@types/uuid": "^11.0.0",
-    "cross-env": "^7.0.3",
+    "archiver": "^7.0.1",
-    "nodemon": "^3.1.9",
+    "cross-env": "^10.1.0",
+    "crypto-js": "^4.2.0",
+    "dayjs": "^1.11.18",
+    "dotenv": "^17.2.3",
+    "formidable": "3.5.4",
+    "ioredis": "^5.8.1",
+    "jsonwebtoken": "^9.0.2",
+    "lodash-es": "^4.17.21",
+    "minio": "^8.0.6",
+    "nanoid": "^5.1.6",
+    "node-fetch": "^3.3.2",
+    "nodemon": "^3.1.10",
+    "p-queue": "^9.0.0",
+    "pg": "^8.16.3",
+    "pm2": "^6.0.13",
     "rimraf": "^6.0.1",
-    "rollup": "^4.36.0",
+    "semver": "^7.7.3",
-    "rollup-plugin-copy": "^3.5.0",
+    "sequelize": "^6.37.7",
-    "rollup-plugin-dts": "^6.2.1",
+    "socket.io": "^4.8.1",
+    "strip-ansi": "^7.1.2",
     "tape": "^5.9.0",
-    "tsx": "^4.19.3",
+    "tar": "^7.5.1",
-    "turbo": "^2.4.4",
+    "tsx": "^4.20.6",
-    "typescript": "^5.8.2"
+    "turbo": "^2.5.8",
+    "typescript": "^5.9.3",
+    "uuid": "^13.0.0",
+    "zod": "^4.1.12"
   },
   "resolutions": {
     "inflight": "latest",
-    "rimraf": "latest",
     "picomatch": "^4.0.2"
   },
-  "pnpm": {},
+  "pnpm": {
-  "packageManager": "pnpm@10.6.5"
+    "onlyBuiltDependencies": [
+      "esbuild",
+      "sqlite3"
+    ]
+  },
+  "packageManager": "pnpm@10.18.3"
 }

rollup.config.mjs

@@ -1,84 +0,0 @@
-import resolve from '@rollup/plugin-node-resolve';
-import commonjs from '@rollup/plugin-commonjs';
-import json from '@rollup/plugin-json';
-import * as glob from 'fast-glob';
-import path from 'path';
-import esbuild from 'rollup-plugin-esbuild';
-import alias from '@rollup/plugin-alias';
-import replace from '@rollup/plugin-replace';
-import pkgs from './package.json' with { type: 'json' };
-
-const isDev = process.env.NODE_ENV === 'development';
-const version = pkgs.version|| '1.0.0';
-/**
- * @type {import('rollup').RollupOptions}
- */
-const config = {
-  input: './src/index.ts',
-  output: {
-    dir: './dist',
-    entryFileNames: 'app.mjs',
-    chunkFileNames: '[name]-[hash].mjs',
-    format: 'esm',
-  },
-  plugins: [
-    replace({
-      preventAssignment: true, // 防止意外赋值
-      DEV_SERVER: JSON.stringify(isDev), // 替换 process.env.NODE_ENV
-      VERSION: JSON.stringify(version), // 替换版本号
-    }),
-    alias({
-      // only esbuild needs to be configured
-      entries: [
-        { find: '@', replacement: path.resolve('src') }, // 配置 @ 为 src 目录
-        { find: 'http', replacement: 'node:http' },
-        { find: 'https', replacement: 'node:https' },
-        { find: 'fs', replacement: 'node:fs' },
-        { find: 'path', replacement: 'node:path' },
-        { find: 'crypto', replacement: 'node:crypto' },
-        { find: 'zlib', replacement: 'node:zlib' },
-        { find: 'stream', replacement: 'node:stream' },
-        { find: 'net', replacement: 'node:net' },
-        { find: 'tty', replacement: 'node:tty' },
-        { find: 'tls', replacement: 'node:tls' },
-        { find: 'buffer', replacement: 'node:buffer' },
-        { find: 'timers', replacement: 'node:timers' },
-        // { find: 'string_decoder', replacement: 'node:string_decoder' },
-        { find: 'dns', replacement: 'node:dns' },
-        { find: 'domain', replacement: 'node:domain' },
-        { find: 'os', replacement: 'node:os' },
-        { find: 'events', replacement: 'node:events' },
-        { find: 'url', replacement: 'node:url' },
-        { find: 'assert', replacement: 'node:assert' },
-        { find: 'util', replacement: 'node:util' },
-      ],
-    }),
-    resolve({
-      preferBuiltins: true, // 强制优先使用内置模块
-    }),
-    commonjs(),
-    esbuild({
-      target: 'node22', // 目标为 Node.js 14
-      minify: false, // 启用代码压缩
-      tsconfig: 'tsconfig.json',
-    }),
-    json(),
-  ],
-  external: [
-    /@kevisual\/router(\/.*)?/, //, // 路由
-    /@kevisual\/use-config(\/.*)?/, //
-
-    'sequelize', // 数据库 orm
-    'ioredis', // redis
-    'socket.io', // socket.io
-    'minio', // minio
-    
-    'pm2',
-    
-    'pg', // pg
-    'pino', // pino
-    'pino-pretty', // pino-pretty
-    '@msgpack/msgpack', // msgpack
-  ],
-};
-export default config;

scripts/update.sh

@@ -3,3 +3,5 @@
 pnpm i -g npm-check-updates
 ncu -u
 pnpm install
+
+# /home/ubuntu/.nvm/versions/node/v22.14.0/bin/ncu -u

src/app-demo/index.ts

@@ -0,0 +1,119 @@
+import { Op } from 'sequelize';
+import { AppDemoModel } from './models/index.ts';
+import { app } from '@/app.ts';
+
+app
+  .route({
+    path: 'app-demo',
+    key: 'list',
+    middleware: ['auth'],
+  })
+  .define(async (ctx) => {
+    const tokenUser = ctx.state.tokenUser;
+    const { page = 1, pageSize = 20, search, sort = 'DESC' } = ctx.query;
+    const searchWhere = search
+      ? {
+          [Op.or]: [{ title: { [Op.like]: `%${search}%` } }, { summary: { [Op.like]: `%${search}%` } }],
+        }
+      : {};
+
+    const { rows: appDemo, count } = await AppDemoModel.findAndCountAll({
+      where: {
+        uid: tokenUser.id,
+        ...searchWhere,
+      },
+      offset: (page - 1) * pageSize,
+      limit: pageSize,
+      order: [['updatedAt', sort]],
+    });
+
+    ctx.body = {
+      list: appDemo,
+      pagination: {
+        page,
+        current: page,
+        pageSize,
+        total: count,
+      },
+    };
+  })
+  .addTo(app);
+
+app
+  .route({
+    path: 'app-demo',
+    key: 'update',
+    middleware: ['auth'],
+  })
+  .define(async (ctx) => {
+    const tokenUser = ctx.state.tokenUser;
+    const { id, data, updatedAt: _clear, createdAt: _clear2, ...rest } = ctx.query.data;
+    let appDemo: AppDemoModel;
+    let isNew = false;
+    if (id) {
+      const appDemo = await AppDemoModel.findByPk(id);
+      if (appDemo.uid !== tokenUser.uid) {
+        ctx.throw(403, 'No permission');
+      }
+    } else {
+      appDemo = await AppDemoModel.create({
+        data: data,
+        ...rest,
+        uid: tokenUser.uid,
+      });
+      isNew = true;
+    }
+    if (!appDemo) {
+      ctx.throw(404, 'AppDemo not found');
+    }
+    if (!isNew) {
+      appDemo = await appDemo.update({
+        data: { ...appDemo.data, ...data },
+        ...rest,
+      });
+    }
+
+    ctx.body = appDemo;
+  })
+  .addTo(app);
+
+app
+  .route({
+    path: 'app-demo',
+    key: 'delete',
+    middleware: ['auth'],
+  })
+  .define(async (ctx) => {
+    const tokenUser = ctx.state.tokenUser;
+    const { id, force = false } = ctx.query.data || {};
+    if (!id) {
+      ctx.throw(400, 'id is required');
+    }
+    const appDemo = await AppDemoModel.findByPk(id);
+    if (appDemo.uid !== tokenUser.id) {
+      ctx.throw(403, 'No permission');
+    }
+    await appDemo.destroy({ force });
+    ctx.body = appDemo;
+  })
+  .addTo(app);
+
+app
+  .route({
+    path: 'app-demo',
+    key: 'get',
+    middleware: ['auth'],
+  })
+  .define(async (ctx) => {
+    const tokenUser = ctx.state.tokenUser;
+    const { id } = ctx.query.data || {};
+    if (!id) {
+      ctx.throw(400, 'id is required');
+    }
+    const appDemo = await AppDemoModel.findByPk(id);
+    if (appDemo.uid !== tokenUser.id) {
+      ctx.throw(403, 'No permission');
+    }
+    ctx.body = appDemo;
+  })
+  .addTo(app);

src/app-demo/models/index.ts

@@ -0,0 +1,71 @@
+import { sequelize } from '@/modules/sequelize.ts';
+import { DataTypes, Model } from 'sequelize';
+
+export interface AppDemoData {
+  [key: string]: any;
+}
+
+export type AppDemo = Partial<InstanceType<typeof AppDemoModel>>;
+
+export class AppDemoModel extends Model {
+  declare id: string;
+  declare title: string;
+  declare description: string;
+  declare summary: string;
+
+  declare data: AppDemoData;
+  declare tags: string[];
+  declare version: string;
+
+  declare uid: string;
+
+  declare createdAt: Date;
+  declare updatedAt: Date;
+}
+
+AppDemoModel.init(
+  {
+    id: {
+      type: DataTypes.UUID,
+      primaryKey: true,
+      defaultValue: DataTypes.UUIDV4,
+    },
+    title: {
+      type: DataTypes.TEXT,
+      defaultValue: '',
+    },
+    description: {
+      type: DataTypes.TEXT,
+      defaultValue: '',
+    },
+    summary: {
+      type: DataTypes.TEXT,
+      defaultValue: '',
+    },
+    tags: {
+      type: DataTypes.JSONB,
+      defaultValue: [],
+    },
+    version: {
+      type: DataTypes.INTEGER,
+      defaultValue: 0,
+    },
+    data: {
+      type: DataTypes.JSONB,
+      defaultValue: {},
+    },
+    uid: {
+      type: DataTypes.UUID,
+      allowNull: false,
+    },
+  },
+  {
+    sequelize,
+    tableName: 'kv_app_demo',
+    paranoid: true,
+  },
+);
+
+AppDemoModel.sync({ alter: true, logging: false }).catch((e) => {
+  console.error('AppDemoModel sync', e);
+});

src/app.ts

@@ -1,14 +1,26 @@
 import { App } from '@kevisual/router';
-import { useConfig } from '@kevisual/use-config';
 import * as redisLib from './modules/redis.ts';
 import * as minioLib from './modules/minio.ts';
 import * as sequelizeLib from './modules/sequelize.ts';
-import { useContextKey, useContext } from '@kevisual/use-config/context';
+import { useContextKey } from '@kevisual/context';
 import { SimpleRouter } from '@kevisual/router/simple';
-
+import { OssBase } from '@kevisual/oss/services';
-useConfig();
 export const router = useContextKey('router', () => new SimpleRouter());
-
+export const runtime = useContextKey('runtime', () => {
+  return {
+    env: process.env.NODE_ENV || 'development',
+    type: 'server',
+  };
+});
+export const oss = useContextKey(
+  'oss',
+  () =>
+    new OssBase({
+      client: minioLib.minioClient,
+      bucketName: minioLib.bucketName,
+      prefix: '',
+    }),
+);
 export const redis = useContextKey('redis', () => redisLib.redis);
 export const redisPublisher = useContextKey('redisPublisher', () => redisLib.redisPublisher);
 export const redisSubscriber = useContextKey('redisSubscriber', () => redisLib.redisSubscriber);

src/aura/asr/index.ts

@@ -0,0 +1,18 @@
+import { app } from '@/app.ts'
+import { asr } from './modules/index.ts'
+app.route({
+  path: 'asr',
+  key: 'text'
+}).define(async (ctx) => {
+  const base64Audio = ctx.query.base64Audio as string
+  if (!base64Audio) {
+    ctx.throw('Missing base64Audio parameter')
+  }
+  const result = await asr.getText({
+    audio: {
+      data: base64Audio
+    }
+  })
+  ctx.body = result
+})
+  .addTo(app)

src/aura/asr/modules/index.ts

@@ -0,0 +1,7 @@
+import { Asr } from '../../libs/auc.ts'
+import { auraConfig } from '../../config.ts'
+
+export const asr = new Asr({
+  appid: auraConfig.VOLCENGINE_AUC_APPID,
+  token: auraConfig.VOLCENGINE_AUC_TOKEN,
+})

src/aura/config.ts

@@ -0,0 +1,6 @@
+import { config } from '@/modules/config.ts'
+export type AIConfig = {
+  VOLCENGINE_AUC_APPID: string
+  VOLCENGINE_AUC_TOKEN: string
+}
+export const auraConfig: AIConfig = config as unknown as AIConfig;

src/aura/index.ts

@@ -0,0 +1 @@
+import './asr/index.ts'

src/aura/libs/auc.ts

@@ -0,0 +1,136 @@
+// https://git.xiongxiao.me/kevisual/video-tools/raw/branch/main/src/asr/provider/volcengine/auc.ts
+import { nanoid } from "nanoid"
+
+export const FlashURL = "https://openspeech.bytedance.com/api/v3/auc/bigmodel/recognize/flash"
+export const AsrBaseURL = 'https://openspeech.bytedance.com/api/v3/auc/bigmodel/submit'
+export const AsrBase = 'volc.bigasr.auc'
+export const AsrTurbo = 'volc.bigasr.auc_turbo'
+
+const uuid = () => nanoid()
+
+type AsrOptions = {
+  url?: string
+  appid?: string
+  token?: string
+  type?: AsrType
+}
+
+type AsrType = 'flash' | 'standard' | 'turbo'
+export class Asr {
+  url: string = FlashURL
+  appid: string = ""
+  token: string = ""
+  type: AsrType = 'flash'
+  constructor(options: AsrOptions = {}) {
+    this.appid = options.appid || ""
+    this.token = options.token || ""
+    this.type = options.type || 'flash'
+    if (this.type !== 'flash') {
+      this.url = AsrBaseURL
+    }
+    if (!this.appid || !this.token) {
+      throw new Error("VOLCENGINE_Asr_APPID or VOLCENGINE_Asr_TOKEN is not set")
+    }
+  }
+
+  header() {
+    const model = this.type === 'flash' ? AsrTurbo : AsrBase
+    return {
+      "X-Api-App-Key": this.appid,
+      "X-Api-Access-Key": this.token,
+      "X-Api-Resource-Id": model,
+      "X-Api-Request-Id": uuid(),
+      "X-Api-Sequence": "-1",
+    }
+  }
+  submit(body: AsrRequest) {
+    if (!body.audio || (!body.audio.url && !body.audio.data)) {
+      throw new Error("audio.url or audio.data is required")
+    }
+    const data: AsrRequest = {
+      ...body,
+    }
+    return fetch(this.url, { method: "POST", headers: this.header(), body: JSON.stringify(data) })
+  }
+  async getText(body: AsrRequest) {
+    const res = await this.submit(body)
+    return res.json()
+  }
+}
+
+export type AsrResponse = {
+  audio_info: {
+    /**
+     * 音频时长，单位为 ms
+     */
+    duration: number;
+  };
+  result: {
+    additions: {
+      duration: string;
+    };
+    text: string;
+    utterances: Array<{
+      end_time: number;
+      start_time: number;
+      text: string;
+      words: Array<{
+        confidence: number;
+        end_time: number;
+        start_time: number;
+        text: string;
+      }>;
+    }>;
+  };
+}
+export interface AsrRequest {
+  user?: {
+    uid: string;
+  };
+  audio: {
+    url?: string;
+    data?: string;
+    format?: 'wav' | 'pcm' | 'mp3' | 'ogg';
+    codec?: 'raw' | 'opus'; 	// raw / opus，默认为 raw(pcm) 。
+    rate?: 8000 | 16000; // 采样率，支持 8000 或 16000，默认为 16000 。
+    channel?: 1 | 2; // 声道数，支持 1 或 2，默认为 1。
+  };
+
+
+  request?: {
+    model_name?: string; // 识别模型名称，如 "bigmodel"
+    enable_words?: boolean; // 是否开启词级别时间戳，默认为 false。
+    enable_sentence_info?: boolean; // 是否开启句子级别时间戳，默认为 false。
+    enable_utterance_info?: boolean; // 是否开启语句级别时间戳，默认为 true。
+    enable_punctuation_prediction?: boolean; // 是否开启标点符号预测，默认为 true。
+    enable_inverse_text_normalization?: boolean; // 是否开启文本规范化，默认为 true。
+    enable_separate_recognition_per_channel?: boolean; // 是否开启声道分离识别，默认为 false。
+    audio_channel_count?: 1 | 2; // 音频声道数，仅在 enable_separate_recognition_per_channel 开启时有效，支持 1 或 2，默认为 1。
+    max_sentence_silence?: number; // 句子最大静音时间，仅在 enable_sentence_info 开启时有效，单位为 ms，默认为 800。
+    custom_words?: string[];
+    enable_channel_split?: boolean; // 是否开启声道分离
+    enable_ddc?: boolean; // 是否开启 DDC（双通道降噪）
+    enable_speaker_info?: boolean; // 是否开启说话人分离
+    enable_punc?: boolean; // 是否开启标点符号预测（简写）
+    enable_itn?: boolean; // 是否开启文本规范化（简写）
+    vad_segment?: boolean; // 是否开启 VAD 断句
+    show_utterances?: boolean; // 是否返回语句级别结果
+    corpus?: {
+      boosting_table_name?: string;
+      correct_table_name?: string;
+      context?: string;
+    };
+  };
+}
+
+// const main = async () => {
+//   const base64Audio = wavToBase64(audioPath);
+//   const auc = new Asr({
+//     appid: config.VOLCENGINE_AUC_APPID,
+//     token: config.VOLCENGINE_AUC_TOKEN,
+//   });
+//   const result = await auc.getText({ audio: { data: base64Audio } });
+//   console.log(util.inspect(result, { showHidden: false, depth: null, colors: true }))
+// }
+
+// main();

src/index.ts

@@ -1,13 +1,11 @@
-import { useConfig } from '@kevisual/use-config';
+import { config } from './modules/config.ts';
 import { app } from './app.ts';
 import './route.ts';
-const config = useConfig();
 import { uploadMiddleware } from './routes-simple/upload.ts';
+import { port } from './modules/config.ts';
 
 // if (import.meta.url === `file://${process.argv[1]}`) {
-app.listen(config.port, () => {
+app.listen(port, () => {
-  console.log(`server is running at http://localhost:${config.port}`);
+  console.log(`server is running at http://localhost:${port}`);
 });
 app.server.on(uploadMiddleware);
-
-console.log(`run ${config.appName} done`);

src/logger/index.ts

@@ -0,0 +1,20 @@
+import { useConfig } from '@kevisual/use-config/env';
+import { Logger } from '@kevisual/logger';
+const config = useConfig();
+
+export const logger = new Logger({
+  level: config.LOG_LEVEL || 'info',
+  showTime: true,
+});
+
+export const logError = (message: string, data?: any) => logger.error({ data }, message);
+export const logWarning = (message: string, data?: any) => logger.warn({ data }, message);
+export const logInfo = (message: string, data?: any) => logger.info({ data }, message);
+export const logDebug = (message: string, data?: any) => logger.debug({ data }, message);
+
+export const log = {
+  error: logError,
+  warn: logWarning,
+  info: logInfo,
+  debug: logDebug,
+};

src/models/org.ts

@@ -1,5 +1,5 @@
 // import { DataTypes, Model, Sequelize } from 'sequelize';
-// import { useContextKey } from '@kevisual/use-config/context';
+// import { useContextKey } from '@kevisual/context';
 // const sequelize = useContextKey<Sequelize>('sequelize');
 // export class Org extends Model {
 //   declare id: string;
@@ -42,7 +42,5 @@
 // });
 
 // useContextKey('OrgModel', () => Org);
-import { Org, OrgInit } from '@kevisual/code-center-module/models';
+import { Org } from '@kevisual/code-center-module/models';
 export { Org };
-
-OrgInit();

src/models/user.ts

@@ -1,297 +1,25 @@
-// import { useConfig } from '@kevisual/use-config';
-// import { DataTypes, Model, Op, Sequelize } from 'sequelize';
-// import { createToken, checkToken } from '@kevisual/auth';
-// import { cryptPwd } from '@kevisual/auth';
-// import { customRandom, nanoid, customAlphabet } from 'nanoid';
-// import { CustomError } from '@kevisual/router';
-// import { Org } from './org.ts';
-
-// import { useContextKey } from '@kevisual/use-config/context';
-// import { Redis } from 'ioredis';
-// export const redis = useContextKey<Redis>('redis');
-// const sequelize = useContextKey<Sequelize>('sequelize');
-// const config = useConfig<{ tokenSecret: string }>();
-
-// type UserData = {
-//   orgs?: string[];
-// };
-// export class User extends Model {
-//   declare id: string;
-//   declare username: string;
-//   declare nickname: string; // 昵称
-//   declare alias: string; // 别名
-//   declare password: string;
-//   declare salt: string;
-//   declare needChangePassword: boolean;
-//   declare description: string;
-//   declare data: UserData;
-//   declare type: string; // user | org | visitor
-//   declare owner: string;
-//   declare orgId: string;
-//   declare email: string;
-//   declare avatar: string;
-//   tokenUser: any;
-//   setTokenUser(tokenUser: any) {
-//     this.tokenUser = tokenUser;
-//   }
-//   /**
-//    * uid 是用于 orgId 的用户id 真实用户的id
-//    * @param uid
-//    * @returns
-//    */
-//   async createToken(uid?: string, loginType?: 'default' | 'plugin' | 'month' | 'season' | 'year') {
-//     const { id, username, type } = this;
-//     let expireTime = 60 * 60 * 24 * 7; // 7 days
-//     switch (loginType) {
-//       case 'plugin':
-//         expireTime = 60 * 60 * 24 * 30 * 12; // 365 days
-//         break;
-//       case 'month':
-//         expireTime = 60 * 60 * 24 * 30; // 30 days
-//         break;
-//       case 'season':
-//         expireTime = 60 * 60 * 24 * 30 * 3; // 90 days
-//         break;
-//       case 'year':
-//         expireTime = 60 * 60 * 24 * 30 * 12; // 365 days
-//         break;
-//     }
-//     const now = new Date().getTime();
-//     const token = await createToken({ id, username, uid, type }, config.tokenSecret);
-//     return { token, expireTime: now + expireTime };
-//   }
-//   static async verifyToken(token: string) {
-//     const ct = await checkToken(token, config.tokenSecret);
-//     const tokenUser = ct.payload;
-//     return tokenUser;
-//   }
-//   static async createUser(username: string, password?: string, description?: string) {
-//     const user = await User.findOne({ where: { username } });
-//     if (user) {
-//       throw new CustomError('User already exists');
-//     }
-//     const salt = nanoid(6);
-//     let needChangePassword = !password;
-//     password = password || '123456';
-//     const cPassword = cryptPwd(password, salt);
-//     return await User.create({ username, password: cPassword, description, salt, needChangePassword });
-//   }
-//   static async createOrg(username: string, owner: string, description?: string) {
-//     const user = await User.findOne({ where: { username } });
-//     if (user) {
-//       throw new CustomError('User already exists');
-//     }
-//     const me = await User.findByPk(owner);
-//     if (!me) {
-//       throw new CustomError('Owner not found');
-//     }
-//     if (me.type !== 'user') {
-//       throw new CustomError('Owner type is not user');
-//     }
-//     const org = await Org.create({ username, description, users: [{ uid: owner, role: 'owner' }] });
-//     const newUser = await User.create({ username, password: '', description, type: 'org', owner, orgId: org.id });
-//     // owner add
-//     await redis.del(`user:${me.id}:orgs`);
-//     return newUser;
-//   }
-//   createPassword(password: string) {
-//     const salt = this.salt;
-//     const cPassword = cryptPwd(password, salt);
-//     this.password = cPassword;
-//     return cPassword;
-//   }
-//   checkPassword(password: string) {
-//     const salt = this.salt;
-//     const cPassword = cryptPwd(password, salt);
-//     return this.password === cPassword;
-//   }
-//   async getInfo() {
-//     const orgs = await this.getOrgs();
-//     return {
-//       id: this.id,
-//       username: this.username,
-//       nickname: this.nickname,
-//       description: this.description,
-//       needChangePassword: this.needChangePassword,
-//       type: this.type,
-//       avatar: this.avatar,
-//       orgs,
-//     };
-//   }
-//   async getOrgs() {
-//     let id = this.id;
-//     if (this.type === 'org') {
-//       if (this.tokenUser && this.tokenUser.uid) {
-//         id = this.tokenUser.uid;
-//       } else {
-//         console.log('getOrgs', 'no uid', this.id, this.username);
-//         throw new CustomError('Permission denied');
-//       }
-//     }
-//     const cache = await redis.get(`user:${id}:orgs`);
-//     if (cache) {
-//       return JSON.parse(cache) as string[];
-//     }
-//     const orgs = await Org.findAll({
-//       order: [['updatedAt', 'DESC']],
-//       where: {
-//         users: {
-//           [Op.contains]: [
-//             {
-//               uid: id,
-//             },
-//           ],
-//         },
-//       },
-//     });
-//     const orgNames = orgs.map((org) => org.username);
-//     if (orgNames.length > 0) {
-//       await redis.set(`user:${id}:orgs`, JSON.stringify(orgNames), 'EX', 60 * 60); // 1 hour
-//     }
-//     return orgNames;
-//   }
-//   async expireOrgs() {
-//     await redis.del(`user:${this.id}:orgs`);
-//   }
-// }
-// User.init(
-//   {
-//     id: {
-//       type: DataTypes.UUID,
-//       primaryKey: true,
-//       defaultValue: DataTypes.UUIDV4,
-//     },
-//     username: {
-//       type: DataTypes.STRING,
-//       allowNull: false,
-//       unique: true,
-//       // 用户名或者手机号
-//       // 创建后避免修改的字段，当注册用户后，用户名注册则默认不能用手机号
-//     },
-//     nickname: {
-//       type: DataTypes.TEXT,
-//       allowNull: true,
-//     },
-//     alias: {
-//       type: DataTypes.TEXT,
-//       allowNull: true, // 别名，网络请求的别名，需要唯一，不能和username重复
-//       defaultValue: '',
-//     },
-//     password: {
-//       type: DataTypes.STRING,
-//       allowNull: true,
-//     },
-//     email: {
-//       type: DataTypes.STRING,
-//       allowNull: true,
-//     },
-//     avatar: {
-//       type: DataTypes.TEXT,
-//       allowNull: true,
-//     },
-//     salt: {
-//       type: DataTypes.STRING,
-//       allowNull: true,
-//     },
-//     description: {
-//       type: DataTypes.TEXT,
-//     },
-//     type: {
-//       type: DataTypes.STRING,
-//       defaultValue: 'user',
-//     },
-//     owner: {
-//       type: DataTypes.UUID,
-//     },
-//     orgId: {
-//       type: DataTypes.UUID,
-//     },
-//     needChangePassword: {
-//       type: DataTypes.BOOLEAN,
-//       defaultValue: false,
-//     },
-//     data: {
-//       type: DataTypes.JSONB,
-//       defaultValue: {},
-//     },
-//   },
-//   {
-//     sequelize,
-//     tableName: 'cf_user', // codeflow user
-//     paranoid: true,
-//   },
-// );
-// User.sync({ alter: true, logging: false })
-//   .then((res) => {
-//     initializeUser();
-//   })
-//   .catch((err) => {
-//     console.error('Sync User error', err);
-//   });
-
-// const letter = 'abcdefghijklmnopqrstuvwxyz';
-// const custom = customAlphabet(letter, 6);
-// export const initializeUser = async (pwd = custom()) => {
-//   const w = await User.findOne({ where: { username: 'root' }, logging: false });
-//   if (!w) {
-//     const root = await User.createUser('root', pwd, '系统管理员');
-//     const org = await User.createOrg('admin', root.id, '管理员');
-//     console.info(' new Users name', root.username, org.username);
-//     console.info('new Users root password', pwd);
-//     console.info('new Users id', root.id, org.id);
-//     const demo = await createDemoUser();
-//     return {
-//       code: 200,
-//       data: { root, org, pwd: pwd, demo },
-//     };
-//   } else {
-//     return {
-//       code: 500,
-//       message: 'Users has been created',
-//     };
-//   }
-// };
-// export const createDemoUser = async (username = 'demo', pwd = custom()) => {
-//   const u = await User.findOne({ where: { username }, logging: false });
-//   if (!u) {
-//     const user = await User.createUser(username, pwd, 'demo');
-//     console.info('new Users name', user.username, pwd);
-//     return {
-//       code: 200,
-//       data: { user, pwd: pwd },
-//     };
-//   } else {
-//     console.info('Users has been created', u.username);
-//     return {
-//       code: 500,
-//       message: 'Users has been created',
-//     };
-//   }
-// };
-// // initializeUser();
-
-// export class UserServices extends User {
-//   static async loginByPhone(phone: string) {
-//     let user = await User.findOne({ where: { username: phone } });
-//     let isNew = false;
-//     if (!user) {
-//       user = await User.createUser(phone, phone.slice(-6));
-//       isNew = true;
-//     }
-//     const token = await user.createToken(null, 'season');
-//     return { ...token, isNew };
-//   }
-//   static initializeUser = initializeUser;
-//   static createDemoUser = createDemoUser;
-// }
-
-// useContextKey('UserModel', () => UserServices);
-
 import { User, UserInit, UserServices } from '@kevisual/code-center-module/models';
-export { User, UserInit, UserServices };
+import { UserSecretInit, UserSecret } from '@kevisual/code-center-module/models';
-UserInit(null, null, {
+import { OrgInit } from '@kevisual/code-center-module/models';
-  alter: true,
+export { User, UserInit, UserServices, UserSecret };
-  logging: false,
+const init = async () => {
-}).catch((e) => {
+  await OrgInit(null, null, {
-  console.error('User sync', e);
+    alter: true,
-});
+    logging: false,
+  }).catch((e) => {
+    console.error('Org sync', e);
+  });
+  await UserInit(null, null, {
+    alter: true,
+    logging: false,
+  }).catch((e) => {
+    console.error('User sync', e);
+  });
+  await UserSecretInit(null, null, {
+    alter: true,
+    logging: false,
+  }).catch((e) => {
+    console.error('UserSecret sync', e);
+  });
+};
+init();

src/modules/config.ts

@@ -0,0 +1,17 @@
+import path from 'path';
+import dotenv from 'dotenv';
+// import { useConfig } from '@kevisual/use-config/env';
+
+export const envFiles = [
+  path.resolve(process.cwd(), process.env.NODE_ENV === 'development' ? '.env.dev' : '.env'),
+  // path.resolve(process.cwd(), '.env'), //
+];
+console.log('envFiles', envFiles);
+export const config = dotenv.config({
+  path: envFiles,
+  override: true,
+}).parsed;
+// const config = useConfig();
+// export const config = process.env;
+// console.log('config', config);
+export const port = config.PORT || 4005;

src/modules/domain.ts

@@ -1,11 +1,5 @@
-import { useConfig } from '@kevisual/use-config';
-
-type MinioConfig = {
-  domain: string;
-};
-const config = useConfig<MinioConfig>();
 
 /**
  * 用来放cookie的域名
  */
-export const domain = config.domain || ''; // 请在这里填写你的域名
+export const domain = process.env.DOMAIN || ''; // 请在这里填写你的域名

src/modules/logger.ts

@@ -0,0 +1,20 @@
+import { useConfig } from '@kevisual/use-config/env';
+import { Logger } from '@kevisual/logger';
+const config = useConfig();
+
+export const logger = new Logger({
+  level: config.LOG_LEVEL || 'info',
+  showTime: true,
+});
+
+export const logError = (message: string, data?: any) => logger.error({ data }, message);
+export const logWarning = (message: string, data?: any) => logger.warn({ data }, message);
+export const logInfo = (message: string, data?: any) => logger.info({ data }, message);
+export const logDebug = (message: string, data?: any) => logger.debug({ data }, message);
+
+export const log = {
+  error: logError,
+  warn: logWarning,
+  info: logInfo,
+  debug: logDebug,
+};

src/modules/minio.ts

@@ -1,24 +1,33 @@
 import { Client, ClientOptions } from 'minio';
-import { useConfig } from '@kevisual/use-config';
+import { config } from './config.ts';
-
+import { OssBase } from '@kevisual/oss/services';
-type MinioConfig = {
+const minioConfig = {
-  minio: ClientOptions & { bucketName: string };
+  endPoint: config.MINIO_ENDPOINT || 'localhost',
+  port: parseInt(config.MINIO_PORT || '9000'),
+  useSSL: config.MINIO_USE_SSL === 'true',
+  accessKey: config.MINIO_ACCESS_KEY,
+  secretKey: config.MINIO_SECRET_KEY,
 };
-const config = useConfig<MinioConfig>();
+// console.log('minioConfig', minioConfig);
+export const minioClient = new Client(minioConfig);
 
-const { bucketName, ...minioRest } = config.minio;
+export const bucketName = config.MINIO_BUCKET_NAME || 'resources';
-export const minioClient = new Client(minioRest);
-export { bucketName };
 if (!minioClient) {
   throw new Error('Minio client not initialized');
 }
 // 验证权限
-// (async () => {
+(async () => {
-//   const bucketExists = await minioClient.bucketExists(bucketName);
+  const bucketExists = await minioClient.bucketExists(bucketName);
-//   if (!bucketExists) {
+  if (!bucketExists) {
-//     await minioClient.makeBucket(bucketName);
+    await minioClient.makeBucket(bucketName);
-//   }
+  }
-//   const res = await minioClient.putObject(bucketName, 'private/test/a.b', 'test');
+  console.log('bucketExists', bucketExists);
-//   console.log('minio putObject', res);
+  // const res = await minioClient.putObject(bucketName, 'root/test/0.0.1/a.txt', 'test');
+  // console.log('minio putObject', res);
+})();
 
-// })();
+export const oss = new OssBase({
+  client: minioClient,
+  bucketName: bucketName,
+  prefix: '',
+});

src/modules/redis.ts

@@ -1,23 +1,29 @@
 import { Redis } from 'ioredis';
-import { useConfig } from '@kevisual/use-config';
+import { config } from './config.ts';
-
+const redisConfig = {
-const config = useConfig<{
+  host: config.REDIS_HOST || 'localhost',
-  redis: ConstructorParameters<typeof Redis>;
+  port: parseInt(config.REDIS_PORT || '6379'),
-}>();
+  password: config.REDIS_PASSWORD,
+};
+export const createRedisClient = (options = {}) => {
+  const redisClient = new Redis({
+    host: 'localhost', // Redis 服务器的主机名或 IP 地址
+    port: 6379, // Redis 服务器的端口号
+    // password: 'your_password', // Redis 的密码 (如果有)
+    db: 0, // 要使用的 Redis 数据库索引 (0-15)
+    keyPrefix: '', // key 前缀
+    retryStrategy(times) {
+      // 连接重试策略
+      return Math.min(times * 50, 2000); // 每次重试时延迟增加
+    },
+    maxRetriesPerRequest: null, // 允许请求重试的次数 (如果需要无限次重试)
+    ...redisConfig,
+    ...options,
+  });
+  return redisClient;
+};
 // 配置 Redis 连接
-export const redis = new Redis({
+export const redis = createRedisClient();
-  host: 'localhost', // Redis 服务器的主机名或 IP 地址
-  port: 6379, // Redis 服务器的端口号
-  // password: 'your_password', // Redis 的密码 (如果有)
-  db: 0, // 要使用的 Redis 数据库索引 (0-15)
-  keyPrefix: '', // key 前缀
-  retryStrategy(times) {
-    // 连接重试策略
-    return Math.min(times * 50, 2000); // 每次重试时延迟增加
-  },
-  maxRetriesPerRequest: null, // 允许请求重试的次数 (如果需要无限次重试)
-  ...config.redis,
-});
 
 // 监听连接事件
 redis.on('connect', () => {
@@ -29,6 +35,5 @@ redis.on('error', (err) => {
 });
 
 // 初始化 Redis 客户端
-export const redisPublisher = new Redis(); // 用于发布消息
+export const redisPublisher = createRedisClient(); // 用于发布消息
-export const redisSubscriber = new Redis(); // 用于订阅消息
+export const redisSubscriber = createRedisClient(); // 用于订阅消息
-

src/modules/self-restart.ts

@@ -1,11 +1,7 @@
-import { useConfig } from '@kevisual/use-config';
 import childProcess from 'child_process';
-const config = useConfig<{
-  appName: string;
-}>();
 
 export const selfRestart = async () => {
-  const appName = config.appName || 'codecenter';
+  const appName = 'code-center';
   // 检测 pm2 是否安装和是否有 appName 这个应用
   try {
     const res = childProcess.execSync(`pm2 list`);

src/modules/sequelize.ts

@@ -1,7 +1,7 @@
-import { useConfig } from '@kevisual/use-config';
 import { Sequelize } from 'sequelize';
-
+import { config } from './config.ts';
-type PostgresConfig = {
+import { log } from './logger.ts';
+export type PostgresConfig = {
   postgres: {
     username: string;
     password: string;
@@ -10,17 +10,31 @@ type PostgresConfig = {
     database: string;
   };
 };
-const config = useConfig<PostgresConfig>();
+if (!config.POSTGRES_PASSWORD || !config.POSTGRES_USER) {
-
+  log.error('postgres config is required password and user');
-const postgresConfig = config.postgres;
+  log.error('config', config);
-
-if (!postgresConfig) {
-  console.error('postgres config is required');
   process.exit(1);
 }
+const postgresConfig = {
+  username: config.POSTGRES_USER,
+  password: config.POSTGRES_PASSWORD,
+  host: config.POSTGRES_HOST || 'localhost',
+  port: parseInt(config.POSTGRES_PORT || '5432'),
+  database: config.POSTGRES_DB || 'postgres',
+};
 // connect to db
 export const sequelize = new Sequelize({
   dialect: 'postgres',
   ...postgresConfig,
   // logging: false,
 });
+
+sequelize
+  .authenticate({ logging: false })
+  .then(() => {
+    log.info('Database connected');
+  })
+  .catch((err) => {
+    log.error('Database connection failed', { err, config: postgresConfig });
+    process.exit(1);
+  });

src/program.ts

@@ -0,0 +1,16 @@
+import { program, Command } from 'commander';
+// import { useContextKey } from '@kevisual/context';
+// import * as redisLib from './modules/redis.ts';
+// import * as sequelizeLib from './modules/sequelize.ts';
+// import * as minioLib from './modules/minio.ts';
+
+// export const redis = useContextKey('redis', () => redisLib.redis);
+// export const redisPublisher = useContextKey('redisPublisher', () => redisLib.redisPublisher);
+// export const redisSubscriber = useContextKey('redisSubscriber', () => redisLib.redisSubscriber);
+// export const minioClient = useContextKey('minioClient', () => minioLib.minioClient);
+// export const sequelize = useContextKey('sequelize', () => sequelizeLib.sequelize);
+
+export { program, Command };
+
+program.description('code-center的一部分工具');
+program.version('1.0.0', '-v, --version');

src/route.ts

@@ -1,8 +1,63 @@
 import './routes/index.ts';
+import './aura/index.ts';
 import { app } from './app.ts';
+import type { App } from '@kevisual/router';
 import { User } from './models/user.ts';
-import { addAuth } from '@kevisual/code-center-module/models';
+import { createCookie, getSomeInfoFromReq } from './routes/user/me.ts';
 
+/**
+ * 添加auth中间件, 用于验证token
+ * 添加 id: auth 必须需要user成功
+ * 添加 id: auth-can 可以不需要user成功，有则赋值
+ *
+ * @param app
+ */
+export const addAuth = (app: App) => {
+  app
+    .route({
+      path: 'auth',
+      id: 'auth',
+    })
+    .define(async (ctx) => {
+      const token = ctx.query.token;
+      if (!token) {
+        app.throw(401, 'Token is required');
+      }
+      const user = await User.getOauthUser(token);
+      if (!user) {
+        app.throw(401, 'Token is invalid');
+      }
+      const someInfo = getSomeInfoFromReq(ctx);
+      if (someInfo.isBrowser && !ctx.req?.cookies?.['token']) {
+        createCookie({ accessToken: token }, ctx);
+      }
+      ctx.state.tokenUser = user;
+    })
+    .addTo(app);
+
+  app
+    .route({
+      path: 'auth',
+      key: 'can',
+      id: 'auth-can',
+    })
+    .define(async (ctx) => {
+      if (ctx.query?.token) {
+        const token = ctx.query.token;
+        const user = await User.getOauthUser(token);
+        if (token) {
+          ctx.state.tokenUser = user;
+          const someInfo = getSomeInfoFromReq(ctx);
+          if (someInfo.isBrowser && !ctx.req?.cookies?.['token']) {
+            createCookie({ accessToken: token }, ctx);
+          }
+        } else {
+          ctx.state.tokenUser = null;
+        }
+      }
+    })
+    .addTo(app);
+};
 addAuth(app);
 
 app
@@ -53,6 +108,7 @@ app
     if (!tokenUser) {
       ctx.throw(401, 'No User For authorized');
     }
+
     try {
       const user = await User.findOne({
         where: {

src/routes-simple/minio/download.ts

@@ -6,7 +6,7 @@ import { router } from '../router.ts';
 router.post('/api/minio', async (ctx) => {
   let { username, appKey } = { username: '', appKey: '' };
   const path = `${username}/${appKey}`;
-  const res = await minioClient.listObjects(bucketName, path, true);
+  const res = await minioClient.listObjectsV2(bucketName, path, true);
   const file = res.filter((item) => item.isFile);
   const fileList = file.map((item) => {
     return {

src/routes-simple/minio/get-minio-resource.ts

@@ -97,7 +97,6 @@ export const authMinio = async (req: IncomingMessage, res: ServerResponse, objec
     etag,
     'last-modified': lastModified,
     'Content-Disposition': contentDisposition,
-    'file-name': filename,
     ...filteredMetaData,
   });
   const objectStream = await minioClient.getObject(bucketName, objectName);

src/routes-simple/resources/chunk.ts

@@ -1,9 +1,8 @@
 import { useFileStore } from '@kevisual/use-config/file-store';
 import { checkAuth, error, router, writeEvents, getKey, getTaskId } from '../router.ts';
 import { IncomingForm } from 'formidable';
-import { app, minioClient } from '@/app.ts';
+import { app, oss } from '@/app.ts';
 
-import { bucketName } from '@/modules/minio.ts';
 import { getContentType } from '@/utils/get-content-type.ts';
 import { User } from '@/models/user.ts';
 import fs from 'fs';
@@ -23,6 +22,7 @@ router.post('/api/s1/resources/upload/chunk', async (req, res) => {
   if (!tokenUser) return;
   const url = new URL(req.url || '', 'http://localhost');
   const share = !!url.searchParams.get('public');
+  const noCheckAppFiles = !!url.searchParams.get('noCheckAppFiles');
   // 使用 formidable 解析 multipart/form-data
   const form = new IncomingForm({
     multiples: false, // 改为单文件上传
@@ -123,8 +123,9 @@ router.post('/api/s1/resources/upload/chunk', async (req, res) => {
         if (share) {
           metadata.share = 'public';
         }
+        const bucketName = oss.bucketName;
         // All chunks uploaded, now upload to MinIO
-        await minioClient.fPutObject(bucketName, minioPath, finalFilePath, {
+        await oss.client.fPutObject(bucketName, minioPath, finalFilePath, {
           'Content-Type': getContentType(relativePath),
           'app-source': 'user-app',
           'Cache-Control': relativePath.endsWith('.html') ? 'no-cache' : 'max-age=31536000, immutable',
@@ -133,38 +134,57 @@ router.post('/api/s1/resources/upload/chunk', async (req, res) => {
 
         // Clean up the final file
         fs.unlinkSync(finalFilePath);
-
-        // Notify the app
-        const r = await app.call({
-          path: 'app',
-          key: 'detect-version-list',
-          payload: {
-            token: token,
-            data: {
-              appKey,
-              version,
-              username,
-            },
-          },
-        });
         const downloadBase = '/api/s1/share';
-        const data: any = {
+
-          code: r.code,
+        const uploadResult = {
-          data: {
+          name: relativePath,
-            app: r.body,
+          path: `${downloadBase}/${minioPath}`,
-            resource: `${downloadBase}/${minioPath}`,
+          appKey,
-          },
+          version,
+          username,
         };
-        if (r.message) {
+        if (!noCheckAppFiles) {
-          data.message = r.message;
+          // Notify the app
+          const r = await app.call({
+            path: 'app',
+            key: 'detectVersionList',
+            payload: {
+              token: token,
+              data: {
+                appKey,
+                version,
+                username,
+              },
+            },
+          });
+          const data: any = {
+            code: r.code,
+            data: {
+              app: r.body,
+              upload: [uploadResult],
+            },
+          };
+          if (r.message) {
+            data.message = r.message;
+          }
+          console.log('upload data', data);
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify(data));
+        } else {
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(
+            JSON.stringify({
+              code: 200,
+              message: 'Chunk uploaded successfully',
+              data: { chunkIndex, totalChunks, upload: [uploadResult] },
+            }),
+          );
         }
-        console.log('upload data', data);
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify(data));
       } else {
         res.writeHead(200, { 'Content-Type': 'application/json' });
         res.end(
           JSON.stringify({
+            code: 200,
             message: 'Chunk uploaded successfully',
             data: {
               chunkIndex,

src/routes-simple/resources/get-resources.ts

@@ -5,7 +5,8 @@ router.all('/api/s1/share/*splat', async (req, res) => {
   try {
     const url = req.url;
     const _url = new URL(url || '', 'http://localhost');
-    const objectName = _url.pathname.replace('/api/s1/share/', '');
+    let objectName = _url.pathname.replace('/api/s1/share/', '');
+    objectName = decodeURIComponent(objectName); 
     await authMinio(req, res, objectName);
   } catch (e) {
     console.log('get share resource error url', req.url);

src/routes-simple/resources/upload.ts

@@ -9,6 +9,9 @@ import { User } from '@/models/user.ts';
 import fs from 'fs';
 import { ConfigModel } from '@/routes/config/models/model.ts';
 import { validateDirectory } from './util.ts';
+import { pick } from 'lodash-es';
+import { getFileStat } from '@/routes/file/index.ts';
+import { logger } from '@/logger/index.ts';
 
 const cacheFilePath = useFileStore('cache-file', { needExists: true });
 
@@ -16,12 +19,91 @@ router.get('/api/s1/resources/upload', async (req, res) => {
   res.writeHead(200, { 'Content-Type': 'text/plain' });
   res.end('Upload API is ready');
 });
+export const parseIfJson = (data = '{}') => {
+  try {
+    const _data = JSON.parse(data);
+    if (typeof _data === 'object') return _data;
+    return {};
+  } catch (error) {
+    return {};
+  }
+};
+router.post('/api/s1/resources/upload/check', async (req, res) => {
+  const { tokenUser, token } = await checkAuth(req, res);
+  if (!tokenUser) {
+    res.end(error('Token is invalid.'));
+    return;
+  }
+  console.log('data', req.url);
+  res.writeHead(200, { 'Content-Type': 'application/json' });
+  const data = await router.getBody(req);
+  type Data = {
+    appKey: string;
+    version: string;
+    username: string;
+    directory: string;
+    files: { path: string; hash: string }[];
+  };
+  let { appKey, version, username, directory, files } = pick(data, ['appKey', 'version', 'username', 'directory', 'files']) as Data;
+  let uid = tokenUser.id;
+  if (username) {
+    const user = await User.getUserByToken(token);
+    const has = await user.hasUser(username, true);
+    if (!has) {
+      res.end(error('username is not found'));
+      return;
+    }
+    const _user = await User.findOne({ where: { username } });
+    uid = _user?.id || '';
+  }
+  if (!appKey || !version) {
+    res.end(error('appKey and version is required'));
+  }
+
+  const { code, message } = validateDirectory(directory);
+  if (code !== 200) {
+    res.end(error(message));
+    return;
+  }
+  type CheckResult = {
+    path: string;
+    stat: any;
+    resourcePath: string;
+    hash: string;
+    uploadHash: string;
+    isUpload?: boolean;
+  };
+  const checkResult: CheckResult[] = [];
+  for (let i = 0; i < files.length; i++) {
+    const file = files[i];
+    const relativePath = file.path;
+    const minioPath = `${username || tokenUser.username}/${appKey}/${version}${directory ? `/${directory}` : ''}/${relativePath}`;
+    let stat = await getFileStat(minioPath, true);
+    const statHash = stat?.etag || '';
+    checkResult.push({
+      path: relativePath,
+      uploadHash: file.hash,
+      resourcePath: minioPath,
+      isUpload: statHash === file.hash,
+      stat,
+      hash: statHash,
+    });
+  }
+  res.end(JSON.stringify({ code: 200, data: checkResult }));
+});
 
 // /api/s1/resources/upload
 router.post('/api/s1/resources/upload', async (req, res) => {
   const { tokenUser, token } = await checkAuth(req, res);
-  if (!tokenUser) return;
+  if (!tokenUser) {
-  // 使用 formidable 解析 multipart/form-data
+    res.end(error('Token is invalid.'));
+    return;
+  }
+  const url = new URL(req.url || '', 'http://localhost');
+  const share = !!url.searchParams.get('public');
+  const meta = parseIfJson(url.searchParams.get('meta'));
+  const noCheckAppFiles = !!url.searchParams.get('noCheckAppFiles');
+  // 使用 formi dable 解析 multipart/form-data
   const form = new IncomingForm({
     multiples: true, // 支持多文件上传
     uploadDir: cacheFilePath, // 上传文件存储目录
@@ -45,10 +127,13 @@ router.post('/api/s1/resources/upload', async (req, res) => {
     const clearFiles = () => {
       const uploadedFiles = Array.isArray(files.file) ? files.file : [files.file];
       uploadedFiles.forEach((file) => {
-        fs.unlinkSync(file.filepath);
+        if (file?.filepath && fs.existsSync(file.filepath)) {
+          fs.unlinkSync(file.filepath);
+        }
       });
     };
     if (err) {
+      logger.error(`Upload error: ${err.message}`);
       res.end(error(`Upload error: ${err.message}`));
       clearFiles();
       return;
@@ -86,6 +171,12 @@ router.post('/api/s1/resources/upload', async (req, res) => {
     }
     // 逐个处理每个上传的文件
     const uploadedFiles = Array.isArray(files.file) ? files.file : [files.file];
+    logger.info(
+      'upload files',
+      uploadedFiles.map((item) => {
+        return pick(item, ['filepath', 'originalFilename']);
+      }),
+    );
     const uploadResults = [];
     for (let i = 0; i < uploadedFiles.length; i++) {
       const file = uploadedFiles[i];
@@ -96,39 +187,62 @@ router.post('/api/s1/resources/upload', async (req, res) => {
       const minioPath = `${username || tokenUser.username}/${appKey}/${version}${directory ? `/${directory}` : ''}/${relativePath}`;
       // 上传到 MinIO 并保留文件夹结构
       const isHTML = relativePath.endsWith('.html');
+      const metadata: any = {};
+      if (share) {
+        metadata.share = 'public';
+      }
+      Object.assign(metadata, meta);
       await minioClient.fPutObject(bucketName, minioPath, tempPath, {
         'Content-Type': getContentType(relativePath),
         'app-source': 'user-app',
         'Cache-Control': isHTML ? 'no-cache' : 'max-age=31536000, immutable', // 缓存一年
+        ...metadata,
       });
       uploadResults.push({
         name: relativePath,
         path: minioPath,
       });
       fs.unlinkSync(tempPath); // 删除临时文件
-    } // 受控
-    const r = await app.call({
-      path: 'app',
-      key: 'uploadFiles',
-      payload: {
-        token: token,
-        data: {
-          appKey,
-          version,
-          username,
-          files: uploadResults,
-        },
-      },
-    });
-    const data: any = {
-      code: r.code,
-      data: r.body,
-    };
-    if (r.message) {
-      data.message = r.message;
     }
-    console.log('upload data', data);
+    if (!noCheckAppFiles) {
-    res.writeHead(200, { 'Content-Type': 'application/json' });
+      // 受控
-    res.end(JSON.stringify(data));
+      const r = await app.call({
+        path: 'app',
+        key: 'uploadFiles',
+        payload: {
+          token: token,
+          data: {
+            appKey,
+            version,
+            username,
+            files: uploadResults,
+          },
+        },
+      });
+      const data: any = {
+        code: r.code,
+        data: {
+          app: r.body,
+          upload: uploadResults,
+        },
+      };
+      if (r.message) {
+        data.message = r.message;
+      }
+      console.log('upload data', data);
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(data));
+    } else {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(
+        JSON.stringify({
+          code: 200,
+          data: {
+            detect: [],
+            upload: uploadResults,
+          },
+        }),
+      );
+    }
   });
 });

src/routes-simple/router.ts

@@ -1,6 +1,6 @@
 import { router } from '@/app.ts';
 import http from 'http';
-import { useContextKey } from '@kevisual/use-config/context';
+import { useContextKey } from '@kevisual/context';
 import { checkAuth, error } from './middleware/auth.ts';
 import formidable from 'formidable';
 export { router, checkAuth, error };

src/routes-simple/upload.ts

@@ -12,7 +12,6 @@ import { getContainerById } from '@/routes/container/module/get-container-file.t
 import { router, error, checkAuth, clients, writeEvents } from './router.ts';
 import './index.ts';
 
-const filePath = useFileStore('upload', { needExists: true });
 const cacheFilePath = useFileStore('cache-file', { needExists: true });
 // curl -X POST http://localhost:4000/api/upload -F "file=@readme.md"
 // curl -X POST http://localhost:4000/api/upload \
@@ -178,13 +177,13 @@ router.get('/api/container/file/:id', async (req, res) => {
   res.end(JSON.stringify(container));
 });
 
-router.get('/api/code/version', async (req, res) => {
+// router.get('/api/code/version', async (req, res) => {
-  const version = VERSION;
+//   const version = VERSION;
-  res.writeHead(200, {
+//   res.writeHead(200, {
-    'Content-Type': 'application/json',
+//     'Content-Type': 'application/json',
-  });
+//   });
-  res.end(JSON.stringify({ code: 200, data: { version } }));
+//   res.end(JSON.stringify({ code: 200, data: { version } }));
-});
+// });
 
 export const uploadMiddleware = async (req: http.IncomingMessage, res: http.ServerResponse) => {
   if (req.url?.startsWith('/api/router')) {

src/routes/app-manager/admin/mv-user-app.ts

@@ -0,0 +1,13 @@
+import { app } from '@/app.ts';
+import { AppModel, AppListModel } from '../module/index.ts';
+export const mvAppFromUserAToUserB = async (userA: string, userB: string) => {
+  const appList = await AppModel.findAll({
+    where: {
+      user: userA,
+    },
+  });
+  for (const app of appList) {
+    app.user = userB;
+    await app.save();
+  }
+};

src/routes/app-manager/domain/domain-self.ts

@@ -0,0 +1,90 @@
+import { app } from '@/app.ts';
+import { AppModel } from '../module/app.ts';
+import { AppDomainModel } from '../module/app-domain.ts';
+
+app
+  .route({
+    path: 'app',
+    key: 'getDomainApp',
+  })
+  .define(async (ctx) => {
+    const { domain } = ctx.query.data;
+    // const query = {
+    // }
+    const domainInfo = await AppDomainModel.findOne({ where: { domain } });
+    if (!domainInfo || !domainInfo.appId) {
+      ctx.throw(404, 'app not found');
+    }
+    const app = await AppModel.findByPk(domainInfo.appId);
+    if (!app) {
+      ctx.throw(404, 'app not found');
+    }
+    ctx.body = app;
+    return ctx;
+  })
+  .addTo(app);
+
+app
+  .route({
+    path: 'app-domain',
+    key: 'create',
+    middleware: ['auth'],
+  })
+  .define(async (ctx) => {
+    const tokenUser = ctx.state.tokenUser;
+    const uid = tokenUser.uid;
+    const { domain, appId } = ctx.query.data || {};
+    if (!domain || !appId) {
+      ctx.throw(400, 'domain and appId are required');
+    }
+    const domainInfo = await AppDomainModel.create({ domain, appId, uid });
+    ctx.body = domainInfo;
+    return ctx;
+  })
+  .addTo(app);
+
+app
+  .route({
+    path: 'app-domain',
+    key: 'update',
+    middleware: ['auth'],
+  })
+  .define(async (ctx) => {
+    const tokenUser = ctx.state.tokenUser;
+    const uid = tokenUser.uid;
+    const { id, domain, appId, status } = ctx.query.data || {};
+    if (!domain && !id) {
+      ctx.throw(400, 'domain and id are required at least one');
+    }
+    if (!status) {
+      ctx.throw(400, 'status is required');
+    }
+    let domainInfo: AppDomainModel | null = null;
+    if (id) {
+      domainInfo = await AppDomainModel.findByPk(id);
+    }
+    if (!domainInfo && domain) {
+      domainInfo = await AppDomainModel.findOne({ where: { domain, appId } });
+    }
+    if (!domainInfo) {
+      ctx.throw(404, 'domain not found');
+    }
+    if (domainInfo.uid !== uid) {
+      ctx.throw(403, 'domain must be owned by the user');
+    }
+    if (!domainInfo.checkCanUpdateStatus(status)) {
+      ctx.throw(400, 'domain status can not be updated');
+    }
+    if (status) {
+      domainInfo.status = status;
+    }
+
+    if (appId) {
+      domainInfo.appId = appId;
+    }
+    await domainInfo.save({ fields: ['status', 'appId'] });
+
+    ctx.body = domainInfo;
+    return ctx;
+  })
+  .addTo(app);

src/routes/app-manager/domain/index.ts

@@ -0,0 +1,2 @@
+import './domain-self.ts';
+import './manager.ts';

src/routes/app-manager/domain/manager.ts

@@ -0,0 +1,125 @@
+import { app } from '@/app.ts';
+import { AppDomainModel } from '../module/app-domain.ts';
+import { AppModel } from '../module/app.ts';
+import { CustomError } from '@kevisual/router';
+
+app
+  .route({
+    path: 'app.domain.manager',
+    key: 'list',
+    middleware: ['auth-admin'],
+  })
+  .define(async (ctx) => {
+    const { page = 1, pageSize = 999 } = ctx.query.data || {};
+    const { count, rows } = await AppDomainModel.findAndCountAll({
+      offset: (page - 1) * pageSize,
+      limit: pageSize,
+    });
+    ctx.body = { count, list: rows, pagination: { page, pageSize } };
+    return ctx;
+  })
+  .addTo(app);
+
+app
+  .route({
+    path: 'app.domain.manager',
+    key: 'update',
+    middleware: ['auth-admin'],
+  })
+  .define(async (ctx) => {
+    const { domain, data, id, ...rest } = ctx.query.data || {};
+    if (!domain) {
+      ctx.throw(400, 'domain is required');
+    }
+    let domainInfo: AppDomainModel;
+    if (id) {
+      domainInfo = await AppDomainModel.findByPk(id);
+    } else {
+      domainInfo = await AppDomainModel.create({ domain });
+    }
+    const checkAppId = async () => {
+      const isUUID = (id: string) => {
+        return /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.test(id);
+      };
+      if (rest.appId) {
+        if (!isUUID(rest.appId)) {
+          ctx.throw(400, 'appId is not valid');
+        }
+        const appInfo = await AppModel.findByPk(rest.appId);
+        if (!appInfo) {
+          ctx.throw(400, 'appId is not exist');
+        }
+      }
+    };
+    try {
+      if (!domainInfo) {
+        domainInfo = await AppDomainModel.create({ domain, data: {}, ...rest });
+        await checkAppId();
+      } else {
+        if (rest.status && domainInfo.status !== rest.status) {
+          await domainInfo.clearCache();
+        }
+        await checkAppId();
+        await domainInfo.update({
+          domain,
+          data: {
+            ...domainInfo.data,
+            ...data,
+          },
+          ...rest,
+        });
+      }
+      ctx.body = domainInfo;
+    } catch (error) {
+      if (error.code) {
+        ctx.throw(error.code, error.message);
+      }
+      console.error(error);
+      ctx.throw(500, 'update domain failed, please check the data');
+    }
+
+    return ctx;
+  })
+  .addTo(app);
+
+app
+  .route({
+    path: 'app.domain.manager',
+    key: 'delete',
+    middleware: ['auth-admin'],
+  })
+  .define(async (ctx) => {
+    const { id, domain } = ctx.query.data || {};
+    if (!id && !domain) {
+      ctx.throw(400, 'id or domain is required');
+    }
+    if (id) {
+      await AppDomainModel.destroy({ where: { id }, force: true });
+    } else {
+      await AppDomainModel.destroy({ where: { domain }, force: true });
+    }
+
+    ctx.body = { message: 'delete domain success' };
+    return ctx;
+  })
+  .addTo(app);
+
+app
+  .route({
+    path: 'app.domain.manager',
+    key: 'get',
+    middleware: ['auth-admin'],
+  })
+  .define(async (ctx) => {
+    const { id, domain } = ctx.query.data || {};
+    if (!id && !domain) {
+      ctx.throw(400, 'id or domain is required');
+    }
+    const domainInfo = await AppDomainModel.findOne({ where: { id } });
+    if (!domainInfo) {
+      ctx.throw(404, 'domain not found');
+    }
+    ctx.body = domainInfo;
+    return ctx;
+  })
+  .addTo(app);

src/routes/app-manager/export.ts

@@ -2,7 +2,7 @@ import { app } from '@/app.ts';
 export const callDetectAppVersion = async ({ appKey, version, username }: { appKey: string; version: string; username: string }, token: string) => {
   const res = await app.call({
     path: 'app',
-    key: 'detect-version-list',
+    key: 'detectVersionList',
     payload: {
       token: token,
       data: { appKey, version, username },

src/routes/app-manager/index.ts

@@ -2,5 +2,8 @@ import './list.ts';
 import './user-app.ts';
 
 import './public/index.ts';
+import './domain/index.ts';
+
+import './proxy/index.ts';
 
 export * from './module/index.ts';

src/routes/app-manager/list.ts

@@ -1,7 +1,7 @@
 import { App, CustomError } from '@kevisual/router';
 import { AppModel, AppListModel } from './module/index.ts';
 import { app, redis } from '@/app.ts';
-import _ from 'lodash';
+import { uniqBy } from 'lodash-es';
 import { getUidByUsername, prefixFix } from './util.ts';
 import { deleteFiles, getMinioListAndSetToAppList } from '../file/index.ts';
 import { setExpire } from './revoke.ts';
@@ -40,15 +40,26 @@ app
   .define(async (ctx) => {
     const tokenUser = ctx.state.tokenUser;
     const id = ctx.query.id;
-    if (!id) {
+    const { key, version } = ctx.query?.data || {};
+    if (!id && (!key || !version)) {
       throw new CustomError('id is required');
     }
-    const am = await AppListModel.findByPk(id);
+    let am: AppListModel;
+    if (id) {
+      am = await AppListModel.findByPk(id);
+    } else if (key && version) {
+      am = await AppListModel.findOne({
+        where: {
+          key,
+          version,
+          uid: tokenUser.id,
+        },
+      });
+    }
     if (!am) {
       throw new CustomError('app not found');
     }
     ctx.body = prefixFix(am, tokenUser.username);
-    return ctx;
   })
   .addTo(app);
 
@@ -91,6 +102,7 @@ app
   })
   .define(async (ctx) => {
     const id = ctx.query.id;
+    const deleteFile = !!ctx.query.deleteFile; // 是否删除文件, 默认不删除
     if (!id) {
       throw new CustomError('id is required');
     }
@@ -106,7 +118,7 @@ app
       throw new CustomError('app is published');
     }
     const files = app.data.files || [];
-    if (files.length > 0) {
+    if (deleteFile && files.length > 0) {
       await deleteFiles(files.map((item) => item.path));
     }
     await app.destroy({
@@ -140,6 +152,7 @@ app
     path: 'app',
     key: 'uploadFiles',
     middleware: ['auth'],
+    isDebug: true,
   })
   .define(async (ctx) => {
     try {
@@ -194,7 +207,7 @@ app
         });
       }
       const dataFiles = app.data.files || [];
-      const newFiles = _.uniqBy([...dataFiles, ...files], 'name');
+      const newFiles = uniqBy([...dataFiles, ...files], 'name');
       const res = await app.update({ data: { ...app.data, files: newFiles } });
       if (version === am.version && !appIsNew) {
         await am.update({ data: { ...am.data, files: newFiles } });
@@ -216,13 +229,25 @@ app
   })
   .define(async (ctx) => {
     const tokenUser = ctx.state.tokenUser;
-    const { id, username } = ctx.query.data;
+    const { id, username, appKey, version } = ctx.query.data;
-    if (!id) {
+    if (!id && !appKey) {
-      throw new CustomError('id is required');
+      throw new CustomError('id or appKey is required');
     }
 
     const uid = await getUidByUsername(app, ctx, username);
-    const appList = await AppListModel.findByPk(id);
+    let appList: AppListModel | null = null;
+    if (id) {
+      appList = await AppListModel.findByPk(id);
+      if (appList?.uid !== uid) {
+        throw new CustomError('no permission');
+      }
+    }
+    if (!appList && appKey) {
+      if (!version) {
+        throw new CustomError('version is required');
+      }
+      appList = await AppListModel.findOne({ where: { key: appKey, version, uid } });
+    }
     if (!appList) {
       throw new CustomError('app not found');
     }
@@ -264,24 +289,6 @@ app
   })
   .addTo(app);
 
-app
-  .route({
-    path: 'app',
-    key: 'getDomainApp',
-  })
-  .define(async (ctx) => {
-    const { domain } = ctx.query.data;
-    // const query = {
-    // }
-    const app = await AppModel.findOne({ where: { domain } });
-    if (!app) {
-      throw new CustomError('app not found');
-    }
-    ctx.body = app;
-    return ctx;
-  })
-  .addTo(app);
-
 app
   .route({
     path: 'app',
@@ -303,7 +310,7 @@ app
 app
   .route({
     path: 'app',
-    key: 'detect-version-list',
+    key: 'detectVersionList',
     description: '检测版本列表，minio中的数据自己上传后，根据版本信息，进行替换',
     middleware: ['auth'],
   })
@@ -336,7 +343,7 @@ app
     let appListFiles = appList.data?.files || [];
     const needAddFiles = newFiles.map((item) => {
       const findFile = appListFiles.find((appListFile) => appListFile.name === item.name);
-      if (findFile && findFile.path === item.path) {
+      if (findFile && findFile.name === item.name) {
         return { ...findFile, ...item };
       }
       return item;

src/routes/app-manager/module/app-domain.ts

@@ -0,0 +1,87 @@
+import { sequelize } from '../../../modules/sequelize.ts';
+import { DataTypes, Model } from 'sequelize';
+export type DomainList = Partial<InstanceType<typeof AppDomainModel>>;
+import { redis } from '../../../modules/redis.ts';
+
+// 审核，通过，驳回
+const appDomainStatus = ['audit', 'auditReject', 'auditPending', 'running', 'stop'] as const;
+
+type AppDomainStatus = (typeof appDomainStatus)[number];
+/**
+ * 应用域名管理
+ */
+export class AppDomainModel extends Model {
+  declare id: string;
+  declare domain: string;
+  declare appId: string;
+  // 状态，
+  declare status: AppDomainStatus;
+  declare uid: string;
+  declare data: Record<string, any>;
+
+  declare createdAt: Date;
+  declare updatedAt: Date;
+
+  checkCanUpdateStatus(newStatus: AppDomainStatus) {
+    // 原本是运行中，可以改为停止，原本是停止，可以改为运行。
+    if (this.status === 'running' || this.status === 'stop') {
+      return true;
+    }
+    // 原本是审核状态，不能修改。
+    return false;
+  }
+  async clearCache() {
+    // 清除缓存
+    const cacheKey = `domain:${this.domain}`;
+    const checkHas = async () => {
+      const has = await redis.get(cacheKey);
+      return has;
+    };
+    const has = await checkHas();
+    if (has) {
+      await redis.set(cacheKey, '', 'EX', 1);
+    }
+  }
+}
+
+AppDomainModel.init(
+  {
+    id: {
+      type: DataTypes.UUID,
+      primaryKey: true,
+      defaultValue: DataTypes.UUIDV4,
+      comment: 'id',
+    },
+    domain: {
+      type: DataTypes.STRING,
+      allowNull: false,
+      unique: true,
+    },
+    data: {
+      type: DataTypes.JSONB,
+      allowNull: true,
+    },
+    status: {
+      type: DataTypes.STRING,
+      allowNull: false,
+      defaultValue: 'running',
+    },
+    appId: {
+      type: DataTypes.STRING,
+      allowNull: true,
+    },
+    uid: {
+      type: DataTypes.STRING,
+      allowNull: true,
+    },
+  },
+  {
+    sequelize,
+    tableName: 'kv_app_domain',
+    paranoid: true,
+  },
+);
+
+AppDomainModel.sync({ alter: true, logging: false }).catch((e) => {
+  console.error('AppDomainModel sync', e);
+});

src/routes/app-manager/module/app-list.ts

@@ -1,6 +1,6 @@
 import { sequelize } from '../../../modules/sequelize.ts';
 import { DataTypes, Model } from 'sequelize';
-import { AppData, AppType, AppStatus } from './app.ts';
+import { AppData } from './app.ts';
 
 export type AppList = Partial<InstanceType<typeof AppListModel>>;
 

src/routes/app-manager/module/app.ts

@@ -36,7 +36,6 @@ export class AppModel extends Model {
   declare title: string;
   declare description: string;
   declare version: string;
-  declare domain: string;
   declare key: string;
   declare uid: string;
   declare pid: string;
@@ -44,6 +43,55 @@ export class AppModel extends Model {
   declare proxy: boolean;
   declare user: string;
   declare status: string;
+  static async moveToNewUser(oldUserName: string, newUserName: string) {
+    const appIds = await AppModel.findAll({
+      where: {
+        user: oldUserName,
+      },
+      attributes: ['id'],
+    });
+    for (const app of appIds) {
+      const appData = await AppModel.findByPk(app.id);
+      appData.user = newUserName;
+      const data = appData.data;
+      data.files = await AppModel.getNewFiles(data.files, {
+        oldUser: oldUserName,
+        newUser: newUserName,
+      });
+      appData.data = { ...data };
+      await appData.save({ fields: ['data', 'user'] });
+    }
+  }
+  static async getNewFiles(files: { name: string; path: string }[] = [], opts: { oldUser: string; newUser: string } = { oldUser: '', newUser: '' }) {
+    const { oldUser, newUser } = opts;
+    const _ = files.map((item) => {
+      if (item.path.startsWith('http')) {
+        return item;
+      }
+      if (oldUser && item.path.startsWith(oldUser)) {
+        return item;
+      }
+      const paths = item.path.split('/');
+      return {
+        ...item,
+        path: newUser + '/' + paths.slice(1).join('/'),
+      };
+    });
+    return _;
+  }
+
+  async getPublic() {
+    const value = this.toJSON();
+    // 删除不需要的字段
+    const data = value.data;
+    if (data && data.permission) {
+      delete data.permission.usernames;
+      delete data.permission.password;
+      delete data.permission['expiration-time'];
+    }
+    value.data = data;
+    return value;
+  }
 }
 AppModel.init(
   {
@@ -69,10 +117,6 @@ AppModel.init(
       type: DataTypes.STRING,
       defaultValue: '',
     },
-    domain: {
-      type: DataTypes.STRING,
-      defaultValue: '',
-    },
     key: {
       type: DataTypes.STRING,
       // 和 uid 组合唯一

src/routes/app-manager/proxy/index.ts

@@ -0,0 +1 @@
+import './page-proxy.ts';

src/routes/app-manager/proxy/page-proxy.ts

@@ -0,0 +1,29 @@
+import { app, redis } from '@/app.ts';
+app
+  .route({
+    path: 'page-proxy-app',
+    key: 'status',
+  })
+  .define(async (ctx) => {
+    //
+    const { user, app } = ctx.query;
+    if (!user || !app) {
+      ctx.body = {
+        code: 400,
+        message: 'user and app are required',
+      };
+      return;
+    }
+    const key = `user:app:status:${app}:${user}`;
+    const status = await redis.get(key);
+    if (!status) {
+      ctx.throw(404, 'status not found');
+    }
+    try {
+      const parsedStatus = JSON.parse(status);
+      ctx.body = parsedStatus;
+    } catch (e) {
+      ctx.throw(400, 'status is not a valid json');
+    }
+  })
+  .addTo(app);

src/routes/app-manager/public/index.ts

@@ -1 +1,3 @@
 import './list.ts';
+
+import './post.ts'

src/routes/app-manager/public/list.ts

@@ -1,5 +1,6 @@
 import { app } from '@/app.ts';
 import { AppModel } from '../module/index.ts';
+import { ConfigPermission } from '@kevisual/permission';
 
 // curl http://localhost:4005/api/router?path=app&key=public-list
 // TODO:
@@ -9,15 +10,28 @@ app
     key: 'public-list',
   })
   .define(async (ctx) => {
-    const list = await AppModel.findAll({
+    const { username = 'root', status = 'running', page = 1, pageSize = 100, order = 'DESC' } = ctx.query.data || {};
+    const { rows, count } = await AppModel.findAndCountAll({
       where: {
-        status: 'running',
+        status,
+        user: username,
       },
-      // attributes: {
+      attributes: {
-      // exclude: ['data'],
+        exclude: [],
-      // },
+      },
+      order: [['updatedAt', order]],
+      limit: pageSize,
+      offset: (page - 1) * pageSize,
+      distinct: true,
       logging: false,
     });
-    ctx.body = list;
+    ctx.body = {
+      list: rows.map((item) => {
+        return ConfigPermission.getDataPublicPermission(item.toJSON());
+      }),
+      pagination: {
+        total: count,
+      },
+    };
   })
   .addTo(app);

src/routes/app-manager/public/post.ts

@@ -0,0 +1,111 @@
+import { app } from '@/app.ts';
+import { AppModel } from '../module/index.ts';
+import { AppListModel } from '../module/index.ts';
+import { oss } from '@/app.ts';
+import { User } from '@/models/user.ts';
+import { permission } from 'process';
+import { customAlphabet } from 'nanoid';
+import dayjs from 'dayjs';
+
+const letter = 'abcdefghijklmnopqrstuvwxyz';
+const number = '0123456789';
+const randomId = customAlphabet(letter + number, 16);
+const getShareUser = async () => {
+  const shareUser = await User.findOne({
+    where: {
+      username: 'share',
+    },
+  });
+  return shareUser?.id || '';
+};
+app
+  .route({
+    path: 'app',
+    key: 'public-upload-html',
+    middleware: ['auth-can'],
+  })
+  .define(async (ctx) => {
+    const tokenUser = ctx.state.tokenUser || {};
+
+    let uid = tokenUser?.id;
+    let username = tokenUser?.username;
+    if (!uid) {
+      uid = await getShareUser();
+      username = 'share';
+    }
+    if (!uid) {
+      ctx.throw(403, 'No permission to upload');
+    }
+    let { title, description, version = '1.0.0', key, content } = ctx.query.data || {};
+    if (!content) {
+      ctx.throw(400, 'Content is required');
+    }
+    if (!key) {
+      key = randomId(16);
+    }
+    if (!title) {
+      const day = dayjs().format('YYYY-MM-DD HH:mm');
+      const time = dayjs().format('YYYY-MM-DD HH:mm:ss');
+      title = `分享应用 - ${day}`;
+
+      description = `创建于 ${time}，分享应用，key: ${key},用户: ${username}`;
+      if (!tokenUser) {
+        description = description + `，会自动删除，过期时间为30天`;
+      }
+    }
+    const urlPath = `${username}/${key}/${version}/index.html`;
+    await oss.putObject(urlPath, content, {
+      'Content-Type': 'text/html; charset=utf-8',
+      'app-source': 'user-app',
+      'Cache-Control': 'no-cache',
+    });
+    const files = [
+      {
+        name: 'index.html',
+        path: urlPath,
+      },
+    ];
+    const appModel = await AppModel.create({
+      title,
+      description,
+      version,
+      key,
+      user: username,
+      uid,
+      proxy: true,
+      data: {
+        delete: 'share',
+        permission: {
+          share: 'public',
+        },
+        files: files,
+      },
+    });
+    const appVersionModel = await AppListModel.create({
+      data: {
+        files: files,
+      },
+      version: appModel.version,
+      key: appModel.key,
+      uid: appModel.uid,
+    });
+
+    ctx.body = {
+      url: `/${username}/${key}/`,
+      username: username,
+      appModel: {
+        id: appModel.id,
+        title: appModel.title,
+        description: appModel.description,
+        version: appModel.version,
+        data: appModel.data,
+      },
+      appVersionModel: {
+        id: appVersionModel.id,
+        version: appVersionModel.version,
+        key: appVersionModel.key,
+        data: appVersionModel.data,
+      },
+    };
+  })
+  .addTo(app);

src/routes/app-manager/user-app.ts

@@ -1,6 +1,7 @@
 import { AppModel, AppListModel } from './module/index.ts';
 import { app } from '@/app.ts';
 import { setExpire } from './revoke.ts';
+import { deleteFileByPrefix } from '../file/index.ts';
 
 app
   .route({
@@ -38,20 +39,21 @@ app
     if (!id && !key) {
       ctx.throw(500, 'id is required');
     }
+    let am: AppModel;
     if (id) {
-      const am = await AppModel.findByPk(id);
+      am = await AppModel.findByPk(id);
       if (!am) {
         ctx.throw(500, 'app not found');
       }
-      ctx.body = am;
     } else {
-      const am = await AppModel.findOne({ where: { key, uid: tokenUser.id } });
+      am = await AppModel.findOne({ where: { key, uid: tokenUser.id } });
       if (!am) {
         ctx.throw(500, 'app not found');
       }
-      ctx.body = am;
     }
 
+    ctx.body = am;
+
     return ctx;
   })
   .addTo(app);
@@ -65,14 +67,22 @@ app
   .define(async (ctx) => {
     const tokenUser = ctx.state.tokenUser;
 
-    const { data, id, ...rest } = ctx.query.data;
+    const { data, id, user, ...rest } = ctx.query.data;
     if (id) {
       const app = await AppModel.findByPk(id);
       if (app) {
         const newData = { ...app.data, ...data };
+        if (app.user !== tokenUser.username) {
+          rest.user = tokenUser.username;
+          let files = newData?.files || [];
+          if (files.length > 0) {
+            files = await AppModel.getNewFiles(files, { oldUser: app.user, newUser: tokenUser.username });
+          }
+          newData.files = files;
+        }
         const newApp = await app.update({ data: newData, ...rest });
         ctx.body = newApp;
-        if (app.status !== 'running') {
+        if (app.status !== 'running' || data?.share || rest?.status) {
           setExpire(newApp.key, app.user);
         }
       } else {
@@ -107,6 +117,7 @@ app
   .define(async (ctx) => {
     const tokenUser = ctx.state.tokenUser;
     const id = ctx.query.id;
+    const deleteFile = !!ctx.query.deleteFile; // 是否删除文件, 默认不删除
     if (!id) {
       ctx.throw(500, 'id is required');
     }
@@ -120,6 +131,10 @@ app
     const list = await AppListModel.findAll({ where: { key: am.key, uid: tokenUser.id } });
     await am.destroy({ force: true });
     await Promise.all(list.map((item) => item.destroy({ force: true })));
+    if (deleteFile) {
+      const username = tokenUser.username;
+      await deleteFileByPrefix(`${username}/${am.key}`);
+    }
     ctx.body = 'success';
     return ctx;
   })

src/routes/app-manager/util.ts

@@ -3,13 +3,29 @@ import { App } from '@kevisual/router';
 type Opts = {
   prefix: string;
 };
+/**
+ * fix path
+ * @param data
+ * @param prefix
+ * @param opts
+ * @returns
+ */
 export const prefixFix = (data: any, prefix: string, opts?: Opts) => {
   const len = prefix.length || 0;
+  console.log('prefixFix', prefix, opts?.prefix);
+  const wrapperPrefix = (path: string, prefix: string) => {
+    if (prefix) {
+      return prefix + '/' + path;
+    }
+    return path;
+  };
   if (data.data.files) {
     data.data.files = data.data.files.map((item) => {
+      const paths = item.path.split('/').filter((item) => item);
       return {
         ...item,
-        path: item.path.slice(len + 1),
+        path: wrapperPrefix(paths.slice(1).join('/'), ''),
+        origin: item.path,
       };
     });
   }

src/routes/config/check.ts

@@ -0,0 +1,78 @@
+import { app } from '@/app.ts';
+import { ConfigModel } from './models/model.ts';
+import { oss } from '@/app.ts';
+import { ConfigOssService } from '@kevisual/oss/services';
+import { Op } from 'sequelize';
+
+app
+  .route({
+    path: 'config',
+    key: 'detect',
+    middleware: ['auth'],
+  })
+  .define(async (ctx) => {
+    const tokenUser = ctx.state.tokenUser;
+    const owner = tokenUser.username;
+    const configOss = ConfigOssService.fromBase({
+      oss,
+      opts: {
+        owner,
+      },
+    });
+    const { list, keys, keyEtagMap } = await configOss.getList();
+    const configList = await ConfigModel.findAll({
+      where: {
+        key: {
+          [Op.in]: keys,
+        },
+        uid: tokenUser.id,
+      },
+    });
+    const needUpdateList = list.filter((item) => {
+      const key = item.key;
+      const hash = keyEtagMap.get(key);
+      const config = configList.find((item) => item.key === key);
+      if (!config) {
+        return true;
+      }
+      return config?.hash !== hash;
+    });
+    const keyDataMap = await configOss.getObjectList(needUpdateList.map((item) => item.key));
+    const updateList = [];
+    for (const [key, json] of keyDataMap.entries()) {
+      const keyETag = keyEtagMap.get(key);
+      const configData = keyDataMap.get(key);
+      if (keyETag && configData) {
+        const [config, created] = await ConfigModel.findOrCreate({
+          where: {
+            key,
+            uid: tokenUser.id,
+          },
+          defaults: {
+            key,
+            title: key,
+            description: `从${key}:${keyETag} 同步而来`,
+            uid: tokenUser.id,
+            hash: keyETag,
+            data: configData,
+          },
+        });
+        if (!created) {
+          await config.update(
+            {
+              hash: keyETag,
+              data: json,
+            },
+            {
+              fields: ['hash', 'data'],
+            },
+          );
+        }
+        updateList.push(config);
+      }
+    }
+    ctx.body = {
+      updateList,
+    };
+  })
+  .addTo(app);

src/routes/config/config-key.ts

@@ -0,0 +1,48 @@
+import { app } from '@/app.ts';
+import { ConfigModel } from './models/model.ts';
+import { ShareConfigService } from './services/share.ts';
+import { oss } from '@/app.ts';
+import { ConfigOssService } from '@kevisual/oss/services';
+import { User } from '@/models/user.ts';
+import { defaultKeys } from './models/default-keys.ts';
+
+app
+  .route({
+    path: 'config',
+    key: 'defaultConfig',
+    middleware: ['auth'],
+  })
+  .define(async (ctx) => {
+    const tokenUser = ctx.state.tokenUser;
+    const { configKey } = ctx.query;
+    if (!configKey) {
+      ctx.throw(400, 'configKey is required');
+    }
+    const user = new User();
+    user.setTokenUser(tokenUser);
+    const isAdmin = await user.hasUser('admin');
+    const usersConfig = ['upload.json', 'workspace.json', 'ai.json', 'user.json'];
+    const adminConfig = ['vip.json'];
+    const configs = [...usersConfig, ...(isAdmin ? adminConfig : [])];
+    if (!configs.includes(configKey)) {
+      ctx.throw(400, 'configKey is invalid');
+    }
+    const defaultConfig = defaultKeys.find((item) => item.key === configKey);
+
+    const [config, created] = await ConfigModel.findOrCreate({
+      where: {
+        key: configKey,
+        uid: tokenUser.id,
+      },
+      defaults: {
+        title: defaultConfig?.key,
+        description: defaultConfig?.description || '',
+        key: configKey,
+        uid: tokenUser.id,
+        data: defaultConfig?.data,
+      },
+    });
+
+    ctx.body = config;
+  })
+  .addTo(app);

src/routes/config/index.ts

@@ -1,3 +1,5 @@
 import './list.ts';
 import './upload-config.ts';
 import './share-config.ts';
+import './check.ts';
+import './config-key.ts';

src/routes/config/list.ts

@@ -1,6 +1,9 @@
 import { app } from '@/app.ts';
 import { ConfigModel } from './models/model.ts';
 import { ShareConfigService } from './services/share.ts';
+import { oss } from '@/app.ts';
+import { ConfigOssService } from '@kevisual/oss/services';
+
 app
   .route({
     path: 'config',
@@ -31,56 +34,57 @@ app
     const tokernUser = ctx.state.tokenUser;
     const tuid = tokernUser.id;
     const { id, data, ...rest } = ctx.query?.data || {};
+    let config: ConfigModel;
     if (id) {
-      const config = await ConfigModel.findByPk(id);
+      config = await ConfigModel.findByPk(id);
       let keyIsChange = false;
       if (rest?.key) {
         keyIsChange = rest.key !== config?.key;
       }
-      if (config && config.uid === tuid) {
+      if (!config || config.uid !== tuid) {
-        if (keyIsChange) {
-          const key = rest.key;
-          const keyConfig = await ConfigModel.findOne({
-            where: {
-              key,
-              uid: tuid,
-            },
-          });
-          if (keyConfig && keyConfig.id !== id) {
-            ctx.throw(403, 'key is already exists');
-          }
-        }
-        await config.update({
-          data: {
-            ...config.data,
-            ...data,
-          },
-          ...rest,
-        });
-        if (config.data?.permission?.share === 'public') {
-          await ShareConfigService.expireShareConfig(config.key, tokernUser.username);
-        }
-        ctx.body = config;
-      } else {
         ctx.throw(403, 'no permission');
       }
+      if (keyIsChange) {
+        const key = rest.key;
+        const keyConfig = await ConfigModel.findOne({
+          where: {
+            key,
+            uid: tuid,
+          },
+        });
+        if (keyConfig && keyConfig.id !== id) {
+          ctx.throw(403, 'key is already exists');
+        }
+      }
+      await config.update({
+        data: {
+          ...config.data,
+          ...data,
+        },
+        ...rest,
+      });
+      if (config.data?.permission?.share === 'public') {
+        await ShareConfigService.expireShareConfig(config.key, tokernUser.username);
+      }
+      ctx.body = config;
     } else if (rest?.key) {
       // id 不存在，key存在，则属于更新，key不能重复
       const key = rest.key;
-      const keyConfig = await ConfigModel.findOne({
+      config = await ConfigModel.findOne({
         where: {
           key,
           uid: tuid,
         },
       });
-      if (keyConfig) {
+      if (config) {
-        await keyConfig.update({
+        await config.update({
-          data: { ...keyConfig.data, ...data },
+          data: { ...config.data, ...data },
           ...rest,
         });
-        ctx.body = keyConfig;
+        ctx.body = config;
       } else {
-        const config = await ConfigModel.create({
+        // 根据key创建一个配置
+        config = await ConfigModel.create({
           key,
           ...rest,
           data: data,
@@ -89,15 +93,33 @@ app
         ctx.body = config;
       }
     }
-    if (id || rest?.key) return;
+    const key = config?.key;
+    const ossConfig = ConfigOssService.fromBase({
+      oss,
+      opts: {
+        owner: tokernUser.username,
+      },
+    });
+    if (ossConfig.isEndWithJson(key)) {
+      const data = config.data;
+      const hash = ossConfig.hash(data);
+      if (config.hash !== hash) {
+        config.hash = hash;
+        await config.save({
+          fields: ['hash'],
+        });
+        await ossConfig.putJsonObject(key, data);
+      }
+    }
+    if (config) return;
 
-    // id和key不存在。创建一个新的配置
+    // id和key不存在。创建一个新的配置, 而且没有id的
-    const config = await ConfigModel.create({
+    const newConfig = await ConfigModel.create({
       ...rest,
       data: data,
       uid: tuid,
     });
-    ctx.body = config;
+    ctx.body = newConfig;
   })
   .addTo(app);
 
@@ -154,6 +176,18 @@ app
         },
       });
       if (config && config.uid === tuid) {
+        const key = config.key;
+        const ossConfig = ConfigOssService.fromBase({
+          oss,
+          opts: {
+            owner: tokernUser.username,
+          },
+        });
+        if (ossConfig.isEndWithJson(key)) {
+          try {
+            await ossConfig.deleteObject(key);
+          } catch (e) {}
+        }
         await config.destroy();
       } else {
         ctx.throw(403, 'no permission');

src/routes/config/models/default-keys.ts

@@ -0,0 +1,33 @@
+export const defaultKeys = [
+  {
+    key: 'upload.json',
+    description: '上传配置',
+    data: { key: 'upload', version: '1.0.0' },
+  },
+  {
+    key: 'workspace.json',
+    description: '工作空间配置',
+    data: { key: 'workspace', version: '1.0.0' },
+  },
+  {
+    key: 'ai.json',
+    description: 'AI配置',
+    data: {
+      title: 'AI Secret Config',
+      description: 'AI Secret配置, 请根据需要配置',
+      version: '1.0.0',
+      models: [],
+      secretKeys: [],
+    },
+  },
+  {
+    key: 'vip.json',
+    description: 'VIP配置',
+    data: { key: 'vip', version: '1.0.0' },
+  },
+  {
+    key: 'user.json',
+    description: '用户配置',
+    data: { key: 'user', version: '1.0.0', redirectURL: '/root/center/' },
+  },
+];

src/routes/config/models/model.ts

@@ -1,4 +1,4 @@
-import { useContextKey } from '@kevisual/use-config/context';
+import { useContextKey } from '@kevisual/context';
 import { sequelize } from '../../../modules/sequelize.ts';
 import { DataTypes, Model } from 'sequelize';
 import { Permission } from '@kevisual/permission';
@@ -20,11 +20,12 @@ export class ConfigModel extends Model {
   declare description: string;
   declare tags: string[];
   /**
-   * 配置key， 默认可以为空，如何设置了，必须要唯一。
+   * @important 配置key， 默认可以为空，如何设置了，必须要唯一。
    */
   declare key: string;
   declare data: ConfigData; // files
   declare uid: string;
+  declare hash: string;
   /**
    * 获取用户配置
    * @param key 配置key
@@ -121,6 +122,10 @@ ConfigModel.init(
       type: DataTypes.JSONB,
       defaultValue: [],
     },
+    hash: {
+      type: DataTypes.TEXT,
+      defaultValue: '',
+    },
     data: {
       type: DataTypes.JSONB,
       defaultValue: {},

src/routes/file-listener/index.ts

@@ -0,0 +1 @@
+import './list.ts';

src/routes/file-listener/list.ts

@@ -0,0 +1,107 @@
+import { Op } from 'sequelize';
+import { app } from '@/app.ts';
+import { FileSyncModel } from './model.ts';
+app
+  .route({
+    path: 'file-listener',
+    key: 'list',
+    middleware: ['auth'],
+    description: '获取用户的某一个文件夹下的所有的列表的数据',
+  })
+  .define(async (ctx) => {
+    const tokenUser = ctx.state.tokenUser;
+    const username = tokenUser.username;
+    const { page = 1, pageSize = 20, sort = 'DESC' } = ctx.query;
+    let { prefix } = ctx.query;
+    if (prefix) {
+      if (typeof prefix !== 'string') {
+        ctx.throw(400, 'prefix must be a string');
+      }
+      if (prefix.startsWith('/')) {
+        prefix = prefix.slice(1); // Remove leading slash if present
+      }
+      if (!prefix.startsWith(username + '/')) {
+        ctx.throw(400, 'prefix must start with the your username:', username);
+      }
+    }
+    const searchWhere = prefix
+      ? {
+          [Op.or]: [{ name: { [Op.like]: `${prefix}%` } }],
+        }
+      : {};
+
+    const { rows: files, count } = await FileSyncModel.findAndCountAll({
+      where: {
+        ...searchWhere,
+      },
+      offset: (page - 1) * pageSize,
+      limit: pageSize,
+      order: [['updatedAt', sort]],
+    });
+    const getPublicFiles = (files: FileSyncModel[]) => {
+      return files.map((file) => {
+        const value = file.toJSON();
+        const stat = value.stat || {};
+        delete stat.password;
+        return {
+          ...value,
+          stat: stat,
+        };
+      });
+    };
+
+    ctx.body = {
+      list: getPublicFiles(files),
+      pagination: {
+        page,
+        current: page,
+        pageSize,
+        total: count,
+      },
+    };
+  })
+  .addTo(app);
+
+app
+  .route({
+    path: 'file-listener',
+    key: 'get',
+    middleware: ['auth'],
+  })
+  .define(async (ctx) => {
+    const tokenUser = ctx.state.tokenUser;
+    const username = tokenUser.username;
+    const { id, name, hash } = ctx.query.data || {};
+
+    if (!id && !name && !hash) {
+      ctx.throw(400, 'id, name or hash is required');
+    }
+    let fileSync: FileSyncModel | null = null;
+    if (id) {
+      fileSync = await FileSyncModel.findByPk(id);
+    }
+    if (name && !fileSync) {
+      fileSync = await FileSyncModel.findOne({
+        where: {
+          name,
+          hash,
+        },
+      });
+    }
+    if (!fileSync && hash) {
+      fileSync = await FileSyncModel.findOne({
+        where: {
+          name: {
+            [Op.like]: `${username}/%`,
+          },
+          hash,
+        },
+      });
+    }
+
+    if (!fileSync || !fileSync.name.startsWith(`${username}/`)) {
+      ctx.throw(404, 'NotFoundFile');
+    }
+    ctx.body = fileSync;
+  })
+  .addTo(app);

src/routes/file-listener/model.ts

@@ -0,0 +1,3 @@
+import { FileSyncModel } from '@kevisual/file-listener/src/file-sync/model.ts';
+import type { FileSyncModelType } from '@kevisual/file-listener/src/file-sync/model.ts';
+export { FileSyncModel, FileSyncModelType };

src/routes/file/list.ts

@@ -1,5 +1,5 @@
 import { app } from '@/app.ts';
-import { getFileStat, getMinioList, deleteFile, updateFileStat } from './module/get-minio-list.ts';
+import { getFileStat, getMinioList, deleteFile, updateFileStat, deleteFiles } from './module/get-minio-list.ts';
 import path from 'path';
 import { CustomError } from '@kevisual/router';
 import { get } from 'http';
@@ -147,3 +147,37 @@ app
     return ctx;
   })
   .addTo(app);
+
+app
+  .route({
+    path: 'file',
+    key: 'delete-all',
+    middleware: ['auth'],
+  })
+  .define(async (ctx) => {
+    const tokenUser = ctx.state.tokenUser;
+    let directory = ctx.query.data?.directory as string;
+    if (!directory) {
+      ctx.throw(400, 'directory is required');
+    }
+    if (directory.startsWith('/')) {
+      ctx.throw(400, 'directory is invalid, cannot start with /');
+    }
+    if (directory.endsWith('/')) {
+      ctx.throw(400, 'directory is invalid, cannot end with /');
+    }
+    const prefix = tokenUser.username + '/' + directory + '/';
+    const list = await getMinioList<true>({ prefix, recursive: true });
+    if (list.length === 0) {
+      ctx.throw(400, 'directory is empty');
+    }
+    const res = await deleteFiles(list.map((item) => item.name));
+    if (!res) {
+      ctx.throw(500, 'delete all failed');
+    }
+    ctx.body = {
+      deleted: list.length,
+      message: 'delete all success',
+    };
+  })
+  .addTo(app);

src/routes/file/module/get-minio-list.ts

@@ -1,6 +1,7 @@
-import { minioClient } from '@/app.ts';
+import dayjs from 'dayjs';
-import { bucketName } from '@/modules/minio.ts';
+import { minioClient } from '../../../modules/minio.ts';
-import { CopyDestinationOptions, CopySourceOptions } from 'minio';
+import { bucketName } from '../../../modules/minio.ts';
+import { BucketItemStat, CopyDestinationOptions, CopySourceOptions } from 'minio';
 type MinioListOpt = {
   prefix: string;
   recursive?: boolean;
@@ -16,10 +17,10 @@ export type MinioDirectory = {
   size: number;
 };
 export type MinioList = (MinioFile | MinioDirectory)[];
-export const getMinioList = async (opts: MinioListOpt): Promise<MinioList> => {
+export const getMinioList = async <IS_FILE extends boolean>(opts: MinioListOpt): Promise<IS_FILE extends true ? MinioFile[] : MinioDirectory[]> => {
   const prefix = opts.prefix;
   const recursive = opts.recursive ?? false;
-  return await new Promise((resolve, reject) => {
+  const res = await new Promise((resolve, reject) => {
     let res: any[] = [];
     let hasError = false;
     minioClient
@@ -40,8 +41,9 @@ export const getMinioList = async (opts: MinioListOpt): Promise<MinioList> => {
         }
       });
   });
+  return res as IS_FILE extends true ? MinioFile[] : MinioDirectory[];
 };
-export const getFileStat = async (prefix: string, isFile?: boolean): Promise<any> => {
+export const getFileStat = async (prefix: string, isFile?: boolean): Promise<BucketItemStat | null> => {
   try {
     const obj = await minioClient.statObject(bucketName, prefix);
     if (isFile && obj.size === 0) {
@@ -94,7 +96,17 @@ export const deleteFiles = async (prefixs: string[]): Promise<any> => {
     return false;
   }
 };
-
+export const deleteFileByPrefix = async (prefix: string): Promise<any> => {
+  try {
+    const allFiles = await getMinioList<true>({ prefix, recursive: true });
+    const files = allFiles.filter((item) => item.name.startsWith(prefix));
+    await deleteFiles(files.map((item) => item.name));
+    return true;
+  } catch (e) {
+    console.error('delete File Error not handle', e);
+    return false;
+  }
+};
 type GetMinioListAndSetToAppListOpts = {
   username: string;
   appKey: string;
@@ -147,3 +159,62 @@ export const updateFileStat = async (
     };
   }
 };
+
+/**
+ * 将用户A的文件移动到用户B
+ * @param usernameA
+ * @param usernameB
+ * @param clearOldUser 是否清除用户A的文件
+ */
+export const mvUserAToUserB = async (usernameA: string, usernameB: string, clearOldUser = false) => {
+  const oldPrefix = `${usernameA}/`;
+  const newPrefix = `${usernameB}/`;
+  const listSource = await getMinioList<true>({ prefix: oldPrefix, recursive: true });
+  for (const item of listSource) {
+    const source = new CopySourceOptions({ Bucket: bucketName, Object: item.name });
+    const stat = await getFileStat(item.name);
+    const newName = item.name.slice(oldPrefix.length);
+    // @ts-ignore
+    const metadata = stat?.userMetadata || stat.metaData;
+    const destination = new CopyDestinationOptions({
+      Bucket: bucketName,
+      Object: `${newPrefix}${newName}`,
+      UserMetadata: metadata,
+      MetadataDirective: 'COPY',
+    });
+    await minioClient.copyObject(source, destination);
+  }
+  if (clearOldUser) {
+    const files = await getMinioList<true>({ prefix: oldPrefix, recursive: true });
+    for (const file of files) {
+      await minioClient.removeObject(bucketName, file.name);
+    }
+  }
+};
+export const backupUserA = async (usernameA: string, id: string, backName?: string) => {
+  const today = backName || dayjs().format('YYYY-MM-DD-HH-mm');
+  const backupAllPrefix = `private/backup/${id}/`;
+  const backupPrefix = `private/backup/${id}/${today}`;
+  const backupList = await getMinioList<false>({ prefix: backupAllPrefix });
+  const backupListSort = backupList.sort((a, b) => -a.prefix.localeCompare(b.prefix));
+  if (backupListSort.length > 2) {
+    const deleteBackup = backupListSort.slice(2);
+    for (const item of deleteBackup) {
+      const files = await getMinioList<true>({ prefix: item.prefix, recursive: true });
+      for (const file of files) {
+        await minioClient.removeObject(bucketName, file.name);
+      }
+    }
+  }
+  await mvUserAToUserB(usernameA, backupPrefix, false);
+};
+/**
+ * 删除用户
+ * @param username
+ */
+export const deleteUser = async (username: string) => {
+  const list = await getMinioList<true>({ prefix: `${username}/`, recursive: true });
+  for (const item of list) {
+    await minioClient.removeObject(bucketName, item.name);
+  }
+};

src/routes/github/lib/get-token.ts

@@ -1,5 +1,5 @@
 import fetch from 'node-fetch';
-import { useConfig } from '@kevisual/use-config';
+import { useConfig } from '@kevisual/use-config/env';
 
 type GithubConfig = {
   clientId: string;

src/routes/index.ts

@@ -1,9 +1,5 @@
 import './container/index.ts';
 
-import './page/index.ts';
-
-import './resource/index.ts';
-
 import './user/index.ts';
 
 import './github/index.ts';
@@ -12,8 +8,10 @@ import './app-manager/index.ts';
 
 import './file/index.ts';
 
-// import './packages/index.ts';
-
 import './micro-app/index.ts';
 
 import './config/index.ts';
+
+import './mark/index.ts';
+
+import './file-listener/index.ts';

src/routes/mark/index.ts

@@ -0,0 +1 @@
+import './list.ts';

src/routes/mark/list.ts

@@ -0,0 +1,239 @@
+import { app } from '@/app.ts';
+import { MarkModel } from './model.ts';
+import { MarkServices } from './services/mark.ts';
+import dayjs from 'dayjs';
+
+app
+  .route({
+    path: 'mark',
+    key: 'list',
+    description: 'mark list.',
+    middleware: ['auth'],
+  })
+  .define(async (ctx) => {
+    const tokenUser = ctx.state.tokenUser;
+    ctx.body = await MarkServices.getList({
+      uid: tokenUser.id,
+      query: ctx.query,
+      queryType: 'simple',
+    });
+  })
+  .addTo(app);
+
+app
+  .route({
+    path: 'mark',
+    key: 'getVersion',
+    middleware: ['auth'],
+  })
+  .define(async (ctx) => {
+    const tokenUser = ctx.state.tokenUser;
+    const { id } = ctx.query;
+    if (id) {
+      const markModel = await MarkModel.findByPk(id);
+      if (!markModel) {
+        ctx.throw(404, 'mark not found');
+      }
+      if (markModel.uid !== tokenUser.id) {
+        ctx.throw(403, 'no permission');
+      }
+      ctx.body = {
+        version: Number(markModel.version),
+        updatedAt: markModel.updatedAt,
+        createdAt: markModel.createdAt,
+        id: markModel.id,
+      };
+    } else {
+      ctx.throw(400, 'id is required');
+      // const [markModel, created] = await MarkModel.findOrCreate({
+      //   where: {
+      //     uid: tokenUser.id,
+      //     puid: tokenUser.uid,
+      //     title: dayjs().format('YYYY-MM-DD'),
+      //   },
+      //   defaults: {
+      //     title: dayjs().format('YYYY-MM-DD'),
+      //     uid: tokenUser.id,
+      //     markType: 'wallnote',
+      //     tags: ['daily'],
+      //   },
+      // });
+      // ctx.body = {
+      //   version: Number(markModel.version),
+      //   updatedAt: markModel.updatedAt,
+      //   createdAt: markModel.createdAt,
+      //   id: markModel.id,
+      //   created: created,
+      // };
+    }
+  })
+  .addTo(app);
+
+app
+  .route({
+    path: 'mark',
+    key: 'get',
+    middleware: ['auth'],
+  })
+  .define(async (ctx) => {
+    const tokenUser = ctx.state.tokenUser;
+    const { id } = ctx.query;
+    if (id) {
+      const markModel = await MarkModel.findByPk(id);
+      if (!markModel) {
+        ctx.throw(404, 'mark not found');
+      }
+      if (markModel.uid !== tokenUser.id) {
+        ctx.throw(403, 'no permission');
+      }
+      ctx.body = markModel;
+    } else {
+      ctx.throw(400, 'id is required');
+      // id 不存在，获取当天的title为 日期的一条数据
+      // const [markModel, created] = await MarkModel.findOrCreate({
+      //   where: {
+      //     uid: tokenUser.id,
+      //     puid: tokenUser.uid,
+      //     title: dayjs().format('YYYY-MM-DD'),
+      //   },
+      //   defaults: {
+      //     title: dayjs().format('YYYY-MM-DD'),
+      //     uid: tokenUser.id,
+      //     markType: 'wallnote',
+      //     tags: ['daily'],
+      //     uname: tokenUser.username,
+      //     puid: tokenUser.uid,
+      //     version: 1,
+      //   },
+      // });
+      // ctx.body = markModel;
+    }
+  })
+  .addTo(app);
+
+app
+  .route({
+    path: 'mark',
+    key: 'update',
+    middleware: ['auth'],
+    isDebug: true,
+  })
+  .define(async (ctx) => {
+    const tokenUser = ctx.state.tokenUser;
+    const { id, createdAt, updatedAt, uid: _, puid: _2, uname: _3, data, ...rest } = ctx.query.data || {};
+    let markModel: MarkModel;
+    if (id) {
+      markModel = await MarkModel.findByPk(id);
+      if (!markModel) {
+        ctx.throw(404, 'mark not found');
+      }
+      if (markModel.uid !== tokenUser.id) {
+        ctx.throw(403, 'no permission');
+      }
+      const version = Number(markModel.version) + 1;
+      await markModel.update({
+        ...markModel.data,
+        ...rest,
+        data: {
+          ...markModel.data,
+          ...data,
+        },
+        version,
+      });
+    } else {
+      markModel = await MarkModel.create({
+        data,
+        ...rest,
+        uname: tokenUser.username,
+        uid: tokenUser.id,
+        puid: tokenUser.uid,
+      });
+    }
+    ctx.body = markModel;
+  })
+  .addTo(app);
+app
+  .route({
+    path: 'mark',
+    key: 'updateNode',
+    middleware: ['auth'],
+  })
+  .define(async (ctx) => {
+    const tokenUser = ctx.state.tokenUser;
+    const operate = ctx.query.operate || 'update';
+    const { id, node } = ctx.query.data || {};
+    const markModel = await MarkModel.findByPk(id);
+    if (!markModel) {
+      ctx.throw(404, 'mark not found');
+    }
+    if (markModel.uid !== tokenUser.id) {
+      ctx.throw(403, 'no permission');
+    }
+    await MarkModel.updateJsonNode(id, node, { operate });
+    ctx.body = markModel;
+  })
+  .addTo(app);
+app
+  .route({
+    path: 'mark',
+    key: 'updateNodes',
+    middleware: ['auth'],
+  })
+  .define(async (ctx) => {
+    const tokenUser = ctx.state.tokenUser;
+    const { id, nodeOperateList } = ctx.query.data || {};
+    const markModel = await MarkModel.findByPk(id);
+    if (!markModel) {
+      ctx.throw(404, 'mark not found');
+    }
+    if (markModel.uid !== tokenUser.id) {
+      ctx.throw(403, 'no permission');
+    }
+    if (!nodeOperateList || !Array.isArray(nodeOperateList) || nodeOperateList.length === 0) {
+      ctx.throw(400, 'nodeOperateList is required');
+    }
+    if (nodeOperateList.some((node) => !node.node)) {
+      ctx.throw(400, 'nodeOperateList node is required');
+    }
+    const newmark = await MarkModel.updateJsonNodes(id, nodeOperateList);
+    ctx.body = newmark;
+  })
+  .addTo(app);
+
+app
+  .route({
+    path: 'mark',
+    key: 'delete',
+    middleware: ['auth'],
+  })
+  .define(async (ctx) => {
+    const tokenUser = ctx.state.tokenUser;
+    const { id } = ctx.query;
+    const markModel = await MarkModel.findByPk(id);
+    if (!markModel) {
+      ctx.throw(404, 'mark not found');
+    }
+    if (markModel.uid !== tokenUser.id) {
+      ctx.throw(403, 'no permission');
+    }
+    await markModel.destroy();
+    ctx.body = markModel;
+  })
+  .addTo(app);
+
+app
+  .route({ path: 'mark', key: 'getMenu', description: '获取菜单', middleware: ['auth'] })
+  .define(async (ctx) => {
+    const tokenUser = ctx.state.tokenUser;
+    const { rows, count } = await MarkModel.findAndCountAll({
+      where: {
+        uid: tokenUser.id,
+      },
+      attributes: ['id', 'title', 'summary', 'tags', 'thumbnail', 'link', 'createdAt', 'updatedAt'],
+    });
+    ctx.body = {
+      list: rows,
+      total: count,
+    };
+  })
+  .addTo(app);

src/routes/mark/mark-model.ts

@@ -0,0 +1,327 @@
+import { useContextKey } from '@kevisual/context';
+import { nanoid, customAlphabet } from 'nanoid';
+import { DataTypes, Model, ModelAttributes } from 'sequelize';
+import type { Sequelize } from 'sequelize';
+export const random = customAlphabet('1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ');
+export type Mark = Partial<InstanceType<typeof MarkModel>>;
+export type MarkData = {
+  md?: string; // markdown
+  mdList?: string[]; // markdown list
+  type?: string; // 类型 markdown | json | html | image | video | audio | code | link | file
+  data?: any;
+  key?: string; // 文件的名称, 唯一
+  push?: boolean; // 是否推送到elasticsearch
+  pushTime?: Date; // 推送时间
+  summary?: string; // 摘要
+  nodes?: MarkDataNode[]; // 节点
+  [key: string]: any;
+};
+export type MarkFile = {
+  id: string;
+  name: string;
+  url: string;
+  size: number;
+  type: 'self' | 'data' | 'generate'; // generate为生成文件
+  query: string; // 'data.nodes[id].content';
+  hash: string;
+  fileKey: string; // 文件的名称, 唯一
+};
+export type MarkDataNode = {
+  id?: string;
+  [key: string]: any;
+};
+export type MarkConfig = {
+  [key: string]: any;
+};
+export type MarkAuth = {
+  [key: string]: any;
+};
+/**
+ * 隐秘内容
+ * auth
+ * config
+ *
+ */
+export class MarkModel extends Model {
+  declare id: string;
+  declare title: string; // 标题，可以ai生成
+  declare description: string; // 描述，可以ai生成
+  declare cover: string; // 封面，可以ai生成
+  declare thumbnail: string; // 缩略图
+  declare key: string; // 文件路径
+  declare markType: string; // markdown | json | html | image | video | audio | code | link | file
+  declare link: string; // 访问链接
+  declare tags: string[]; // 标签
+  declare summary: string; // 摘要， description的简化版
+  declare data: MarkData; // 数据
+
+  declare uid: string; // 操作用户的id
+  declare puid: string; // 父级用户的id, 真实用户
+  declare config: MarkConfig; // mark属于一定不会暴露的内容。
+
+  declare fileList: MarkFile[]; // 文件管理
+  declare uname: string; // 用户的名称, 或者着别名
+
+  declare markedAt: Date; // 标记时间
+  declare createdAt: Date;
+  declare updatedAt: Date;
+  declare version: number;
+  /**
+   * 加锁更新data中的node的节点，通过node的id
+   * @param param0
+   */
+  static async updateJsonNode(id: string, node: MarkDataNode, opts?: { operate?: 'update' | 'delete'; Model?: any; sequelize?: Sequelize }) {
+    const sequelize = opts?.sequelize || (await useContextKey('sequelize'));
+    const transaction = await sequelize.transaction(); // 开启事务
+    const operate = opts.operate || 'update';
+    const isUpdate = operate === 'update';
+    const Model = opts.Model || MarkModel;
+    try {
+      // 1. 获取当前的 JSONB 字段值（加锁）
+      const mark = await Model.findByPk(id, {
+        transaction,
+        lock: transaction.LOCK.UPDATE, // 加锁，防止其他事务同时修改
+      });
+      if (!mark) {
+        throw new Error('Mark not found');
+      }
+      // 2. 修改特定的数组元素
+      const data = mark.data as MarkData;
+      const items = data.nodes;
+      if (!node.id) {
+        node.id = random(12);
+      }
+
+      // 找到要更新的元素
+      const itemIndex = items.findIndex((item) => item.id === node.id);
+      if (itemIndex === -1) {
+        isUpdate && items.push(node);
+      } else {
+        if (isUpdate) {
+          items[itemIndex] = node;
+        } else {
+          items.splice(itemIndex, 1);
+        }
+      }
+      const version = Number(mark.version) + 1;
+      // 4. 更新 JSONB 字段
+      const result = await mark.update(
+        {
+          data: {
+            ...data,
+            nodes: items,
+          },
+          version,
+        },
+        { transaction },
+      );
+
+      await transaction.commit();
+      return result;
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+  static async updateJsonNodes(id: string, nodes: { node: MarkDataNode; operate?: 'update' | 'delete' }[], opts?: { Model?: any; sequelize?: Sequelize }) {
+    const sequelize = opts?.sequelize || (await useContextKey('sequelize'));
+    const transaction = await sequelize.transaction(); // 开启事务
+    const Model = opts?.Model || MarkModel;
+    try {
+      const mark = await Model.findByPk(id, {
+        transaction,
+        lock: transaction.LOCK.UPDATE, // 加锁，防止其他事务同时修改
+      });
+      if (!mark) {
+        throw new Error('Mark not found');
+      }
+      const data = mark.data as MarkData;
+      const _nodes = data.nodes || [];
+      // 过滤不在nodes中的节点
+      const blankNodes = nodes.filter((node) => !_nodes.find((n) => n.id === node.node.id)).map((node) => node.node);
+      // 更新或删除节点
+      const newNodes = _nodes
+        .map((node) => {
+          const nodeOperate = nodes.find((n) => n.node.id === node.id);
+          if (nodeOperate) {
+            if (nodeOperate.operate === 'delete') {
+              return null;
+            }
+            return nodeOperate.node;
+          }
+          return node;
+        })
+        .filter((node) => node !== null);
+      const version = Number(mark.version) + 1;
+      const result = await mark.update(
+        {
+          data: {
+            ...data,
+            nodes: [...blankNodes, ...newNodes],
+          },
+          version,
+        },
+        { transaction },
+      );
+      await transaction.commit();
+      return result;
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  }
+  static async updateData(id: string, data: MarkData, opts: { Model?: any; sequelize?: Sequelize }) {
+    const sequelize = opts.sequelize || (await useContextKey('sequelize'));
+    const transaction = await sequelize.transaction(); // 开启事务
+    const Model = opts.Model || MarkModel;
+    const mark = await Model.findByPk(id, {
+      transaction,
+      lock: transaction.LOCK.UPDATE, // 加锁，防止其他事务同时修改
+    });
+    if (!mark) {
+      throw new Error('Mark not found');
+    }
+    const version = Number(mark.version) + 1;
+    const result = await mark.update(
+      {
+        ...mark.data,
+        ...data,
+        data: {
+          ...mark.data,
+          ...data,
+        },
+        version,
+      },
+      { transaction },
+    );
+    await transaction.commit();
+    return result;
+  }
+  static async createNew(data: any, opts: { Model?: any; sequelize?: Sequelize }) {
+    const sequelize = opts.sequelize || (await useContextKey('sequelize'));
+    const transaction = await sequelize.transaction(); // 开启事务
+    const Model = opts.Model || MarkModel;
+    const result = await Model.create({ ...data, version: 1 }, { transaction });
+    await transaction.commit();
+    return result;
+  }
+}
+export type MarkInitOpts<T = any> = {
+  tableName: string;
+  sequelize?: Sequelize;
+  callInit?: (attribute: ModelAttributes) => ModelAttributes;
+  Model?: T extends typeof MarkModel ? T : typeof MarkModel;
+};
+export type Opts = {
+  sync?: boolean;
+  alter?: boolean;
+  logging?: boolean | ((...args: any) => any);
+  force?: boolean;
+};
+export const MarkMInit = async <T = any>(opts: MarkInitOpts<T>, sync?: Opts) => {
+  const sequelize = await useContextKey('sequelize');
+  opts.sequelize = opts.sequelize || sequelize;
+  const { callInit, Model, ...optsRest } = opts;
+  const modelAttribute = {
+    id: {
+      type: DataTypes.UUID,
+      primaryKey: true,
+      defaultValue: DataTypes.UUIDV4,
+      comment: 'id',
+    },
+    title: {
+      type: DataTypes.TEXT,
+      defaultValue: '',
+    },
+    key: {
+      type: DataTypes.TEXT, // 对应的minio的文件路径
+      defaultValue: '',
+    },
+    markType: {
+      type: DataTypes.TEXT,
+      defaultValue: 'md', // markdown | json | html | image | video | audio | code | link | file
+      comment: '类型',
+    },
+    description: {
+      type: DataTypes.TEXT,
+      defaultValue: '',
+    },
+    cover: {
+      type: DataTypes.TEXT,
+      defaultValue: '',
+      comment: '封面',
+    },
+    thumbnail: {
+      type: DataTypes.TEXT,
+      defaultValue: '',
+      comment: '缩略图',
+    },
+    link: {
+      type: DataTypes.TEXT,
+      defaultValue: '',
+      comment: '链接',
+    },
+    tags: {
+      type: DataTypes.JSONB,
+      defaultValue: [],
+    },
+    summary: {
+      type: DataTypes.TEXT,
+      defaultValue: '',
+      comment: '摘要',
+    },
+    config: {
+      type: DataTypes.JSONB,
+      defaultValue: {},
+    },
+    data: {
+      type: DataTypes.JSONB,
+      defaultValue: {},
+    },
+    fileList: {
+      type: DataTypes.JSONB,
+      defaultValue: [],
+    },
+    uname: {
+      type: DataTypes.STRING,
+      defaultValue: '',
+      comment: '用户的名称, 更新后的用户的名称',
+    },
+    version: {
+      type: DataTypes.INTEGER, // 更新刷新版本，多人协作
+      defaultValue: 1,
+    },
+    markedAt: {
+      type: DataTypes.DATE,
+      allowNull: true,
+      comment: '标记时间',
+    },
+    uid: {
+      type: DataTypes.UUID,
+      allowNull: true,
+    },
+    puid: {
+      type: DataTypes.UUID,
+      allowNull: true,
+    },
+  };
+  const InitModel = Model || MarkModel;
+  InitModel.init(callInit ? callInit(modelAttribute) : modelAttribute, {
+    sequelize,
+    paranoid: true,
+    ...optsRest,
+  });
+  if (sync && sync.sync) {
+    const { sync: _, ...rest } = sync;
+    MarkModel.sync({ alter: true, logging: false, ...rest }).catch((e) => {
+      console.error('MarkModel sync', e);
+    });
+  }
+};
+
+export const markModelInit = MarkMInit;
+
+export const syncMarkModel = async (sync?: Opts, tableName = 'micro_mark') => {
+  const sequelize = await useContextKey('sequelize');
+  await MarkMInit({ sequelize, tableName }, sync);
+};

src/routes/mark/model.ts

@@ -0,0 +1,5 @@
+export * from '@kevisual/code-center-module/src/mark/mark-model.ts';
+import { markModelInit, MarkModel, syncMarkModel } from '@kevisual/code-center-module/src/mark/mark-model.ts';
+export { markModelInit, MarkModel };
+
+syncMarkModel({ sync: true, alter: true, logging: false });

src/routes/mark/services/mark.ts

@@ -0,0 +1,58 @@
+import { FindAttributeOptions, Op } from 'sequelize';
+import { MarkModel } from '../model.ts';
+
+export class MarkServices {
+  static getList = async (opts: {
+    /** 查询用户的 */
+    uid?: string;
+    query?: {
+      page?: number;
+      pageSize?: number;
+      search?: string;
+      markType?: string;
+      sort?: string;
+    };
+    /**
+     * 查询类型
+     * simple: 简单查询 默认
+     */
+    queryType?: string;
+  }) => {
+    const { uid, query } = opts;
+    const { page = 1, pageSize = 999, search, sort = 'DESC' } = query;
+    const searchWhere = search
+      ? {
+          [Op.or]: [{ title: { [Op.like]: `%${search}%` } }, { summary: { [Op.like]: `%${search}%` } }],
+        }
+      : {};
+    if (opts.query?.markType) {
+      searchWhere['markType'] = opts.query.markType;
+    }
+    const attributes: FindAttributeOptions = {
+      exclude: [],
+    };
+    const queryType = opts.queryType || 'simple';
+    if (queryType === 'simple') {
+      // attributes.include = ['id', 'title', 'link', 'summary', 'thumbnail', 'markType', 'tags', 'uid', 'share', 'uname'];
+      attributes.exclude = ['data', 'config', 'cover', 'description'];
+    }
+    const { rows, count } = await MarkModel.findAndCountAll({
+      where: {
+        uid: uid,
+        ...searchWhere,
+      },
+      order: [['updatedAt', sort]],
+      attributes: attributes,
+      limit: pageSize,
+      offset: (page - 1) * pageSize,
+    });
+    return {
+      pagination: {
+        current: page,
+        pageSize,
+        total: count,
+      },
+      list: rows,
+    };
+  };
+}

src/routes/micro-app/list.ts

@@ -18,17 +18,33 @@ app
   .define(async (ctx) => {
     const tokenUser = ctx.state.tokenUser;
     const data = ctx.query?.data;
-    const { id, key, force, install } = data;
+    const { id, key, force, install, appKey: postAppKey, version: postVersion = '1.0.0' } = data;
-    if (!id) {
+    if (!id && !postAppKey) {
-      ctx.throw(400, 'Invalid id');
+      ctx.throw(400, 'Invalid id or postAppKey');
     }
     let username = tokenUser.username;
-    if (data.username) {
+    if (data.username && username === 'admin') {
-      // username = data.username;
+      username = data.username;
     }
-    const microApp = await AppListModel.findByPk(id);
+    let microApp: AppListModel;
+    if (!microApp && id) {
+      microApp = await AppListModel.findByPk(id);
+    }
+    if (!microApp && postAppKey) {
+      microApp = await AppListModel.findOne({
+        where: {
+          key: postAppKey,
+          version: postVersion,
+        },
+      });
+    }
+
     if (!microApp) {
-      ctx.throw(400, 'Invalid id');
+      if (id) {
+        ctx.throw(400, 'Invalid id');
+      } else {
+        ctx.throw(400, `Invalid appKey , no found app with key: ${postAppKey} and version: ${postVersion}`);
+      }
     }
     const { key: appKey, version } = microApp;
     const check = await appPathCheck({ key: key });

src/routes/micro-app/manager-app.ts

@@ -1,5 +1,9 @@
 // import { app } from '@/app.ts';
 import { manager, loadManager, app as ManagerApp } from '@kevisual/local-app-manager';
+import { fileIsExist } from '@kevisual/use-config/env';
+import path from 'path';
+const assistantAppsConfig = path.join(process.cwd(), 'assistant-apps-config.json');
+const isExist = fileIsExist(assistantAppsConfig);
 export const existDenpend = [
   'sequelize', // commonjs
   'pg', // commonjs
@@ -16,7 +20,11 @@ export { manager };
 // console.log('app', app, );
 // console.log('app2 context', global.context);
 // console.log('app equal', app === ManagerApp);
-loadManager();
+if (isExist) {
+  loadManager({ runtime: 'server', configFilename: 'assistant-apps-config.json' });
+} else {
+  loadManager({ runtime: 'server' });
+}
 
 // middleware: ['auth-admin']
 /*

src/routes/micro-app/module/manager.ts

@@ -25,7 +25,7 @@ export const installAppFromKey = async (key: string) => {
   }
   let showAppInfo = {
     key,
-    status: 'inactive',
+    status: 'inactive' as const,
     type: app?.type || 'system-app',
     description: readmeDesc || '',
     version,

src/routes/packages/index.ts

@@ -1 +0,0 @@
-import './list.ts'

src/routes/packages/list.ts

@@ -1,120 +0,0 @@
-import { app } from '@/app.ts';
-import { PackagesModel } from './models/index.ts';
-import { Op } from 'sequelize';
-import { CustomError } from '@kevisual/router';
-
-app
-  .route({
-    path: 'packages',
-    key: 'list',
-    middleware: ['auth'],
-  })
-  .define(async (ctx) => {
-    const tokenUser = ctx.state.tokenUser;
-    const { uid } = tokenUser;
-    const { page = 1, pageSize = 999, search } = ctx.query;
-    const searchWhere = search ? { title: { [Op.like]: `%${search}%` } } : {};
-    const { rows: packages, count } = await PackagesModel.findAndCountAll({
-      where: {
-        uid,
-        ...searchWhere,
-      },
-      limit: pageSize,
-      offset: (page - 1) * pageSize,
-    });
-    ctx.body = {
-      pagination: {
-        current: page,
-        pageSize,
-        total: count,
-      },
-      list: packages,
-    };
-  })
-  .addTo(app);
-
-app
-  .route({
-    path: 'packages',
-    key: 'get',
-    middleware: ['auth'],
-  })
-  .define(async (ctx) => {
-    const tokenUser = ctx.state.tokenUser;
-    const { uid } = tokenUser;
-    const { id } = ctx.query;
-    if (!id) {
-      throw new CustomError('id is required');
-    }
-    const packages = await PackagesModel.findOne({
-      where: {
-        uid,
-        id,
-      },
-    });
-    if (!packages) {
-      throw new CustomError('not found data');
-    }
-    ctx.body = packages;
-  })
-  .addTo(app);
-
-app
-  .route({
-    path: 'packages',
-    key: 'update',
-  })
-  .define(async (ctx) => {
-    const tokenUser = ctx.state.tokenUser;
-    const { uid } = tokenUser;
-    const { id, ...rest } = ctx.request.body;
-    let packages: PackagesModel;
-    if (!id) {
-      packages = await PackagesModel.create({
-        ...rest,
-        uid,
-      });
-    } else {
-      packages = await PackagesModel.findOne({
-        where: {
-          uid,
-          id,
-        },
-      });
-      if (!packages) {
-        throw new CustomError('not found data');
-      }
-      await packages.update({
-        ...rest,
-      });
-    }
-    ctx.body = packages;
-  })
-  .addTo(app);
-
-app
-  .route({
-    path: 'packages',
-    key: 'delete',
-    middleware: ['auth'],
-  })
-  .define(async (ctx) => {
-    const tokenUser = ctx.state.tokenUser;
-    const { uid } = tokenUser;
-    const { id } = ctx.request.body;
-    if (!id) {
-      throw new CustomError('id is required');
-    }
-    const packages = await PackagesModel.findOne({
-      where: {
-        uid,
-        id,
-      },
-    });
-    if (!packages) {
-      throw new CustomError('not found data');
-    }
-    await packages.destroy();
-    ctx.body = packages;
-  })
-  .addTo(app);

src/routes/packages/models/index.ts

@@ -1,73 +0,0 @@
-import { sequelize } from '../../../modules/sequelize.ts';
-import { DataTypes, Model } from 'sequelize';
-
-export interface PackagesData {}
-export type PackagesPublish = {
-  key: string;
-  title?: string;
-  description?: string;
-  version?: string;
-  filesName?: any[];
-};
-export type Packages = Partial<InstanceType<typeof PackagesModel>>;
-
-/**
- * 用户代码容器
- */
-export class PackagesModel extends Model {
-  declare id: string;
-  declare title: string;
-  declare description: string;
-  declare tags: string[];
-  declare data: PackagesData; // files
-  declare publish: PackagesPublish;
-  declare uid: string;
-  declare expand: any;
-}
-PackagesModel.init(
-  {
-    id: {
-      type: DataTypes.UUID,
-      primaryKey: true,
-      defaultValue: DataTypes.UUIDV4,
-      comment: 'id',
-    },
-    title: {
-      type: DataTypes.TEXT,
-      defaultValue: '',
-    },
-    description: {
-      type: DataTypes.TEXT,
-      defaultValue: '',
-    },
-    tags: {
-      type: DataTypes.JSONB,
-      defaultValue: [],
-    },
-    data: {
-      type: DataTypes.JSONB,
-      defaultValue: {},
-    },
-    publish: {
-      type: DataTypes.JSONB,
-      defaultValue: {},
-    }, 
-    expand: {
-      type: DataTypes.JSONB,
-      defaultValue: {},
-    },
-    uid: {
-      type: DataTypes.UUID,
-      allowNull: true,
-    },
-  },
-  {
-    sequelize,
-    tableName: 'kv_packages',
-    paranoid: true,
-  },
-);
-
-PackagesModel.sync({ alter: true, logging: false }).catch((e) => {
-  console.error('PackagesModel sync', e);
-});

src/routes/page/module/cache-file.ts

@@ -3,8 +3,8 @@ import { PageModel } from '../models/index.ts';
 import { ContainerModel } from '@/routes/container/models/index.ts';
 import { Op } from 'sequelize';
 import { getContainerData } from './get-container.ts';
-import path from 'path';
+import path from 'node:path';
-import fs from 'fs';
+import fs from 'node:fs';
 import { getHTML, getDataJs, getOneHTML } from './file-template.ts';
 import { minioClient } from '@/app.ts';
 import { bucketName } from '@/modules/minio.ts';
@@ -174,7 +174,7 @@ export const getZip = async (page: PageModel, opts: { tokenUser: any }) => {
 
     // 添加 JavaScript 字符串作为文件到 zip 中
     zip.append(dataJs, { name: 'data.js' });
-    zip.append(JSON.stringify(page), { name: 'app.config.json5' });
+    zip.append(JSON.stringify(page), { name: 'app.config.json' });
     // 可以继续添加更多内容，文件或目录等
     // zip.append('Another content', { name: 'other.txt' });
 

src/routes/page/publish.ts

@@ -6,7 +6,7 @@ import { ContainerModel } from '../container/models/index.ts';
 import { Op } from 'sequelize';
 import { AppListModel, AppModel } from '../app-manager/index.ts';
 import { cachePage, getZip } from './module/cache-file.ts';
-import _ from 'lodash';
+import { uniqBy } from 'lodash-es';
 import semver from 'semver';
 
 app
@@ -53,7 +53,7 @@ app
       // 上传文件
       const res = await cachePage(page, { tokenUser, key, version: _version });
       const appFiles = appList?.data?.files || [];
-      const newFiles = _.uniqBy([...appFiles, ...res], 'name');
+      const newFiles = uniqBy([...appFiles, ...res], 'name');
       appList.data = {
         ...appList?.data,
         files: newFiles,

src/routes/resource/index.ts

@@ -1,2 +0,0 @@
-import './publish.ts';
-import './list.ts';

src/routes/resource/lib/index.ts

@@ -1 +0,0 @@
-export * from './publish-minio.ts';

src/routes/resource/lib/publish-minio.ts

@@ -1,35 +0,0 @@
-import { Resource } from '../models/index.ts';
-import { minioClient, bucketName } from '../../../modules/minio.ts';
-
-type MinioRes = {
-  etag?: string; // 文件的etag, 用于后续的文件下载
-  versionId?: string;
-};
-
-type PublishOptions = {
-  name: string;
-  version: string;
-  code: string;
-};
-
-export const publishJsCode = async ({ name, version, code }: PublishOptions) => {
-  // publish to minio
-  const codeBuffer = Buffer.from(code);
-  const codePath = `${name}/${version}/index.js`;
-  try {
-    const res = await minioClient.putObject(bucketName, codePath, codeBuffer, codeBuffer.length, {
-      'Content-Type': 'application/javascript',
-      'Cache-Control': 'max-age=31536000, immutable',
-    });
-    return {
-      code: 200,
-      data: { ...res, path: codePath },
-    };
-  } catch (e) {
-    console.error('publish error', e.message);
-    return {
-      code: 500,
-      message: e.message,
-    };
-  }
-};

src/routes/resource/list.ts

@@ -1,77 +0,0 @@
-import { ResourceModel } from './models/index.ts';
-import { app } from '../../app.ts';
-
-app
-  .route({
-    path: 'resource',
-    key: 'list',
-    middleware: ['auth'],
-  })
-  .define(async (ctx) => {
-    const tokenUser = ctx.state.tokenUser;
-    const list = await ResourceModel.findAll({
-      order: [['updatedAt', 'DESC']],
-      where: {
-        uid: tokenUser.id,
-      },
-    });
-    ctx.body = list;
-    return ctx;
-  })
-  .addTo(app);
-
-app
-  .route({
-    path: 'resource',
-    key: 'get',
-  })
-  .define(async (ctx) => {
-    const id = ctx.query.id;
-    if (!id) {
-      ctx.throw('id is required');
-    }
-    const rm = await ResourceModel.findByPk(id);
-    if (!rm) {
-      ctx.throw('resource not found');
-    }
-    ctx.body = rm;
-    return ctx;
-  })
-  .addTo(app);
-
-app
-  .route({ path: 'resource', key: 'update' })
-  .define(async (ctx) => {
-    const { data, id, ...rest } = ctx.query.data;
-    if (id) {
-      const resource = await ResourceModel.findByPk(id);
-      if (resource) {
-        const newResource = await resource.update({ data, ...rest });
-        ctx.body = newResource;
-      }
-    } else if (data) {
-      const resource = await ResourceModel.create({ data, ...rest });
-      ctx.body = resource;
-    }
-  })
-  .addTo(app);
-
-app
-  .route({
-    path: 'resource',
-    key: 'delete',
-    middleware: ['auth'],
-  })
-  .define(async (ctx) => {
-    const id = ctx.query.id;
-    if (!id) {
-      ctx.throw('id is required');
-    }
-    const resource = await ResourceModel.findByPk(id);
-    if (!resource) {
-      ctx.throw('resource not found');
-    }
-    await resource.destroy();
-    ctx.body = 'success';
-  })
-  .addTo(app);

src/routes/resource/models/index.ts

@@ -1,91 +0,0 @@
-import { sequelize } from '../../../modules/sequelize.ts';
-import { DataTypes, Model } from 'sequelize';
-
-type FileUrlList = {
-  path: string;
-  etag: string;
-  versionId: string;
-};
-export interface ResourceData {
-  list: FileUrlList[];
-  lastestVersion: string;
-  updatedAt: string;
-  [key: string]: any;
-}
-export const defaultData: ResourceData = {
-  list: [],
-  lastestVersion: '0.0.0',
-  updatedAt: '',
-};
-export type Resource = {
-  id?: string;
-  name?: string;
-  description?: string;
-  source?: string;
-  sourceId?: string;
-  data?: ResourceData;
-  version?: string;
-  uid?: string;
-};
-
-/**
- * 资源管理
- */
-export class ResourceModel extends Model {
-  declare id: string;
-  declare name: string;
-  declare description: string;
-  declare source: string;
-  declare sourceId: string;
-  declare data: ResourceData;
-  declare version: string;
-  declare uid: string;
-}
-
-ResourceModel.init(
-  {
-    id: {
-      type: DataTypes.UUID,
-      primaryKey: true,
-      defaultValue: DataTypes.UUIDV4,
-      comment: 'id',
-    },
-    name: {
-      type: DataTypes.STRING, // 第一次创建之后就不能修改了，因为这个是用来做唯一标识的
-      defaultValue: '',
-    },
-    description: {
-      type: DataTypes.TEXT,
-      defaultValue: '',
-    },
-    source: {
-      type: DataTypes.STRING,
-      defaultValue: '',
-    },
-    sourceId: {
-      type: DataTypes.STRING,
-      defaultValue: '',
-    },
-    version: {
-      type: DataTypes.STRING,
-      defaultValue: '0.0.0',
-    },
-    data: {
-      type: DataTypes.JSON,
-      defaultValue: {},
-    },
-    uid: {
-      type: DataTypes.UUID,
-      allowNull: true,
-    },
-  },
-  {
-    sequelize,
-    tableName: 'kv_resource',
-    paranoid: true,
-  },
-);
-
-ResourceModel.sync({ alter: true, logging: false }).catch((e) => {
-  console.error('ResourceModel sync', e);
-});

src/routes/resource/publish.ts

@@ -1,69 +0,0 @@
-import { defaultData, Resource, ResourceModel } from './models/index.ts';
-import { ContainerModel } from './../container/models/index.ts';
-
-import { app } from '../../app.ts';
-import { Op } from 'sequelize';
-import { publishJsCode } from './lib/publish-minio.ts';
-import { CustomError } from '@kevisual/router';
-
-// app
-//   .route({
-//     path: 'resource',
-//     key: 'publishContainer',
-//     idUsePath: true,
-//   })
-//   .define(async (ctx) => {
-//     const container = ctx.state.container as ContainerModel;
-//     const publish = container.publish;
-//     const code = container.code;
-//     let { name, rid, description, version = '0.0.1' } = publish;
-//     const where = [];
-//     if (rid) {
-//       where.push({ id: rid });
-//     }
-//     if (name) {
-//       where.push({ name });
-//     }
-//     let resource = await ResourceModel.findOne({ where: { [Op.or]: where } });
-//     let isCreate = false;
-//     if (!resource) {
-//       isCreate = true;
-//       resource = await ResourceModel.create({
-//         name,
-//         description,
-//         version,
-//         source: 'container',
-//         sourceId: container.id,
-//         data: {
-//           ...defaultData,
-//           updatedAt: new Date().toISOString(),
-//         },
-//       });
-//     }
-//     publish.rid = publish.rid || resource.id;
-//     // TODO: check version
-//     const res = await publishJsCode({ name, version, code });
-//     if (res.code === 200) {
-//       await container.update({ publish });
-//       const { etag, versionId, path } = res.data;
-//       resource.version = version;
-//       const newData = {
-//         list: [],
-//         ...resource.data,
-//       };
-//       newData.list.push({
-//         etag,
-//         versionId,
-//         path,
-//       });
-//       newData.lastestVersion = version;
-//       newData.updatedAt = new Date().toISOString();
-//       resource.data = newData;
-//       await resource.save();
-//       ctx.body = { resource, container, resourceIsNew: isCreate };
-//     } else {
-//       throw new CustomError(res.message);
-//     }
-//     // await container.update({ publish });
-//   })
-//   .addTo(app);

src/routes/user/admin/user.ts

@@ -0,0 +1,159 @@
+import { app } from '@/app.ts';
+import { User } from '@/models/user.ts';
+import { nanoid } from 'nanoid';
+import { CustomError } from '@kevisual/router';
+import { backupUserA, deleteUser, mvUserAToUserB } from '@/routes/file/index.ts';
+import { AppModel } from '@/routes/app-manager/index.ts';
+// import { mvAppFromUserAToUserB } from '@/routes/app-manager/admin/mv-user-app.ts';
+
+export const checkUsername = (username: string) => {
+  if (username.length > 30) {
+    throw new CustomError(400, 'Username cannot be too long');
+  }
+  if (!/^[a-zA-Z0-9_@]+$/.test(username)) {
+    throw new CustomError(400, 'Username cannot contain special characters');
+  }
+  if (username.includes(' ')) {
+    throw new CustomError(400, 'Username cannot contain spaces');
+  }
+};
+export const checkUsernameShort = (username: string) => {
+  if (username.length < 3) {
+    throw new CustomError(400, 'Username cannot be too short');
+  }
+};
+
+app
+  .route({
+    path: 'user',
+    key: 'changeName',
+    middleware: ['auth-admin'],
+  })
+  .define(async (ctx) => {
+    const { id, newName } = ctx.query.data || {};
+    const user = await User.findByPk(id);
+    if (!user) {
+      ctx.throw(404, 'User not found');
+    }
+    const oldName = user.username;
+    checkUsername(newName);
+    const findUserByUsername = await User.findOne({ where: { username: newName } });
+    if (findUserByUsername) {
+      ctx.throw(400, 'Username already exists');
+    }
+    user.username = newName;
+    try {
+      await user.save();
+      // 迁移文件数据
+      await backupUserA(oldName, user.id); // 备份文件数据
+      await mvUserAToUserB(oldName, newName, true); // 迁移文件数据
+      // await mvAppFromUserAToUserB(oldName, newName); // 迁移应用数据
+
+      if (['org', 'user'].includes(user.type)) {
+        const type = user.type === 'org' ? 'org' : 'user';
+        await User.clearUserToken(user.id, type); // 清除旧token
+      }
+      await AppModel.moveToNewUser(oldName, newName); // 更新用户数据
+    } catch (error) {
+      console.error('迁移文件数据失败', error);
+      ctx.throw(500, 'Failed to change username');
+    }
+    ctx.body = user;
+  })
+  .addTo(app);
+
+app
+  .route({
+    path: 'user',
+    key: 'checkUserExist',
+    middleware: ['auth'],
+  })
+  .define(async (ctx) => {
+    const { username } = ctx.query.data || {};
+    if (!username) {
+      ctx.throw(400, 'Username is required');
+    }
+    checkUsername(username);
+    const user = await User.findOne({ where: { username } });
+
+    ctx.body = {
+      id: user?.id,
+      username: user?.username,
+    };
+  })
+  .addTo(app);
+
+app
+  .route({
+    path: 'user',
+    key: 'resetPassword',
+    middleware: ['auth-admin'],
+  })
+  .define(async (ctx) => {
+    const { id, password } = ctx.query.data || {};
+    const user = await User.findByPk(id);
+    if (!user) {
+      ctx.throw(404, 'User not found');
+    }
+    let pwd = password || nanoid(6);
+    user.createPassword(pwd);
+    await user.save();
+
+    ctx.body = {
+      id: user.id,
+      username: user.username,
+      password: !password ? pwd : undefined,
+    };
+  })
+  .addTo(app);
+
+app
+  .route({
+    path: 'user',
+    key: 'createNewUser',
+    middleware: ['auth-admin'],
+  })
+  .define(async (ctx) => {
+    const { username, password, description } = ctx.query.data || {};
+    if (!username) {
+      ctx.throw(400, 'Username is required');
+    }
+    checkUsername(username);
+    const findUserByUsername = await User.findOne({ where: { username } });
+    if (findUserByUsername) {
+      ctx.throw(400, 'Username already exists');
+    }
+    let pwd = password || nanoid(6);
+    const user = await User.createUser(username, pwd, description);
+    ctx.body = {
+      id: user.id,
+      username: user.username,
+      description: user.description,
+      password: pwd,
+    };
+  })
+  .addTo(app);
+
+app
+  .route({
+    path: 'user',
+    key: 'deleteUser',
+    middleware: ['auth-admin'],
+  })
+  .define(async (ctx) => {
+    const { id } = ctx.query.data || {};
+    const user = await User.findByPk(id);
+    if (!user) {
+      ctx.throw(404, 'User not found');
+    }
+    await user.destroy();
+    backupUserA(user.username, user.id);
+    deleteUser(user.username);
+    // TODO: EXPIRE 删除token
+    ctx.body = {
+      id: user.id,
+      username: user.username,
+      message: 'User deleted successfully',
+    };
+  })
+  .addTo(app);

src/routes/user/index.ts

@@ -3,10 +3,14 @@ import './org.ts';
 
 import './me.ts';
 
-import './update.ts'
+import './update.ts';
 
-import './init.ts'
+import './init.ts';
 
-import './web-login.ts'
+import './web-login.ts';
 
-import './org-user/list.ts'
+import './org-user/list.ts';
+
+import './admin/user.ts';
+
+import './secret-key/list.ts';

src/routes/user/list.ts

@@ -1,6 +1,8 @@
 import { app } from '@/app.ts';
 import { User } from '@/models/user.ts';
 import { CustomError } from '@kevisual/router';
+import { checkUsername } from './admin/user.ts';
+import { nanoid } from 'nanoid';
 
 app
   .route({
@@ -18,7 +20,6 @@ app
   })
   .addTo(app);
 
-
 app
   .route({
     path: 'user',
@@ -28,9 +29,12 @@ app
   .define(async (ctx) => {
     const tokenUser = ctx.state.tokenUser;
     const { id, username, password, description } = ctx.query.data || {};
+    if (!id) {
+      throw new CustomError(400, 'id is required');
+    }
     const user = await User.findByPk(id);
     if (user.id !== tokenUser.id) {
-      throw new CustomError(401, 'Permission denied');
+      throw new CustomError(403, 'Permission denied');
     }
 
     if (!user) {
@@ -59,21 +63,26 @@ app
   .route({
     path: 'user',
     key: 'add',
-    middleware: ['auth'],
+    middleware: ['auth-admin'],
   })
   .define(async (ctx) => {
-    const tokenUser = ctx.state.tokenUser;
     const { username, password, description } = ctx.query.data || {};
     if (!username) {
       throw new CustomError(400, 'username is required');
     }
-    const user = await User.createUser(username, password, description);
+    checkUsername(username);
-    const token = await user.createToken();
+    const findUserByUsername = await User.findOne({ where: { username } });
+    if (findUserByUsername) {
+      throw new CustomError(400, 'username already exists');
+    }
+    const pwd = password || nanoid(6);
+    const user = await User.createUser(username, pwd, description);
     ctx.body = {
       id: user.id,
       username: user.username,
       description: user.description,
       needChangePassword: user.needChangePassword,
-      token,
+      password: pwd,
     };
-  });
+  })
+  .addTo(app);

src/routes/user/me.ts

@@ -12,25 +12,85 @@ export const createCookie = (token: any, ctx: any) => {
   if (!domain) {
     return;
   }
-  if (ctx.res.cookie) {
+  //TODO, 获取访问的 hostname， 如果访问的和 domain 的不一致，也创建cookie
-    ctx.res.cookie('token', token.token, {
+  const browser = ctx.req.headers['user-agent'];
+  const isBrowser = browser.includes('Mozilla'); // 浏览器
+  if (isBrowser && ctx.res.cookie) {
+    ctx.res.cookie('token', token.accessToken || token?.token, {
       maxAge: 7 * 24 * 60 * 60 * 1000, // 过期时间， 设置7天
       domain,
+      path: '/',
       sameSite: 'lax',
       httpOnly: true,
     });
   }
 };
-const clearCookie = (ctx: any) => {
+export type ReqHeaders = {
+  host: string;
+  'x-forwarded-for': string;
+  'x-real-ip': string;
+  'sec-ch-ua': string; // 浏览器
+  'sec-ch-ua-mobile': string; // 移动设备
+  'sec-ch-ua-platform': string; // 平台
+  'sec-ch-ua-arch': string; // 架构
+  'sec-ch-ua-bitness': string; // 位数
+  'sec-ch-ua-full-version': string; // 完整版本
+  'sec-ch-ua-full-version-list': string; // 完整版本列表
+  'sec-fetch-dest': string; // 目标
+  'sec-fetch-mode': string; // 模式
+  'sec-fetch-site': string; // 站点
+  'sec-fetch-user': string; // 用户
+  'upgrade-insecure-requests': string; // 升级不安全请求
+  'user-agent': string; // 用户代理
+  accept: string; // 接受
+  'accept-language': string; // 接受语言
+  'accept-encoding': string; // 接受编码
+  'cache-control': string; // 缓存控制
+  pragma: string; // 预先
+  expires: string; // 过期
+  connection: string; // 连接
+  cookie: string; // 饼干
+};
+export const getSomeInfoFromReq = (ctx: any) => {
+  const headers = ctx.req?.headers as ReqHeaders;
+  if (!headers) {
+    console.log('no req headers', ctx.req);
+    return {
+      'user-agent': '',
+      browser: '',
+      isBrowser: false,
+      host: '',
+      ip: '',
+      headers: {},
+    };
+  }
+  const userAgent = headers?.['user-agent'] || '';
+  const host = headers?.['host'];
+  const ip = headers?.['x-forwarded-for'] || ctx.req?.connection?.remoteAddress;
+  return {
+    'user-agent': userAgent,
+    browser: userAgent,
+    isBrowser: userAgent.includes('Mozilla'),
+    host,
+    ip,
+    headers,
+  };
+};
+export const clearCookie = (ctx: any) => {
   if (!domain) {
     return;
   }
-  ctx.res.cookie('token', '', {
+  const browser = ctx.req.headers['user-agent'];
-    maxAge: 0,
+  const isBrowser = browser.includes('Mozilla'); // 浏览器
-    domain,
+  if (isBrowser && ctx.res.cookie) {
-    sameSite: 'lax',
+    ctx.res.cookie('token', '_', {
-    httpOnly: true,
+      maxAge: 1,
-  });
+      domain,
+      path: '/',
+      sameSite: 'lax',
+      httpOnly: true,
+    });
+  }
 };
 app
   .route({
@@ -87,7 +147,12 @@ app
       ctx.throw(500, 'Password error');
     }
     user.expireOrgs();
-    const token = await user.createToken(null, loginType);
+    const someInfo = getSomeInfoFromReq(ctx);
+    const token = await user.createToken(null, loginType, {
+      ip: someInfo.ip,
+      browser: someInfo['user-agent'],
+      host: someInfo.host,
+    });
     createCookie(token, ctx);
     ctx.body = token;
   })
@@ -99,10 +164,17 @@ app
     key: 'logout',
   })
   .define(async (ctx) => {
+    const token = ctx.query?.token;
     const { tokens = [] } = ctx.query?.data || {};
     clearCookie(ctx);
-    for (const token of tokens) {
+    let needDelTokens = Array.from(new Set([...tokens, token].filter(Boolean)));
-      await User.oauth.delToken(token);
+    for (const token of needDelTokens) {
+      try {
+        await User.oauth.delToken(token);
+      } catch (e) {
+        // console.log('logout error', e);
+        console.log('error token is has been deleted', token);
+      }
     }
     ctx.body = {
       code: 200,
@@ -142,13 +214,13 @@ app
     const { id } = tokenUser;
     const user = await User.findByPk(id);
     if (!user) {
-      ctx.throw(500, 'user not found');
+      ctx.throw(404, 'user not found');
     }
     user.setTokenUser(tokenUser);
     if (username) {
       user.username = username;
     }
-    if (password) {
+    if (password && user.type !== 'org') {
       user.createPassword(password);
     }
     if (description) {

src/routes/user/secret-key/list.ts

@@ -0,0 +1,136 @@
+import { Op } from 'sequelize';
+import { User, UserSecret } from '@/models/user.ts';
+import { app } from '@/app.ts';
+
+app
+  .route({
+    path: 'secret',
+    key: 'list',
+    middleware: ['auth'],
+  })
+  .define(async (ctx) => {
+    const tokenUser = ctx.state.tokenUser;
+    const { page = 1, pageSize = 20, search, sort = 'DESC', orgId } = ctx.query;
+    const searchWhere: Record<string, any> = search
+      ? {
+          [Op.or]: [{ title: { [Op.like]: `%${search}%` } }, { description: { [Op.like]: `%${search}%` } }],
+        }
+      : {};
+    if (orgId) {
+      searchWhere.orgId = orgId;
+    }
+    const { rows: secrets, count } = await UserSecret.findAndCountAll({
+      where: {
+        userId: tokenUser.userId,
+        ...searchWhere,
+      },
+      offset: (page - 1) * pageSize,
+      limit: pageSize,
+      attributes: {
+        exclude: ['token'], // Exclude sensitive token field
+      },
+      order: [['updatedAt', sort]],
+    });
+
+    ctx.body = {
+      list: secrets,
+      pagination: {
+        page,
+        current: page,
+        pageSize,
+        total: count,
+      },
+    };
+  })
+  .addTo(app);
+
+app
+  .route({
+    path: 'secret',
+    key: 'update',
+    middleware: ['auth'],
+  })
+  .define(async (ctx) => {
+    const tokenUser = ctx.state.tokenUser;
+    const { id, updatedAt: _clear, createdAt: _clear2, token, ...rest } = ctx.query.data;
+    let secret: UserSecret;
+    let isNew = false;
+
+    if (id) {
+      secret = await UserSecret.findByPk(id);
+      if (!secret) {
+        ctx.throw(404, 'Secret not found');
+      }
+
+      if (secret.userId !== tokenUser.userId) {
+        ctx.throw(403, 'No permission');
+      }
+    } else {
+      secret = await UserSecret.createSecret(tokenUser);
+      isNew = true;
+    }
+    if (secret) {
+      secret = await secret.update({
+        ...rest,
+      });
+    }
+
+    ctx.body = secret;
+  })
+  .addTo(app);
+
+app
+  .route({
+    path: 'secret',
+    key: 'delete',
+    middleware: ['auth'],
+  })
+  .define(async (ctx) => {
+    const tokenUser = ctx.state.tokenUser;
+    const { id } = ctx.query.data || {};
+
+    if (!id) {
+      ctx.throw(400, 'id is required');
+    }
+
+    const secret = await UserSecret.findByPk(id);
+
+    if (!secret) {
+      ctx.throw(404, 'Secret not found');
+    }
+    if (secret.userId !== tokenUser.userId) {
+      ctx.throw(403, 'No permission');
+    }
+
+    await secret.destroy();
+    ctx.body = secret;
+  })
+  .addTo(app);
+
+app
+  .route({
+    path: 'secret',
+    key: 'get',
+    middleware: ['auth'],
+  })
+  .define(async (ctx) => {
+    const tokenUser = ctx.state.tokenUser;
+    const { id } = ctx.query.data || {};
+
+    if (!id) {
+      ctx.throw(400, 'id is required');
+    }
+
+    const secret = await UserSecret.findByPk(id);
+
+    if (!secret) {
+      ctx.throw(404, 'Secret not found');
+    }
+
+    if (secret.userId !== tokenUser.uid) {
+      ctx.throw(403, 'No permission');
+    }
+
+    ctx.body = secret;
+  })
+  .addTo(app);

src/routes/user/update.ts

@@ -1,56 +1,57 @@
-import { app } from '@/app.ts'
+import { app } from '@/app.ts';
-import { User } from '@/models/user.ts'
+import { User } from '@/models/user.ts';
 
 app
   .route({
     path: 'user',
     key: 'getUpdateInfo',
-    middleware: ['auth']
+    middleware: ['auth'],
   })
   .define(async (ctx) => {
-    const tokenUser = ctx.state?.tokenUser || {}
+    const tokenUser = ctx.state?.tokenUser || {};
-    const user = await User.findByPk(tokenUser.id)
+    const user = await User.findByPk(tokenUser.id);
     if (!user) {
-      ctx.throw(500, 'user not found')
+      ctx.throw(500, 'user not found');
     }
     ctx.body = {
       nickname: user.nickname,
       avatar: user.avatar,
-      data: user.data
+      data: user.data,
-    }
+    };
   })
-  .addTo(app)
+  .addTo(app);
 app
   .route('user', 'updateInfo', {
-    middleware: ['auth']
+    middleware: ['auth'],
   })
   .define(async (ctx) => {
-    const { nickname, avatar, data } = ctx.query.data || {}
+    const { nickname, avatar, data } = ctx.query.data || {};
-    const tokenUser = ctx.state?.tokenUser || {}
+    const tokenUser = ctx.state?.tokenUser || {};
-    const { id } = tokenUser
+    const { id, uid } = tokenUser;
-    const user = await User.findByPk(id)
+    const user = await User.findByPk(id);
-    let updateData: any = {}
+    let updateData: any = {};
     if (!user) {
-      ctx.throw(500, 'user not found')
+      ctx.throw(500, 'user not found');
     }
     if (nickname) {
-      updateData.nickname = nickname
+      updateData.nickname = nickname;
     }
     if (avatar) {
-      updateData.avatar = avatar
+      updateData.avatar = avatar;
     }
     await user.update(
       {
         ...updateData,
         data: {
           ...user.data,
-          ...data
+          ...data,
-        }
+        },
       },
       {
-        fields: ['nickname', 'avatar', 'data']
+        fields: ['nickname', 'avatar', 'data'],
-      }
+      },
-    )
+    );
-    ctx.body = await user.getInfo()
+    user.setTokenUser(tokenUser);
+    ctx.body = await user.getInfo();
   })
-  .addTo(app)
+  .addTo(app);

src/routes/user/web-login.ts

@@ -1,30 +1,72 @@
 import { app } from '@/app.ts';
 import { User } from '@/models/user.ts';
 import MD5 from 'crypto-js/md5.js';
-
+import { authCan } from '@kevisual/code-center-module/models';
 import jsonwebtoken from 'jsonwebtoken';
 
-// const tokenData: Record<string, string> = {};
 import { redis } from '@/app.ts';
-import { createCookie } from './me.ts';
+import { createCookie, clearCookie } from './me.ts';
 
 app
   .route({
     path: 'user',
     key: 'webLogin',
-    middleware: ['auth'],
+    middleware: [authCan],
   })
   .define(async (ctx) => {
     const tokenUser = ctx.state.tokenUser;
+    const token = ctx.query.token;
     const { loginToken, sign, randomId } = ctx.query || {};
+    const setErrorLoginTokenRedis = async (loginToken: string) => {
+      await redis.set(loginToken, JSON.stringify({}), 'EX', 2 * 60); // 2分钟
+    };
+    if (!tokenUser) {
+      if (token) {
+        console.log('web-login, token', ' run clearCookie', token, tokenUser);
+        // clearCookie(ctx);
+      } else {
+        // const message = 'token is expired, please login in web page. ';
+      }
+      try {
+        ctx.res.setHeader('Content-Type', 'text/html');
+        const createRedirectHtml = () => {
+          const reqUrl = ctx.req.url;
+          return `
+          <html lang="zh-CN">
+          <body>
+            <h1>login with web page</h1>
+            <a href="${reqUrl}">${reqUrl}</a>
+            <script>
+            const redirect = new URL('${reqUrl}', window.location.origin);
+              const encodeRedirect = encodeURIComponent(redirect.toString());
+              const toPage = new URL('/user/login/?user-check=true&redirect='+encodeRedirect, window.location.origin);
+              setTimeout(() => {
+                window.location.href = toPage.toString();
+              }, 1000);
+              </script>
+            </body>
+            </html>
+          `;
+        };
+        ctx.res.end(createRedirectHtml());
+      } catch (e) {
+        await setErrorLoginTokenRedis(loginToken);
+        ctx.throw(400, 'token is expired and redirect error');
+      }
+
+      return;
+    }
     if (!loginToken) {
+      await setErrorLoginTokenRedis(loginToken);
       ctx.throw(400, 'loginToken is required');
     }
     if (!sign) {
+      await setErrorLoginTokenRedis(loginToken);
       ctx.throw(400, 'sign is required');
     }
 
     if (!randomId) {
+      await setErrorLoginTokenRedis(loginToken);
       ctx.throw(400, 'randomId is required');
     }
     const tokenSecret = 'xiao' + randomId;
@@ -32,16 +74,19 @@ app
     try {
       payload = jsonwebtoken.verify(loginToken, tokenSecret);
     } catch (e) {
+      await setErrorLoginTokenRedis(loginToken);
       ctx.throw(400, 'loginToken error');
     }
     const { timestamp } = payload;
 
     const checkSign = MD5(`${tokenSecret}${timestamp}`).toString();
     if (sign !== checkSign) {
+      await setErrorLoginTokenRedis(loginToken);
       ctx.throw(400, 'sign error');
     }
     const user = await User.findByPk(tokenUser.id);
     if (!user) {
+      await setErrorLoginTokenRedis(loginToken);
       ctx.throw(400, 'user not found');
     }
     const data = await user.createToken(null, 'plugin', { loginWith: 'cli' });
@@ -63,11 +108,16 @@ app
     // const data = tokenData[loginToken];
     const data = await redis.get(loginToken);
     if (data) {
-      ctx.body = JSON.parse(data);
+      const token = JSON.parse(data);
-      await redis.expire(loginToken, 3600);
+      if (token.accessToken) {
+        ctx.body = token;
+        createCookie(token, ctx);
+      } else {
+        ctx.throw(500, 'Checked error Failed, login failed, please login again');
+      }
+      await redis.expire(loginToken, 2 * 60); // 2分钟
     } else {
       ctx.throw(400, 'Checked Failed');
     }
-    createCookie(data, ctx);
   })
   .addTo(app);

src/run.ts

@@ -0,0 +1,9 @@
+import { program } from './program.ts';
+
+//
+import './scripts/change-user-pwd.ts';
+import './scripts/list-app.ts';
+
+//
+
+program.parse(process.argv);

src/scripts/change-user-pwd.ts

@@ -0,0 +1,50 @@
+import { program, Command } from '../program.ts';
+import { initUser, logger, close } from './common.ts';
+const usrCommand = new Command('user').description('用户相关操作');
+program.addCommand(usrCommand);
+
+const changePwd = new Command('pwd')
+  .description('修改用户密码')
+  .option('-u, --username <username>', '用户名')
+  .option('-p, --password <password>', '新密码')
+  .action(async (opts) => {
+    const username = opts.username;
+    const password = opts.password;
+    if (!username) {
+      logger.error('用户名不能为空');
+      close();
+      return;
+    }
+    const { User } = await initUser();
+    const newPassword = password || 'kevisual';
+
+    logger.info(`用户名: ${username}`);
+    logger.info(`新密码: ${newPassword}`);
+    const user = await User.findOne({ where: { username: username }, logging: false });
+    if (!user) {
+      logger.error('用户不存在');
+      return;
+    }
+    const newP = await user.createPassword(newPassword);
+    logger.info('新密码加密成功', '新密码: ', newPassword);
+    close();
+  });
+usrCommand.addCommand(changePwd);
+
+const list = new Command('list').description('列出所有用户').action(async () => {
+  console.log('列出所有用户 start');
+  const { User } = await initUser();
+  console.log('列出所有用户');
+  const users = await User.findAll({ limit: 10, order: [['createdAt', 'DESC']] });
+  if (users.length === 0) {
+    logger.info('没有用户');
+    return;
+  }
+  users.forEach((user) => {
+    console.log(`用户名: ${user.username}`);
+  });
+  console.log(`用户数量: ${users.length}`);
+  await close();
+});
+
+usrCommand.addCommand(list);