221 lines
8.6 KiB
JavaScript
221 lines
8.6 KiB
JavaScript
/**
|
|
* Data Unification Migration Script
|
|
* Merges codex data into the primary (claude) directories.
|
|
*
|
|
* Run AFTER stopping both services.
|
|
*/
|
|
const Database = require('/home/clone-ej/EJClaw/node_modules/better-sqlite3');
|
|
const fs = require('fs');
|
|
const path = require('path');
|
|
|
|
const BASE = '/home/clone-ej/EJClaw';
|
|
const CLAUDE_DB = path.join(BASE, 'store/messages.db');
|
|
const CODEX_DB = path.join(BASE, 'store-codex/messages.db');
|
|
|
|
console.log('=== EJClaw Data Unification ===\n');
|
|
|
|
// 1. Open both DBs
|
|
const primary = new Database(CLAUDE_DB);
|
|
const codex = new Database(CODEX_DB);
|
|
|
|
primary.pragma('journal_mode = WAL');
|
|
primary.pragma('busy_timeout = 5000');
|
|
|
|
// 2. Merge registered_groups (codex → primary, skip JID conflicts)
|
|
console.log('--- Merging registered_groups ---');
|
|
const codexGroups = codex.prepare('SELECT * FROM registered_groups').all();
|
|
const insertGroup = primary.prepare(`
|
|
INSERT OR IGNORE INTO registered_groups
|
|
(jid, name, folder, trigger_pattern, added_at, container_config, requires_trigger, is_main, agent_type, work_dir)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
|
`);
|
|
|
|
let groupsAdded = 0;
|
|
let groupsSkipped = 0;
|
|
for (const g of codexGroups) {
|
|
// Check if JID already exists with different agent_type
|
|
const existing = primary.prepare('SELECT agent_type FROM registered_groups WHERE jid = ?').get(g.jid);
|
|
if (existing) {
|
|
// Same JID, different bots — both need to be registered
|
|
// Since JID is PK, we can't have duplicates. The group with claude-code type stays,
|
|
// and the codex one is already differentiated by agent_type in the same row.
|
|
// But wait — in the unified DB, the same JID can only appear once.
|
|
// For shared channels (both bots respond), we keep the claude registration
|
|
// and the codex service will also load it IF we adjust the filter.
|
|
// Actually, the codex service filters by agent_type='codex', so it won't see claude-code groups.
|
|
// We need BOTH registrations for shared channels.
|
|
// Solution: codex groups with different folder names get inserted.
|
|
// Same JID + same folder = skip (duplicate)
|
|
// Same JID + different folder = need a unique folder for codex
|
|
if (existing.agent_type !== g.agent_type) {
|
|
// Same JID but different agent types — need both
|
|
// Change JID to make it unique: append agent type suffix
|
|
const codexJid = g.jid + ':codex';
|
|
const existsCodex = primary.prepare('SELECT 1 FROM registered_groups WHERE jid = ?').get(codexJid);
|
|
if (!existsCodex) {
|
|
insertGroup.run(codexJid, g.name, g.folder, g.trigger_pattern, g.added_at,
|
|
g.container_config, g.requires_trigger, g.is_main, g.agent_type, g.work_dir);
|
|
groupsAdded++;
|
|
console.log(` + ${g.folder} (codex, jid=${codexJid})`);
|
|
} else {
|
|
groupsSkipped++;
|
|
}
|
|
} else {
|
|
groupsSkipped++;
|
|
}
|
|
} else {
|
|
insertGroup.run(g.jid, g.name, g.folder, g.trigger_pattern, g.added_at,
|
|
g.container_config, g.requires_trigger, g.is_main, g.agent_type, g.work_dir);
|
|
groupsAdded++;
|
|
console.log(` + ${g.folder} (${g.agent_type})`);
|
|
}
|
|
}
|
|
console.log(` Added: ${groupsAdded}, Skipped: ${groupsSkipped}\n`);
|
|
|
|
// 3. Merge sessions (codex → primary, agent_type='codex')
|
|
console.log('--- Merging sessions ---');
|
|
const codexSessions = codex.prepare('SELECT * FROM sessions').all();
|
|
const insertSession = primary.prepare(
|
|
'INSERT OR IGNORE INTO sessions (group_folder, agent_type, session_id) VALUES (?, ?, ?)'
|
|
);
|
|
let sessionsAdded = 0;
|
|
for (const s of codexSessions) {
|
|
insertSession.run(s.group_folder, s.agent_type, s.session_id);
|
|
sessionsAdded++;
|
|
console.log(` + ${s.group_folder} [${s.agent_type}]`);
|
|
}
|
|
console.log(` Added: ${sessionsAdded}\n`);
|
|
|
|
// 4. Merge router_state (codex → primary, already prefixed)
|
|
console.log('--- Merging router_state ---');
|
|
const codexState = codex.prepare('SELECT * FROM router_state').all();
|
|
const insertState = primary.prepare(
|
|
'INSERT OR IGNORE INTO router_state (key, value) VALUES (?, ?)'
|
|
);
|
|
for (const s of codexState) {
|
|
insertState.run(s.key, s.value);
|
|
console.log(` + ${s.key}`);
|
|
}
|
|
console.log('');
|
|
|
|
// 5. Merge messages (codex → primary, skip duplicates by PK)
|
|
console.log('--- Merging messages ---');
|
|
const codexMsgs = codex.prepare('SELECT * FROM messages').all();
|
|
const insertMsg = primary.prepare(`
|
|
INSERT OR IGNORE INTO messages
|
|
(id, chat_jid, sender, sender_name, content, timestamp, is_from_me, is_bot_message)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?)
|
|
`);
|
|
let msgsAdded = 0;
|
|
let msgsSkipped = 0;
|
|
const batchInsert = primary.transaction((msgs) => {
|
|
for (const m of msgs) {
|
|
const result = insertMsg.run(m.id, m.chat_jid, m.sender, m.sender_name,
|
|
m.content, m.timestamp, m.is_from_me, m.is_bot_message);
|
|
if (result.changes > 0) msgsAdded++;
|
|
else msgsSkipped++;
|
|
}
|
|
});
|
|
batchInsert(codexMsgs);
|
|
console.log(` Added: ${msgsAdded}, Skipped (duplicates): ${msgsSkipped}\n`);
|
|
|
|
// 6. Merge chats (codex → primary, UPSERT with newer timestamp)
|
|
console.log('--- Merging chats ---');
|
|
const codexChats = codex.prepare('SELECT * FROM chats').all();
|
|
const upsertChat = primary.prepare(`
|
|
INSERT INTO chats (jid, name, last_message_time, channel, is_group) VALUES (?, ?, ?, ?, ?)
|
|
ON CONFLICT(jid) DO UPDATE SET
|
|
name = COALESCE(excluded.name, name),
|
|
last_message_time = MAX(last_message_time, excluded.last_message_time),
|
|
channel = COALESCE(excluded.channel, channel),
|
|
is_group = COALESCE(excluded.is_group, is_group)
|
|
`);
|
|
let chatsUpserted = 0;
|
|
for (const c of codexChats) {
|
|
upsertChat.run(c.jid, c.name, c.last_message_time, c.channel, c.is_group);
|
|
chatsUpserted++;
|
|
}
|
|
console.log(` Upserted: ${chatsUpserted}\n`);
|
|
|
|
// 7. Merge scheduled_tasks (codex → primary, skip duplicates)
|
|
const codexTasks = codex.prepare('SELECT * FROM scheduled_tasks').all();
|
|
if (codexTasks.length > 0) {
|
|
console.log('--- Merging scheduled_tasks ---');
|
|
const insertTask = primary.prepare(`
|
|
INSERT OR IGNORE INTO scheduled_tasks
|
|
(id, group_folder, chat_jid, prompt, schedule_type, schedule_value, next_run, last_run, last_result, status, created_at, context_mode)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
|
`);
|
|
for (const t of codexTasks) {
|
|
insertTask.run(t.id, t.group_folder, t.chat_jid, t.prompt, t.schedule_type,
|
|
t.schedule_value, t.next_run, t.last_run, t.last_result, t.status, t.created_at, t.context_mode);
|
|
console.log(` + ${t.id}`);
|
|
}
|
|
console.log('');
|
|
}
|
|
|
|
// Close DBs
|
|
primary.close();
|
|
codex.close();
|
|
|
|
// 8. Merge groups directories
|
|
console.log('--- Merging groups-codex/ → groups/ ---');
|
|
const codexGroupsDir = path.join(BASE, 'groups-codex');
|
|
const claudeGroupsDir = path.join(BASE, 'groups');
|
|
if (fs.existsSync(codexGroupsDir)) {
|
|
const entries = fs.readdirSync(codexGroupsDir);
|
|
for (const entry of entries) {
|
|
const src = path.join(codexGroupsDir, entry);
|
|
const dst = path.join(claudeGroupsDir, entry);
|
|
if (fs.existsSync(dst)) {
|
|
// Merge: copy files that don't exist in dst
|
|
if (fs.statSync(src).isDirectory()) {
|
|
const files = fs.readdirSync(src);
|
|
for (const f of files) {
|
|
const srcFile = path.join(src, f);
|
|
const dstFile = path.join(dst, f);
|
|
if (!fs.existsSync(dstFile)) {
|
|
fs.cpSync(srcFile, dstFile, { recursive: true });
|
|
console.log(` cp ${entry}/${f}`);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
fs.cpSync(src, dst, { recursive: true });
|
|
console.log(` + ${entry}/`);
|
|
}
|
|
}
|
|
}
|
|
console.log('');
|
|
|
|
// 9. Merge data-codex/sessions/ → data/sessions/
|
|
console.log('--- Merging data-codex/sessions/ → data/sessions/ ---');
|
|
const codexDataSessions = path.join(BASE, 'data-codex/sessions');
|
|
const claudeDataSessions = path.join(BASE, 'data/sessions');
|
|
if (fs.existsSync(codexDataSessions)) {
|
|
const entries = fs.readdirSync(codexDataSessions);
|
|
for (const entry of entries) {
|
|
const src = path.join(codexDataSessions, entry);
|
|
const dst = path.join(claudeDataSessions, entry);
|
|
if (fs.existsSync(dst)) {
|
|
// Both exist — merge .codex/ subdirectory
|
|
const codexSubdir = path.join(src, '.codex');
|
|
const dstCodexSubdir = path.join(dst, '.codex');
|
|
if (fs.existsSync(codexSubdir) && !fs.existsSync(dstCodexSubdir)) {
|
|
fs.cpSync(codexSubdir, dstCodexSubdir, { recursive: true });
|
|
console.log(` cp ${entry}/.codex/`);
|
|
}
|
|
} else {
|
|
fs.cpSync(src, dst, { recursive: true });
|
|
console.log(` + ${entry}/`);
|
|
}
|
|
}
|
|
}
|
|
console.log('');
|
|
|
|
console.log('=== Migration complete ===');
|
|
console.log('Next steps:');
|
|
console.log('1. Update .env.codex to remove EJCLAW_STORE_DIR, EJCLAW_DATA_DIR, EJCLAW_GROUPS_DIR');
|
|
console.log('2. Restart both services');
|
|
console.log('3. Verify, then rename old dirs to .bak');
|