@kevisual/api 0.0.1

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@kevisual/api",
+  "version": "0.0.1",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "build": "bun bun.config.mjs"
+  },
+  "keywords": [],
+  "files": [
+    "src",
+    "query",
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "abearxiong <xiongxiao@xiongxiao.me> (https://www.xiongxiao.me)",
+  "license": "MIT",
+  "packageManager": "pnpm@10.6.2",
+  "type": "module",
+  "dependencies": {
+    "@kevisual/query": "^0.0.18",
+    "@kevisual/router": "^0.0.20"
+  },
+  "devDependencies": {
+    "@kevisual/types": "^0.0.10",
+    "@types/node": "^22.15.27"
+  }
+}

package/query/index.ts

@@ -0,0 +1,7 @@
+import { Query } from '@kevisual/query';
+
+export const query = new Query();
+
+export const clientQuery = new Query({ url: '/client/router' });
+
+export { QueryUtil } from '@kevisual/router/define';

package/query/kevisual.json

@@ -0,0 +1,25 @@
+{
+  "$schema": "https://kevisual.xiongxiao.me/root/ai/kevisual/tools/kevisual-sync/schema.json?v=2",
+  "metadata": {
+    "share": "public"
+  },
+  "checkDir": {
+    "src/query": {
+      "url": "https://kevisual.xiongxiao.me/root/ai/code/registry/query",
+      "enabled": true
+    }
+  },
+  "syncDirectory": [
+    {
+      "files": [
+        "src/query/**/*"
+      ],
+      "ignore": [],
+      "registry": "https://kevisual.xiongxiao.me/root/ai/code/registry",
+      "replace": {
+        "src/": ""
+      }
+    }
+  ],
+  "sync": {}
+}

package/query/query-ai/defines/ai.ts

@@ -0,0 +1,42 @@
+import { QueryUtil } from '@/query/index.ts';
+
+type Message = {
+  role?: 'user' | 'assistant' | 'system' | 'tool';
+  content?: string;
+  name?: string;
+};
+export type PostChat = {
+  messages?: Message[];
+  model?: string;
+  group?: string;
+  user?: string;
+};
+
+export type ChatDataOpts = {
+  id?: string;
+  title?: string;
+  messages?: any[];
+  data?: any;
+  type?: 'temp' | 'keep' | string;
+};
+export type ChatOpts = {
+  username: string;
+  model: string;
+  /**
+   * 获取完整消息回复
+   */
+  getFull?: boolean;
+  group: string;
+  /**
+   * openai的参数
+   */
+  options?: any;
+};
+
+export const appDefine = QueryUtil.create({
+  chat: {
+    path: 'ai',
+    key: 'chat',
+    description: '与 AI 进行对话, 调用 GPT 的AI 服务，生成结果，并返回。',
+  },
+});

package/query/query-ai/query-ai.ts

