froggo-mission-control 1.1.9 → 1.2.2

package/app/api/accounts/route.ts

@@ -1,16 +1,37 @@
-import { NextResponse } from 'next/server';
+import { NextRequest, NextResponse } from 'next/server';
 import { getDb } from '@/lib/database';
 
 export async function GET() {
   try {
     const db = getDb();
-    const state = db.prepare("SELECT value FROM module_state WHERE module_id = 'accounts'").get() as { value: string } | undefined;
-    if (state?.value) return NextResponse.json(JSON.parse(state.value));
-  } catch { /* table may not have value column or no matching row */ }
-  return NextResponse.json([]);
+    const row = db.prepare("SELECT value FROM settings WHERE key = 'accounts_list'").get() as { value: string } | undefined;
+    if (row?.value) {
+      const parsed = JSON.parse(row.value);
+      return NextResponse.json(Array.isArray(parsed) ? parsed : []);
+    }
+    return NextResponse.json([]);
+  } catch (error) {
+    console.error('GET /api/accounts error:', error);
+    return NextResponse.json([]);
+  }
 }
 
-export async function POST(request: Request) {
-  const body = await request.json();
-  return NextResponse.json({ success: true, id: `acct-${Date.now()}`, ...body });
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+    const db = getDb();
+
+    const row = db.prepare("SELECT value FROM settings WHERE key = 'accounts_list'").get() as { value: string } | undefined;
+    let accounts: unknown[] = [];
+    try { if (row?.value) accounts = JSON.parse(row.value); } catch { /* */ }
+
+    const newAccount = { ...body, id: `acct-${Date.now()}`, createdAt: new Date().toISOString() };
+    accounts.push(newAccount);
+
+    db.prepare("INSERT OR REPLACE INTO settings (key, value) VALUES ('accounts_list', ?)").run(JSON.stringify(accounts));
+    return NextResponse.json(newAccount, { status: 201 });
+  } catch (error) {
+    console.error('POST /api/accounts error:', error);
+    return NextResponse.json({ error: 'Internal server error' }, { status: 500 });
+  }
 }

package/app/api/agents/[id]/config/route.ts

