mojulo 0.0.0 → 0.1.1

package/package.json

@@ -1,9 +1,72 @@
 {
   "name": "mojulo",
-  "version": "0.0.0",
-  "description": "Placeholder. Real release will expose a stdio MCP server for building self-hosted bots from inside Claude.",
+  "version": "0.1.1",
+  "license": "Apache-2.0",
+  "description": "Mojulo — MCP server for building self-hosted chatbots from inside Claude.",
+  "author": "Franz Ombico",
   "homepage": "https://github.com/zombico/mojulo",
-  "repository": { "type": "git", "url": "https://github.com/zombico/mojulo.git" },
-  "author": "Franz Ombico <franzombico@gmail.com>",
-  "license": "UNLICENSED"
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zombico/mojulo.git"
+  },
+  "bugs": {
+    "url": "https://github.com/zombico/mojulo/issues"
+  },
+  "keywords": [
+    "mcp",
+    "claude",
+    "anthropic",
+    "claude-code",
+    "chatbot",
+    "bot-builder",
+    "rag",
+    "self-hosted",
+    "mojulo"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "bin": {
+    "mojulo": "./scripts/mcp-stdio.mjs",
+    "mojulo-config": "./scripts/mcp-config.mjs"
+  },
+  "files": [
+    "lib/**",
+    "!lib/embedder/models/**",
+    "!lib/**/*.test.js",
+    "scripts/mcp-stdio.mjs",
+    "scripts/mcp-stdio-loader.mjs",
+    "scripts/mcp-config.mjs",
+    "scripts/mojulo-paths.mjs",
+    "messages/**"
+  ],
+  "scripts": {
+    "dev": "next dev -p 3001",
+    "build": "next build",
+    "start": "next start -p 3001",
+    "build:bot": "docker build -t mojulo/bot:latest ../lite-template",
+    "mcp-stdio": "node scripts/mcp-stdio.mjs",
+    "mcp-config": "node scripts/mcp-config.mjs",
+    "stage-lite-template": "node scripts/stage-lite-template.mjs",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@aws-sdk/client-bedrock-runtime": "^3.1011.0",
+    "@huggingface/transformers": "^4.2.0",
+    "archiver": "^7.0.1",
+    "better-sqlite3": "^12.4.1",
+    "dotenv": "^17.2.3",
+    "next": "^16.0.7",
+    "next-intl": "^4.8.3",
+    "officeparser": "^5.2.2",
+    "pdf2json": "^4.0.0",
+    "react": "19.2.0",
+    "react-dom": "19.2.0",
+    "swr": "^2.4.1"
+  },
+  "devDependencies": {
+    "@tailwindcss/postcss": "^4",
+    "tailwindcss": "^4",
+    "vitest": "^4.1.6"
+  }
 }

package/scripts/mcp-config.mjs