@@ -0,0 +1,101 @@
+import { appDefine } from './defines/ai.ts';
+import { PostChat, ChatOpts, ChatDataOpts } from './defines/ai.ts';
+
+import { BaseQuery, DataOpts, Query } from '@kevisual/query/query';
+
+export { appDefine };
+
+export class QueryApp<T extends Query = Query> extends BaseQuery<T, typeof appDefine> {
+  constructor(opts?: { query: T }) {
+    super({
+      ...opts,
+      query: opts?.query!,
+      queryDefine: appDefine,
+    });
+  }
+  /**
+   * 与 AI 进行对话, 调用 GPT 的AI 服务，生成结果，并返回。
+   * @param data
+   * @param opts
+   * @returns
+   */
+  postChat(data: PostChat, opts?: DataOpts) {
+    return this.chain('chat').post(data, opts);
+  }
+  /**
+   * 获取模型列表
+   * @param opts
+   * @returns
+   */
+  getModelList(data?: { usernames?: string[] }, opts?: DataOpts) {
+    return this.query.post(
+      {
+        path: 'ai',
+        key: 'get-model-list',
+        data,
+      },
+      opts,
+    );
+  }
+  /**
+   * 聊天对话模型
+   * @param data
+   * @param chatOpts
+   * @param opts
+   * @returns
+   */
+  chat(data: ChatDataOpts, chatOpts: ChatOpts, opts?: DataOpts) {
+    const { username, model, group, getFull = true } = chatOpts;
+    if (!username || !model || !group) {
+      throw new Error('username, model, group is required');
+    }
+    return this.query.post(
+      {
+        path: 'ai',
+        key: 'chat',
+        ...chatOpts,
+        getFull,
+        data,
+      },
+      opts,
+    );
+  }
+  clearConfigCache(opts?: DataOpts) {
+    return this.query.post(
+      {
+        path: 'ai',
+        key: 'clear-cache',
+      },
+      opts,
+    );
+  }
+  /**
+   * 获取聊天使用情况
+   * @param opts
+   * @returns
+   */
+  getChatUsage(opts?: DataOpts) {
+    return this.query.post(
+      {
+        path: 'ai',
+        key: 'get-chat-usage',
+      },
+      opts,
+    );
+  }
+
+  /**
+   * 清除当前用户模型自己的统计
+   * @param opts
+   * @returns
+   */
+  clearSelfUsage(opts?: DataOpts) {
+    return this.query.post(
+      {
+        path: 'ai',
+        key: 'clear-chat-limit',
+      },
+      opts,
+    );
+  }
+}

package/query/query-app/defines/index.ts

@@ -0,0 +1,3 @@
+import { appDefine } from './user-app-list';
+import { userAppDefine } from './user-app';
+export { appDefine, userAppDefine };

package/query/query-app/defines/user-app-list.ts

@@ -0,0 +1,62 @@
+import { QueryUtil } from '@/query/index.ts';
+
+export const appDefine = QueryUtil.create({
+  getApp: {
+    path: 'app',
+    key: 'get',
+    description: '获取应用信息',
+  },
+
+  updateApp: {
+    path: 'app',
+    key: 'update',
+    description: '更新应用信息',
+  },
+
+  deleteApp: {
+    path: 'app',
+    key: 'delete',
+    description: '删除应用信息',
+  },
+
+  listApps: {
+    path: 'app',
+    key: 'list',
+    description: '列出所有应用信息',
+  },
+
+  canUploadFiles: {
+    path: 'app',
+    key: 'canUploadFiles',
+    description: '检查是否可以上传文件',
+  },
+
+  uploadFiles: {
+    path: 'app',
+    key: 'uploadFiles',
+    description: '上传文件',
+  },
+
+  publishApp: {
+    path: 'app',
+    key: 'publish',
+    description: '发布应用',
+  },
+
+  getMinioList: {
+    path: 'app',
+    key: 'get-minio-list',
+    description: '获取 MinIO 文件列表',
+  },
+
+  detectVersionList: {
+    path: 'app',
+    key: 'detectVersionList',
+    description: '检测版本列表并同步 MinIO 数据',
+  },
+  publicList: {
+    path: 'app',
+    key: 'public-list',
+    description: '获取公开应用列表',
+  },
+});

package/query/query-app/defines/user-app.ts

@@ -0,0 +1,33 @@
+import { QueryUtil } from '@/query/index.ts';
+
+export const userAppDefine = QueryUtil.create({
+  listUserApps: {
+    path: 'user-app',
+    key: 'list',
+    description: '列出当前用户的所有应用（不包含 data 字段）',
+  },
+
+  getUserApp: {
+    path: 'user-app',
+    key: 'get',
+    description: '获取用户应用信息，可以指定 id 或 key',
+  },
+
+  updateUserApp: {
+    path: 'user-app',
+    key: 'update',
+    description: '更新或创建用户应用',
+  },
+
+  deleteUserApp: {
+    path: 'user-app',
+    key: 'delete',
+    description: '删除用户应用及关联数据',
+  },
+
+  testUserApp: {
+    path: 'user-app',
+    key: 'test',
+    description: '对 user-app 的数据进行测试，获取版本信息',
+  },
+});

package/query/query-app/query-app-define.ts

@@ -0,0 +1 @@
+export * from './defines/index.ts';

package/query/query-app/query-app.ts

