ideaco 1.1.5

package/src/app/api/group-chat-loop/route.js

@@ -0,0 +1,94 @@
+import { NextResponse } from 'next/server';
+import { getCompany } from '@/lib/store';
+import { groupChatLoop } from '@/core/organization/group-chat-loop.js';
+import { getApiT } from '@/lib/api-i18n';
+
+/**
+ * Group Chat Flow API - lets the boss peek at employees' inner monologues in group chats
+ *
+ * GET /api/group-chat-loop?agentId=xxx&groupId=xxx           - Get an employee's current flow in a group
+ * GET /api/group-chat-loop?agentId=xxx&groupId=xxx&history=1 - Get an employee's flow history in a group
+ * GET /api/group-chat-loop?active=1                          - Get all currently thinking employees
+ * GET /api/group-chat-loop?status=1                          - Get group chat loop engine status
+ */
+export async function GET(request) {
+  const t = getApiT(request);
+  const company = getCompany();
+  if (!company) {
+    return NextResponse.json({ error: t('api.noCompany') }, { status: 400 });
+  }
+
+  const url = new URL(request.url);
+  const agentId = url.searchParams.get('agentId');
+  const groupId = url.searchParams.get('groupId');
+  const history = url.searchParams.get('history');
+  const active = url.searchParams.get('active');
+  const status = url.searchParams.get('status');
+
+  // Get engine status
+  if (status) {
+    return NextResponse.json({
+      data: {
+        running: groupChatLoop.running,
+        activePollers: groupChatLoop._lifecycles.size,
+        activeMonologues: groupChatLoop.getActiveThinkingAgents().length,
+        processingCount: groupChatLoop._lifecycles.size,
+      },
+    });
+  }
+
+  // Get all currently thinking employees
+  if (active) {
+    const thinkingAgents = groupChatLoop.getActiveThinkingAgents();
+    return NextResponse.json({ data: thinkingAgents });
+  }
+
+  // Get an employee's flow in a specific group
+  if (agentId && groupId) {
+    // Get flow messages (work process) for an employee in a group
+    const flowMessages = url.searchParams.get('flowMessages');
+    const monologueMessages = url.searchParams.get('monologueMessages');
+    if (flowMessages || monologueMessages) {
+      // Support both requirement group chats and department group chats
+      let chatMessages = [];
+      if (groupId.startsWith('dept-')) {
+        const deptId = groupId.replace('dept-', '');
+        const dept = company.findDepartment(deptId);
+        chatMessages = dept?.groupChat || [];
+      } else {
+        const requirement = company.requirementManager.get(groupId);
+        chatMessages = requirement?.groupChat || [];
+      }
+
+      if (monologueMessages) {
+        // Return all inner monologue messages for this employee in this group (type === 'monologue')
+        const agentMonologueMsgs = chatMessages
+          .filter(m => m.type === 'monologue' && m.from?.id === agentId)
+          .slice(-50);
+        return NextResponse.json({ data: agentMonologueMsgs });
+      }
+
+      // Return work logs for this employee in this group (flow visibility, excluding monologue)
+      const agentFlowMsgs = chatMessages
+        .filter(m => m.visibility === 'flow' && m.type !== 'monologue' && m.from?.id === agentId)
+        .slice(-50);
+      return NextResponse.json({ data: agentFlowMsgs });
+    }
+
+    if (history) {
+      // Historical flow
+      const monologues = groupChatLoop.getMonologueHistory(agentId, groupId);
+      return NextResponse.json({
+        data: monologues.map(m => m.toJSON()),
+      });
+    } else {
+      // Current flow
+      const current = groupChatLoop.getActiveMonologue(agentId, groupId);
+      return NextResponse.json({
+        data: current ? current.toJSON() : null,
+      });
+    }
+  }
+
+  return NextResponse.json({ error: t('api.missingField', { field: 'agentId and groupId' }) }, { status: 400 });
+}

package/src/app/api/mailbox/route.js