@@ -35,6 +35,10 @@ export async function GET(_req: NextRequest, { params }: Params) {
     let capabilities: string[] = [];
     try { capabilities = JSON.parse(agent.capabilities || '[]'); } catch { /* */ }
 
+    const mcpRaw = db.prepare('SELECT value FROM settings WHERE key = ?').get(settingKey(id, 'mcpServers')) as { value: string } | undefined;
+    let mcpServers: unknown[] = [];
+    try { if (mcpRaw?.value) { const p = JSON.parse(mcpRaw.value); if (Array.isArray(p)) mcpServers = p; } } catch { /* */ }
+
     return NextResponse.json({
       model: agent.model || 'sonnet',
       trustTier: agent.trust_tier || 'apprentice',
@@ -42,6 +46,7 @@ export async function GET(_req: NextRequest, { params }: Params) {
       skills: getSettingArray(db, settingKey(id, 'skills')),
       tools: getSettingArray(db, settingKey(id, 'tools')),
       apiKeys: getSettingArray(db, settingKey(id, 'apiKeys')),
+      mcpServers,
     });
   } catch (error) {
     console.error('GET /api/agents/:id/config error:', error);
@@ -74,8 +79,8 @@ export async function PATCH(req: NextRequest, { params }: Params) {
       db.prepare('UPDATE agents SET trust_tier = ? WHERE id = ?').run(body.trustTier, id);
     }
 
-    // skills, tools, apiKeys → settings table
-    for (const field of ['skills', 'tools', 'apiKeys'] as const) {
+    // skills, tools, apiKeys, mcpServers → settings table
+    for (const field of ['skills', 'tools', 'apiKeys', 'mcpServers'] as const) {
       if (Array.isArray(body[field])) {
         const key = settingKey(id, field);
         const value = JSON.stringify(body[field]);

package/app/api/agents/clara/review/route.ts

@@ -1,22 +1,28 @@
 import { NextRequest, NextResponse } from 'next/server';
-import { runReviewCycle } from '@/lib/claraReviewCron';
+import { runReviewCycle, spawnClaraReview } from '@/lib/claraReviewCron';
+import { getDb } from '@/lib/database';
 
 export const dynamic = 'force-dynamic';
 export const runtime = 'nodejs';
 
-// Trigger Clara review for a specific task or sweep all pending
 export async function POST(request: NextRequest) {
-  const body = await request.json().catch(() => ({}));
-  const { taskId } = body;
+  try {
+    const body = await request.json().catch(() => ({}));
+    const { taskId } = body as { taskId?: string };
 
-  if (taskId) {
-    // Single task: import and use the shared spawn logic
-    const { runReviewCycle: _ } = await import('@/lib/claraReviewCron');
-    void _;
-    // For single-task trigger, just run the full sweep — it will pick it up
-    // (The sweep already deduplicates via inReview set)
-  }
+    if (taskId) {
+      const task = getDb()
+        .prepare(`SELECT id, title, description, assignedTo, progress, lastAgentUpdate FROM tasks WHERE id = ? AND status = 'review'`)
+        .get(taskId) as Record<string, unknown> | undefined;
+      if (!task) return NextResponse.json({ error: 'Task not found or not in review status' }, { status: 404 });
+      spawnClaraReview(task);
+      return NextResponse.json({ queued: 1, taskId });
+    }
 
-  const { queued } = runReviewCycle();
-  return NextResponse.json({ queued });
+    const { queued } = runReviewCycle();
+    return NextResponse.json({ queued });
+  } catch (err) {
+    console.error('[clara-review] Error:', err);
+    return NextResponse.json({ error: 'Internal server error' }, { status: 500 });
+  }
 }

package/app/api/chat/generate-reply/route.ts

@@ -1,5 +1,37 @@
-import { NextResponse } from 'next/server';
+import { NextRequest, NextResponse } from 'next/server';
+import Anthropic from '@anthropic-ai/sdk';
 
-export async function POST() {
-  return NextResponse.json({ success: false, error: 'Generate reply not configured' }, { status: 501 });
+export const runtime = 'nodejs';
+
+export async function POST(request: NextRequest) {
+  try {
+    const { message, context, tone = 'professional' } = await request.json();
+    if (!message) {
+      return NextResponse.json({ error: 'message is required' }, { status: 400 });
+    }
+
+    const apiKey = process.env.ANTHROPIC_API_KEY;
+    if (!apiKey) {
+      return NextResponse.json({ success: false, error: 'ANTHROPIC_API_KEY not configured' }, { status: 424 });
+    }
+
+    const client = new Anthropic({ apiKey });
+    const systemPrompt = `You are a helpful assistant generating a ${tone} reply to a message. Be concise and direct. Only output the reply text, nothing else.`;
+    const userPrompt = context
+      ? `Context: ${context}\n\nMessage to reply to: ${message}`
+      : `Message to reply to: ${message}`;
+
+    const response = await client.messages.create({
+      model: 'claude-haiku-4-5-20251001',
+      max_tokens: 512,
+      messages: [{ role: 'user', content: userPrompt }],
+      system: systemPrompt,
+    });
+
+    const reply = response.content[0]?.type === 'text' ? response.content[0].text : '';
+    return NextResponse.json({ success: true, reply });
+  } catch (error) {
+    console.error('POST /api/chat/generate-reply error:', error);
+    return NextResponse.json({ success: false, error: 'Failed to generate reply' }, { status: 500 });
+  }
 }

package/app/api/finance/accounts/route.ts

@@ -1,5 +1,24 @@
 import { NextResponse } from 'next/server';
+import { getDb } from '@/lib/database';
 
 export async function GET() {
-  return NextResponse.json([]);
+  try {
+    const db = getDb();
+    const rows = db.prepare(`
+      SELECT a.id, a.name, a.role,
+             COALESCE(SUM(t.costUsd), 0)        AS totalSpend,
+             COALESCE(SUM(t.inputTokens), 0)    AS inputTokens,
+             COALESCE(SUM(t.outputTokens), 0)   AS outputTokens,
+             COUNT(t.id)                         AS txCount
+      FROM agents a
+      LEFT JOIN token_usage t ON t.agentId = a.id
+      GROUP BY a.id
+      ORDER BY totalSpend DESC
+    `).all() as Record<string, unknown>[];
+
+    return NextResponse.json(rows);
+  } catch (error) {
+    console.error('GET /api/finance/accounts error:', error);
+    return NextResponse.json([]);
+  }
 }

package/app/api/finance/budget/route.ts

@@ -1,5 +1,43 @@
-import { NextResponse } from 'next/server';
+import { NextRequest, NextResponse } from 'next/server';
+import { getDb } from '@/lib/database';
 
 export async function GET() {
-  return NextResponse.json({ total: 0, spent: 0, remaining: 0, categories: [] });
+  try {
+    const db = getDb();
+
+    const budgetRow = db.prepare("SELECT value FROM settings WHERE key = 'finance_budget_usd'").get() as { value: string } | undefined;
+    const budget = budgetRow ? parseFloat(budgetRow.value) : 500;
+
+    const spendRow = db.prepare("SELECT COALESCE(SUM(costUsd), 0) AS total FROM token_usage").get() as { total: number };
+    const spent = spendRow.total ?? 0;
+
+    const byAgent = db.prepare(`
+      SELECT agentId, COALESCE(SUM(costUsd), 0) AS spend
+      FROM token_usage GROUP BY agentId ORDER BY spend DESC
+    `).all() as { agentId: string; spend: number }[];
+
+    return NextResponse.json({
+      total:     budget,
+      spent,
+      remaining: Math.max(0, budget - spent),
+      categories: byAgent.map(r => ({ name: r.agentId, amount: r.spend })),
+    });
+  } catch (error) {
+    console.error('GET /api/finance/budget error:', error);
+    return NextResponse.json({ total: 0, spent: 0, remaining: 0, categories: [] });
+  }
+}
+
+export async function PATCH(request: NextRequest) {
+  try {
+    const { limit } = await request.json();
+    if (typeof limit !== 'number' || limit < 0) {
+      return NextResponse.json({ error: 'limit must be a non-negative number' }, { status: 400 });
+    }
+    getDb().prepare("INSERT OR REPLACE INTO settings (key, value) VALUES ('finance_budget_usd', ?)").run(String(limit));
+    return NextResponse.json({ ok: true, limit });
+  } catch (error) {
+    console.error('PATCH /api/finance/budget error:', error);
+    return NextResponse.json({ error: 'Internal server error' }, { status: 500 });
+  }
 }

package/app/api/finance/transactions/route.ts

@@ -1,5 +1,31 @@
-import { NextResponse } from 'next/server';
+import { NextRequest, NextResponse } from 'next/server';
+import { getDb } from '@/lib/database';
 
-export async function GET() {
-  return NextResponse.json([]);
+export async function GET(request: NextRequest) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const agentId = searchParams.get('agentId');
+    const taskId  = searchParams.get('taskId');
+    const limit   = Math.min(parseInt(searchParams.get('limit') ?? '50', 10), 200);
+    const offset  = parseInt(searchParams.get('offset') ?? '0', 10);
+
+    const db = getDb();
+    const conditions: string[] = [];
+    const params: unknown[] = [];
+
+    if (agentId) { conditions.push('agentId = ?'); params.push(agentId); }
+    if (taskId)  { conditions.push('taskId = ?');  params.push(taskId); }
+
+    const where = conditions.length ? `WHERE ${conditions.join(' AND ')}` : '';
+    const rows = db.prepare(
+      `SELECT id, agentId, taskId, model, inputTokens, outputTokens, costUsd, createdAt
+       FROM token_usage ${where}
+       ORDER BY createdAt DESC LIMIT ? OFFSET ?`
+    ).all(...params, limit, offset) as Record<string, unknown>[];
+
+    return NextResponse.json(rows);
+  } catch (error) {
+    console.error('GET /api/finance/transactions error:', error);
+    return NextResponse.json([], { status: 200 });
+  }
 }

package/app/api/inbox/rejections/route.ts

@@ -1,5 +1,19 @@
-import { NextResponse } from 'next/server';
+import { NextRequest, NextResponse } from 'next/server';
+import { getDb } from '@/lib/database';
 
-export async function GET() {
-  return NextResponse.json([]);
+export async function GET(request: NextRequest) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const limit = Math.min(parseInt(searchParams.get('limit') ?? '50', 10), 200);
+
+    const db = getDb();
+    const rows = db.prepare(
+      `SELECT * FROM inbox WHERE status = 'rejected' ORDER BY updatedAt DESC LIMIT ?`
+    ).all(limit) as Record<string, unknown>[];
+
+    return NextResponse.json(rows);
+  } catch (error) {
+    console.error('GET /api/inbox/rejections error:', error);
+    return NextResponse.json([]);
+  }
 }

package/app/api/logs/route.ts

@@ -0,0 +1,46 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { existsSync, statSync, openSync, readSync, closeSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+export const dynamic = 'force-dynamic';
+export const runtime = 'nodejs';
+
+const LOG_PATH = process.env.LOG_PATH || join(homedir(), 'mission-control', 'logs', 'mission-control.log');
+const MAX_READ = 256 * 1024; // 256 KB max per request
+
+export async function GET(request: NextRequest) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const cursor = parseInt(searchParams.get('cursor') ?? '0', 10);
+    const limit  = Math.min(parseInt(searchParams.get('limit') ?? '200', 10), 1000);
+
+    if (!existsSync(LOG_PATH)) {
+      return NextResponse.json({ file: LOG_PATH, cursor: 0, size: 0, lines: [], truncated: false });
+    }
+
+    const stat = statSync(LOG_PATH);
+    const size = stat.size;
+    const start = cursor > 0 ? cursor : Math.max(0, size - MAX_READ);
+    const readLen = Math.min(size - start, MAX_READ);
+
+    if (readLen <= 0) {
+      return NextResponse.json({ file: LOG_PATH, cursor: size, size, lines: [], truncated: false });
+    }
+
+    const buf = Buffer.alloc(readLen);
+    const fd = openSync(LOG_PATH, 'r');
+    readSync(fd, buf, 0, readLen, start);
+    closeSync(fd);
+
+    const text = buf.toString('utf-8');
+    const rawLines = text.split('\n').filter(Boolean);
+    const lines = rawLines.slice(-limit);
+    const truncated = rawLines.length > limit;
+
+    return NextResponse.json({ file: LOG_PATH, cursor: start + readLen, size, lines, truncated });
+  } catch (error) {
+    console.error('GET /api/logs error:', error);
+    return NextResponse.json({ file: LOG_PATH, cursor: 0, size: 0, lines: [], truncated: false });
+  }
+}

package/app/api/meetings/route.ts

@@ -1,5 +1,58 @@
-import { NextResponse } from 'next/server';
+import { NextRequest, NextResponse } from 'next/server';
+import { getDb } from '@/lib/database';
 
-export async function GET() {
-  return NextResponse.json([]);
+export async function GET(request: NextRequest) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const status = searchParams.get('status');
+    const from   = searchParams.get('from');
+    const to     = searchParams.get('to');
+
+    const db = getDb();
+    const conditions = ["(type LIKE '%meeting%' OR type LIKE '%call%' OR type LIKE '%event%')"];
+    const params: unknown[] = [];
+
+    if (status) { conditions.push('status = ?'); params.push(status); }
+    if (from)   { conditions.push('scheduledAt >= ?'); params.push(new Date(from).getTime()); }
+    if (to)     { conditions.push('scheduledAt <= ?'); params.push(new Date(to).getTime()); }
+
+    const rows = db.prepare(
+      `SELECT * FROM scheduled_items WHERE ${conditions.join(' AND ')} ORDER BY scheduledAt ASC`
+    ).all(...params) as Record<string, unknown>[];
+
+    return NextResponse.json(rows);
+  } catch (error) {
+    console.error('GET /api/meetings error:', error);
+    return NextResponse.json([]);
+  }
+}
+
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+    const { title, description, scheduledAt, duration, attendees, type = 'meeting' } = body;
+    if (!title || !scheduledAt) {
+      return NextResponse.json({ error: 'title and scheduledAt required' }, { status: 400 });
+    }
+
+    const db = getDb();
+    const id  = `meeting-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`;
+    const now = Date.now();
+
+    db.prepare(`
+      INSERT INTO scheduled_items (id, title, description, type, scheduledAt, duration, attendees, status, createdAt, updatedAt)
+      VALUES (?, ?, ?, ?, ?, ?, ?, 'scheduled', ?, ?)
+    `).run(
+      id, title, description ?? null, type,
+      new Date(scheduledAt).getTime(),
+      duration ?? 60,
+      attendees ? JSON.stringify(attendees) : null,
+      now, now
+    );
+
+    return NextResponse.json({ id }, { status: 201 });
+  } catch (error) {
+    console.error('POST /api/meetings error:', error);
+    return NextResponse.json({ error: 'Internal server error' }, { status: 500 });
+  }
 }