@@ -0,0 +1,18 @@
+import { appDefine, userAppDefine } from './defines/index.ts';
+
+import { BaseQuery, DataOpts, Query } from '@kevisual/query/query';
+
+export { appDefine, userAppDefine };
+
+export class QueryApp extends BaseQuery {
+  appDefine = appDefine;
+  userAppDefine = userAppDefine;
+  constructor(opts?: { query: Query }) {
+    super(opts!);
+    this.appDefine.query = this.query;
+    this.userAppDefine.query = this.query;
+  }
+  getList(data: any, opts?: DataOpts) {
+    return this.appDefine.queryChain('listApps').post(data, opts);
+  }
+}

package/query/query-login/login-cache.ts

@@ -0,0 +1,204 @@
+export interface Cache {
+  /**
+   * @update 获取缓存
+   */
+  get(key: string): Promise<any>;
+  /**
+   * @update 设置缓存
+   */
+  set(key: string, value: any): Promise<any>;
+  /**
+   * @update 删除缓存
+   */
+  del(): Promise<void>;
+  /**
+   * 初始化
+   */
+  init?: () => Promise<any>;
+}
+type User = {
+  avatar?: string;
+  description?: string;
+  id?: string;
+  needChangePassword?: boolean;
+  orgs?: string[];
+  type?: string;
+  username?: string;
+};
+
+export type CacheLoginUser = {
+  user?: User;
+  id?: string;
+  accessToken?: string;
+  refreshToken?: string;
+};
+type CacheLogin = {
+  loginUsers: CacheLoginUser[];
+} & CacheLoginUser;
+
+export type CacheStore<T = Cache> = {
+  name: string;
+  /**
+   * 缓存数据
+   * @important 需要先调用init
+   */
+  cacheData: CacheLogin;
+  /**
+   * 实际操作的cache, 需要先调用init
+   */
+  cache: T;
+
+  /**
+   * 设置当前用户
+   */
+  setLoginUser(user: CacheLoginUser): Promise<void>;
+  /**
+   * 获取当前用户
+   */
+  getCurrentUser(): Promise<User>;
+  /**
+   * 获取当前用户列表
+   */
+  getCurrentUserList(): Promise<CacheLoginUser[]>;
+  /**
+   * 获取缓存的refreshToken
+   */
+  getRefreshToken(): Promise<string>;
+  /**
+   * 获取缓存的accessToken
+   */
+  getAccessToken(): Promise<string>;
+  /**
+   * 清除当前用户
+   */
+  clearCurrentUser(): Promise<void>;
+  /**
+   * 清除所有用户
+   */
+  clearAll(): Promise<void>;
+
+  getValue(): Promise<CacheLogin>;
+  setValue(value: CacheLogin): Promise<CacheLogin>;
+  delValue(): Promise<void>;
+  init(): Promise<any>;
+};
+
+export type LoginCacheStoreOpts = {
+  name: string;
+  cache: Cache;
+};
+export class LoginCacheStore implements CacheStore<any> {
+  cache: Cache;
+  name: string;
+  cacheData: CacheLogin;
+  constructor(opts: LoginCacheStoreOpts) {
+    if (!opts.cache) {
+      throw new Error('cache is required');
+    }
+    // @ts-ignore
+    this.cache = opts.cache;
+    this.cacheData = {
+      loginUsers: [],
+      user: undefined,
+      id: undefined,
+      accessToken: undefined,
+      refreshToken: undefined,
+    };
+    this.name = opts.name;
+  }
+  /**
+   * 设置缓存
+   * @param key
+   * @param value
+   * @returns
+   */
+  async setValue(value: CacheLogin) {
+    await this.cache.set(this.name, value);
+    this.cacheData = value;
+    return value;
+  }
+  /**
+   * 删除缓存
+   */
+  async delValue() {
+    await this.cache.del();
+  }
+  getValue(): Promise<CacheLogin> {
+    return this.cache.get(this.name);
+  }
+  /**
+   * 初始化,设置默认值
+   */
+  async init() {
+    const defaultData = {
+      loginUsers: [],
+      user: null,
+      id: null,
+      accessToken: null,
+      refreshToken: null,
+    };
+    if (this.cache.init) {
+      try {
+        const cacheData = await this.cache.init();
+        this.cacheData = cacheData || defaultData;
+      } catch (error) {
+        console.log('cacheInit error', error);
+      }
+    } else {
+      this.cacheData = (await this.getValue()) || defaultData;
+    }
+  }
+  /**
+   * 设置当前用户
+   * @param user
+   */
+  async setLoginUser(user: CacheLoginUser) {
+    const has = this.cacheData.loginUsers.find((u) => u.id === user.id);
+    if (has) {
+      this.cacheData.loginUsers = this.cacheData?.loginUsers?.filter((u) => u?.id && u.id !== user.id);
+    }
+    this.cacheData.loginUsers.push(user);
+    this.cacheData.user = user.user;
+    this.cacheData.id = user.id;
+    this.cacheData.accessToken = user.accessToken;
+    this.cacheData.refreshToken = user.refreshToken;
+    await this.setValue(this.cacheData);
+  }
+
+  getCurrentUser(): Promise<CacheLoginUser> {
+    const cacheData = this.cacheData;
+    return Promise.resolve(cacheData.user!);
+  }
+  getCurrentUserList(): Promise<CacheLoginUser[]> {
+    return Promise.resolve(this.cacheData.loginUsers.filter((u) => u?.id));
+  }
+  getRefreshToken(): Promise<string> {
+    const cacheData = this.cacheData;
+    return Promise.resolve(cacheData.refreshToken || '');
+  }
+  getAccessToken(): Promise<string> {
+    const cacheData = this.cacheData;
+    return Promise.resolve(cacheData.accessToken || '');
+  }
+
+  async clearCurrentUser() {
+    const user = await this.getCurrentUser();
+    const has = this.cacheData.loginUsers.find((u) => u.id === user.id);
+    if (has) {
+      this.cacheData.loginUsers = this.cacheData?.loginUsers?.filter((u) => u?.id && u.id !== user.id);
+    }
+    this.cacheData.user = undefined;
+    this.cacheData.id = undefined;
+    this.cacheData.accessToken = undefined;
+    this.cacheData.refreshToken = undefined;
+    await this.setValue(this.cacheData);
+  }
+  async clearAll() {
+    this.cacheData.loginUsers = [];
+    this.cacheData.user = undefined;
+    this.cacheData.id = undefined;
+    this.cacheData.accessToken = undefined;
+    this.cacheData.refreshToken = undefined;
+    await this.setValue(this.cacheData);
+  }
+}

