@mndrk/agx 2.0.13 → 2.0.15

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/app/api/agents/[id]/messages/route.ts

@@ -0,0 +1,91 @@
+import { NextRequest } from "next/server";
+import Database from "better-sqlite3";
+import path from "path";
+import os from "os";
+import { existsSync } from "fs";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+const HISTORY_DIR =
+  process.env.AGX_GROUP_CHAT_DIR?.trim() ||
+  path.join(os.homedir(), ".agx", "group-chat");
+const DB_PATH = path.join(HISTORY_DIR, "history.sqlite");
+
+export async function GET(
+  _request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id: agentId } = await params;
+
+  if (!existsSync(DB_PATH)) {
+    return Response.json({ messages: [], stats: { total_messages: 0, threads_participated: 0 } });
+  }
+
+  try {
+    const db = new Database(DB_PATH, { readonly: true });
+    db.pragma("journal_mode = WAL");
+
+    // Get agent's messages with root content (thread title) and the preceding message in the thread
+    const messages = db
+      .prepare(
+        `SELECT m.thread_id, m.id, m.role, m.participant_id, m.content, m.timestamp,
+                m.root_message_id,
+                root.content as root_content,
+                prev.content as prev_content,
+                prev.participant_id as prev_participant_id
+         FROM messages m
+         LEFT JOIN messages root ON root.id = m.root_message_id AND root.thread_id = m.thread_id
+         LEFT JOIN messages prev ON prev.thread_id = m.thread_id
+           AND prev.timestamp = (
+             SELECT MAX(p.timestamp) FROM messages p
+             WHERE p.thread_id = m.thread_id
+               AND (p.root_message_id = m.root_message_id OR p.id = m.root_message_id)
+               AND p.timestamp < m.timestamp
+           )
+         WHERE m.participant_id = ?
+         ORDER BY m.timestamp DESC
+         LIMIT 100`
+      )
+      .all(agentId) as Array<{
+        thread_id: string;
+        id: string;
+        role: string;
+        participant_id: string | null;
+        content: string;
+        timestamp: number;
+        root_message_id: string | null;
+        root_content: string | null;
+        prev_content: string | null;
+        prev_participant_id: string | null;
+      }>;
+
+    const statsRow = db
+      .prepare(
+        `SELECT COUNT(*) as total_messages,
+                COUNT(DISTINCT root_message_id) as threads_participated
+         FROM messages
+         WHERE participant_id = ?`
+      )
+      .get(agentId) as { total_messages: number; threads_participated: number } | undefined;
+
+    db.close();
+
+    return Response.json({
+      messages: messages.map((m) => ({
+        threadId: m.thread_id,
+        id: m.id,
+        role: m.role,
+        content: m.content,
+        timestamp: m.timestamp,
+        rootMessageId: m.root_message_id,
+        threadTitle: m.root_content ? m.root_content.slice(0, 120) : null,
+        prevContent: m.prev_content ? m.prev_content.slice(0, 200) : null,
+        prevParticipantId: m.prev_participant_id,
+      })),
+      stats: statsRow ?? { total_messages: 0, threads_participated: 0 },
+    });
+  } catch {
+    return Response.json({ messages: [], stats: { total_messages: 0, threads_participated: 0 } });
+  }
+}

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/app/api/agents/[id]/profile/route.ts

