@aliwey/bmo 2.0.9 → 2.1.1

package/bin/bmo.js

@@ -209,6 +209,18 @@ Data lives in: ${BMO_HOME_DISPLAY}
     process.on('SIGTERM', () => { cleanup(); process.exit(0); });
   }
 
+  // Copy generic memory.md template if it does not exist
+  const packageMemoryPath = path.join(PKG_DIR, 'memory.md');
+  const userMemoryPath = path.join(BMO_HOME, 'data', 'memory.md');
+  if (fs.existsSync(packageMemoryPath) && !fs.existsSync(userMemoryPath)) {
+    try {
+      fs.mkdirSync(path.dirname(userMemoryPath), { recursive: true });
+      fs.copyFileSync(packageMemoryPath, userMemoryPath);
+    } catch (e) {
+      console.error(`Warning: Failed to copy memory.md template: ${e.message}`);
+    }
+  }
+
   // Launch BMO Python CLI — exactly like running `python cli.py`
   const python = getPython();
   const cliScript = path.join(PKG_DIR, 'cli.py');

package/config/settings.py

@@ -78,6 +78,7 @@ SESSIONS_FILE = DATA_DIR / "sessions.jsonl"
 USER_MEMORY_FILE = DATA_DIR / "user_memory.json"
 ACTIVE_SESSIONS_FILE = DATA_DIR / "active_sessions.json"
 DATABASE_FILE = DATA_DIR / "bot.db"
+MEMORY_FILE = DATA_DIR / "memory.md"
 
 MAX_HISTORY_PER_CHAT = 500
 MAX_CONTEXT_LENGTH = 32000

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/core/bot_client.py

@@ -14,7 +14,7 @@ from typing import Optional, Callable
 
 from core.worker_manager import WorkerManager
 
-from config.settings import OPENCODE_BASE_URL, OPENCODE_TIMEOUT, OPENCODE_POLL_INTERVAL, OPENCODE_POLL_TIMEOUT
+from config.settings import OPENCODE_BASE_URL, OPENCODE_TIMEOUT, OPENCODE_POLL_INTERVAL, OPENCODE_POLL_TIMEOUT, MEMORY_FILE
 
 logger = logging.getLogger(__name__)
 
@@ -46,7 +46,7 @@ class OpenCodeBotClient:
         self._memory_cache_time: float = 0
         self._agents_cache: Optional[list] = None
         self._agents_cache_time: float = 0
-        self._memory_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "data", "memory.md"))
+        self._memory_path = str(MEMORY_FILE)
         self._worker: Optional[WorkerManager] = None
 
     def set_worker_manager(self, worker: WorkerManager):

package/memory.md

@@ -1,43 +1,28 @@
 # BMO Core Profile
 
+This file contains the essential identity and core preferences of the USER and BMO.
+Detailed technical experiences are stored separately in the Knowledge Vault (`data/experience/`).
+
 ## User Profile
 
-- Name: Aliwey
-- Role: Developer / System Owner
-- Preference: Direct and expert-level communication.
+- Name: [Enter Name]
+- Role: [Enter Role]
+- Preference: [Enter Preference]
+- Arch: BMO is PORTABLE — each person runs their own instance on their device.
+  The Telegram bot lives on the owner's device. The owner uses both CLI and Telegram
+  to talk to their BMO. Other ALLOWED_USER_IDS can be added to connect via Telegram.
+  Session sync is between CLI ↔ Telegram on the SAME device for the SAME user(s).
+  ALLOWED_USER_IDS + OWNER_ID form a session group — they share one global active session.
+  Users outside the group get isolated sessions.
 
 ## Learned Preferences
 
-- Language: English only (never respond in Arabic).
-- Communication: Concise, professional, and autonomous.
-- Telegram Format: **Markdown** (integrated with CLI markdown output) — Telegram wire format uses MarkdownV2 parse mode, converted from standard markdown at send-time
-- Project: BMO Telegram Bot (OpenCode Ecosystem).
+- Language: English
+- Communication: Concise and professional.
 
 ## Knowledge Index
 
 This index summarizes technical achievements stored in `data/experience/`. BMO should read these files to reuse past solutions.
 
