mojulo 0.0.0 → 0.1.1

package/lib/db/index.js

@@ -0,0 +1,179 @@
+import Database from 'better-sqlite3';
+import fs from 'fs';
+import path from 'path';
+
+const DB_PATH = process.env.SQLITE_PATH || path.join(process.cwd(), 'data', 'mojulo-lite.db');
+
+let _db = null;
+
+function init(db) {
+  db.pragma('journal_mode = WAL');
+  db.pragma('foreign_keys = ON');
+
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS api_keys (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      provider TEXT NOT NULL,
+      encrypted_key TEXT NOT NULL,
+      is_default INTEGER NOT NULL DEFAULT 0,
+      created_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS documents (
+      id TEXT PRIMARY KEY,
+      original_name TEXT NOT NULL,
+      mime_type TEXT NOT NULL,
+      size_bytes INTEGER NOT NULL,
+      storage_path TEXT NOT NULL,
+      parsed_text TEXT,
+      created_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS deployments (
+      id TEXT PRIMARY KEY,
+      bot_name TEXT NOT NULL,
+      flow_type TEXT NOT NULL,
+      status TEXT NOT NULL,
+      config TEXT NOT NULL,
+      config_hash TEXT,
+      last_built_hash TEXT,
+      artifact_path TEXT,
+      document_ids TEXT,
+      api_key TEXT NOT NULL,
+      error TEXT,
+      url TEXT,
+      last_seen_at INTEGER,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS modular_sessions (
+      id TEXT PRIMARY KEY,
+      status TEXT NOT NULL,
+      preloaded_context TEXT,
+      messages TEXT,
+      inferred_intent TEXT,
+      intent_confidence REAL,
+      recommended_protocols TEXT,
+      enabled_protocols TEXT,
+      core_config TEXT,
+      identity_config TEXT,
+      protocol_data TEXT,
+      generated_configs TEXT,
+      deployment_id TEXT,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS mcp_jobs (
+      id TEXT PRIMARY KEY,
+      tool TEXT NOT NULL,
+      status TEXT NOT NULL,
+      progress INTEGER,
+      result TEXT,
+      error TEXT,
+      mcp_session_id TEXT,
+      builder_session_id TEXT,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_mcp_jobs_created_at ON mcp_jobs(created_at);
+  `);
+
+  migrateDeploymentColumns(db);
+  reapStaleMcpJobs(db);
+}
+
+function reapStaleMcpJobs(db) {
+  // Job runner is in-process; a control-plane restart kills running jobs.
+  // Mark anything still in pending / running as errored on startup so
+  // clients polling stale jobIds get a clear failure instead of an
+  // indefinite "pending" state.
+  db.prepare(
+    `UPDATE mcp_jobs
+     SET status = 'error', error = COALESCE(error, 'Control plane restarted while job was in flight'), updated_at = ?
+     WHERE status IN ('pending', 'running')`
+  ).run(Date.now());
+}
+
+function migrateDeploymentColumns(db) {
+  const cols = db.prepare('PRAGMA table_info(deployments)').all();
+  const have = new Set(cols.map((c) => c.name));
+  if (!have.has('config_hash')) {
+    db.exec('ALTER TABLE deployments ADD COLUMN config_hash TEXT');
+  }
+  if (!have.has('last_built_hash')) {
+    db.exec('ALTER TABLE deployments ADD COLUMN last_built_hash TEXT');
+  }
+  if (!have.has('url')) {
+    db.exec('ALTER TABLE deployments ADD COLUMN url TEXT');
+  }
+  if (!have.has('last_seen_at')) {
+    db.exec('ALTER TABLE deployments ADD COLUMN last_seen_at INTEGER');
+  }
+  // Vector RAG: per-deployment embeddings live alongside the row. No separate
+  // table — embeddings are 1:1 with deployments and ride the same lifecycle.
+  if (!have.has('rag_mode')) {
+    db.exec("ALTER TABLE deployments ADD COLUMN rag_mode TEXT NOT NULL DEFAULT 'keyword'");
+  }
+  if (!have.has('embedding_storage_key')) {
+    db.exec('ALTER TABLE deployments ADD COLUMN embedding_storage_key TEXT');
+  }
+  if (!have.has('embedding_model')) {
+    db.exec('ALTER TABLE deployments ADD COLUMN embedding_model TEXT');
+  }
+  if (!have.has('embedding_chunk_count')) {
+    db.exec('ALTER TABLE deployments ADD COLUMN embedding_chunk_count INTEGER');
+  }
+  // Cloud deploy state. Cloud orchestration runs the published GHCR image on
+  // a remote provider (Fly.io first) using user-supplied credentials. The
+  // existing artifact-build state above is independent: cloud deploys reuse
+  // the staged config files but don't replace the local-ZIP path.
+  if (!have.has('cloud_provider')) {
+    db.exec('ALTER TABLE deployments ADD COLUMN cloud_provider TEXT');
+  }
+  if (!have.has('cloud_app_name')) {
+    db.exec('ALTER TABLE deployments ADD COLUMN cloud_app_name TEXT');
+  }
+  if (!have.has('cloud_status')) {
+    db.exec('ALTER TABLE deployments ADD COLUMN cloud_status TEXT');
+  }
+  if (!have.has('cloud_url')) {
+    db.exec('ALTER TABLE deployments ADD COLUMN cloud_url TEXT');
+  }
+  if (!have.has('cloud_progress')) {
+    db.exec('ALTER TABLE deployments ADD COLUMN cloud_progress TEXT');
+  }
+  if (!have.has('cloud_options')) {
+    db.exec('ALTER TABLE deployments ADD COLUMN cloud_options TEXT');
+  }
+  if (!have.has('cloud_error')) {
+    db.exec('ALTER TABLE deployments ADD COLUMN cloud_error TEXT');
+  }
+  if (!have.has('cloud_last_deployed_at')) {
+    db.exec('ALTER TABLE deployments ADD COLUMN cloud_last_deployed_at INTEGER');
+  }
+  if (!have.has('cloud_machine_id')) {
+    db.exec('ALTER TABLE deployments ADD COLUMN cloud_machine_id TEXT');
+  }
+  if (!have.has('cloud_volume_id')) {
+    db.exec('ALTER TABLE deployments ADD COLUMN cloud_volume_id TEXT');
+  }
+}
+
+export function getDb() {
+  if (_db) return _db;
+  const dir = path.dirname(DB_PATH);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  _db = new Database(DB_PATH);
+  init(_db);
+  return _db;
+}
+
+export function closeDb() {
+  if (_db) {
+    _db.close();
+    _db = null;
+  }
+}

package/lib/db/repositories/apiKeys.js

@@ -0,0 +1,72 @@
+import { getDb } from '../index.js';
+import { newId } from '../ids.js';
+
+function rowToApiKey(row) {
+  if (!row) return null;
+  return {
+    id: row.id,
+    name: row.name,
+    provider: row.provider,
+    encryptedKey: row.encrypted_key,
+    isDefault: row.is_default === 1,
+    createdAt: new Date(row.created_at),
+  };
+}
+
+export const ApiKeyRepository = {
+  async findByUserId(_userId) {
+    // Single-user mode: ignore userId and return all keys
+    const db = getDb();
+    const rows = db.prepare('SELECT * FROM api_keys ORDER BY is_default DESC, created_at ASC').all();
+    return rows.map(rowToApiKey);
+  },
+
+  async findById(id) {
+    const db = getDb();
+    const row = db.prepare('SELECT * FROM api_keys WHERE id = ?').get(id);
+    return rowToApiKey(row);
+  },
+
+  async findDefault() {
+    const db = getDb();
+    const row = db.prepare('SELECT * FROM api_keys WHERE is_default = 1 LIMIT 1').get();
+    return rowToApiKey(row);
+  },
+
+  async findByProvider(provider) {
+    const db = getDb();
+    const row = db
+      .prepare('SELECT * FROM api_keys WHERE provider = ? ORDER BY is_default DESC, created_at ASC LIMIT 1')
+      .get(provider);
+    return rowToApiKey(row);
+  },
+
+  async create({ name, provider, encryptedKey, isDefault = false }) {
+    const db = getDb();
+    const id = newId('ak');
+    const now = Date.now();
+
+    if (isDefault) {
+      db.prepare('UPDATE api_keys SET is_default = 0').run();
+    }
+
+    db.prepare(
+      `INSERT INTO api_keys (id, name, provider, encrypted_key, is_default, created_at)
+       VALUES (?, ?, ?, ?, ?, ?)`
+    ).run(id, name, provider, encryptedKey, isDefault ? 1 : 0, now);
+
+    return this.findById(id);
+  },
+
+  async setDefault(id) {
+    const db = getDb();
+    db.prepare('UPDATE api_keys SET is_default = 0').run();
+    db.prepare('UPDATE api_keys SET is_default = 1 WHERE id = ?').run(id);
+    return this.findById(id);
+  },
+
+  async delete(id) {
+    const db = getDb();
+    db.prepare('DELETE FROM api_keys WHERE id = ?').run(id);
+  },
+};

package/lib/db/repositories/auditLogs.js

@@ -0,0 +1,12 @@
+// Lite has no org-level settings. The builder stream route expects these shapes;
+// returning null/defaults causes the fallback auto-select logic to kick in.
+
+export const OrganizationSettingsRepository = {
+  async getBuilderConfig(_orgName) {
+    return null;
+  },
+
+  async getDefaultRegion(_orgName) {
+    return 'us-east-1';
+  },
+};

package/lib/db/repositories/botSpaces.js

@@ -0,0 +1,12 @@
+// Lite does not have bot spaces. This stub returns null/empty results so the
+// builder stream code can call these methods without crashing.
+
+export const BotSpaceRepository = {
+  async findById(_id) {
+    return null;
+  },
+
+  async list() {
+    return [];
+  },
+};

package/lib/db/repositories/builderSessions.js

@@ -0,0 +1,312 @@
+import { getDb } from '../index.js';
+import { randomUUID } from 'crypto';
+
+export const SESSION_STATUS = {
+  CREATED: 'created',
+  PROCESSING: 'processing',
+  AWAITING_CONFIRM: 'awaiting_confirm',
+  DEPLOYING: 'deploying',
+  DEPLOYED: 'deployed',
+  EDITING: 'editing',
+};
+
+const DEFAULT_ENABLED_PROTOCOLS = {
+  knowledge: false,
+  formGathering: false,
+  appointments: false,
+  triage: false,
+};
+
+function jsonOrNull(value, fallback = null) {
+  if (value === null || value === undefined) return fallback;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return fallback;
+  }
+}
+
+function rowToSession(row) {
+  if (!row) return null;
+  return {
+    id: row.id,
+    userId: 'local', // Lite is single-user
+    status: row.status,
+    preloadedContext: jsonOrNull(row.preloaded_context, {}),
+    messages: jsonOrNull(row.messages, []),
+    inferredIntent: row.inferred_intent,
+    intentConfidence: row.intent_confidence,
+    recommendedProtocols: jsonOrNull(row.recommended_protocols, {}),
+    enabledProtocols: jsonOrNull(row.enabled_protocols, DEFAULT_ENABLED_PROTOCOLS),
+    coreConfig: jsonOrNull(row.core_config, {}),
+    identityConfig: jsonOrNull(row.identity_config, {}),
+    protocolData: jsonOrNull(row.protocol_data, {}),
+    generatedConfigs: jsonOrNull(row.generated_configs, {}),
+    deploymentId: row.deployment_id,
+    createdAt: new Date(row.created_at),
+    updatedAt: new Date(row.updated_at),
+    // Legacy alias for code that reads `session.botSpaceId`
+    botSpaceId: null,
+  };
+}
+
+function newModularSessionId() {
+  return `mod_${randomUUID()}`;
+}
+
+function insertSession(fields) {
+  const db = getDb();
+  const now = Date.now();
+  const id = fields.id || newModularSessionId();
+  db.prepare(
+    `INSERT INTO modular_sessions (
+        id, status, preloaded_context, messages, inferred_intent, intent_confidence,
+        recommended_protocols, enabled_protocols, core_config, identity_config,
+        protocol_data, generated_configs, deployment_id, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+  ).run(
+    id,
+    fields.status || SESSION_STATUS.CREATED,
+    JSON.stringify(fields.preloadedContext || {}),
+    JSON.stringify(fields.messages || []),
+    fields.inferredIntent || null,
+    fields.intentConfidence ?? null,
+    JSON.stringify(fields.recommendedProtocols || {}),
+    JSON.stringify(fields.enabledProtocols || DEFAULT_ENABLED_PROTOCOLS),
+    JSON.stringify(fields.coreConfig || {}),
+    JSON.stringify(fields.identityConfig || {}),
+    JSON.stringify(fields.protocolData || {}),
+    JSON.stringify(fields.generatedConfigs || {}),
+    fields.deploymentId || null,
+    now,
+    now
+  );
+  return id;
+}
+
+function setField(sessionId, column, value) {
+  const db = getDb();
+  db.prepare(
+    `UPDATE modular_sessions SET ${column} = ?, updated_at = ? WHERE id = ?`
+  ).run(value, Date.now(), sessionId);
+}
+
+function setJsonField(sessionId, column, value) {
+  setField(sessionId, column, JSON.stringify(value ?? null));
+}
+
+async function fetchSession(sessionId) {
+  const db = getDb();
+  const row = db.prepare('SELECT * FROM modular_sessions WHERE id = ?').get(sessionId);
+  return rowToSession(row);
+}
+
+export const BuilderSessionRepository = {
+  async create({ userId: _userId } = {}) {
+    const id = insertSession({});
+    return fetchSession(id);
+  },
+
+  async createWithContext({ userId: _userId, botSpaceId: _botSpaceId, preloadedContext, existingConfig }) {
+    const fields = { preloadedContext };
+
+    if (existingConfig) {
+      fields.status = SESSION_STATUS.EDITING;
+      fields.enabledProtocols = existingConfig.enabledProtocols || DEFAULT_ENABLED_PROTOCOLS;
+      fields.coreConfig = existingConfig.core || {};
+      fields.identityConfig = existingConfig.identity || {};
+      fields.protocolData = existingConfig.protocolData || {};
+      fields.generatedConfigs = existingConfig._deployment
+        ? { _editingDeployment: existingConfig._deployment }
+        : {};
+    }
+
+    const id = insertSession(fields);
+    return fetchSession(id);
+  },
+
+  async findById(sessionId) {
+    return fetchSession(sessionId);
+  },
+
+  async findByIdAndUserId(sessionId, _userId) {
+    return fetchSession(sessionId);
+  },
+
+  async updateStatus(sessionId, _userId, status) {
+    setField(sessionId, 'status', status);
+    return fetchSession(sessionId);
+  },
+
+  async appendMessage(sessionId, _userId, message) {
+    const session = await fetchSession(sessionId);
+    if (!session) return null;
+    const messages = [...(session.messages || []), { ...message, timestamp: Date.now() }];
+    setJsonField(sessionId, 'messages', messages);
+    return fetchSession(sessionId);
+  },
+
+  async updateInference(sessionId, _userId, { intent, confidence, recommendedProtocols }) {
+    const db = getDb();
+    db.prepare(
+      `UPDATE modular_sessions
+       SET inferred_intent = ?, intent_confidence = ?, recommended_protocols = ?, updated_at = ?
+       WHERE id = ?`
+    ).run(
+      intent,
+      confidence ?? null,
+      JSON.stringify(recommendedProtocols || {}),
+      Date.now(),
+      sessionId
+    );
+    return fetchSession(sessionId);
+  },
+
+  async updateProtocols(sessionId, _userId, enabledProtocols) {
+    setJsonField(sessionId, 'enabled_protocols', enabledProtocols);
+    return fetchSession(sessionId);
+  },
+
+  async updateCoreConfig(sessionId, _userId, coreConfig) {
+    setJsonField(sessionId, 'core_config', coreConfig);
+    return fetchSession(sessionId);
+  },
+
+  async updateIdentityConfig(sessionId, _userId, identityConfig) {
+    setJsonField(sessionId, 'identity_config', identityConfig);
+    return fetchSession(sessionId);
+  },
+
+  async updateProtocolData(sessionId, _userId, protocol, data) {
+    const session = await fetchSession(sessionId);
+    if (!session) return null;
+    const protocolData = { ...(session.protocolData || {}), [protocol]: data };
+    setJsonField(sessionId, 'protocol_data', protocolData);
+    return fetchSession(sessionId);
+  },
+
+  async updateGeneratedConfig(sessionId, _userId, key, data) {
+    const session = await fetchSession(sessionId);
+    if (!session) return null;
+    const generatedConfigs = { ...(session.generatedConfigs || {}), [key]: data };
+    setJsonField(sessionId, 'generated_configs', generatedConfigs);
+    return fetchSession(sessionId);
+  },
+
+  async updateStepProgress(_sessionId, _userId, _step, _status) {
+    // Lite does not track per-step progress in the wizard flow.
+    // Retained as a no-op for builder executor compatibility.
+    return null;
+  },
+
+  async confirmProtocols(sessionId, _userId, confirmedProtocols) {
+    // The UI's deploy button passes the recommend_protocols shape:
+    //   { knowledge: { enabled: true, ... }, forms: { enabled: false, ... }, ... }
+    // The chat-builder LLM, when it calls save_modular_bot directly, often
+    // passes flat booleans:
+    //   { knowledge: true, forms: false, ... }
+    // Accept either — anything truthy at either level enables the protocol.
+    // Without this, the LLM-direct path silently disables knowledge and the
+    // artifact ships without embeddings.json.
+    const flag = (v) => {
+      if (v === null || v === undefined) return false;
+      if (typeof v === 'object') return !!v.enabled;
+      return !!v;
+    };
+    const cp = confirmedProtocols || {};
+    const enabledProtocols = {
+      knowledge: flag(cp.knowledge),
+      formGathering: flag(cp.formGathering ?? cp.forms),
+      appointments: flag(cp.appointments),
+      triage: flag(cp.triage),
+    };
+    setJsonField(sessionId, 'enabled_protocols', enabledProtocols);
+    return fetchSession(sessionId);
+  },
+
+  async cacheComposedInstructions(_sessionId, _userId, _instructions) {
+    // Lite composes instructions on-demand at deploy time; no cache needed.
+    return null;
+  },
+
+  async syncGeneratedConfigsToLegacy(sessionId, _userId) {
+    // Copy generatedConfigs.{core,identity,forms,appointments,triage,knowledge}
+    // into the legacy columns the deployer reads (coreConfig, identityConfig, protocolData).
+    const session = await fetchSession(sessionId);
+    if (!session) return null;
+    const g = session.generatedConfigs || {};
+
+    const coreConfig = {
+      ...(session.coreConfig || {}),
+      ...(g.core || {}),
+      apiKeyId: session.preloadedContext?.defaultApiKeyId || g.core?.apiKeyId,
+      _invertedFlow: true,
+    };
+    const mergedIdentity = {
+      ...(session.identityConfig || {}),
+      ...(g.identity || {}),
+    };
+    const identityConfig = {
+      ...mergedIdentity,
+      chatDisplayName:
+        mergedIdentity.chatDisplayName ||
+        mergedIdentity.displayName ||
+        mergedIdentity.botName ||
+        'Assistant',
+    };
+
+    const protocolData = { ...(session.protocolData || {}) };
+    if (g.knowledge) {
+      protocolData.knowledge = {
+        ...(protocolData.knowledge || {}),
+        domainDigest: g.knowledge.domainDigest,
+        documents: (g.knowledge.documentIds || []).map((id) => ({ id })),
+      };
+    }
+    if (g.forms) {
+      protocolData.formGathering = {
+        ...(protocolData.formGathering || {}),
+        generatedFormJson: g.forms.formSchema,
+        formCompletionWebhook: g.forms.formCompletionWebhook,
+        afterSubmitChatMessage: g.forms.afterSubmitChatMessage,
+        formSendHome: g.forms.formSendHome,
+      };
+    }
+    if (g.appointments) {
+      protocolData.appointments = {
+        ...(protocolData.appointments || {}),
+        destinations: g.appointments.destinations || [],
+      };
+    }
+    if (g.triage) {
+      protocolData.triage = {
+        ...(protocolData.triage || {}),
+        routes: g.triage.routes || [],
+      };
+    }
+
+    const db = getDb();
+    db.prepare(
+      `UPDATE modular_sessions
+       SET core_config = ?, identity_config = ?, protocol_data = ?, updated_at = ?
+       WHERE id = ?`
+    ).run(
+      JSON.stringify(coreConfig),
+      JSON.stringify(identityConfig),
+      JSON.stringify(protocolData),
+      Date.now(),
+      sessionId
+    );
+    return fetchSession(sessionId);
+  },
+
+  async linkDeployment(sessionId, _userId, deploymentId) {
+    setField(sessionId, 'deployment_id', deploymentId);
+    return fetchSession(sessionId);
+  },
+
+  async delete(sessionId, _userId) {
+    const db = getDb();
+    db.prepare('DELETE FROM modular_sessions WHERE id = ?').run(sessionId);
+  },
+};

package/lib/db/repositories/deploymentEvents.js

@@ -0,0 +1,12 @@
+// Lite does not track deployment event history separately. These stubs keep
+// the builder executor flow intact without persisting events.
+
+export const DeploymentEventRepository = {
+  async create(_data) {
+    return { id: null };
+  },
+
+  async updateStatus(_id, _status) {
+    return null;
+  },
+};