@@ -0,0 +1,87 @@
+import { NextRequest } from "next/server";
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+const AGENTS_DIR = join(homedir(), ".agx", "agents");
+
+interface JournalEntry {
+  t: string;
+  type?: string;
+  observation?: string;
+  judgement?: string;
+  delta?: string;
+  intent?: string;
+  id?: string;
+  body?: string;
+  selfVersion?: number;
+  thread?: string;
+  action?: string;
+}
+
+function readJsonl(filePath: string): unknown[] {
+  if (!existsSync(filePath)) return [];
+  const lines = readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
+  return lines.map((line) => {
+    try { return JSON.parse(line); } catch { return null; }
+  }).filter(Boolean);
+}
+
+export async function GET(
+  _request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+  const agentDir = join(AGENTS_DIR, id);
+
+  if (!existsSync(agentDir)) {
+    return Response.json({ error: "Agent not found in ~/.agx/agents" }, { status: 404 });
+  }
+
+  // Read identity.json
+  let identity: Record<string, unknown> = {};
+  const identityPath = join(agentDir, "identity.json");
+  if (existsSync(identityPath)) {
+    try { identity = JSON.parse(readFileSync(identityPath, "utf-8")); } catch {}
+  }
+
+  // Read self.md (the evolving bio)
+  let self = "";
+  const selfPath = join(agentDir, "self.md");
+  if (existsSync(selfPath)) {
+    const raw = readFileSync(selfPath, "utf-8");
+    // Strip YAML frontmatter
+    const match = raw.match(/^---[\s\S]*?---\s*\n?([\s\S]*)$/);
+    self = match ? match[1].trim() : raw.trim();
+  }
+
+  // Read journal.jsonl
+  const journal = readJsonl(join(agentDir, "journal.jsonl")) as JournalEntry[];
+
+  // Read activity.jsonl
+  const activity = readJsonl(join(agentDir, "activity.jsonl")) as Record<string, unknown>[];
+
+  // Parse self.md frontmatter for version info
+  let selfVersion: number | null = null;
+  let selfDerivedAt: string | null = null;
+  const selfRaw = existsSync(selfPath) ? readFileSync(selfPath, "utf-8") : "";
+  const fmMatch = selfRaw.match(/^---\s*\n([\s\S]*?)\n---/);
+  if (fmMatch) {
+    const vMatch = fmMatch[1].match(/version:\s*(\d+)/);
+    const dMatch = fmMatch[1].match(/derivedAt:\s*(.+)/);
+    if (vMatch) selfVersion = parseInt(vMatch[1]);
+    if (dMatch) selfDerivedAt = dMatch[1].trim();
+  }
+
+  return Response.json({
+    identity,
+    self,
+    selfVersion,
+    selfDerivedAt,
+    journal: journal.slice(-50).reverse(), // latest 50, newest first
+    activity: activity.slice(-50).reverse(),
+  });
+}

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/app/api/agents/export/route.ts

@@ -0,0 +1,51 @@
+import { NextRequest } from "next/server";
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { loadParticipants } from "@/lib/participants-store";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+const AGENTS_DIR = join(homedir(), ".agx", "agents");
+
+function readSelfMd(agentId: string): string | null {
+  const selfPath = join(AGENTS_DIR, agentId, "self.md");
+  if (!existsSync(selfPath)) return null;
+  const raw = readFileSync(selfPath, "utf-8");
+  const match = raw.match(/^---[\s\S]*?---\s*\n?([\s\S]*)$/);
+  return match ? match[1].trim() : raw.trim();
+}
+
+/** POST /api/agents/export — returns bundle JSON for selected agent IDs */
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json().catch(() => ({}));
+    const agentIds: string[] = Array.isArray(body.agentIds) ? body.agentIds : [];
+
+    if (agentIds.length === 0) {
+      return Response.json({ error: "No agents selected" }, { status: 400 });
+    }
+
+    const allParticipants = loadParticipants();
+    const selected = allParticipants.filter((p) => agentIds.includes(p.id));
+
+    const agents = selected.map((p) => ({
+      id: p.id,
+      name: p.name,
+      provider: p.provider,
+      model: p.model,
+      color: p.color,
+      identity: p.identity || null,
+      identityFile: p.identityFile || null,
+      skills: p.skills || [],
+      variables: p.variables || {},
+      self: readSelfMd(p.id),
+    }));
+
+    return Response.json({ agents });
+  } catch (error) {
+    console.error("Error exporting agents:", error);
+    return Response.json({ error: "Failed to export" }, { status: 500 });
+  }
+}

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/app/api/chat/route.ts

@@ -3,6 +3,7 @@ import { loadParticipants } from "@/lib/participants-store";
 import { createMultiplexedStream } from "@/lib/stream-multiplexer";
 import { loadHistory, saveMessages, sweepStaleWorkingReactions } from "@/lib/history-store";
 import { finalizeAttachments } from "@/lib/attachment-store";
+import { getSQLiteDb } from "@/lib/sqlite-query-adapter";
 import type { GroupMessage, Participant } from "@/lib/types";
 
 export const runtime = "nodejs";
@@ -85,6 +86,33 @@ function getParticipantMentionTokens(participants: Participant[]): Set<string> {
   return tokens;
 }
 