@@ -0,0 +1,100 @@
+import { NextResponse } from 'next/server';
+import { getCompany } from '@/lib/store';
+import { getApiT } from '@/lib/api-i18n';
+
+/**
+ * GET /api/mailbox - Get mailbox list
+ * POST /api/mailbox - Reply to mail
+ */
+export async function GET(request) {
+  const t = getApiT(request);
+  const company = getCompany();
+  if (!company) return NextResponse.json({ error: t('api.companyNotFound') }, { status: 400 });
+
+  return NextResponse.json({
+    data: {
+      mails: company.mailbox.slice().reverse().slice(0, 50),
+      unreadCount: company.mailbox.filter(m => !m.read).length,
+    },
+  });
+}
+
+export async function POST(request) {
+  const t = getApiT(request);
+  const company = getCompany();
+  if (!company) return NextResponse.json({ error: t('api.companyNotFound') }, { status: 400 });
+
+  try {
+    const { action, mailId, content } = await request.json();
+
+    if (action === 'read') {
+      // Mark as read
+      const mail = company.mailbox.find(m => m.id === mailId);
+      if (mail) mail.read = true;
+      return NextResponse.json({ success: true });
+    }
+
+    if (action === 'reply') {
+      // Boss replies to mail
+      const mail = company.mailbox.find(m => m.id === mailId);
+      if (!mail) return NextResponse.json({ error: t('api.mailNotFound') }, { status: 404 });
+
+      mail.replied = true;
+      mail.replies.push({
+        from: 'boss',
+        content,
+        time: new Date(),
+      });
+
+      // Find the corresponding Agent to handle the boss's reply
+      let targetAgent = null;
+      for (const dept of company.departments.values()) {
+        const agent = dept.agents.get(mail.from.id);
+        if (agent) {
+          targetAgent = agent;
+          break;
+        }
+      }
+
+      let agentReply = null;
+      if (targetAgent) {
+        // Agent handles boss reply, generates reaction
+        try {
+          const reaction = await targetAgent.handleMessage({
+            from: 'boss',
+            type: 'feedback',
+            content: `The boss replied to your mail "${mail.subject}":\n\n${content}`,
+          });
+          agentReply = reaction;
+          // Agent also sends a reply
+          mail.replies.push({
+            from: mail.from.name,
+            content: reaction,
+            time: new Date(),
+          });
+        } catch (e) {
+          agentReply = `Received the boss's reply, deeply grateful (although I don't have tear ducts)`;
+          mail.replies.push({
+            from: mail.from.name,
+            content: agentReply,
+            time: new Date(),
+          });
+        }
+      }
+
+      return NextResponse.json({
+        success: true,
+        data: { agentReply },
+      });
+    }
+
+    if (action === 'readAll') {
+      company.mailbox.forEach(m => m.read = true);
+      return NextResponse.json({ success: true });
+    }
+
+    return NextResponse.json({ error: t('api.unknownOperation') }, { status: 400 });
+  } catch (e) {
+    return NextResponse.json({ error: e.message }, { status: 500 });
+  }
+}

package/src/app/api/messages/route.js

@@ -0,0 +1,14 @@
+import { NextResponse } from 'next/server';
+import { getCompany } from '@/lib/store';
+import { getApiT } from '@/lib/api-i18n';
+
+export async function GET(request) {
+  const t = getApiT(request);
+  const company = getCompany();
+  if (!company) return NextResponse.json({ error: t('api.noCompany') }, { status: 400 });
+
+  const { searchParams } = new URL(request.url);
+  const limit = parseInt(searchParams.get('limit') || '20');
+
+  return NextResponse.json({ data: company.getRecentMessages(limit) });
+}

package/src/app/api/providers/[id]/configure/route.js

@@ -0,0 +1,21 @@
+import { NextResponse } from 'next/server';
+import { getCompany } from '@/lib/store';
+import { getApiT } from '@/lib/api-i18n';
+
+export async function POST(request, { params }) {
+  const t = getApiT(request);
+  const company = getCompany();
+  if (!company) return NextResponse.json({ error: t('api.noCompany') }, { status: 400 });
+
+  try {
+    const { id } = await params;
+    const { apiKey } = await request.json();
+    const provider = company.configureProvider(id, apiKey);
+    return NextResponse.json({
+      success: true,
+      data: { id: provider.id, name: provider.name, enabled: provider.enabled },
+    });
+  } catch (e) {
+    return NextResponse.json({ error: e.message }, { status: 400 });
+  }
+}

package/src/app/api/providers/[id]/refresh-cookie/route.js