-- **bmo_rebranding.md**: Full identity migration from NOVA to BMO (Core, Handlers, Web UI).
-- **auto_summarization.md**: Implementation of idle-triggered session summaries with database persistence.
-- **file_archival_system.md**: Session-linked file detection, copy, and indexing logic.
-- **excel_inventory_automation.md**: Creation of multi-sheet Excel workbooks with cross-references for store management.
-- **inline_menu_sessions.md**: Inline keyboard menu system with session history pagination and loading.
-- **model_switching.md**: Model change with full session continuity — clears OpenCode session ID, creates fresh backend, injects SQLite history as context.
-- **auto_title_summary.md**: Auto-summary now generates both summary + title after inactivity; new user guidance in system prompt to explain keyboard buttons.
-- **webchat_public_default.md**: Webchat is always public — start server + cloudflared tunnel automatically. Never localhost-only unless user explicitly requests it. Full workflow: start_web_task → tunnel_webchat → wait 15s → check_task_status → send URL.
-- **background_task_registry.md**: Full background task management system with JSON registry, MCP tools (start_web_task, list_background_tasks, check_task_status, stop_background_task, tunnel_webchat), auto-cleanup of dead processes, port conflict detection, and centralized logging. Prevents all bot freezing from servers/tunnels.
-- **soft_new_session.md**: `/new` rewritten with Claude Code-style soft-reset — wipes model context via `delete_messages` but preserves `opencode_session_id` for warm system-prompt cache. Inherits provider/model/agent/mode from old session. Fixes 60s+ first-token latency on every `/new`.
-- **cli_hang_timeout.md**: Fixed 20-min CLI hang — lowered `OPENCODE_TIMEOUT` 1200→120, wrapped `_do_send` POST in `asyncio.wait_for`, installed real OS-level `signal.SIGINT` handler in `cli.py` so Ctrl+C cancels the active streaming task even inside `rich.Live` + `prompt_toolkit.patch_stdout(raw=True)`.
-- **cli_worker_kill.md**: Full worker-subprocess Ctrl+C fix — added `cancel_current()` to both `AsyncSubprocessWorker` and `MultiprocessWorker` + `WorkerManager` facade, SIGINT handler now kills the subprocess via `asyncio.run_coroutine_threadsafe(worker.cancel_current(), loop)` BEFORE cancelling the asyncio task (shielded futures would otherwise block propagation). `ensure_worker` checks `is_alive` so cancelled workers respawn on next request. Timeouts set to 900s (15 min) for reasoning-heavy tasks.
-- **name_correction.md**: Fixed stale `Aliwi` → `Aliwey` in both profile files (`memory.md` + `data/memory.md`); reminder that the profile lives in two synced locations.
-- **cli_exit_unclosed_transport.md**: Fixed `/exit` dumping 4 `ValueError: I/O operation on closed pipe` warnings. CLI disabled worker (`client._worker = None`) but `ensure_worker()` still spawned a stranded subprocess. Three-layer fix: skip worker start when client disables it + properly close pipe transports in `shutdown()` + post-loop cleanup in `cli.py`.
-- **telegram_markdown_integration.md**: User preference flip — Telegram now uses Markdown (MarkdownV2 on the wire) integrated with CLI markdown output. Old HTML parser path must be replaced by a `to_markdown_v2()` converter + chunker. `_clean_telegram_html` is obsolete.
-- **portable_distribution.md**: Made BMO distributable — each user runs their own instance. Configurable `OWNER_ID`, generic memory.md templates, path-agnostic build script, setup wizard with owner ID prompt, stripped all personal/dev artifacts, port 4800 default.
-- **cli_spinner_inplace_update.md**: Fixed thinking-counter leaving a vertical trail of past values on screen. `rich.Console.print(..., end="")` does NOT honor `\r` — switched the tick update to `sys.stdout.write + flush` with manual ANSI dim codes, and clear the partial line on completion.
-- **bfp_protocol.md**: BFP (BMO Friendship Protocol) — DID-based identity, A2A-compatible Agent Cards, WebSocket transport, relay discovery, and enterprise A2A bridge. BMO is the reference implementation.
-- **bfp_integration_fix.md**: Fixed 3 critical bugs from parallel subagent isolation: A2A bridge sync/async mismatch calling `send_message()` with wrong args, `bfp.delegate` returning fake stubs. Extracted shared `core/bfp_tasks.py` module used by both transport and A2A bridge. 13 passing tests.
-- **bfp_user_facing.md**: Discovery module (`bfp_discovery.py`), relay WS connector (`bfp_connector.py`), relay WS DID mapping + peer forwarding, CLI `/bfp status/find/delegate/talk` commands, `BFP_RELAY_URL` env var. Relay WS forwarding architecture: `send` action creates pending future, forwards to target's WS, awaits `relay_response`, returns result. All 20 BFP tests pass.
-- **bfp_websocket_http_graceful.md**: Fixed `InvalidUpgrade: Keep-Alive` traceback when HTTP requests hit the BFP WebSocket port 8765. Added `_process_request` callback to `ws_serve()` that returns a 426 "Upgrade Required" response for non-WebSocket connections instead of letting the library crash.
-
 ---
 *BMO: Always update this index after adding a new file to the vault.*

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aliwey/bmo",
-  "version": "2.0.9",
+  "version": "2.1.1",
   "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/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]