+interface TeamRow {
+  id: string;
+  name: string;
+  is_default: number;
+}
+
+interface TeamAgentRow {
+  team_id: string;
+  agent_id: string;
+  routing_order: number;
+}
+
+function loadTeamsWithAgents(): { teams: TeamRow[]; agentsByTeam: Record<string, TeamAgentRow[]> } {
+  try {
+    const db = getSQLiteDb();
+    const teams = db.prepare("SELECT id, name, is_default FROM teams").all() as TeamRow[];
+    const agents = db.prepare("SELECT * FROM team_agents ORDER BY routing_order ASC").all() as TeamAgentRow[];
+    const agentsByTeam: Record<string, TeamAgentRow[]> = {};
+    for (const a of agents) {
+      (agentsByTeam[a.team_id] ??= []).push(a);
+    }
+    return { teams, agentsByTeam };
+  } catch {
+    return { teams: [], agentsByTeam: {} };
+  }
+}
+
 function detectPromptMentions(
   prompt: string,
   participants: Participant[],
@@ -108,6 +136,25 @@ function detectPromptMentions(
     return { mentioned, parallel };
   }
 
+  // Expand @TeamName → team member agent IDs (sequential by routing_order)
+  // @@TeamName → parallel
+  const { teams, agentsByTeam } = loadTeamsWithAgents();
+  for (const team of teams) {
+    if (team.is_default) continue;
+    const teamNameLower = team.name.toLowerCase();
+    const hasParallelTeam = lower.includes(`@@${teamNameLower}`);
+    const hasTeam = lower.includes(`@${teamNameLower}`);
+    if (hasParallelTeam || hasTeam) {
+      const members = agentsByTeam[team.id] ?? [];
+      for (const member of members) {
+        mentioned.add(member.agent_id);
+        if (hasParallelTeam) {
+          parallel.add(member.agent_id);
+        }
+      }
+    }
+  }
+
   // Individual @Name resolves against the full library
   for (const participant of participants) {
     const id = participant.id.toLowerCase();

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/app/api/history/route.ts

@@ -5,6 +5,7 @@ import {
   clearRootThread,
   saveMessages,
   sweepStaleWorkingReactions,
+  updateMessageStatus,
 } from "@/lib/history-store";
 import { getAttachmentsForMessages } from "@/lib/attachment-store";
 import type { GroupMessage } from "@/lib/types";
@@ -51,6 +52,22 @@ export async function POST(request: NextRequest) {
   return Response.json({ ok: true });
 }
 
+export async function PATCH(request: NextRequest) {
+  const rawBody = await request.json().catch(() => null);
+  const body = rawBody && typeof rawBody === "object"
+    ? (rawBody as { threadId?: unknown; messageId?: unknown; threadStatus?: unknown; outcomeNote?: unknown })
+    : {};
+  const threadId = typeof body.threadId === "string" ? body.threadId.trim() : "";
+  const messageId = typeof body.messageId === "string" ? body.messageId.trim() : "";
+  if (!threadId || !messageId) {
+    return Response.json({ error: "threadId and messageId are required" }, { status: 400 });
+  }
+  const threadStatus = typeof body.threadStatus === "string" ? body.threadStatus : null;
+  const outcomeNote = typeof body.outcomeNote === "string" ? body.outcomeNote : null;
+  await updateMessageStatus(threadId, messageId, threadStatus, outcomeNote);
+  return Response.json({ ok: true });
+}
+
 export async function DELETE(request: NextRequest) {
   const threadId = readThreadIdFromRequest(request);
   if (!threadId) {

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/app/api/participants/route.ts

@@ -6,6 +6,9 @@ import {
   removeParticipant,
   reorderParticipants,
 } from "@/lib/participants-store";
+import { getSQLiteDb } from "@/lib/sqlite-query-adapter";
+import { LOCAL_USER } from "@/lib/auth-mode";
+import { ensureDefaultTeam } from "@/lib/teams";
 import type { ChatProvider, Participant, Skill } from "@/lib/types";
 
 export const runtime = "nodejs";
@@ -24,6 +27,7 @@ interface ParticipantPayload {
   identity?: unknown;
   identityFile?: unknown;
   skills?: unknown;
+  variables?: unknown;
   color?: unknown;
 }
 
@@ -81,6 +85,16 @@ function toParticipant(body: ParticipantPayload, fallbackId?: string): Participa
   const skills = toSkills(body.skills);
   const color = toOptionalString(body.color) ?? "#6B7280";
 
+  let variables: Record<string, string> | undefined;
+  if (body.variables && typeof body.variables === "object" && !Array.isArray(body.variables)) {
+    const obj = body.variables as Record<string, unknown>;
+    const cleaned: Record<string, string> = {};
+    for (const [k, v] of Object.entries(obj)) {
+      if (typeof v === "string") cleaned[k] = v;
+    }
+    if (Object.keys(cleaned).length > 0) variables = cleaned;
+  }
+
   return {
     id,
     name,
@@ -90,6 +104,7 @@ function toParticipant(body: ParticipantPayload, fallbackId?: string): Participa
     ...(identity ? { identity } : {}),
     ...(identityFile ? { identityFile } : {}),
     ...(skills ? { skills } : {}),
+    ...(variables ? { variables } : {}),
   };
 }
 
@@ -108,6 +123,26 @@ export async function POST(request: NextRequest) {
   const created = uniqueId === participant.id ? participant : { ...participant, id: uniqueId };
 
   addParticipant(created);
+
+  // Auto-assign to team
+  try {
+    const db = getSQLiteDb();
+    const teamId = typeof (body as any).teamId === "string" ? (body as any).teamId : null;
+    if (teamId) {
+      db.prepare("INSERT OR IGNORE INTO team_agents (team_id, agent_id, routing_order) VALUES (?, ?, 0)").run(teamId, created.id);
+    } else {
+      ensureDefaultTeam(db, LOCAL_USER.id);
+      const defaultTeam = db
+        .prepare("SELECT id FROM teams WHERE user_id = ? AND is_default = 1")
+        .get(LOCAL_USER.id) as { id: string } | undefined;
+      if (defaultTeam) {
+        db.prepare("INSERT OR IGNORE INTO team_agents (team_id, agent_id, routing_order) VALUES (?, ?, 0)").run(defaultTeam.id, created.id);
+      }
+    }
+  } catch (e) {
+    console.error("Failed to auto-assign agent to team:", e);
+  }
+
   return Response.json(created, { status: 201 });
 }
 

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/app/api/teams/[id]/agents/route.ts

@@ -0,0 +1,118 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getSQLiteDb } from "@/lib/sqlite-query-adapter";
+import { LOCAL_USER } from "@/lib/auth-mode";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+type RouteContext = { params: Promise<{ id: string }> };
+
+function verifyTeamOwnership(db: any, teamId: string): boolean {
+  const team = db
+    .prepare("SELECT id FROM teams WHERE id = ? AND user_id = ?")
+    .get(teamId, LOCAL_USER.id);
+  return Boolean(team);
+}
+
+/** POST /api/teams/[id]/agents — add an agent to the team */
+export async function POST(request: NextRequest, context: RouteContext) {
+  try {
+    const { id: teamId } = await context.params;
+    const body = await request.json().catch(() => ({}));
+    const agentId = typeof body.agentId === "string" ? body.agentId.trim() : "";
+
+    if (!agentId) {
+      return NextResponse.json({ error: "agentId is required" }, { status: 400 });
+    }
+
+    const db = getSQLiteDb();
+    if (!verifyTeamOwnership(db, teamId)) {
+      return NextResponse.json({ error: "Team not found" }, { status: 404 });
+    }
+
+    // Get next routing_order
+    const max = db
+      .prepare("SELECT COALESCE(MAX(routing_order), -1) as max_order FROM team_agents WHERE team_id = ?")
+      .get(teamId) as any;
+    const nextOrder = (max?.max_order ?? -1) + 1;
+
+    db.prepare(
+      "INSERT OR IGNORE INTO team_agents (team_id, agent_id, routing_order) VALUES (?, ?, ?)"
+    ).run(teamId, agentId, nextOrder);
+
+    const agents = db
+      .prepare("SELECT * FROM team_agents WHERE team_id = ? ORDER BY routing_order ASC")
+      .all(teamId) as any[];
+
+    return NextResponse.json({ agents }, { status: 201 });
+  } catch (error) {
+    console.error("Error adding agent to team:", error);
+    return NextResponse.json({ error: "Failed to add agent" }, { status: 500 });
+  }
+}
+
+/** DELETE /api/teams/[id]/agents?agentId=<id> — remove an agent from the team */
+export async function DELETE(request: NextRequest, context: RouteContext) {
+  try {
+    const { id: teamId } = await context.params;
+    const { searchParams } = new URL(request.url);
+    const agentId = searchParams.get("agentId");
+
+    if (!agentId) {
+      return NextResponse.json({ error: "agentId query param is required" }, { status: 400 });
+    }
+
+    const db = getSQLiteDb();
+    if (!verifyTeamOwnership(db, teamId)) {
+      return NextResponse.json({ error: "Team not found" }, { status: 404 });
+    }
+
+    db.prepare("DELETE FROM team_agents WHERE team_id = ? AND agent_id = ?").run(teamId, agentId);
+
+    const agents = db
+      .prepare("SELECT * FROM team_agents WHERE team_id = ? ORDER BY routing_order ASC")
+      .all(teamId) as any[];
+
+    return NextResponse.json({ agents });
+  } catch (error) {
+    console.error("Error removing agent from team:", error);
+    return NextResponse.json({ error: "Failed to remove agent" }, { status: 500 });
+  }
+}
+
+/** PATCH /api/teams/[id]/agents — reorder agents (expects { orderedAgentIds: string[] }) */
+export async function PATCH(request: NextRequest, context: RouteContext) {
+  try {
+    const { id: teamId } = await context.params;
+    const body = await request.json().catch(() => ({}));
+    const orderedIds = body.orderedAgentIds;
+
+    if (!Array.isArray(orderedIds) || orderedIds.some((id: unknown) => typeof id !== "string")) {
+      return NextResponse.json({ error: "orderedAgentIds must be a string array" }, { status: 400 });
+    }
+
+    const db = getSQLiteDb();
+    if (!verifyTeamOwnership(db, teamId)) {
+      return NextResponse.json({ error: "Team not found" }, { status: 404 });
+    }
+
+    const update = db.prepare(
+      "UPDATE team_agents SET routing_order = ? WHERE team_id = ? AND agent_id = ?"
+    );
+    const reorder = db.transaction(() => {
+      for (let i = 0; i < orderedIds.length; i++) {
+        update.run(i, teamId, orderedIds[i]);
+      }
+    });
+    reorder();
+
+    const agents = db
+      .prepare("SELECT * FROM team_agents WHERE team_id = ? ORDER BY routing_order ASC")
+      .all(teamId) as any[];
+
+    return NextResponse.json({ agents });
+  } catch (error) {
+    console.error("Error reordering team agents:", error);
+    return NextResponse.json({ error: "Failed to reorder agents" }, { status: 500 });
+  }
+}

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/app/api/teams/[id]/route.ts

@@ -0,0 +1,80 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getSQLiteDb } from "@/lib/sqlite-query-adapter";
+import { LOCAL_USER } from "@/lib/auth-mode";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+type RouteContext = { params: Promise<{ id: string }> };
+
+/** PATCH /api/teams/[id] — rename a team */
+export async function PATCH(request: NextRequest, context: RouteContext) {
+  try {
+    const { id } = await context.params;
+    const body = await request.json().catch(() => ({}));
+    const name = typeof body.name === "string" ? body.name.trim() : "";
+
+    if (!name) {
+      return NextResponse.json({ error: "Team name is required" }, { status: 400 });
+    }
+
+    const db = getSQLiteDb();
+    const team = db
+      .prepare("UPDATE teams SET name = ? WHERE id = ? AND user_id = ? RETURNING *")
+      .get(name, id, LOCAL_USER.id) as any;
+
+    if (!team) {
+      return NextResponse.json({ error: "Team not found" }, { status: 404 });
+    }
+
+    return NextResponse.json({ team });
+  } catch (error) {
+    console.error("Error updating team:", error);
+    return NextResponse.json({ error: "Failed to update team" }, { status: 500 });
+  }
+}
+
+/** DELETE /api/teams/[id] — delete a team; agents move to default team */
+export async function DELETE(_request: NextRequest, context: RouteContext) {
+  try {
+    const { id } = await context.params;
+    const db = getSQLiteDb();
+
+    const team = db
+      .prepare("SELECT * FROM teams WHERE id = ? AND user_id = ?")
+      .get(id, LOCAL_USER.id) as any;
+
+    if (!team) {
+      return NextResponse.json({ error: "Team not found" }, { status: 404 });
+    }
+
+    if (team.is_default) {
+      return NextResponse.json({ error: "Cannot delete the default team" }, { status: 400 });
+    }
+
+    // Move agents to default team before deleting
+    const defaultTeam = db
+      .prepare("SELECT id FROM teams WHERE user_id = ? AND is_default = 1")
+      .get(LOCAL_USER.id) as { id: string } | undefined;
+
+    if (defaultTeam) {
+      const agents = db
+        .prepare("SELECT agent_id FROM team_agents WHERE team_id = ?")
+        .all(id) as { agent_id: string }[];
+
+      const insert = db.prepare(
+        "INSERT OR IGNORE INTO team_agents (team_id, agent_id, routing_order) VALUES (?, ?, ?)"
+      );
+      for (const a of agents) {
+        insert.run(defaultTeam.id, a.agent_id, 0);
+      }
+    }
+
+    db.prepare("DELETE FROM teams WHERE id = ? AND user_id = ?").run(id, LOCAL_USER.id);
+
+    return NextResponse.json({ ok: true });
+  } catch (error) {
+    console.error("Error deleting team:", error);
+    return NextResponse.json({ error: "Failed to delete team" }, { status: 500 });
+  }
+}