aicodeswitch 1.0.0 → 1.1.0

package/CLAUDE.md

@@ -0,0 +1,182 @@
+```
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+```
+
+## AI Code Switch - Project Overview
+
+AI Code Switch is a local proxy server that manages AI programming tool connections to large language models, allowing tools like Claude Code and Codex to use custom model APIs instead of official ones.
+
+## Development Commands
+
+### Installation
+```bash
+npm install
+```
+
+### Development
+```bash
+npm run dev              # Run both UI and server in watch mode
+npm run dev:ui           # Run only React UI (Vite dev server)
+npm run dev:server       # Run only Node.js server (TSX watch)
+```
+
+### Build
+```bash
+npm run build            # Build both UI and server
+npm run build:ui         # Build React UI to dist/ui
+npm run build:server     # Build TypeScript server to dist/server
+```
+
+### Linting
+```bash
+npm run lint             # Run ESLint on all .ts/.tsx files
+```
+
+### CLI Commands
+```bash
+npm link                 # Link local package for CLI testing
+aicos start              # Start the proxy server
+aicos stop               # Stop the proxy server
+aicos restart            # Restart the proxy server
+```
+
+## Architecture
+
+### High-Level Structure
+```
+┌─────────────────────────────────────────────────────────────┐
+│                     AI Code Switch                          │
+├─────────────────────────────────────────────────────────────┤
+│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐     │
+│  │   React UI   │  │  Express API │  │  Proxy Core  │     │
+│  │  (Vite dev)  │  │  (Node.js)   │  │              │     │
+│  └──────────────┘  └──────────────┘  └──────────────┘     │
+│            │              │              │                  │
+│            └──────────────┼──────────────┘                  │
+│                           ▼                                 │
+│                    ┌──────────────┐                        │
+│                    │   Database   │                        │
+│                    │  (SQLite3)   │                        │
+│                    └──────────────┘                        │
+│                           │                                 │
+│                           ▼                                 │
+│                    ┌──────────────┐                        │
+│                    │  Transformers │                        │
+│                    │  (Stream/SSE) │                        │
+│                    └──────────────┘                        │
+│                           │                                 │
+│                           ▼                                 │
+│                    ┌──────────────┐                        │
+│                    │  Upstream    │                        │
+│                    │  APIs (LLMs) │                        │
+│                    └──────────────┘                        │
+└─────────────────────────────────────────────────────────────┘
+```
+
+### Core Components
+
+#### 1. Server (Node.js/Express) - `server/main.ts`
+- Main entry point
+- Configures Express with CORS, body parsing
+- Reads configuration from `~/.aicodeswitch/aicodeswitch.conf`
+- Sets up authentication middleware
+- Registers all API routes
+- Initializes database and proxy server
+
+#### 2. Proxy Server - `server/proxy-server.ts`
+- **Route Matching**: Finds active route based on target type (claude-code/codex)
+- **Rule Matching**: Determines content type from request (image-understanding/thinking/long-context/background/default)
+- **Request Transformation**: Converts between different API formats (Claude ↔ OpenAI ↔ OpenAI Responses)
+- **Streaming**: Handles SSE (Server-Sent Events) streaming responses with real-time transformation
+- **Logging**: Tracks requests, responses, and errors
+
+#### 3. Transformers - `server/transformers/`
+- **streaming.ts**: SSE parsing/serialization and event transformation
+- **claude-openai.ts**: Claude ↔ OpenAI Chat format conversion
+- **openai-responses.ts**: OpenAI Responses format conversion
+- **chunk-collector.ts**: Collects streaming chunks for logging
+
+#### 4. Database - `server/database.ts`
+- SQLite3 database wrapper
+- Manages: Vendors, API Services, Routes, Rules, Logs
+- Configuration storage (API key, logging settings, etc.)
+
+#### 5. UI (React) - `ui/`
+- Main app: `App.tsx` - Navigation and layout
+- Pages:
+  - `VendorsPage.tsx` - Manage AI service vendors
+  - `RoutesPage.tsx` - Configure routing rules
+  - `LogsPage.tsx` - View request/access/error logs
+  - `SettingsPage.tsx` - Application settings
+  - `WriteConfigPage.tsx` - Overwrite Claude Code/Codex config files
+  - `UsagePage.tsx` - Usage statistics
+
+#### 6. Types - `types/`
+- TypeScript type definitions for:
+  - Database models (Vendors, Services, Routes, Rules)
+  - API requests/responses
+  - Configuration
+  - Token usage tracking
+
+#### 7. CLI - `bin/`
+- `cli.js` - Main CLI entry point
+- `start.js` - Server startup with PID management
+- `stop.js` - Server shutdown
+- `restart.js` - Restart server
+
+## Key Features
+
+### Routing System
+- **Routes**: Define target type (Claude Code or Codex) and activation status
+- **Rules**: Match requests by content type and route to specific API services
+- **Content Type Detection**:
+  - `image-understanding`: Requests with image content
+  - `thinking`: Requests with reasoning/thinking signals
+  - `long-context`: Requests with large context (≥12000 chars or ≥8000 max tokens)
+  - `background`: Background/priority requests
+  - `default`: All other requests
+
+### Request Transformation
+- Supports multiple source types:
+  - OpenAI Chat
+  - OpenAI Code
+  - OpenAI Responses
+  - Claude Chat
+  - Claude Code
+  - DeepSeek Chat
+
+### Configuration Management
+- Writes/ restores Claude Code config files (`~/.claude/settings.json`, `~/.claude.json`)
+- Writes/ restores Codex config files (`~/.codex/config.toml`, `~/.codex/auth.json`)
+- Exports/ imports encrypted configuration data
+
+### Logging
+- Request logs: Detailed API call records with token usage
+- Access logs: System access records
+- Error logs: Error and exception records
+
+## Development Tips
+
+1. **Environment Variables**: Copy `.env.example` to `.env` and modify as needed
+2. **Data Directory**: Default: `~/.aicodeswitch/data/` (SQLite3 database)
+3. **Config File**: `~/.aicodeswitch/aicodeswitch.conf` (HOST, PORT, AUTH)
+4. **Dev Ports**: UI (4568), Server (4567) - configured in `vite.config.ts` and `server/main.ts`
+5. **API Endpoints**: All routes are prefixed with `/api/` except proxy routes (`/claude-code/`, `/codex/`)
+
+## Build and Deployment
+
+1. Run `npm run build` to create production builds
+2. UI build outputs to `dist/ui/` (static files)
+3. Server build outputs to `dist/server/` (JavaScript)
+4. Configuration files are created in user's home directory on first run
+
+## Technology Stack
+
+- **Backend**: Node.js, Express, TypeScript, SQLite3
+- **Frontend**: React 18, TypeScript, Vite, React Router
+- **Streaming**: SSE (Server-Sent Events)
+- **HTTP Client**: Axios
+- **Encryption**: CryptoJS (AES)
+- **CLI**: Yargs-like custom implementation

