negotium 0.1.7 → 0.1.8

package/dist/runtime/src/storage/forum/repository.ts

@@ -0,0 +1,283 @@
+import { SESSION_AGENT } from "#platform/config";
+import { type AgentKind, isAgentKind } from "#types";
+import {
+  db,
+  type ForumTopicInfo,
+  logger,
+  rowToTopic,
+  type TopicRow,
+  type UserForumConfig,
+  type UserRow,
+} from "./schema";
+
+export function getUserConfig(userId: number): UserForumConfig | null {
+  const user = db.query<UserRow, string>("SELECT * FROM users WHERE id = ?").get(String(userId));
+  if (!user) return null;
+
+  const topicRows = db
+    .query<TopicRow, string>("SELECT * FROM topics WHERE user_id = ?")
+    .all(String(userId));
+  const topics: { [name: string]: ForumTopicInfo } = {};
+  for (const row of topicRows) topics[row.name] = rowToTopic(row);
+
+  return {
+    ...(user.dm_session_id && { dmSessionId: user.dm_session_id }),
+    ...(user.communicate_thread_id != null && { communicateThreadId: user.communicate_thread_id }),
+    topics,
+  };
+}
+
+export function getTopicByName(userId: number, name: string): ForumTopicInfo | null {
+  const row = db
+    .query<TopicRow, [string, string]>("SELECT * FROM topics WHERE user_id = ? AND name = ?")
+    .get(String(userId), name);
+  return row ? rowToTopic(row) : null;
+}
+
+export function findUserByThread(
+  threadId: number,
+): { userId: number; topic: ForumTopicInfo } | null {
+  const row = db
+    .query<TopicRow, number>("SELECT * FROM topics WHERE message_thread_id = ?")
+    .get(threadId);
+  if (!row) return null;
+  return { userId: Number(row.user_id), topic: rowToTopic(row) };
+}
+
+export function getSessionForTopic(userId: number, topicName: string): string | null {
+  const row = db
+    .query<{ session_id: string | null }, [string, string]>(
+      "SELECT session_id FROM topics WHERE user_id = ? AND name = ?",
+    )
+    .get(String(userId), topicName);
+  return row?.session_id || null;
+}
+
+export function getTopicNames(userId: number): string[] {
+  const rows = db
+    .query<{ name: string }, string>("SELECT name FROM topics WHERE user_id = ?")
+    .all(String(userId));
+  return rows.map((r) => r.name);
+}
+
+export function getAllTopics(userId: number): ForumTopicInfo[] {
+  const rows = db
+    .query<TopicRow, string>("SELECT * FROM topics WHERE user_id = ?")
+    .all(String(userId));
+  return rows.map(rowToTopic);
+}
+
+export function getAllUserIds(): number[] {
+  const rows = db.query<{ id: string }, []>("SELECT id FROM users").all();
+  return rows.map((r) => Number(r.id)).filter((n) => !Number.isNaN(n));
+}
+
+export function getCommunicateThreadId(userId: number): number | null {
+  const row = db
+    .query<{ communicate_thread_id: number | null }, string>(
+      "SELECT communicate_thread_id FROM users WHERE id = ?",
+    )
+    .get(String(userId));
+  return row?.communicate_thread_id ?? null;
+}
+
+export function getDmSessionId(userId: number): string | null {
+  const row = db
+    .query<{ dm_session_id: string | null }, string>("SELECT dm_session_id FROM users WHERE id = ?")
+    .get(String(userId));
+  return row?.dm_session_id ?? null;
+}
+
+export function getTopicDescription(userId: number, topicName: string): string | null {
+  const row = db
+    .query<{ description: string | null }, [string, string]>(
+      "SELECT description FROM topics WHERE user_id = ? AND name = ?",
+    )
+    .get(String(userId), topicName);
+  return row?.description || null;
+}
+
+export function getTopicMcpConfig(
+  userId: number,
+  topicName: string,
+): { enabled: string[] | null; extra: Record<string, unknown> } {
+  const row = db
+    .query<{ mcp_enabled: string | null; mcp_extra: string | null }, [string, string]>(
+      "SELECT mcp_enabled, mcp_extra FROM topics WHERE user_id = ? AND name = ?",
+    )
+    .get(String(userId), topicName);
+  let enabled: string[] | null = null;
+  let extra: Record<string, unknown> = {};
+  try {
+    if (row?.mcp_enabled) enabled = JSON.parse(row.mcp_enabled);
+  } catch (e) {
+    logger.warn({ err: e }, "getTopicMcpConfig: failed to parse mcp_enabled");
+  }
+  try {
+    if (row?.mcp_extra) extra = JSON.parse(row.mcp_extra);
+  } catch (e) {
+    logger.warn({ err: e }, "getTopicMcpConfig: failed to parse mcp_extra");
+  }
+  return { enabled, extra };
+}
+
+export function addTopic(
+  userId: number,
+  name: string,
+  messageThreadId: number,
+  sessionId?: string,
+  createdAt?: string,
+): boolean {
+  if (name.startsWith("__")) {
+    logger.warn({ name }, "addTopic: refusing reserved __ prefix");
+    return false;
+  }
+  db.query("INSERT OR IGNORE INTO users (id) VALUES (?)").run(String(userId));
+  db.query(`
+    INSERT INTO topics (user_id, name, message_thread_id, session_id, created_at, agent)
+    VALUES (?, ?, ?, ?, ?, ?)
+    ON CONFLICT(user_id, name) DO UPDATE SET
+      message_thread_id = excluded.message_thread_id,
+      session_id = COALESCE(excluded.session_id, topics.session_id),
+      created_at = excluded.created_at
+  `).run(
+    String(userId),
+    name,
+    messageThreadId,
+    sessionId ?? null,
+    createdAt ?? new Date().toISOString(),
+    SESSION_AGENT,
+  );
+  return true;
+}
+
+export function renameTopic(
+  userId: number,
+  oldName: string,
+  newName: string,
+): { ok: true } | { ok: false; reason: "not_found" | "name_taken" } {
+  if (oldName === newName) return { ok: true };
+  if (getTopicByName(userId, newName)) return { ok: false, reason: "name_taken" };
+  const result = db
+    .prepare("UPDATE topics SET name = ? WHERE user_id = ? AND name = ?")
+    .run(newName, String(userId), oldName);
+  if (result.changes === 0) return { ok: false, reason: "not_found" };
+  return { ok: true };
+}
+
+export function removeTopic(userId: number, name: string) {
+  db.query("DELETE FROM topics WHERE user_id = ? AND name = ?").run(String(userId), name);
+}
+
+export function setSessionForTopic(userId: number, topicName: string, sessionId: string) {
+  db.query("UPDATE topics SET session_id = ? WHERE user_id = ? AND name = ?").run(
+    sessionId,
+    String(userId),
+    topicName,
+  );
+}
+
+export function clearSessionForTopic(userId: number, topicName: string) {
+  db.query("UPDATE topics SET session_id = NULL WHERE user_id = ? AND name = ?").run(
+    String(userId),
+    topicName,
+  );
+}
+
+export function setDmSessionId(userId: number, sessionId: string) {
+  db.query(`
+    INSERT INTO users (id, dm_session_id) VALUES (?, ?)
+    ON CONFLICT(id) DO UPDATE SET dm_session_id = excluded.dm_session_id
+  `).run(String(userId), sessionId);
+}
+
+export function clearDmSessionId(userId: number) {
+  db.query("UPDATE users SET dm_session_id = NULL WHERE id = ?").run(String(userId));
+}
+
+export function setTopicDescription(
+  userId: number,
+  topicName: string,
+  description: string,
+): boolean {
+  const result = db
+    .query("UPDATE topics SET description = ? WHERE user_id = ? AND name = ?")
+    .run(description, String(userId), topicName);
+  return result.changes > 0;
+}
+
+export function getLastShownConfig(
+  userId: number,
+  topicName: string,
+): { agent: AgentKind | null; model: string | null; effort: string | null } | null {
+  type LastShownRow = {
+    last_shown_agent: string | null;
+    last_shown_model: string | null;
+    last_shown_effort: string | null;
+  };
+  const row = db
+    .query<LastShownRow, [string, string]>(
+      "SELECT last_shown_agent, last_shown_model, last_shown_effort FROM topics WHERE user_id = ? AND name = ?",
+    )
+    .get(String(userId), topicName);
+  if (!row) return null;
+  const agent =
+    row.last_shown_agent && isAgentKind(row.last_shown_agent) ? row.last_shown_agent : null;
+  return { agent, model: row.last_shown_model, effort: row.last_shown_effort };
+}
+
+export function setLastShownConfig(
+  userId: number,
+  topicName: string,
+  agent: AgentKind,
+  model: string,
+  effort: string | undefined,
+): boolean {
+  const result = db
+    .query(
+      "UPDATE topics SET last_shown_agent = ?, last_shown_model = ?, last_shown_effort = ? WHERE user_id = ? AND name = ?",
+    )
+    .run(agent, model, effort ?? null, String(userId), topicName);
+  return result.changes > 0;
+}
+
+export function setTopicForkOrigin(userId: number, topicName: string, origin: string): boolean {
+  const result = db
+    .query("UPDATE topics SET fork_origin = ? WHERE user_id = ? AND name = ?")
+    .run(origin, String(userId), topicName);
+  return result.changes > 0;
+}
+
+export function updateTopicThreadId(
+  userId: number,
+  topicName: string,
+  newThreadId: number,
+): boolean {
+  const result = db
+    .query("UPDATE topics SET message_thread_id = ? WHERE user_id = ? AND name = ?")
+    .run(newThreadId, String(userId), topicName);
+  return result.changes > 0;
+}
+
+export function setTopicMcpEnabled(
+  userId: number,
+  topicName: string,
+  enabled: string[] | null,
+): boolean {
+  const value = enabled !== null ? JSON.stringify(enabled) : null;
+  const result = db
+    .query("UPDATE topics SET mcp_enabled = ? WHERE user_id = ? AND name = ?")
+    .run(value, String(userId), topicName);
+  return result.changes > 0;
+}
+
+export function setTopicMcpExtra(
+  userId: number,
+  topicName: string,
+  extra: Record<string, unknown>,
+): boolean {
+  const result = db
+    .query("UPDATE topics SET mcp_extra = ? WHERE user_id = ? AND name = ?")
+    .run(JSON.stringify(extra), String(userId), topicName);
+  return result.changes > 0;
+}