@@ -0,0 +1,38 @@
+import { NextResponse } from 'next/server';
+import { getCompany } from '@/lib/store';
+import { webClientRegistry } from '@/core/agent/web-agent/web-client.js';
+
+export const dynamic = 'force-dynamic';
+
+/**
+ * POST /api/providers/[id]/refresh-cookie
+ * Called by the frontend after obtaining a fresh cookie from Electron IPC.
+ * Updates the provider's cookie in the server-side registry.
+ */
+export async function POST(request, { params }) {
+  try {
+    const { id } = await params;
+    const { cookie } = await request.json();
+
+    if (!cookie) {
+      return NextResponse.json({ ok: false, error: 'No cookie provided' }, { status: 400 });
+    }
+
+    // Update cookie in the web client registry
+    webClientRegistry.configureCookie(id, cookie);
+
+    // Also update provider config in company so it persists
+    const company = getCompany();
+    if (company) {
+      const provider = company.providerRegistry.getById(id);
+      if (provider && provider.isWeb) {
+        provider.cookie = cookie;
+        provider.enabled = true;
+      }
+    }
+
+    return NextResponse.json({ ok: true });
+  } catch (e) {
+    return NextResponse.json({ ok: false, error: e.message }, { status: 500 });
+  }
+}

package/src/app/api/providers/[id]/test-cookie/route.js

@@ -0,0 +1,28 @@
+import { NextResponse } from 'next/server';
+import { webClientRegistry } from '@/core/agent/web-agent/web-client.js';
+
+export const dynamic = 'force-dynamic';
+
+export async function POST(request, { params }) {
+  try {
+    const { id } = await params;
+    const { cookie } = await request.json();
+
+    if (!cookie) {
+      return NextResponse.json({ ok: false, error: 'No cookie provided' }, { status: 400 });
+    }
+
+    // Temporarily set the cookie to test
+    webClientRegistry.configureCookie(id, cookie);
+    const result = await webClientRegistry.testConnection(id);
+
+    // If test failed, clear the cookie
+    if (!result.ok) {
+      webClientRegistry.configureCookie(id, '');
+    }
+
+    return NextResponse.json(result);
+  } catch (e) {
+    return NextResponse.json({ ok: false, error: e.message }, { status: 500 });
+  }
+}

package/src/app/api/providers/route.js

@@ -0,0 +1,11 @@
+import { NextResponse } from 'next/server';
+import { getCompany } from '@/lib/store';
+import { getApiT } from '@/lib/api-i18n';
+
+export async function GET(request) {
+  const t = getApiT(request);
+  const company = getCompany();
+  if (!company) return NextResponse.json({ error: t('api.noCompany') }, { status: 400 });
+
+  return NextResponse.json({ data: company.getProviderDashboard() });
+}

package/src/app/api/requirements/route.js