@@ -0,0 +1,162 @@
+#!/usr/bin/env node
+/**
+ * Config CLI for the mojulo control plane.
+ *
+ * Writes / reads provider keys in the existing encrypted api_keys table —
+ * same source the Settings UI populates, same AES-256-GCM encryption
+ * ([@/lib/deployment-auth](../lib/deployment-auth.js)). This deviates from
+ * §9 of the release plan (which sketched a plaintext ~/.mojulo/config.json):
+ * single source of truth, reuses encryption, no downstream resolver shim.
+ *
+ * Usage:
+ *   mojulo-mcp-config set anthropic sk-ant-...
+ *   mojulo-mcp-config set openai sk-...
+ *   mojulo-mcp-config set ollama http://localhost:11434
+ *   mojulo-mcp-config set fly fo1_...
+ *   mojulo-mcp-config list
+ *   mojulo-mcp-config unset openai
+ *
+ * `set` replaces any existing key(s) for that provider with a single fresh
+ * row, and marks it default if no default exists.
+ */
+
+import { register } from 'node:module';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+import { resolveMojuloPaths } from './mojulo-paths.mjs';
+
+register('./mcp-stdio-loader.mjs', import.meta.url);
+
+resolveMojuloPaths();
+
+const CONTROL_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+process.chdir(CONTROL_DIR);
+
+const ALLOWED_PROVIDERS = new Set(['anthropic', 'openai', 'ollama', 'fly']);
+
+function usage(exitCode = 0) {
+  const lines = [
+    'Usage:',
+    '  mojulo-mcp-config set <provider> <value>',
+    '  mojulo-mcp-config list',
+    '  mojulo-mcp-config unset <provider>',
+    '',
+    `Providers: ${[...ALLOWED_PROVIDERS].join(', ')}`,
+  ];
+  process.stdout.write(lines.join('\n') + '\n');
+  process.exit(exitCode);
+}
+
+function maskValue(plaintext) {
+  if (!plaintext) return '(empty)';
+  if (plaintext.length <= 8) return '*'.repeat(plaintext.length);
+  return `${plaintext.slice(0, 4)}…${plaintext.slice(-4)}`;
+}
+
+async function setKey(provider, value) {
+  const { ApiKeyRepository } = await import('@/lib/db/repositories/apiKeys');
+  const { encryptApiKey } = await import('@/lib/deployment-auth');
+
+  const existing = await ApiKeyRepository.findByUserId('local');
+  const sameProvider = existing.filter((k) => k.provider === provider);
+  for (const row of sameProvider) {
+    await ApiKeyRepository.delete(row.id);
+  }
+
+  const remaining = existing.filter((k) => k.provider !== provider);
+  const isDefault = !remaining.some((k) => k.isDefault);
+
+  await ApiKeyRepository.create({
+    name: `${provider}-cli`,
+    provider,
+    encryptedKey: encryptApiKey(value),
+    isDefault,
+  });
+
+  process.stdout.write(
+    `Set ${provider} → ${maskValue(value)}${isDefault ? ' (default)' : ''}\n`
+  );
+}
+
+async function listKeys() {
+  const { ApiKeyRepository } = await import('@/lib/db/repositories/apiKeys');
+  const keys = await ApiKeyRepository.findByUserId('local');
+  if (keys.length === 0) {
+    process.stdout.write('No provider keys configured.\n');
+    process.stdout.write('Set one with: mojulo-mcp-config set anthropic sk-ant-...\n');
+    return;
+  }
+  const rows = keys.map((k) => ({
+    provider: k.provider,
+    name: k.name,
+    default: k.isDefault ? '*' : '',
+  }));
+  const widths = {
+    provider: Math.max(8, ...rows.map((r) => r.provider.length)),
+    name: Math.max(4, ...rows.map((r) => r.name.length)),
+    default: 7,
+  };
+  const fmt = (r) =>
+    `${r.provider.padEnd(widths.provider)}  ${r.name.padEnd(widths.name)}  ${r.default}`;
+  process.stdout.write(fmt({ provider: 'provider', name: 'name', default: 'default' }) + '\n');
+  process.stdout.write(
+    `${'-'.repeat(widths.provider)}  ${'-'.repeat(widths.name)}  ${'-'.repeat(widths.default)}\n`
+  );
+  for (const r of rows) process.stdout.write(fmt(r) + '\n');
+}
+
+async function unsetKey(provider) {
+  const { ApiKeyRepository } = await import('@/lib/db/repositories/apiKeys');
+  const existing = await ApiKeyRepository.findByUserId('local');
+  const sameProvider = existing.filter((k) => k.provider === provider);
+  if (sameProvider.length === 0) {
+    process.stdout.write(`No keys for ${provider}.\n`);
+    return;
+  }
+  for (const row of sameProvider) {
+    await ApiKeyRepository.delete(row.id);
+  }
+  process.stdout.write(`Removed ${sameProvider.length} key(s) for ${provider}.\n`);
+}
+
+const [, , subcommand, ...rest] = process.argv;
+
+if (!subcommand || subcommand === '-h' || subcommand === '--help') {
+  usage(0);
+}
+
+try {
+  if (subcommand === 'set') {
+    const [provider, value] = rest;
+    if (!provider || !value) {
+      process.stderr.write('set requires <provider> <value>\n');
+      usage(2);
+    }
+    if (!ALLOWED_PROVIDERS.has(provider)) {
+      process.stderr.write(`Unknown provider: ${provider}\n`);
+      usage(2);
+    }
+    await setKey(provider, value);
+  } else if (subcommand === 'list') {
+    await listKeys();
+  } else if (subcommand === 'unset') {
+    const [provider] = rest;
+    if (!provider) {
+      process.stderr.write('unset requires <provider>\n');
+      usage(2);
+    }
+    if (!ALLOWED_PROVIDERS.has(provider)) {
+      process.stderr.write(`Unknown provider: ${provider}\n`);
+      usage(2);
+    }
+    await unsetKey(provider);
+  } else {
+    process.stderr.write(`Unknown subcommand: ${subcommand}\n`);
+    usage(2);
+  }
+} catch (err) {
+  process.stderr.write(`mojulo-mcp-config: ${err.message || err}\n`);
+  process.exit(1);
+}
+
+process.exit(0);

