@aliwey/bmo 2.1.0 → 2.1.2

package/bin/bmo.js

@@ -163,20 +163,34 @@ Data lives in: ${BMO_HOME_DISPLAY}
       // Ignore failures
     }
 
-    console.log(`🗑️ Uninstalling old version of @aliwey/bmo...`);
-    try {
-      execSync('npm uninstall -g @aliwey/bmo', { stdio: 'inherit' });
-    } catch (e) {
-      // Ignore uninstall failures if it wasn't already installed
-    }
-    console.log(`🔄 Installing @aliwey/bmo${ver}...`);
-    try {
-      execSync(`npm install -g @aliwey/bmo${ver}`, { stdio: 'inherit' });
-    } catch {
-      console.error('❌ Update failed. Try manually: npm install -g @aliwey/bmo');
-      process.exit(1);
+    if (os.platform() === 'win32') {
+      console.log('Launching updater in a new window to release folder/file locks...');
+      
+      const cmdStr = `timeout /t 2 /nobreak >nul && echo [BMO Updater] Upgrading to @aliwey/bmo${ver}... && npm install -g @aliwey/bmo${ver} && echo [OK] BMO updated successfully! Press any key to close. && pause`;
+      
+      spawn('cmd.exe', ['/c', 'start', 'cmd.exe', '/c', cmdStr], {
+        detached: true,
+        stdio: 'ignore'
+      });
+      
+      console.log('Updater launched. This window will now close to release file locks.');
+      process.exit(0);
+    } else {
+      console.log(`Uninstalling old version of @aliwey/bmo...`);
+      try {
+        execSync('npm uninstall -g @aliwey/bmo', { stdio: 'inherit' });
+      } catch (e) {
+        // Ignore uninstall failures if it wasn't already installed
+      }
+      console.log(`Installing @aliwey/bmo${ver}...`);
+      try {
+        execSync(`npm install -g @aliwey/bmo${ver}`, { stdio: 'inherit' });
+      } catch {
+        console.error('Update failed. Try manually: npm install -g @aliwey/bmo');
+        process.exit(1);
+      }
+      process.exit(0);
     }
-    process.exit(0);
   }
 
   // ── bmo init ──────────────────────────────────────────────────────────────

package/core/bmo_engine.py

@@ -12,7 +12,7 @@ from uuid import uuid4
 from datetime import datetime
 from typing import Optional, List, Dict, AsyncGenerator
 
-from config.settings import OPENCODE_BASE_URL, BFP_RELAY_URL, BFP_TRANSPORT_PORT, BFP_A2A_PORT
+from config.settings import OPENCODE_BASE_URL, BFP_RELAY_URL, BFP_TRANSPORT_PORT, BFP_A2A_PORT, OWNER_ID, ALLOWED_USER_IDS
 from core.bot_client import OpenCodeBotClient
 from core.worker_manager import WorkerManager
 from models.chat_models import ChatSession, ChatMessage
@@ -38,6 +38,7 @@ class BMOEngine:
             self.storage = SQLiteStorage(db_path=db_path)
         else:
             self.storage = get_storage()
+        self.storage.sync_session_groups(OWNER_ID, ALLOWED_USER_IDS)
         self.client = OpenCodeBotClient()
         self.worker_manager = WorkerManager(backend=worker_backend)
         self.client.set_worker_manager(self.worker_manager)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aliwey/bmo",
-  "version": "2.1.0",
+  "version": "2.1.2",
   "description": "BMO — AI coding assistant with Telegram, CLI & Web sync. One command, all frontends.",
   "keywords": ["ai", "coding-assistant", "telegram-bot", "cli", "opencode", "bfp"],
   "homepage": "https://github.com/aliwey/bmo",

package/scripts/bmo_init.js

@@ -13,6 +13,7 @@ const os = require('os');
 
 const BMO_HOME = process.env.BMO_HOME || path.join(os.homedir(), '.bmo');
 const ENV_PATH = path.join(BMO_HOME, '.env');
+const PKG_DIR = path.join(__dirname, '..');
 
 function mkdirp(p) { fs.mkdirSync(p, { recursive: true }); }
 