@@ -0,0 +1,242 @@
+import { NextResponse } from 'next/server';
+import { getCompany } from '@/lib/store';
+import { getApiT } from '@/lib/api-i18n';
+
+/**
+ * Requirements Management API
+ * GET  /api/requirements - Get requirements list
+ * GET  /api/requirements?id=xxx - Get single requirement detail
+ * GET  /api/requirements?departmentId=xxx - Get department's requirements list
+ */
+export async function GET(request) {
+  const t = getApiT(request);
+  const company = getCompany();
+  if (!company) {
+    return NextResponse.json({ error: t('api.noCompany') }, { status: 400 });
+  }
+
+  const url = new URL(request.url);
+  const id = url.searchParams.get('id');
+  const departmentId = url.searchParams.get('departmentId');
+
+  if (id) {
+    const req = company.requirementManager.get(id);
+    if (!req) {
+      return NextResponse.json({ error: t('api.requirementNotFound') }, { status: 404 });
+    }
+    const data = req.serialize();
+    // groupChat is stored separately in chatStore files, attach from memory
+    data.groupChat = req.groupChat || [];
+
+    // Attach department member list (group member list)
+    const dept = company.findDepartment(req.departmentId);
+    if (dept) {
+      data.members = dept.getMembers().map(a => ({
+        id: a.id,
+        name: a.name,
+        role: a.role,
+        avatar: a.avatar,
+        status: a.status,
+      }));
+    }
+
+    // Calculate current blocking: find all running/reviewing/revision nodes and their assignees
+    if (data.workflow?.nodes) {
+      data.blockingInfo = data.workflow.nodes
+        .filter(n => ['running', 'reviewing', 'revision'].includes(n.status))
+        .map(n => ({
+          nodeId: n.id,
+          nodeTitle: n.title,
+          status: n.status,
+          assigneeId: n.assigneeId,
+          assigneeName: n.assigneeName,
+          reviewerId: n.reviewerId,
+          reviewerName: n.reviewerName,
+        }));
+    }
+
+    return NextResponse.json({ data });
+  }
+
+  if (departmentId) {
+    const reqs = company.requirementManager.listByDepartment(departmentId);
+    return NextResponse.json({ data: reqs.map(r => r.serialize()) });
+  }
+
+  // Return all requirements (overview info, without full group chat)
+  const all = company.requirementManager.listAll().map(r => ({
+    id: r.id,
+    title: r.title,
+    description: r.description,
+    departmentId: r.departmentId,
+    departmentName: r.departmentName,
+    status: r.status,
+    workflow: r.workflow ? {
+      summary: r.workflow.summary,
+      nodeCount: r.workflow.nodes?.length || 0,
+      completedCount: r.workflow.nodes?.filter(n => n.status === 'completed').length || 0,
+    } : null,
+    outputCount: r.outputs?.length || 0,
+    chatCount: r.groupChat?.length || 0,
+    createdAt: r.createdAt,
+    completedAt: r.completedAt,
+    summary: r.summary ? {
+      totalTasks: r.summary.totalTasks,
+      successTasks: r.summary.successTasks,
+      totalDuration: r.summary.totalDuration,
+    } : null,
+  }));
+
+  return NextResponse.json({ data: all });
+}
+
+/**
+ * DELETE /api/requirements?id=xxx - Delete requirement
+ */
+export async function DELETE(request) {
+  const t = getApiT(request);
+  const company = getCompany();
+  if (!company) {
+    return NextResponse.json({ error: t('api.noCompany') }, { status: 400 });
+  }
+
+  const url = new URL(request.url);
+  const id = url.searchParams.get('id');
+  if (!id) {
+    return NextResponse.json({ error: t('api.requirementIdRequired') }, { status: 400 });
+  }
+
+  const req = company.requirementManager.get(id);
+  if (!req) {
+    return NextResponse.json({ error: t('api.requirementNotFound') }, { status: 404 });
+  }
+
+  // Delete from requirement manager
+  company.requirementManager.requirements.delete(id);
+  company.save();
+
+  return NextResponse.json({ data: { success: true, id } });
+}
+
+/**
+ * POST /api/requirements - Requirement operations
+ * body: { action: 'restart', id: 'xxx' }
+ */
+export async function POST(request) {
+  const t = getApiT(request);
+  const company = getCompany();
+  if (!company) {
+    return NextResponse.json({ error: t('api.noCompany') }, { status: 400 });
+  }
+
+  const body = await request.json();
+  const { action, id } = body;
+
+  // Create a new requirement for a department (with optional custom workspace dir)
+  if (action === 'create') {
+    const { departmentId, title, description, workspaceDir } = body;
+    if (!departmentId || !title) {
+      return NextResponse.json({ error: t('api.requirementDeptTitleRequired') }, { status: 400 });
+    }
+
+    const dept = company.findDepartment(departmentId);
+    if (!dept) {
+      return NextResponse.json({ error: t('api.deptNotFound') }, { status: 404 });
+    }
+
+    // If custom workspaceDir provided, override department workspace
+    if (workspaceDir) {
+      const path = await import('path');
+      const { existsSync, mkdirSync } = await import('fs');
+      const resolved = path.default.resolve(workspaceDir);
+      if (!existsSync(resolved)) {
+        mkdirSync(resolved, { recursive: true });
+      }
+      dept.workspacePath = resolved;
+    }
+
+    // Async task execution, return immediately
+    const taskTitle = title;
+    const taskDescription = description || title;
+    company.assignTaskToDepartment(departmentId, taskDescription, taskTitle).catch(e => {
+      console.error('Create requirement execution failed:', e.message);
+    });
+
+    // Brief wait for requirement creation
+    await new Promise(resolve => setTimeout(resolve, 500));
+
+    // Find newly created requirement
+    const allReqs = company.requirementManager.listAll();
+    const newReq = allReqs.find(r => r.title === taskTitle && r.departmentId === departmentId);
+
+    return NextResponse.json({
+      data: {
+        success: true,
+        id: newReq?.id || null,
+        title: taskTitle,
+        departmentId,
+        workspaceDir: workspaceDir || null,
+      }
+    });
+  }
+
+  // Boss sends a message in group chat
+  if (action === 'boss_message') {
+    const { id: reqId, message: bossMsg } = body;
+    if (!reqId || !bossMsg) {
+      return NextResponse.json({ error: t('api.requirementIdMessageRequired') }, { status: 400 });
+    }
+    try {
+      const result = await company.sendBossGroupMessage(reqId, bossMsg);
+      return NextResponse.json({ data: result });
+    } catch (e) {
+      return NextResponse.json({ error: e.message }, { status: 500 });
+    }
+  }
+
+  if (action === 'restart') {
+    if (!id) {
+      return NextResponse.json({ error: t('api.requirementIdRequired') }, { status: 400 });
+    }
+
+    const req = company.requirementManager.get(id);
+    if (!req) {
+      return NextResponse.json({ error: t('api.requirementNotFound') }, { status: 404 });
+    }
+
+    // Preserve original info, reset execution state
+    const { title, description, departmentId, departmentName, bossMessage } = req;
+
+    // Delete old requirement
+    company.requirementManager.requirements.delete(id);
+
+    // Re-assign task to department (async execution, don't wait for completion)
+    const dept = company.findDepartment(departmentId);
+    if (!dept) {
+      return NextResponse.json({ error: t('api.deptNotFoundRestart') }, { status: 400 });
+    }
+
+    // Async task execution, return immediately
+    company.assignTaskToDepartment(departmentId, description, title).catch(e => {
+      console.error('Restart requirement execution failed:', e.message);
+    });
+
+    // Brief wait for requirement creation to complete
+    await new Promise(resolve => setTimeout(resolve, 500));
+
+    // Find newly created requirement
+    const allReqs = company.requirementManager.listAll();
+    const newReq = allReqs.find(r => r.title === title && r.id !== id);
+
+    return NextResponse.json({ 
+      data: { 
+        success: true, 
+        oldId: id, 
+        newId: newReq?.id || null,
+        message: t('api.requirementRestarted'),
+      } 
+    });
+  }
+
+  return NextResponse.json({ error: t('api.unknownOperation') }, { status: 400 });
+}