package/scripts/mcp-stdio-loader.mjs

@@ -0,0 +1,42 @@
+/**
+ * ESM resolver hook that maps `@/...` imports to the control directory so the
+ * stdio MCP entry can run under plain Node (Next.js handles `@/` natively via
+ * jsconfig.json, but Node does not).
+ *
+ * Registered by [mcp-stdio.mjs](./mcp-stdio.mjs) via `module.register`. Hooks
+ * run in a worker thread and fire for every subsequent dynamic import — the
+ * stdio entry's `await import('@/lib/mcp/server')` is resolved here.
+ */
+
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { existsSync, statSync } from 'node:fs';
+
+const CONTROL_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+
+const EXTS = ['', '.js', '.mjs', '.cjs', '.json'];
+
+function resolveAlias(specifier) {
+  const base = path.join(CONTROL_DIR, specifier.slice(2));
+  for (const ext of EXTS) {
+    const candidate = base + ext;
+    if (existsSync(candidate) && statSync(candidate).isFile()) return candidate;
+  }
+  if (existsSync(base) && statSync(base).isDirectory()) {
+    for (const ext of ['.js', '.mjs']) {
+      const indexFile = path.join(base, `index${ext}`);
+      if (existsSync(indexFile)) return indexFile;
+    }
+  }
+  return null;
+}
+
+export function resolve(specifier, context, nextResolve) {
+  if (specifier.startsWith('@/')) {
+    const resolved = resolveAlias(specifier);
+    if (resolved) {
+      return nextResolve(pathToFileURL(resolved).href, context);
+    }
+  }
+  return nextResolve(specifier, context);
+}

package/scripts/mcp-stdio.mjs

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+/**
+ * Stdio MCP transport for the control plane.
+ *
+ * One process per MCP connection (the client spawns this and communicates over
+ * stdin/stdout). Newline-delimited JSON-RPC 2.0 frames; logs go to stderr only
+ * because stdout is the protocol channel.
+ *
+ * Usage:
+ *   claude mcp add mojulo --command "node /abs/path/to/control/scripts/mcp-stdio.mjs"
+ *
+ * This is the working-tree entry referenced in §12 Milestone 1 of
+ * [lite-template/integration/npx_package_release_plan.md]. The npm package
+ * (§12 Milestone 3) will ship a bundled equivalent as `bin/mojulo-mcp`.
+ */
+
+import { register } from 'node:module';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+import readline from 'node:readline';
+import { resolveMojuloPaths } from './mojulo-paths.mjs';
+
+// Resolve `@/...` like Next.js does, so the stdio entry can reuse the same
+// server.js + tool modules the Next.js route uses.
+register('./mcp-stdio-loader.mjs', import.meta.url);
+
+// User data lives under MOJULO_HOME (default ~/.mojulo). This populates
+// SQLITE_PATH / ARTIFACTS_DIR / STORAGE_ROOT / MOJULO_MODELS_DIR so the lib
+// code lands user state there instead of a cwd-relative ./data/.
+resolveMojuloPaths();
+
+// chdir to control/ for packaged-asset paths the lib still reads from cwd
+// (lib/composer/composer.js PROTOCOLS_DIR default). M3 v0.2.0 will swap
+// these for __dirname-relative resolution when the UI bin lands and we
+// re-ship lite-template/ for the wizard preview path.
+const CONTROL_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+process.chdir(CONTROL_DIR);
+
+// Stdout is the MCP protocol channel — any stray log corrupts the frame
+// stream. Several tool executors and the composer emit progress via
+// console.log; pin those to stderr for the stdio process only. The Next.js
+// route is unaffected.
+console.log = console.error;
+console.info = console.error;
+
+const { dispatchMcpRequest, ensureToolsRegistered } = await import('@/lib/mcp/server');
+await ensureToolsRegistered();
+
+// Kick off the embedder model fetch in background. The first RAG bot build
+// is the iconic genesis flow, and the model load (~113MB on a cold cache)
+// is the longest single step. Starting it now lets the download/load overlap
+// with Claude's initial exchanges instead of blocking process_documents at
+// T6. The lazy path in lib/embedder/local.js shares promise state, so a
+// tool call arriving mid-load simply awaits whatever's left. Failures here
+// surface at first use — don't crash the MCP server.
+import('@/lib/embedder/local').then(({ preloadModel }) =>
+  preloadModel().catch((err) =>
+    console.error('[mcp-stdio] embedder preload failed:', err.message)
+  )
+);
+
+const CONTEXT = { mcpSessionId: 'stdio', userId: 'local' };
+
+function writeFrame(payload) {
+  process.stdout.write(JSON.stringify(payload) + '\n');
+}
+
+function parseError() {
+  return { jsonrpc: '2.0', id: null, error: { code: -32700, message: 'Parse error' } };
+}
+
+async function handleLine(line) {
+  let body;
+  try {
+    body = JSON.parse(line);
+  } catch {
+    writeFrame(parseError());
+    return;
+  }
+
+  if (Array.isArray(body)) {
+    const responses = [];
+    for (const msg of body) {
+      const resp = await dispatchMcpRequest(msg, CONTEXT);
+      if (resp !== null) responses.push(resp);
+    }
+    if (responses.length > 0) writeFrame(responses);
+    return;
+  }
+
+  const resp = await dispatchMcpRequest(body, CONTEXT);
+  if (resp !== null) writeFrame(resp);
+}
+
+const rl = readline.createInterface({ input: process.stdin, crlfDelay: Infinity });
+
+rl.on('line', (line) => {
+  if (!line.trim()) return;
+  handleLine(line).catch((err) => {
+    console.error('[mcp-stdio] dispatch error:', err);
+  });
+});
+
+rl.on('close', () => process.exit(0));
+
+for (const signal of ['SIGINT', 'SIGTERM']) {
+  process.on(signal, () => process.exit(0));
+}