package/dist/runtime/src/storage/forum/schema.ts

@@ -0,0 +1,300 @@
+import { errMsg } from "#platform/error";
+import { logger } from "#platform/logger";
+import { db } from "#storage/forum-db";
+import { type AgentKind, isAgentKind } from "#types";
+
+export { db };
+
+export interface ForumTopicInfo {
+  messageThreadId: number;
+  sessionId: string;
+  createdAt: string;
+  name: string;
+  description?: string;
+  forkOrigin?: string;
+  agent: AgentKind;
+}
+
+export interface UserForumConfig {
+  communicateThreadId?: number;
+  dmSessionId?: string;
+  topics: { [topicName: string]: ForumTopicInfo };
+}
+
+export type TopicRow = {
+  user_id: string;
+  name: string;
+  message_thread_id: number;
+  session_id: string | null;
+  created_at: string;
+  description: string | null;
+  fork_origin: string | null;
+  agent: string | null;
+};
+
+export type UserRow = {
+  id: string;
+  dm_session_id: string | null;
+  communicate_thread_id: number | null;
+};
+
+db.exec(`
+  CREATE TABLE IF NOT EXISTS users (
+    id TEXT PRIMARY KEY,
+    dm_session_id TEXT,
+    communicate_thread_id INTEGER
+  );
+
+  CREATE TABLE IF NOT EXISTS topics (
+    user_id TEXT NOT NULL REFERENCES users(id),
+    name TEXT NOT NULL,
+    message_thread_id INTEGER NOT NULL,
+    session_id TEXT,
+    created_at TEXT NOT NULL,
+    description TEXT,
+    fork_origin TEXT,
+    agent TEXT NOT NULL DEFAULT 'claude',
+    mcp_enabled TEXT,
+    mcp_extra TEXT,
+    last_shown_model TEXT,
+    last_shown_effort TEXT,
+    last_shown_agent TEXT,
+    PRIMARY KEY (user_id, name),
+    UNIQUE (user_id, message_thread_id)
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_topics_lookup ON topics(user_id, message_thread_id);
+`);
+
+function tryMigrate(sql: string, expectedMsg?: string): void {
+  try {
+    db.exec(sql);
+  } catch (e) {
+    if (expectedMsg && errMsg(e).includes(expectedMsg)) return;
+    logger.error({ err: e, sql }, "DB migration failed");
+    throw e;
+  }
+}
+
+type SqlValue = string | number | bigint | boolean | null | Uint8Array;
+
+function sqlValue(value: unknown): SqlValue {
+  if (value === undefined || value === null) return null;
+  if (
+    typeof value === "string" ||
+    typeof value === "number" ||
+    typeof value === "bigint" ||
+    typeof value === "boolean"
+  ) {
+    return value;
+  }
+  if (value instanceof Uint8Array) return value;
+  return String(value);
+}
+
+function columnExists(table: string, column: string): boolean {
+  return db
+    .query<{ name: string }, []>(`PRAGMA table_info(${table})`)
+    .all()
+    .some((c) => c.name === column);
+}
+
+function tableSql(table: string): string | null {
+  return (
+    db
+      .query<{ sql: string }, string>(
+        "SELECT sql FROM sqlite_master WHERE type = 'table' AND name = ?",
+      )
+      .get(table)?.sql ?? null
+  );
+}
+
+function dropColumnIfExists(table: string, column: string): void {
+  if (columnExists(table, column)) {
+    tryMigrate(`ALTER TABLE ${table} DROP COLUMN ${column}`);
+  }
+}
+
+function topicTableNeedsRebuild(): boolean {
+  const sql = tableSql("topics");
+  if (!sql) return false;
+  const cols = db.query<{ name: string }, []>("PRAGMA table_info(topics)").all();
+  const names = new Set(cols.map((c) => c.name));
+  return (
+    names.has("forum_group_id") ||
+    names.has("system_prompt_extra") ||
+    names.has("model") ||
+    names.has("effort") ||
+    names.has("model_pinned") ||
+    names.has("effort_pinned") ||
+    names.has("memory_files") ||
+    names.has("memory_summary") ||
+    names.has("privacy_mode") ||
+    names.has("advisor_enabled") ||
+    names.has("agent_settings") ||
+    !/PRIMARY KEY \(\s*user_id\s*,\s*name\s*\)/i.test(sql)
+  );
+}
+
+function normalizeStoredAgent(value: unknown): AgentKind {
+  if (isAgentKind(value)) return value;
+  if (value === "hermes" || value === "alpha") return "maestro";
+  return "claude";
+}
+
+function rebuildTopicsTableIfNeeded(): void {
+  if (!topicTableNeedsRebuild()) return;
+
+  const cols = db.query<{ name: string }, []>("PRAGMA table_info(topics)").all();
+  const has = new Set(cols.map((c) => c.name));
+  const pick = (row: Record<string, unknown>, column: string, fallback: unknown = null) =>
+    has.has(column) ? (row[column] ?? fallback) : fallback;
+  const descriptionFor = (row: Record<string, unknown>) =>
+    pick(row, "description", pick(row, "system_prompt_extra", null));
+
+  const rows = db
+    .query<Record<string, unknown>, []>("SELECT rowid AS __rowid, * FROM topics")
+    .all()
+    .sort((a, b) => {
+      const aCreated = String(pick(a, "created_at", ""));
+      const bCreated = String(pick(b, "created_at", ""));
+      const byDate = bCreated.localeCompare(aCreated);
+      if (byDate !== 0) return byDate;
+      return Number(b.__rowid ?? 0) - Number(a.__rowid ?? 0);
+    });
+
+  const previousForeignKeys = db
+    .query<{ foreign_keys: number }, []>("PRAGMA foreign_keys")
+    .get()?.foreign_keys;
+  db.exec("PRAGMA foreign_keys = OFF");
+  try {
+    db.transaction(() => {
+      db.exec("DROP TABLE IF EXISTS topics_new");
+      db.exec(`
+        CREATE TABLE topics_new (
+          user_id TEXT NOT NULL REFERENCES users(id),
+          name TEXT NOT NULL,
+          message_thread_id INTEGER NOT NULL,
+          session_id TEXT,
+          created_at TEXT NOT NULL,
+          description TEXT,
+          fork_origin TEXT,
+          agent TEXT NOT NULL DEFAULT 'claude',
+          mcp_enabled TEXT,
+          mcp_extra TEXT,
+          last_shown_model TEXT,
+          last_shown_effort TEXT,
+          last_shown_agent TEXT,
+          PRIMARY KEY (user_id, name),
+          UNIQUE (user_id, message_thread_id)
+        )
+      `);
+
+      const insert = db.query(`
+        INSERT OR IGNORE INTO topics_new
+          (user_id, name, message_thread_id, session_id, created_at, description,
+           fork_origin, agent, mcp_enabled, mcp_extra, last_shown_model,
+           last_shown_effort, last_shown_agent)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `);
+      let inserted = 0;
+      const fallbackCreatedAt = new Date().toISOString();
+      for (const row of rows) {
+        const result = insert.run(
+          String(pick(row, "user_id", "")),
+          String(pick(row, "name", "")),
+          Number(pick(row, "message_thread_id", 0)),
+          sqlValue(pick(row, "session_id", null)),
+          String(pick(row, "created_at", fallbackCreatedAt)),
+          sqlValue(descriptionFor(row)),
+          sqlValue(pick(row, "fork_origin", null)),
+          normalizeStoredAgent(pick(row, "agent", "claude")),
+          sqlValue(pick(row, "mcp_enabled", null)),
+          sqlValue(pick(row, "mcp_extra", null)),
+          sqlValue(pick(row, "last_shown_model", null)),
+          sqlValue(pick(row, "last_shown_effort", null)),
+          sqlValue(pick(row, "last_shown_agent", null)),
+        );
+        if (Number(result.changes ?? 0) > 0) inserted += 1;
+      }
+
+      db.exec("DROP TABLE topics");
+      db.exec("ALTER TABLE topics_new RENAME TO topics");
+      db.exec("CREATE INDEX IF NOT EXISTS idx_topics_lookup ON topics(user_id, message_thread_id)");
+      logger.info(
+        { migrated: inserted, skippedConflicts: rows.length - inserted },
+        "topics schema migrated to current user-scoped schema",
+      );
+    })();
+  } finally {
+    db.exec(`PRAGMA foreign_keys = ${previousForeignKeys ? "ON" : "OFF"}`);
+  }
+}
+
+rebuildTopicsTableIfNeeded();
+
+tryMigrate("ALTER TABLE topics ADD COLUMN fork_origin TEXT", "duplicate column");
+tryMigrate(
+  "ALTER TABLE topics ADD COLUMN agent TEXT NOT NULL DEFAULT 'claude'",
+  "duplicate column",
+);
+tryMigrate("ALTER TABLE topics ADD COLUMN mcp_enabled TEXT", "duplicate column");
+tryMigrate("ALTER TABLE topics ADD COLUMN mcp_extra TEXT", "duplicate column");
+tryMigrate("ALTER TABLE topics ADD COLUMN last_shown_model TEXT", "duplicate column");
+tryMigrate("ALTER TABLE topics ADD COLUMN last_shown_effort TEXT", "duplicate column");
+tryMigrate("ALTER TABLE topics ADD COLUMN last_shown_agent TEXT", "duplicate column");
+
+for (const column of ["privacy_mode", "advisor_enabled", "agent_settings"]) {
+  dropColumnIfExists("topics", column);
+}
+dropColumnIfExists("users", "manager_session_id");
+
+tryMigrate("DROP INDEX idx_topics_lookup", "no such index");
+tryMigrate("CREATE INDEX IF NOT EXISTS idx_topics_lookup ON topics(user_id, message_thread_id)");
+
+function assertColumn(table: string, column: string): void {
+  if (!columnExists(table, column)) {
+    throw new Error(`Schema migration failed: ${table}.${column} is missing`);
+  }
+}
+
+for (const column of ["id", "dm_session_id", "communicate_thread_id"]) {
+  assertColumn("users", column);
+}
+for (const column of [
+  "user_id",
+  "name",
+  "message_thread_id",
+  "session_id",
+  "created_at",
+  "description",
+  "fork_origin",
+  "agent",
+  "mcp_enabled",
+  "mcp_extra",
+  "last_shown_model",
+  "last_shown_effort",
+  "last_shown_agent",
+]) {
+  assertColumn("topics", column);
+}
+
+export function rowToTopic(row: TopicRow): ForumTopicInfo {
+  if (!isAgentKind(row.agent)) throw new Error(`Invalid agent in DB: ${row.agent}`);
+  const agent: AgentKind = row.agent;
+  return {
+    messageThreadId: row.message_thread_id,
+    sessionId: row.session_id ?? "",
+    createdAt: row.created_at,
+    name: row.name,
+    agent,
+    ...(row.description && { description: row.description }),
+    ...(row.fork_origin && { forkOrigin: row.fork_origin }),
+  };
+}
+
+export function flushSessionCache() {
+  db.close();
+}
+
+export { logger };

package/dist/runtime/src/storage/forum-db.ts

@@ -0,0 +1,23 @@
+import { mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import { SESSIONS_DB } from "#platform/config";
+import { Database } from "#storage/sqlite";
+
+mkdirSync(dirname(SESSIONS_DB), { recursive: true });
+
+export const db = new Database(SESSIONS_DB, { create: true });
+db.exec("PRAGMA journal_mode = WAL");
+db.exec("PRAGMA foreign_keys = ON");
+db.exec("PRAGMA busy_timeout = 5000");
+// Auto-checkpoint every ~1000 WAL pages (~4 MB at 4KB page size) to keep the
+// WAL file from growing unbounded during long-running pm2 sessions. The
+// default is 1000 but we set it explicitly so the policy is auditable.
+db.exec("PRAGMA wal_autocheckpoint = 1000");
+// Also run a TRUNCATE checkpoint on startup to reclaim any WAL space
+// accumulated while the bot was stopped (checkpointer doesn't run when
+// no connections are open).
+try {
+  db.exec("PRAGMA wal_checkpoint(TRUNCATE)");
+} catch {
+  // Non-fatal; a concurrent writer may hold the WAL briefly.
+}