@@ -26,9 +27,9 @@ function ask(rl, question, defaultValue) {
 }
 
 (async () => {
-  console.log('\n╭───────────────────────────────────────────────────╮');
+  console.log('\n╭───────────────────────────────────────────╮');
   console.log('│            BMO Setup Wizard                       │');
-  console.log('╰───────────────────────────────────────────────────╯\n');
+  console.log('╰───────────────────────────────────────────╯\n');
 
   // Load existing .env values as defaults
   let existing = {};
@@ -38,7 +39,24 @@ function ask(rl, question, defaultValue) {
       const m = line.match(/^([^#=]+)=(.*)$/);
       if (m) existing[m[1].trim()] = m[2].trim();
     }
-    console.log(`  ℹ️  Existing config found at ${ENV_PATH} — press Enter to keep values.\n`);
+    console.log(`  [Info] Existing config found at ${ENV_PATH} — press Enter to keep values.\n`);
+  }
+
+  // Load existing memory.md values if available
+  let existing_name = '';
+  let existing_role = '';
+  let existing_preference = '';
+  const userMemoryPath = path.join(BMO_HOME, 'data', 'memory.md');
+  if (fs.existsSync(userMemoryPath)) {
+    try {
+      const memoryContent = fs.readFileSync(userMemoryPath, 'utf8');
+      const nameMatch = memoryContent.match(/-\s*Name:\s*(.*)/i);
+      const roleMatch = memoryContent.match(/-\s*Role:\s*(.*)/i);
+      const prefMatch = memoryContent.match(/-\s*Preference:\s*(.*)/i);
+      if (nameMatch && nameMatch[1].trim() !== '[Enter Name]') existing_name = nameMatch[1].trim();
+      if (roleMatch && roleMatch[1].trim() !== '[Enter Role]') existing_role = roleMatch[1].trim();
+      if (prefMatch && prefMatch[1].trim() !== '[Enter Preference]') existing_preference = prefMatch[1].trim();
+    } catch (e) {}
   }
 
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
@@ -73,6 +91,13 @@ function ask(rl, question, defaultValue) {
     existing.BFP_REGISTRY_URL || 'https://bfp-registry.aliwey.workers.dev'
   );
 
+  // ── User Profile ──────────────────────────────────────────────────────────────
+  console.log('\n── User Profile ─────────────────────────────────────');
+  console.log('  Provide details to personalize your BMO companion.');
+  const userName = await ask(rl, 'Your Name', existing_name || 'Developer');
+  const userRole = await ask(rl, 'Your Knowledge / Background Description', existing_role || 'Python/Web Developer');
+  const userPref = await ask(rl, 'What should BMO do / Where should BMO focus', existing_preference || 'Assist with software development, debugging, and task automation');
+
   rl.close();
 
   // ── Write .env ────────────────────────────────────────────────────────────────
@@ -106,8 +131,25 @@ function ask(rl, question, defaultValue) {
 
   fs.writeFileSync(ENV_PATH, envContent, 'utf8');
 
+  // ── Update memory.md ──────────────────────────────────────────────────────────
+  const packageMemoryPath = path.join(PKG_DIR, 'memory.md');
+
+  let memoryContent = '';
+  if (fs.existsSync(userMemoryPath)) {
+    memoryContent = fs.readFileSync(userMemoryPath, 'utf8');
+  } else if (fs.existsSync(packageMemoryPath)) {
+    memoryContent = fs.readFileSync(packageMemoryPath, 'utf8');
+  }
+
+  if (memoryContent) {
+    memoryContent = memoryContent.replace(/-\s*Name:\s*[^\r\n]*/i, `- Name: ${userName}`);
+    memoryContent = memoryContent.replace(/-\s*Role:\s*[^\r\n]*/i, `- Role: ${userRole}`);
+    memoryContent = memoryContent.replace(/-\s*Preference:\s*[^\r\n]*/i, `- Preference: ${userPref}`);
+    fs.writeFileSync(userMemoryPath, memoryContent, 'utf8');
+  }
+
   console.log('\n╭───────────────────────────────────────────────────╮');
-  console.log(`│  ✅ Config saved to ${ENV_PATH.padEnd(27)}│`);
+  console.log('│' + `  [OK] Config saved to ${ENV_PATH}`.padEnd(51) + '│');
   console.log('│                                                   │');
   console.log('│  Run:  bmo        ← start BMO                    │');
   console.log('│        bmo relay  ← go online for BFP discovery  │');

package/scripts/postinstall.js

@@ -53,9 +53,9 @@ const CF_URLS = {
 // ── Helpers ──────────────────────────────────────────────────────────────────
 
 const step = (n, msg) => console.log(`\n[${n}/5] ${msg}`);
-const ok   = msg => console.log(`  ✅ ${msg}`);
-const warn = msg => console.log(`  ⚠️  ${msg}`);
-const err  = msg => console.error(`  ❌ ${msg}`);
+const ok   = msg => console.log(`  [OK] ${msg}`);
+const warn = msg => console.log(`  [Warning] ${msg}`);
+const err  = msg => console.error(`  [Error] ${msg}`);
 
 function mkdirp(p) { fs.mkdirSync(p, { recursive: true }); }
 
@@ -250,16 +250,18 @@ function installWebchatDeps() {
     await installCloudflared();
     installWebchatDeps();
 
-    console.log('\n╭──────────────────────────────────────────╮');
-    console.log('│  ✅ BMO installed successfully!            │');
-    console.log('│                                          │');
-    console.log('│  Next step:                              │');
-    console.log('│    bmo init   ← configure your bot       │');
-    console.log('│    bmo        ← start BMO                │');
-    console.log('╰──────────────────────────────────────────╯\n');
+    console.log('\n╭───────────────────────────────────────────────────╮');
+    console.log('│  [OK] BMO installed successfully!                 │');
+    console.log('│                                                   │');
+    console.log('│  IMPORTANT: You must run the setup wizard first:  │');
+    console.log('│    bmo --init                                     │');
+    console.log('│                                                   │');
+    console.log('│  Then start BMO:                                  │');
+    console.log('│    bmo                                            │');
+    console.log('╰───────────────────────────────────────────────────╯\n');
   } catch (e) {
     err(`Installation failed: ${e.message}`);
-    console.log('\nRun `bmo init` to retry configuration, or check the docs.');
+    console.log('\nRun `bmo --init` to retry configuration, or check the docs.');
     process.exit(1);
   }
 })();

package/scripts/web_cmd.js

@@ -37,7 +37,7 @@ function getCloudflaredExe() {
     : path.join(BMO_BIN, 'cloudflared');
   if (fs.existsSync(embedded)) return embedded;
   try { execSync('cloudflared --version', { stdio: 'ignore' }); return 'cloudflared'; } catch {}
-  console.error('❌ cloudflared not found. Run: bmo init');
+  console.error('[Error] cloudflared not found. Run: bmo init');
   process.exit(1);
 }
 
@@ -70,7 +70,7 @@ function waitForTunnelUrl(proc) {
     const tasks = loadTasks();
     const existing = tasks.webchat_tunnel_url;
     if (existing) {
-      console.log(`\n💬 Webchat already running!`);
+      console.log(`\n[Info] Webchat already running!`);
       console.log(`   Local:  http://127.0.0.1:${WEBCHAT_PORT}`);
       console.log(`   Public: ${existing}\n`);
       process.exit(0);
@@ -78,11 +78,18 @@ function waitForTunnelUrl(proc) {
   }
 
   // Start webchat server
-  console.log('⏳ Starting webchat server...');
+  console.log('Starting webchat server...');
   const webchatDir = path.join(PKG_DIR, 'webchat');
+  
+  // Ensure logs directory exists
+  const logDir = path.join(BMO_HOME, 'logs');
+  fs.mkdirSync(logDir, { recursive: true });
+  const webchatLogPath = path.join(logDir, 'webchat.log');
+  const logStream = fs.openSync(webchatLogPath, 'a');
+
   const webchat = spawn('node', ['server.js'], {
     cwd: webchatDir,
-    stdio: 'ignore',
+    stdio: ['ignore', logStream, logStream],
     detached: true,
     env: {
       ...process.env,
@@ -94,15 +101,32 @@ function waitForTunnelUrl(proc) {
   webchat.unref();
 
   // Wait for webchat to be ready
+  let started = false;
   for (let i = 0; i < 20; i++) {
     await sleep(500);
-    if (await isPortOpen(WEBCHAT_PORT)) break;
-    if (i === 19) { console.error('❌ Webchat failed to start'); process.exit(1); }
+    if (await isPortOpen(WEBCHAT_PORT)) {
+      started = true;
+      break;
+    }
+  }
+
+  if (!started) {
+    console.error('[Error] Webchat failed to start');
+    try {
+      const logContent = fs.readFileSync(webchatLogPath, 'utf8').trim();
+      const lines = logContent.split('\n');
+      const lastLines = lines.slice(-15).join('\n');
+      console.error('\nLast log output:');
+      console.error(lastLines);
+    } catch (e) {
+      console.error('Could not read webchat log file.');
+    }
+    process.exit(1);
   }
-  console.log('✓ Webchat server running on port', WEBCHAT_PORT);
+  console.log('[OK] Webchat server running on port', WEBCHAT_PORT);
 
   // Start cloudflared tunnel
-  console.log('⏳ Starting cloudflared tunnel...');
+  console.log('Starting cloudflared tunnel...');
   const cfExe = getCloudflaredExe();
   const cf = spawn(cfExe, ['tunnel', '--url', `http://localhost:${WEBCHAT_PORT}`], {
     stdio: ['ignore', 'pipe', 'pipe'],
@@ -114,7 +138,7 @@ function waitForTunnelUrl(proc) {
   try {
     tunnelUrl = await waitForTunnelUrl(cf);
   } catch {
-    console.error('❌ Could not get tunnel URL from cloudflared');
+    console.error('[Error] Could not get tunnel URL from cloudflared');
     process.exit(1);
   }
 
@@ -127,7 +151,7 @@ function waitForTunnelUrl(proc) {
   saveTasks(tasks);
 
   console.log('\n╭────────────────────────────────────────────╮');
-  console.log('│  💬 BMO Webchat is live!                   │');
+  console.log('│  [OK] BMO Webchat is live!                 │');
   console.log(`│  Local:  http://127.0.0.1:${WEBCHAT_PORT}             │`);
   console.log(`│  Public: ${tunnelUrl.padEnd(34)} │`);
   console.log('╰────────────────────────────────────────────╯\n');

package/storage/sqlite_storage.py

@@ -117,6 +117,11 @@ class SQLiteStorage:
                 created_at REAL NOT NULL,
                 UNIQUE(user_id, scope)
             );
+
+            CREATE TABLE IF NOT EXISTS session_groups (
+                chat_id  INTEGER PRIMARY KEY,
+                group_id INTEGER NOT NULL
+            );
         """)
         conn.commit()
 
@@ -254,6 +259,22 @@ class SQLiteStorage:
         except Exception as e:
             print(f"_fix_active_sessions error: {e}")
 
+    # ── Session Groups ─────────────────────────────────────────────────────
+
+    def sync_session_groups(self, owner_id: int, allowed_ids: set[int]):
+        """Populate session_groups table from OWNER_ID + ALLOWED_USER_IDS config."""
+        if not owner_id and not allowed_ids:
+            return
+        group_id = owner_id or next(iter(allowed_ids))
+        ids_to_map = {owner_id} if owner_id else set()
+        ids_to_map.update(allowed_ids)
+        for cid in ids_to_map:
+            self._exec(
+                "INSERT OR REPLACE INTO session_groups (chat_id, group_id) VALUES (?, ?)",
+                (cid, group_id),
+            )
+        self._conn().commit()
+
     # ── Session CRUD ──────────────────────────────────────────────────────
 
     def save_session(self, session: ChatSession) -> bool:
@@ -292,16 +313,17 @@ class SQLiteStorage:
                 ),
             )
 
-            # Only set active session pointer if none exists yet for this chat.
+            # Only set active session pointer if none exists yet for this group.
             # This prevents save_session from overwriting a manual session switch.
+            group_id = self._resolve_group(session.chat_id)
             existing_active = self._fetchone(
                 "SELECT session_id FROM active_sessions WHERE chat_id = ?",
-                (session.chat_id,),
+                (group_id,),
             )
             if not existing_active:
                 self._exec(
                     "INSERT OR REPLACE INTO active_sessions (chat_id, session_id) VALUES (?, ?)",
-                    (session.chat_id, session.session_id),
+                    (group_id, session.session_id),
                 )
 
             self._conn().commit()
@@ -312,9 +334,10 @@ class SQLiteStorage:
 
     def load_session(self, chat_id: int) -> Optional[ChatSession]:
         try:
+            group_id = self._resolve_group(chat_id)
             active = self._fetchone(
                 "SELECT session_id FROM active_sessions WHERE chat_id = ?",
-                (chat_id,),
+                (group_id,),
             )
             session_id = active["session_id"] if active else None
 
@@ -326,14 +349,19 @@ class SQLiteStorage:
                     return self._row_to_session(row)
 
             candidates = self._fetchall(
-                "SELECT * FROM sessions WHERE chat_id = ? ORDER BY updated_at DESC LIMIT 1",
-                (chat_id,),
+                "SELECT s.* FROM sessions s JOIN session_groups sg ON s.chat_id = sg.chat_id WHERE sg.group_id = ? ORDER BY s.updated_at DESC LIMIT 1",
+                (group_id,),
             )
+            if not candidates:
+                candidates = self._fetchall(
+                    "SELECT * FROM sessions WHERE chat_id = ? ORDER BY updated_at DESC LIMIT 1",
+                    (chat_id,),
+                )
             if candidates:
                 row = candidates[0]
                 self._exec(
                     "INSERT OR REPLACE INTO active_sessions (chat_id, session_id) VALUES (?, ?)",
-                    (chat_id, dict(row)["id"]),
+                    (group_id, dict(row)["id"]),
                 )
                 self._conn().commit()
                 return self._row_to_session(row)
@@ -346,9 +374,10 @@ class SQLiteStorage:
     def set_active_session(self, chat_id: int, session_id: str) -> bool:
         """Explicitly switch the active session pointer for a chat."""
         try:
+            group_id = self._resolve_group(chat_id)
             self._exec(
                 "INSERT OR REPLACE INTO active_sessions (chat_id, session_id) VALUES (?, ?)",
-                (chat_id, session_id),
+                (group_id, session_id),
             )
             self._conn().commit()
             return True
@@ -358,9 +387,10 @@ class SQLiteStorage:
 
     def delete_session(self, chat_id: int) -> bool:
         try:
+            group_id = self._resolve_group(chat_id)
             active = self._fetchone(
                 "SELECT session_id FROM active_sessions WHERE chat_id = ?",
-                (chat_id,),
+                (group_id,),
             )
             if active:
                 self._exec("DELETE FROM messages WHERE session_id = ?", (active["session_id"],))
@@ -375,9 +405,10 @@ class SQLiteStorage:
     def add_message(self, chat_id: int, sender: str, content: str, interface: str = 'telegram') -> bool:
         """Insert a single message directly into DB without rewriting the whole session."""
         try:
+            group_id = self._resolve_group(chat_id)
             active = self._fetchone(
                 "SELECT session_id FROM active_sessions WHERE chat_id = ?",
-                (chat_id,),
+                (group_id,),
             )
             if not active:
                 return False
@@ -415,14 +446,26 @@ class SQLiteStorage:
         return [dict(r) for r in reversed(rows)]
 
     def list_chat_sessions(self, chat_id: int) -> List[dict]:
+        group_id = self._resolve_group(chat_id)
         rows = self._fetchall(
             """SELECT id, title, summary,
                       (SELECT COUNT(*) FROM messages WHERE session_id = sessions.id) as msg_count,
                       updated_at,
                       (SELECT session_id FROM active_sessions WHERE chat_id = ?) as active_id
-               FROM sessions WHERE chat_id = ? ORDER BY updated_at DESC""",
-            (chat_id, chat_id),
+               FROM sessions
+               WHERE chat_id IN (SELECT chat_id FROM session_groups WHERE group_id = ?)
+               ORDER BY updated_at DESC""",
+            (group_id, group_id),
         )
+        if not rows:
+            rows = self._fetchall(
+                """SELECT id, title, summary,
+                          (SELECT COUNT(*) FROM messages WHERE session_id = sessions.id) as msg_count,
+                          updated_at,
+                          (SELECT session_id FROM active_sessions WHERE chat_id = ?) as active_id
+                   FROM sessions WHERE chat_id = ? ORDER BY updated_at DESC""",
+                (group_id, chat_id),
+            )
         return [
             {
                 "session_id": r["id"],
@@ -441,9 +484,10 @@ class SQLiteStorage:
         )
         if not exists:
             return False
+        group_id = self._resolve_group(chat_id)
         self._exec(
             "INSERT OR REPLACE INTO active_sessions (chat_id, session_id) VALUES (?, ?)",
-            (chat_id, session_id),
+            (group_id, session_id),
         )
         self._conn().commit()
         return True
@@ -546,6 +590,13 @@ class SQLiteStorage:
             session_id=row_dict["id"],
         )
 
+    def _resolve_group(self, chat_id: int) -> int:
+        """Return the group_id for a chat_id, or chat_id itself if not in a group."""
+        row = self._fetchone(
+            "SELECT group_id FROM session_groups WHERE chat_id = ?", (chat_id,)
+        )
+        return row["group_id"] if row else chat_id
+
     def get_stats(self) -> dict:
         """Returns global statistics for the admin."""
         user_count = self._fetchone("SELECT COUNT(DISTINCT chat_id) FROM sessions")[0]