package/app/api/settings/route.ts

@@ -17,3 +17,27 @@ export async function GET(_request: NextRequest) {
     return NextResponse.json({ error: 'Internal server error' }, { status: 500 });
   }
 }
+
+export async function PATCH(request: NextRequest) {
+  try {
+    const db = getDb();
+    const body = await request.json();
+
+    if (typeof body !== 'object' || Array.isArray(body)) {
+      return NextResponse.json({ error: 'Body must be a key/value object' }, { status: 400 });
+    }
+
+    const upsert = db.prepare("INSERT OR REPLACE INTO settings (key, value) VALUES (?, ?)");
+    const upsertAll = db.transaction((entries: [string, string][]) => {
+      for (const [key, value] of entries) {
+        upsert.run(key, typeof value === 'string' ? value : JSON.stringify(value));
+      }
+    });
+
+    upsertAll(Object.entries(body) as [string, string][]);
+    return NextResponse.json({ success: true, updated: Object.keys(body).length });
+  } catch (error) {
+    console.error('PATCH /api/settings error:', error);
+    return NextResponse.json({ error: 'Internal server error' }, { status: 500 });
+  }
+}

package/bin/cli.js

@@ -19,7 +19,7 @@
 'use strict';
 
 const { execSync, spawnSync, spawn } = require('child_process');