package/scripts/mojulo-paths.mjs

@@ -0,0 +1,48 @@
+/**
+ * Resolve the mojulo home / data / models directories and seed the env vars
+ * the rest of the control plane reads.
+ *
+ * Layered defaults:
+ *   MOJULO_HOME       (default: ~/.mojulo)
+ *   MOJULO_DATA_DIR   (default: $MOJULO_HOME/data)
+ *   MOJULO_MODELS_DIR (default: $MOJULO_HOME/models)
+ *
+ * From those, sets — without overriding — the lower-level env vars the lib
+ * code already honors:
+ *   SQLITE_PATH    → $MOJULO_DATA_DIR/mojulo-lite.db
+ *   ARTIFACTS_DIR  → $MOJULO_DATA_DIR/artifacts
+ *   STORAGE_ROOT   → $MOJULO_DATA_DIR/storage
+ *
+ * Shared by [mcp-stdio.mjs](./mcp-stdio.mjs) and [mcp-config.mjs](./mcp-config.mjs)
+ * so a fresh `~/.mojulo/` works for both stdio and the config CLI.
+ */
+
+import os from 'node:os';
+import path from 'node:path';
+import fs from 'node:fs';
+
+export function resolveMojuloPaths() {
+  const home = process.env.MOJULO_HOME || path.join(os.homedir(), '.mojulo');
+  const dataDir = process.env.MOJULO_DATA_DIR || path.join(home, 'data');
+  const modelsDir = process.env.MOJULO_MODELS_DIR || path.join(home, 'models');
+
+  process.env.MOJULO_HOME ??= home;
+  process.env.MOJULO_DATA_DIR ??= dataDir;
+  process.env.MOJULO_MODELS_DIR ??= modelsDir;
+  process.env.SQLITE_PATH ??= path.join(dataDir, 'mojulo-lite.db');
+  process.env.ARTIFACTS_DIR ??= path.join(dataDir, 'artifacts');
+  process.env.STORAGE_ROOT ??= path.join(dataDir, 'storage');
+
+  for (const dir of [home, dataDir, modelsDir, process.env.ARTIFACTS_DIR, process.env.STORAGE_ROOT]) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+
+  return {
+    home,
+    dataDir,
+    modelsDir,
+    dbPath: process.env.SQLITE_PATH,
+    artifactsDir: process.env.ARTIFACTS_DIR,
+    storageRoot: process.env.STORAGE_ROOT,
+  };
+}