@lightharu/krouter 1.8.0

package/out-server/server/store.js

@@ -0,0 +1,266 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebStore = void 0;
+exports.hashPassword = hashPassword;
+exports.verifyPassword = verifyPassword;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const crypto_1 = __importDefault(require("crypto"));
+const SENSITIVE_KEY_RE = /^(accessToken|refreshToken|csrfToken|clientSecret|password|apiKey|key|token|secret)$/i;
+const ENCRYPTED_MARKER = '__kiroWebEncrypted';
+function dataDir() {
+    return path_1.default.resolve(process.env.KROUTER_DATA_DIR || process.env.KAM_DATA_DIR || process.env.KIRO_WEB_DATA_DIR || '.web-data');
+}
+function storePath() {
+    return path_1.default.join(dataDir(), 'store.json');
+}
+function encryptionKey() {
+    const configured = process.env.APP_ENCRYPTION_KEY || 'development-only-change-me';
+    return crypto_1.default.createHash('sha256').update(configured).digest();
+}
+function hashSessionId(sessionId) {
+    const secret = process.env.SESSION_SECRET || 'development-session-secret';
+    return crypto_1.default.createHmac('sha256', secret).update(sessionId).digest('hex');
+}
+function encryptString(value) {
+    const iv = crypto_1.default.randomBytes(12);
+    const cipher = crypto_1.default.createCipheriv('aes-256-gcm', encryptionKey(), iv);
+    const encrypted = Buffer.concat([cipher.update(value, 'utf8'), cipher.final()]);
+    const tag = cipher.getAuthTag();
+    return {
+        [ENCRYPTED_MARKER]: true,
+        v: 1,
+        iv: iv.toString('base64'),
+        tag: tag.toString('base64'),
+        data: encrypted.toString('base64')
+    };
+}
+function decryptString(value) {
+    const decipher = crypto_1.default.createDecipheriv('aes-256-gcm', encryptionKey(), Buffer.from(String(value.iv), 'base64'));
+    decipher.setAuthTag(Buffer.from(String(value.tag), 'base64'));
+    const decrypted = Buffer.concat([
+        decipher.update(Buffer.from(String(value.data), 'base64')),
+        decipher.final()
+    ]);
+    return decrypted.toString('utf8');
+}
+function protect(value, keyName) {
+    if (value === null || value === undefined)
+        return value;
+    if (typeof value === 'string' && keyName && SENSITIVE_KEY_RE.test(keyName)) {
+        return encryptString(value);
+    }
+    if (typeof value !== 'object')
+        return value;
+    if (Array.isArray(value))
+        return value.map((item) => protect(item));
+    const record = value;
+    if (record[ENCRYPTED_MARKER])
+        return value;
+    return Object.fromEntries(Object.entries(record).map(([key, child]) => [key, protect(child, key)]));
+}
+function unprotect(value) {
+    if (value === null || value === undefined || typeof value !== 'object')
+        return value;
+    if (Array.isArray(value))
+        return value.map((item) => unprotect(item));
+    const record = value;
+    if (record[ENCRYPTED_MARKER])
+        return decryptString(record);
+    return Object.fromEntries(Object.entries(record).map(([key, child]) => [key, unprotect(child)]));
+}
+function defaultStore() {
+    return {
+        version: 1,
+        users: [],
+        sessions: [],
+        accountDataByUser: {},
+        settingsByUser: {},
+        proxyStateByUser: {},
+        auditEvents: []
+    };
+}
+function hashPassword(password, salt = crypto_1.default.randomBytes(16).toString('hex')) {
+    const hash = crypto_1.default.pbkdf2Sync(password, salt, 120000, 32, 'sha256').toString('hex');
+    return { hash, salt };
+}
+function verifyPassword(password, user) {
+    const { hash } = hashPassword(password, user.passwordSalt);
+    return crypto_1.default.timingSafeEqual(Buffer.from(hash, 'hex'), Buffer.from(user.passwordHash, 'hex'));
+}
+class WebStore {
+    data = defaultStore();
+    loaded = false;
+    async load() {
+        if (this.loaded)
+            return;
+        await fs_1.promises.mkdir(dataDir(), { recursive: true });
+        try {
+            const raw = await fs_1.promises.readFile(storePath(), 'utf8');
+            this.data = { ...defaultStore(), ...JSON.parse(raw) };
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+            this.data = defaultStore();
+            await this.save();
+        }
+        this.loaded = true;
+        await this.ensureConfiguredAdminUser();
+        this.pruneExpiredSessions();
+        await this.save();
+    }
+    snapshot() {
+        return this.data;
+    }
+    async save() {
+        await fs_1.promises.mkdir(dataDir(), { recursive: true });
+        await fs_1.promises.writeFile(storePath(), JSON.stringify(this.data, null, 2), 'utf8');
+    }
+    isSetupRequired() {
+        return this.data.users.length === 0;
+    }
+    static generateAdminPassword() {
+        const alphabet = 'ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz23456789';
+        const bytes = crypto_1.default.randomBytes(18);
+        let value = '';
+        for (const byte of bytes)
+            value += alphabet[byte % alphabet.length];
+        return `kr-${value.slice(0, 6)}-${value.slice(6, 12)}-${value.slice(12, 18)}`;
+    }
+    adminEmailFromEnv() {
+        return process.env.KROUTER_ADMIN_EMAIL
+            || process.env.KAM_ADMIN_EMAIL
+            || process.env.ADMIN_EMAIL
+            || 'admin@krouter.local';
+    }
+    configuredAdminPassword() {
+        return process.env.KROUTER_ADMIN_PASSWORD
+            || process.env.KAM_ADMIN_PASSWORD
+            || process.env.ADMIN_PASSWORD;
+    }
+    async ensureConfiguredAdminUser() {
+        if (this.data.users.length > 0)
+            return;
+        const password = this.configuredAdminPassword();
+        if (!password)
+            return;
+        await this.createInitialAdmin({ email: this.adminEmailFromEnv(), password });
+    }
+    async createInitialAdmin(input) {
+        if (this.data.users.length > 0)
+            throw new Error('Krouter is already set up');
+        const password = String(input.password || '');
+        if (password.length < 8)
+            throw new Error('Password must be at least 8 characters');
+        const email = String(input.email || this.adminEmailFromEnv()).trim() || 'admin@krouter.local';
+        const { hash, salt } = hashPassword(password);
+        const user = {
+            id: crypto_1.default.randomUUID(),
+            email,
+            name: input.name || 'Admin',
+            role: 'admin',
+            passwordHash: hash,
+            passwordSalt: salt,
+            createdAt: Date.now()
+        };
+        this.data.users.push(user);
+        await this.save();
+        return user;
+    }
+    findUserByEmail(email) {
+        return this.data.users.find((user) => user.email.toLowerCase() === email.toLowerCase());
+    }
+    getUsers() {
+        return [...this.data.users];
+    }
+    findUserBySession(sessionId) {
+        if (!sessionId)
+            return undefined;
+        const idHash = hashSessionId(sessionId);
+        const session = this.data.sessions.find((item) => item.idHash === idHash && item.expiresAt > Date.now());
+        if (!session)
+            return undefined;
+        return this.data.users.find((user) => user.id === session.userId);
+    }
+    async createSession(userId) {
+        const id = crypto_1.default.randomBytes(32).toString('base64url');
+        const expiresAt = Date.now() + 1000 * 60 * 60 * 24 * 7;
+        this.data.sessions.push({
+            idHash: hashSessionId(id),
+            userId,
+            expiresAt,
+            createdAt: Date.now()
+        });
+        await this.save();
+        return { id, expiresAt };
+    }
+    async deleteSession(sessionId) {
+        if (!sessionId)
+            return;
+        const idHash = hashSessionId(sessionId);
+        this.data.sessions = this.data.sessions.filter((session) => session.idHash !== idHash);
+        await this.save();
+    }
+    getAccountData(userId) {
+        return unprotect(this.data.accountDataByUser[userId] || null);
+    }
+    async setAccountData(userId, accountData) {
+        this.data.accountDataByUser[userId] = protect(accountData);
+        await this.save();
+    }
+    getUserSettings(userId) {
+        const settings = this.data.settingsByUser[userId];
+        if (!settings) {
+            this.data.settingsByUser[userId] = {};
+            return this.data.settingsByUser[userId];
+        }
+        return settings;
+    }
+    async setUserSetting(userId, key, value) {
+        const settings = this.getUserSettings(userId);
+        settings[key] = protect(value);
+        await this.save();
+    }
+    getUserSetting(userId, key, fallback) {
+        const settings = this.getUserSettings(userId);
+        if (!(key in settings))
+            return fallback;
+        return unprotect(settings[key]);
+    }
+    getProxyState(userId) {
+        if (!this.data.proxyStateByUser[userId]) {
+            this.data.proxyStateByUser[userId] = {};
+        }
+        return this.data.proxyStateByUser[userId];
+    }
+    async updateProxyState(userId, patch) {
+        const current = this.getProxyState(userId);
+        Object.assign(current, protect(patch));
+        await this.save();
+        return unprotect(current);
+    }
+    async audit(userId, type, data) {
+        this.data.auditEvents.push({ ts: Date.now(), userId, type, data: protect(data) });
+        if (this.data.auditEvents.length > 1000)
+            this.data.auditEvents.splice(0, this.data.auditEvents.length - 1000);
+        await this.save();
+    }
+    getAuditEvents(userId) {
+        return this.data.auditEvents
+            .filter((event) => event.userId === userId)
+            .map((event) => ({
+            ts: event.ts,
+            type: event.type,
+            data: unprotect(event.data)
+        }));
+    }
+    pruneExpiredSessions() {
+        const now = Date.now();
+        this.data.sessions = this.data.sessions.filter((session) => session.expiresAt > now);
+    }
+}
+exports.WebStore = WebStore;