-const { existsSync, readFileSync, writeFileSync, mkdirSync, copyFileSync } = require('fs');
+const { existsSync, readFileSync, writeFileSync, mkdirSync, copyFileSync, readdirSync } = require('fs');
 const path   = require('path');
 const os     = require('os');
 const http   = require('http');
@@ -316,6 +316,25 @@ async function cmdSetup(force = false) {
   }
   success('Memory vault ready');
 
+  // ── Seed knowledge base ────────────────────────────────────────────────
+  const knowledgeSrcDir = path.join(INSTALL_DIR, 'templates', 'knowledge');
+  const knowledgeDestDir = path.join(MC_MEMORY, 'knowledge');
+  if (existsSync(knowledgeSrcDir)) {
+    const knowledgeFiles = readdirSync(knowledgeSrcDir).filter(f => f.endsWith('.md'));
+    let seeded = 0;
+    for (const file of knowledgeFiles) {
+      const dest = path.join(knowledgeDestDir, file);
+      if (!existsSync(dest)) {
+        try {
+          const content = readFileSync(path.join(knowledgeSrcDir, file), 'utf-8');
+          writeFileSync(dest, content);
+          seeded++;
+        } catch { /* skip */ }
+      }
+    }
+    if (seeded > 0) success(`Seeded ${seeded} knowledge base articles`);
+  }
+
   // ── Write .env ──────────────────────────────────────────────────────────
   step('Writing configuration');
   const resolvedClaude = findClaudeBin();