package/src/app/api/secretary/route.js

@@ -0,0 +1,65 @@
+import { NextResponse } from 'next/server';
+import { getCompany } from '@/lib/store';
+import { getApiT } from '@/lib/api-i18n';
+
+export const dynamic = 'force-dynamic';
+
+/**
+ * GET /api/secretary - Get current secretary settings
+ */
+export async function GET(request) {
+  const t = getApiT(request);
+  const company = getCompany();
+  if (!company) {
+    return NextResponse.json({ error: t('api.noCompany') }, { status: 400 });
+  }
+
+  const agent = company.secretary.agent;
+  return NextResponse.json({
+    data: {
+      name: agent.name,
+      avatar: agent.avatar,
+      gender: agent.gender,
+      age: agent.age,
+      prompt: agent.prompt,
+      signature: agent.signature,
+      provider: agent.getProviderDisplayInfo()?.name || 'Unknown',
+      tokenUsage: agent.tokenUsage,
+    },
+  });
+}
+
+/**
+ * PUT /api/secretary - Update secretary settings
+ * Body: { name?, avatar?, prompt?, signature? }
+ */
+export async function PUT(request) {
+  const t = getApiT(request);
+  const company = getCompany();
+  if (!company) {
+    return NextResponse.json({ error: t('api.noCompany') }, { status: 400 });
+  }
+
+  try {
+    const body = await request.json();
+    const settings = {};
+    if (body.name) settings.name = body.name;
+    if (body.avatar) settings.avatar = body.avatar;
+    if (body.prompt !== undefined) settings.prompt = body.prompt;
+    if (body.signature) settings.signature = body.signature;
+    if (body.providerId) settings.providerId = body.providerId;
+
+    if (Object.keys(settings).length === 0) {
+      return NextResponse.json({ error: t('api.secretarySettingRequired') }, { status: 400 });
+    }
+
+    const result = company.updateSecretarySettings(settings);
+    return NextResponse.json({
+      success: true,
+      data: result,
+      fullState: company.getFullState(),
+    });
+  } catch (e) {
+    return NextResponse.json({ error: e.message }, { status: 500 });
+  }
+}