package/package.json

@@ -0,0 +1,113 @@
+{
+  "name": "@lightharu/krouter",
+  "version": "1.8.0",
+  "description": "Krouter - Web dashboard and CLI router for Kiro accounts, quota balancing, and API proxy",
+  "main": "./out-server/server/index.js",
+  "bin": {
+    "krouter": "scripts/krouter-cli.cjs"
+  },
+  "author": "LightHaru",
+  "license": "AGPL-3.0",
+  "homepage": "https://github.com/LightHaru/Krouter",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/LightHaru/Krouter.git"
+  },
+  "bugs": {
+    "url": "https://github.com/LightHaru/Krouter/issues"
+  },
+  "keywords": [
+    "krouter",
+    "kiro",
+    "openclaw",
+    "api-proxy",
+    "openai-compatible",
+    "cli"
+  ],
+  "files": [
+    "dist-web/",
+    "out-server/",
+    "scripts/krouter-cli.cjs",
+    "scripts/kiro-manager-cli.cjs",
+    "resources/tls-client-xgo-1.14.0-windows-amd64.dll",
+    "src/renderer/src/assets/krouter-logo.svg",
+    "src/renderer/src/assets/krouter-mark.svg",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "format": "prettier --write .",
+    "lint": "eslint --cache .",
+    "typecheck:node": "tsc --noEmit -p tsconfig.node.json --composite false",
+    "typecheck:web": "tsc --noEmit -p tsconfig.web.json --composite false",
+    "typecheck:server": "tsc --noEmit -p tsconfig.server.json",
+    "typecheck": "npm run typecheck:node && npm run typecheck:web",
+    "start": "electron-vite preview",
+    "dev": "chcp 65001 >nul && electron-vite dev",
+    "build": "npm run typecheck && electron-vite build",
+    "dev:web": "vite --config vite.web.config.ts",
+    "dev:api": "tsc -w -p tsconfig.server.json",
+    "build:web": "vite build --config vite.web.config.ts",
+    "build:api": "tsc -p tsconfig.server.json",
+    "clean:fullstack": "node -e \"const fs=require('fs'); for (const p of ['dist-web','out-server']) fs.rmSync(p,{recursive:true,force:true})\"",
+    "build:fullstack": "npm run clean:fullstack && npm run typecheck:web && npm run typecheck:server && npm run build:web && npm run build:api",
+    "start:api": "node out-server/server/index.js --api-only",
+    "start:backend": "node out-server/server/index.js --api-only",
+    "start:fullstack": "node out-server/server/index.js",
+    "cli": "node scripts/krouter-cli.cjs",
+    "prepack": "npm run build:fullstack",
+    "build:unpack": "npm run build && electron-builder --dir",
+    "build:win": "npm run build && electron-builder --win",
+    "build:mac": "electron-vite build && electron-builder --mac",
+    "build:linux": "electron-vite build && electron-builder --linux",
+    "test:e2e": "node test/e2e-fullsuite/run.mjs",
+    "test:e2e:only": "node test/e2e-fullsuite/run.mjs --only",
+    "test:e2e:install": "playwright install chromium"
+  },
+  "dependencies": {
+    "@electron-toolkit/preload": "^3.0.2",
+    "@electron-toolkit/utils": "^4.0.0",
+    "@tailwindcss/vite": "^4.1.17",
+    "@tanstack/react-virtual": "^3.13.12",
+    "cbor-x": "^1.6.0",
+    "class-variance-authority": "^0.7.1",
+    "clsx": "^2.1.1",
+    "electron-store": "^11.0.2",
+    "electron-updater": "^6.3.9",
+    "framer-motion": "^12.40.0",
+    "js-tiktoken": "^1.0.21",
+    "lucide-react": "^0.555.0",
+    "node-forge": "^1.3.3",
+    "socks": "^2.8.9",
+    "tailwind-merge": "^3.4.0",
+    "tailwindcss": "^4.1.17",
+    "tlsclientwrapper": "^4.2.0",
+    "undici": "^7.19.2",
+    "uuid": "^13.0.0",
+    "zustand": "^5.0.9"
+  },
+  "devDependencies": {
+    "@electron-toolkit/eslint-config-prettier": "^3.0.0",
+    "@electron-toolkit/eslint-config-ts": "^3.1.0",
+    "@electron-toolkit/tsconfig": "^2.0.0",
+    "@types/node": "^22.18.6",
+    "@types/node-forge": "^1.3.14",
+    "@types/react": "^19.1.13",
+    "@types/react-dom": "^19.1.9",
+    "@types/uuid": "^10.0.0",
+    "@vitejs/plugin-react": "^5.0.3",
+    "electron": "^38.1.2",
+    "electron-builder": "^25.1.8",
+    "electron-vite": "^4.0.1",
+    "eslint": "^9.36.0",
+    "eslint-plugin-react": "^7.37.5",
+    "eslint-plugin-react-hooks": "^5.2.0",
+    "eslint-plugin-react-refresh": "^0.4.20",
+    "playwright": "^1.60.0",
+    "prettier": "^3.6.2",
+    "react": "^19.1.1",
+    "react-dom": "^19.1.1",
+    "typescript": "^5.9.2",
+    "vite": "^7.1.6"
+  }
+}

package/scripts/kiro-manager-cli.cjs

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+require('./krouter-cli.cjs')