package/install.sh

@@ -771,11 +771,37 @@ StandardError=journal
 WantedBy=default.target
 EOF
   
+  # cron daemon systemd service
+  cat > "${SYSTEMD_DIR}/mission-control-cron.service" << EOF
+[Unit]
+Description=Mission Control Cron Daemon
+After=network.target
+
+[Service]
+Type=simple
+WorkingDirectory=${REPO_DIR}
+ExecStart=${NODE_BIN} ${REPO_DIR}/tools/cron-daemon.js
+Restart=always
+RestartSec=5
+Environment=HOME=${HOME}
+Environment=MC_DB_PATH=${MC_DATA}/mission-control.db
+Environment=SCHEDULE_PATH=${MC_DATA}/schedule.json
+Environment=PROJECT_DIR=${REPO_DIR}
+StandardOutput=journal
+StandardError=journal
+
+[Install]
+WantedBy=default.target
+EOF
+
   systemctl --user daemon-reload
   systemctl --user enable mission-control.service
+  systemctl --user enable mission-control-cron.service
   systemctl --user start mission-control.service
-  success "systemd service installed and started"
+  systemctl --user start mission-control-cron.service
+  success "systemd services installed and started (app + cron daemon)"
   info "Logs: journalctl --user -fu mission-control"
+  info "Cron logs: journalctl --user -fu mission-control-cron"
 else
   warn "Unknown OS (${OS}) — manual startup only. Run: npm start"
 fi

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "froggo-mission-control",
-  "version": "1.1.9",
+  "version": "1.2.2",
   "description": "Self-hosted AI agent platform for Claude Code CLI. Multi-agent orchestration, task management, Gmail, Calendar, Kanban and more.",
   "keywords": [
     "claude",
@@ -48,7 +48,6 @@
     "tools/e2e-smoke-test.sh",
     "tools/db/",
     "next.config.js",
-    "next.config.ts",
     "tsconfig.json",
     "tailwind.config.js",
     "tailwind.config.ts",
@@ -59,7 +58,8 @@
     "APPROVAL_RULES.md",
     "README.md",
     "ecosystem.config.js",
-    "install.sh"
+    "install.sh",
+    "templates/"
   ],
   "scripts": {
     "postinstall": "node scripts/postinstall.js",
@@ -104,6 +104,9 @@
     "lucide-react": "^0.303.0",
     "next": "^16.1.6",
     "node-gyp": "^12.2.0",
+    "postcss": "^8.4.32",
+    "autoprefixer": "^10.4.16",
+    "tailwindcss": "3.4.17",
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
     "react-draggable": "^4.5.0",
@@ -133,7 +136,6 @@
     "@typescript-eslint/parser": "^8.0.0",
     "@vitejs/plugin-react": "^5.1.4",
     "@vitest/ui": "^4.0.18",
-    "autoprefixer": "^10.4.16",
     "eslint": "^8.56.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-jsx-a11y": "^6.10.2",
@@ -142,9 +144,7 @@
     "happy-dom": "^20.4.0",
     "jsdom": "^27.4.0",
     "playwright": "^1.58.0",
-    "postcss": "^8.4.32",
     "prettier": "^3.2.0",
-    "tailwindcss": "^3.4.0",
     "typescript": "^5.3.3",
     "vitest": "^4.0.18",
     "ws": "^8.19.0"