package/query/query-login/login-node-cache.ts

@@ -0,0 +1,132 @@
+import { Cache } from './login-cache.ts';
+import { homedir } from 'node:os';
+import { join, dirname } from 'node:path';
+import fs from 'node:fs';
+import { readFileSync, writeFileSync, accessSync } from 'node:fs';
+import { readFile, writeFile, unlink, mkdir } from 'node:fs/promises';
+export const fileExists = async (
+  filePath: string,
+  { createIfNotExists = true, isFile = true, isDir = false }: { createIfNotExists?: boolean; isFile?: boolean; isDir?: boolean } = {},
+) => {
+  try {
+    accessSync(filePath, fs.constants.F_OK);
+    return true;
+  } catch (error) {
+    if (createIfNotExists && isDir) {
+      await mkdir(filePath, { recursive: true });
+      return true;
+    } else if (createIfNotExists && isFile) {
+      await mkdir(dirname(filePath), { recursive: true });
+      return false;
+    }
+    return false;
+  }
+};
+export const readConfigFile = (filePath: string) => {
+  try {
+    const data = readFileSync(filePath, 'utf-8');
+    const jsonData = JSON.parse(data);
+    return jsonData;
+  } catch (error) {
+    return {};
+  }
+};
+export const writeConfigFile = (filePath: string, data: any) => {
+  writeFileSync(filePath, JSON.stringify(data, null, 2));
+};
+export const getHostName = () => {
+  const configDir = join(homedir(), '.config', 'envision');
+  const configFile = join(configDir, 'config.json');
+  const config = readConfigFile(configFile);
+  const baseURL = config.baseURL || 'https://kevisual.cn';
+  const hostname = new URL(baseURL).hostname;
+  return hostname;
+};
+export class StorageNode implements Storage {
+  cacheData: any;
+  filePath: string;
+  constructor() {
+    this.cacheData = {};
+    const configDir = join(homedir(), '.config', 'envision');
+    const hostname = getHostName();
+    this.filePath = join(configDir, 'config', `${hostname}-storage.json`);
+    fileExists(this.filePath, { isFile: true });
+  }
+  async loadCache() {
+    const filePath = this.filePath;
+    try {
+      const data = await readConfigFile(filePath);
+      this.cacheData = data;
+    } catch (error) {
+      this.cacheData = {};
+      await writeFile(filePath, JSON.stringify(this.cacheData, null, 2));
+    }
+  }
+  get length() {
+    return Object.keys(this.cacheData).length;
+  }
+  getItem(key: string) {
+    return this.cacheData[key];
+  }
+  setItem(key: string, value: any) {
+    this.cacheData[key] = value;
+    writeFile(this.filePath, JSON.stringify(this.cacheData, null, 2));
+  }
+  removeItem(key: string) {
+    delete this.cacheData[key];
+    writeFile(this.filePath, JSON.stringify(this.cacheData, null, 2));
+  }
+  clear() {
+    this.cacheData = {};
+    writeFile(this.filePath, JSON.stringify(this.cacheData, null, 2));
+  }
+  key(index: number) {
+    return Object.keys(this.cacheData)[index];
+  }
+}
+export class LoginNodeCache implements Cache {
+  filepath: string;
+
+  constructor(filepath?: string) {
+    this.filepath = filepath || join(homedir(), '.config', 'envision', 'config', `${getHostName()}-login.json`);
+    fileExists(this.filepath, { isFile: true });
+  }
+  async get(_key: string) {
+    try {
+      const filePath = this.filepath;
+      const data = readConfigFile(filePath);
+      return data;
+    } catch (error) {
+      console.log('get error', error);
+      return {};
+    }
+  }
+  async set(_key: string, value: any) {
+    try {
+      const data = readConfigFile(this.filepath);
+      const newData = { ...data, ...value };
+      writeConfigFile(this.filepath, newData);
+    } catch (error) {
+      console.log('set error', error);
+    }
+  }
+  async del() {
+    await unlink(this.filepath);
+  }
+  async loadCache(filePath: string) {
+    try {
+      const data = await readFile(filePath, 'utf-8');
+      const jsonData = JSON.parse(data);
+      return jsonData;
+    } catch (error) {
+      // console.log('loadCache error', error);
+      console.log('create new cache file:', filePath);
+      const defaultData = { loginUsers: [] };
+      writeConfigFile(filePath, defaultData);
+      return defaultData;
+    }
+  }
+  async init() {
+    return await this.loadCache(this.filepath);
+  }
+}

package/query/query-login/query-login-browser.ts

@@ -0,0 +1,12 @@
+import { QueryLogin, QueryLoginOpts } from './query-login.ts';
+import { MyCache } from '@kevisual/cache';
+type QueryLoginNodeOptsWithoutCache = Omit<QueryLoginOpts, 'cache'>;
+
+export class QueryLoginBrowser extends QueryLogin {
+  constructor(opts: QueryLoginNodeOptsWithoutCache) {
+    super({
+      ...opts,
+      cache: new MyCache('login'),
+    });
+  }
+}

package/query/query-login/query-login-node.ts

@@ -0,0 +1,14 @@
+import { QueryLogin, QueryLoginOpts } from './query-login.ts';
+import { LoginNodeCache, StorageNode } from './login-node-cache.ts';
+type QueryLoginNodeOptsWithoutCache = Omit<QueryLoginOpts, 'cache'>;
+export const storage = new StorageNode();
+await storage.loadCache();
+export class QueryLoginNode extends QueryLogin {
+  constructor(opts: QueryLoginNodeOptsWithoutCache) {
+    super({
+      ...opts,
+      storage,
+      cache: new LoginNodeCache(),
+    });
+  }
+}