package/README.md

@@ -21,6 +21,12 @@ npm install -g aicodeswitch
 aicos start
 ```
 
+**停止服务**
+
+```
+aicos stop
+```
+
 **进入管理界面**
 
 ```

package/bin/cli.js

@@ -1,12 +1,40 @@
 #!/usr/bin/env node
 
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
 const args = process.argv.slice(2);
 const command = args[0];
 
+// 检查是否有更新版本的 current 文件
+const CURRENT_FILE = path.join(os.homedir(), '.aicodeswitch', 'current');
+
+let binDir = __dirname;
+let useLocalVersion = true;
+
+// 如果存在 current 文件，使用更新版本的脚本
+if (fs.existsSync(CURRENT_FILE)) {
+  try {
+    const currentPath = fs.readFileSync(CURRENT_FILE, 'utf-8').trim();
+    const currentBinDir = path.join(currentPath, 'bin');
+
+    // 检查新版本的 bin 目录是否存在
+    if (fs.existsSync(currentBinDir) && fs.existsSync(path.join(currentBinDir, 'cli.js'))) {
+      binDir = currentBinDir;
+      useLocalVersion = false;
+    }
+  } catch (err) {
+    // 读取失败，使用本地版本
+  }
+}
+
 const commands = {
-  start: () => require('./start'),
-  stop: () => require('./stop'),
-  restart: () => require('./restart'),
+  start: () => require(path.join(binDir, 'start')),
+  stop: () => require(path.join(binDir, 'stop')),
+  restart: () => require(path.join(binDir, 'restart')),
+  update: () => require(path.join(binDir, 'update')),
+  version: () => require(path.join(binDir, 'version')),
 };
 
 if (!command || !commands[command]) {
@@ -17,11 +45,15 @@ Commands:
   start      Start the AI Code Switch server
   stop       Stop the AI Code Switch server
   restart    Restart the AI Code Switch server
+  update     Update to the latest version and restart
+  version    Show current version information
 
 Example:
   aicos start
   aicos stop
   aicos restart
+  aicos update
+  aicos version
   `);
   process.exit(1);
 }

package/bin/update.js

@@ -0,0 +1,251 @@
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const https = require('https');
+const { spawn } = require('child_process');
+const chalk = require('chalk');
+const ora = require('ora');
+const boxen = require('boxen');
+
+const AICOSWITCH_DIR = path.join(os.homedir(), '.aicodeswitch');
+const RELEASES_DIR = path.join(AICOSWITCH_DIR, 'releases');
+const CURRENT_FILE = path.join(AICOSWITCH_DIR, 'current');
+const PACKAGE_NAME = 'aicodeswitch';
+const NPM_REGISTRY = 'https://registry.npmjs.org';
+
+// 确保目录存在
+const ensureDir = (dirPath) => {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+};
+
+// 获取当前使用的版本（从 current 文件或本地 package.json）
+const getCurrentVersion = () => {
+  // 先检查是否有 current 文件（更新的版本）
+  if (fs.existsSync(CURRENT_FILE)) {
+    try {
+      const currentPath = fs.readFileSync(CURRENT_FILE, 'utf-8').trim();
+      const currentPackageJson = path.join(currentPath, 'package.json');
+      if (fs.existsSync(currentPackageJson)) {
+        const pkg = JSON.parse(fs.readFileSync(currentPackageJson, 'utf-8'));
+        return pkg.version;
+      }
+    } catch (err) {
+      // 读取失败，fallback 到本地版本
+    }
+  }
+
+  // 使用本地 package.json
+  try {
+    const packageJson = path.join(__dirname, '..', 'package.json');
+    const pkg = JSON.parse(fs.readFileSync(packageJson, 'utf-8'));
+    return pkg.version;
+  } catch (err) {
+    return '0.0.0';
+  }
+};
+
+// 比较版本号
+const compareVersions = (v1, v2) => {
+  const parts1 = v1.split('.').map(Number);
+  const parts2 = v2.split('.').map(Number);
+
+  for (let i = 0; i < 3; i++) {
+    if (parts1[i] > parts2[i]) return 1;
+    if (parts1[i] < parts2[i]) return -1;
+  }
+  return 0;
+};
+
+// 从 npm registry 获取最新版本
+const getLatestVersion = () => {
+  return new Promise((resolve, reject) => {
+    const options = {
+      hostname: 'registry.npmjs.org',
+      path: `/${PACKAGE_NAME}`,
+      method: 'GET',
+      headers: {
+        'User-Agent': 'aicodeswitch'
+      }
+    };
+
+    const req = https.request(options, (res) => {
+      let data = '';
+
+      res.on('data', (chunk) => {
+        data += chunk;
+      });
+
+      res.on('end', () => {
+        try {
+          const packageInfo = JSON.parse(data);
+          const latestVersion = packageInfo['dist-tags'].latest;
+          resolve({
+            version: latestVersion,
+            tarball: packageInfo.versions[latestVersion].dist.tarball
+          });
+        } catch (err) {
+          reject(new Error('Failed to parse package info from npm'));
+        }
+      });
+    });
+
+    req.on('error', reject);
+    req.end();
+  });
+};
+
+// 使用 npm 安装指定版本到指定目录
+const installPackage = (version, targetDir) => {
+  return new Promise((resolve, reject) => {
+    const npmProcess = spawn('npm', [
+      'install',
+      `${PACKAGE_NAME}@${version}`,
+      '--prefix',
+      targetDir,
+      '--no-save',
+      '--no-package-lock',
+      '--no-bin-links'
+    ]);
+
+    let stderr = '';
+
+    npmProcess.stderr.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    npmProcess.on('close', (code) => {
+      if (code === 0) {
+        // npm install 会把包安装到 targetDir/node_modules/ 目录下
+        const packageDir = path.join(targetDir, 'node_modules', PACKAGE_NAME);
+        if (fs.existsSync(packageDir)) {
+          resolve(packageDir);
+        } else {
+          reject(new Error('Package installation directory not found'));
+        }
+      } else {
+        reject(new Error(`npm install failed: ${stderr}`));
+      }
+    });
+
+    npmProcess.on('error', reject);
+  });
+};
+
+// 更新 current 文件
+const updateCurrentFile = (versionPath) => {
+  fs.writeFileSync(CURRENT_FILE, versionPath);
+};
+
+// 执行 restart
+const restart = () => {
+  return new Promise((resolve, reject) => {
+    const restartScript = path.join(__dirname, 'restart.js');
+
+    const restartProcess = spawn('node', [restartScript], {
+      stdio: 'inherit'
+    });
+
+    restartProcess.on('close', (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`Restart failed with exit code ${code}`));
+      }
+    });
+
+    restartProcess.on('error', reject);
+  });
+};
+
+// 主更新逻辑
+const update = async () => {
+  console.log('\n');
+
+  const currentVersion = getCurrentVersion();
+  const spinner = ora({
+    text: chalk.cyan('Checking for updates...'),
+    color: 'cyan'
+  }).start();
+
+  try {
+    // 获取最新版本信息
+    const latestInfo = await getLatestVersion();
+    const latestVersion = latestInfo.version;
+
+    spinner.succeed(chalk.green(`Latest version: ${chalk.bold(latestVersion)}`));
+
+    // 检查是否需要更新
+    const comparison = compareVersions(latestVersion, currentVersion);
+
+    if (comparison <= 0) {
+      console.log(chalk.yellow(`\n✓ You are already on the latest version (${chalk.bold(currentVersion)})\n`));
+      process.exit(0);
+      return;
+    }
+
+    console.log(chalk.cyan(`\n📦 Update available: ${chalk.bold(currentVersion)} → ${chalk.bold(latestVersion)}\n`));
+
+    // 确保目录存在
+    ensureDir(RELEASES_DIR);
+
+    // 安装新版本
+    const installSpinner = ora({
+      text: chalk.cyan('Downloading and installing from npm...'),
+      color: 'cyan'
+    }).start();
+
+    const versionDir = path.join(RELEASES_DIR, latestVersion);
+    ensureDir(versionDir);
+
+    try {
+      const packageDir = await installPackage(latestVersion, versionDir);
+      installSpinner.succeed(chalk.green('Package installed'));
+    } catch (err) {
+      installSpinner.fail(chalk.red('Installation failed'));
+      console.log(chalk.red(`Error: ${err.message}\n`));
+      process.exit(1);
+      return;
+    }
+
+    // 实际的包在 node_modules/aicodeswitch 目录下
+    const actualPackageDir = path.join(versionDir, 'node_modules', PACKAGE_NAME);
+    updateCurrentFile(actualPackageDir);
+
+    // 显示更新成功信息
+    console.log(boxen(
+      chalk.green.bold('✨ Update Successful!\n\n') +
+      chalk.white('Version:  ') + chalk.cyan.bold(latestVersion) + '\n' +
+      chalk.white('Location: ') + chalk.gray(actualPackageDir) + '\n\n' +
+      chalk.gray('Restarting server with the new version...'),
+      {
+        padding: 1,
+        margin: 1,
+        borderStyle: 'double',
+        borderColor: 'green'
+      }
+    ));
+
+    // 重启服务器
+    try {
+      await restart();
+    } catch (err) {
+      console.log(chalk.yellow(`\n⚠️  Update completed, but restart failed: ${err.message}`));
+      console.log(chalk.cyan('Please manually run: ') + chalk.yellow('aicos restart\n'));
+      process.exit(1);
+      return;
+    }
+
+    process.exit(0);
+
+  } catch (err) {
+    spinner.fail(chalk.red('Update check failed'));
+    console.log(chalk.red(`Error: ${err.message}\n`));
+    console.log(chalk.gray('You can check for updates manually at:\n'));
+    console.log(chalk.cyan('  https://www.npmjs.com/package/aicodeswitch\n'));
+    process.exit(1);
+  }
+};
+
+module.exports = update();

package/bin/version.js

@@ -0,0 +1,97 @@
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const chalk = require('chalk');
+const boxen = require('boxen');
+
+const AICOSWITCH_DIR = path.join(os.homedir(), '.aicodeswitch');
+const CURRENT_FILE = path.join(AICOSWITCH_DIR, 'current');
+
+const getVersionInfo = () => {
+  // 先检查是否有 current 文件（更新的版本）
+  if (fs.existsSync(CURRENT_FILE)) {
+    try {
+      const currentPath = fs.readFileSync(CURRENT_FILE, 'utf-8').trim();
+      const currentPackageJson = path.join(currentPath, 'package.json');
+
+      if (fs.existsSync(currentPackageJson)) {
+        const pkg = JSON.parse(fs.readFileSync(currentPackageJson, 'utf-8'));
+
+        return {
+          version: pkg.version,
+          source: 'npm',
+          path: currentPath,
+          isUpdated: true
+        };
+      }
+    } catch (err) {
+      // 读取失败，fallback 到本地版本
+    }
+  }
+
+  // 使用本地 package.json
+  try {
+    const packageJson = path.join(__dirname, '..', 'package.json');
+    const pkg = JSON.parse(fs.readFileSync(packageJson, 'utf-8'));
+
+    return {
+      version: pkg.version,
+      source: 'local',
+      path: path.dirname(packageJson),
+      isUpdated: false
+    };
+  } catch (err) {
+    return {
+      version: 'unknown',
+      source: 'unknown',
+      path: 'unknown',
+      isUpdated: false
+    };
+  }
+};
+
+const version = () => {
+  const info = getVersionInfo();
+
+  console.log('\n');
+
+  if (info.isUpdated) {
+    console.log(boxen(
+      chalk.green.bold('AI Code Switch\n\n') +
+      chalk.white('Version:  ') + chalk.cyan.bold(info.version) + '\n' +
+      chalk.white('Source:   ') + chalk.yellow.bold('npm (updated)') + '\n' +
+      chalk.white('Location: ') + chalk.gray(info.path),
+      {
+        padding: 1,
+        margin: 1,
+        borderStyle: 'double',
+        borderColor: 'green'
+      }
+    ));
+
+    console.log(chalk.cyan('💡 Tips:\n'));
+    console.log(chalk.white('  • Check for updates: ') + chalk.yellow('aicos update'));
+    console.log(chalk.white('  • Revert to local:   ') + chalk.gray('rm ~/.aicodeswitch/current\n'));
+  } else {
+    console.log(boxen(
+      chalk.cyan.bold('AI Code Switch\n\n') +
+      chalk.white('Version:  ') + chalk.cyan.bold(info.version) + '\n' +
+      chalk.white('Source:   ') + chalk.yellow.bold('local development') + '\n' +
+      chalk.white('Location: ') + chalk.gray(info.path),
+      {
+        padding: 1,
+        margin: 1,
+        borderStyle: 'double',
+        borderColor: 'cyan'
+      }
+    ));
+
+    console.log(chalk.cyan('💡 Tips:\n'));
+    console.log(chalk.white('  • Check for updates: ') + chalk.yellow('aicos update'));
+    console.log(chalk.white('  • Update to latest:  ') + chalk.yellow('aicos update\n'));
+  }
+
+  process.exit(0);
+};
+
+module.exports = version();

package/dist/server/database.js

@@ -99,14 +99,15 @@ class DatabaseManager {
       CREATE TABLE IF NOT EXISTS rules (
         id TEXT PRIMARY KEY,
         route_id TEXT NOT NULL,
-        content_type TEXT NOT NULL CHECK(content_type IN ('default', 'background', 'thinking', 'long-context', 'image-understanding')),
+        content_type TEXT NOT NULL CHECK(content_type IN ('default', 'background', 'thinking', 'long-context', 'image-understanding', 'model-mapping')),
         target_service_id TEXT NOT NULL,
         target_model TEXT,
+        replaced_model TEXT,
+        sort_order INTEGER DEFAULT 0,
         created_at INTEGER NOT NULL,
         updated_at INTEGER NOT NULL,
         FOREIGN KEY (route_id) REFERENCES routes(id) ON DELETE CASCADE,
-        FOREIGN KEY (target_service_id) REFERENCES api_services(id) ON DELETE CASCADE,
-        UNIQUE(route_id, content_type)
+        FOREIGN KEY (target_service_id) REFERENCES api_services(id) ON DELETE CASCADE
       );
 
       CREATE TABLE IF NOT EXISTS config (
@@ -246,8 +247,8 @@ class DatabaseManager {
     // Rule operations
     getRules(routeId) {
         const query = routeId
-            ? 'SELECT * FROM rules WHERE route_id = ? ORDER BY created_at DESC'
-            : 'SELECT * FROM rules ORDER BY created_at DESC';
+            ? 'SELECT * FROM rules WHERE route_id = ? ORDER BY sort_order DESC, created_at DESC'
+            : 'SELECT * FROM rules ORDER BY sort_order DESC, created_at DESC';
         const stmt = routeId ? this.db.prepare(query).bind(routeId) : this.db.prepare(query);
         const rows = stmt.all();
         return rows.map((row) => ({
@@ -256,6 +257,8 @@ class DatabaseManager {
             contentType: row.content_type,
             targetServiceId: row.target_service_id,
             targetModel: row.target_model,
+            replacedModel: row.replaced_model,
+            sortOrder: row.sort_order,
             createdAt: row.created_at,
             updatedAt: row.updated_at,
         }));
@@ -264,15 +267,15 @@ class DatabaseManager {
         const id = crypto_1.default.randomUUID();
         const now = Date.now();
         this.db
-            .prepare('INSERT INTO rules (id, route_id, content_type, target_service_id, target_model, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)')
-            .run(id, route.routeId, route.contentType, route.targetServiceId, route.targetModel || null, now, now);
+            .prepare('INSERT INTO rules (id, route_id, content_type, target_service_id, target_model, replaced_model, sort_order, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)')
+            .run(id, route.routeId, route.contentType, route.targetServiceId, route.targetModel || null, route.replacedModel || null, route.sortOrder || 0, now, now);
         return Object.assign(Object.assign({}, route), { id, createdAt: now, updatedAt: now });
     }
     updateRule(id, route) {
         const now = Date.now();
         const result = this.db
-            .prepare('UPDATE rules SET content_type = ?, target_service_id = ?, target_model = ?, updated_at = ? WHERE id = ?')
-            .run(route.contentType, route.targetServiceId, route.targetModel || null, now, id);
+            .prepare('UPDATE rules SET content_type = ?, target_service_id = ?, target_model = ?, replaced_model = ?, sort_order = ?, updated_at = ? WHERE id = ?')
+            .run(route.contentType, route.targetServiceId, route.targetModel || null, route.replacedModel || null, route.sortOrder || 0, now, id);
         return result.changes > 0;
     }
     deleteRule(id) {
@@ -324,6 +327,14 @@ class DatabaseManager {
         return __awaiter(this, void 0, void 0, function* () {
             const id = crypto_1.default.randomUUID();
             yield this.accessLogDb.put(id, JSON.stringify(Object.assign(Object.assign({}, log), { id })));
+            return id;
+        });
+    }
+    updateAccessLog(id, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const log = yield this.accessLogDb.get(id);
+            const updatedLog = Object.assign(Object.assign({}, JSON.parse(log)), data);
+            yield this.accessLogDb.put(id, JSON.stringify(updatedLog));
         });
     }
     getAccessLogs() {
@@ -459,8 +470,8 @@ class DatabaseManager {
                 // Import rules
                 for (const rule of importData.rules) {
                     this.db
-                        .prepare('INSERT INTO rules (id, route_id, content_type, target_service_id, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)')
-                        .run(rule.id, rule.routeId, rule.contentType || 'default', rule.targetServiceId, rule.createdAt, rule.updatedAt);
+                        .prepare('INSERT INTO rules (id, route_id, content_type, target_service_id, target_model, replaced_model, sort_order, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)')
+                        .run(rule.id, rule.routeId, rule.contentType || 'default', rule.targetServiceId, rule.targetModel || null, rule.replacedModel || null, rule.sortOrder || 0, rule.createdAt, rule.updatedAt);
                 }
                 // Update config
                 this.updateConfig(importData.config);