@mndrk/agx 2.0.19 → 2.0.21

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/hooks/useThreadState.ts

@@ -1,4 +1,5 @@
 import { useCallback, useEffect, useRef, useState } from "react";
+import { useSearchParams } from "next/navigation";
 import { threadService } from "@/services/threadService";
 import type { SaveThreadInput, Thread, ThreadStatus } from "@/lib/storage";
 import type { GroupMessage } from "@/lib/types";
@@ -12,7 +13,8 @@ import {
 const sortByCreatedAt = (threads: Thread[]) =>
   [...threads].sort((a, b) => b.createdAt - a.createdAt);
 
-export function useThreadState() {
+export function useThreadState(initialThreadId?: string) {
+  const searchParams = useSearchParams();
   const isMounted = useRef(true);
   const [threads, setThreads] = useState<Thread[]>([]);
   const [activeThreadId, setActiveThreadId] = useState<string | null>(null);
@@ -42,8 +44,9 @@ export function useThreadState() {
         const fetched = await threadService.listThreads();
         if (cancelled || !isMounted.current) return;
         setThreads(fetched);
-        const savedThreadId = loadLastThreadId();
-        const { threadId: initialThreadId, shouldClearSavedId, restoredFromStorage } =
+        const urlThreadId = initialThreadId || searchParams.get("thread");
+        const savedThreadId = urlThreadId || loadLastThreadId();
+        const { threadId: resolvedThreadId, shouldClearSavedId, restoredFromStorage } =
           resolveInitialThreadSelection(fetched, savedThreadId);
         if (shouldClearSavedId) {
           clearLastThreadId();
@@ -51,10 +54,10 @@ export function useThreadState() {
         if (!hasHydratedActiveThreadRef.current) {
           hasHydratedActiveThreadRef.current = true;
         }
-        if (restoredFromStorage && initialThreadId) {
-          selectThread(initialThreadId);
-        } else if (initialThreadId) {
-          setActiveThreadId((prev) => prev ?? initialThreadId);
+        if (restoredFromStorage && resolvedThreadId) {
+          selectThread(resolvedThreadId);
+        } else if (resolvedThreadId) {
+          setActiveThreadId((prev) => prev ?? resolvedThreadId);
         } else {
           setActiveThreadId(null);
         }
@@ -71,7 +74,7 @@ export function useThreadState() {
     return () => {
       cancelled = true;
     };
-  }, [selectThread]);
+  }, [selectThread, searchParams, initialThreadId]);
 
   useEffect(() => {
     if (!hasHydratedActiveThreadRef.current) {

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/instrumentation.ts

@@ -1,3 +1,5 @@
+const SCHEDULE_POLL_INTERVAL_MS = 15_000;
+
 export async function register() {
   if (process.env.NEXT_RUNTIME === 'nodejs') {
     const { getQueue, QUEUE_NAMES } = await import('@/lib/queue/boss');
@@ -6,5 +8,64 @@ export async function register() {
     const queue = await getQueue();
     await queue.work(QUEUE_NAMES.TASK_PROCESS, taskProcessor, { batchSize: 5 });
     console.log('[worker] queue worker started (embedded)');
+
+    // Schedule poller — drives recurring graph ticks
+    const { pollSchedules } = await import('@/src/graph/schedule-runner');
+    const { createDispatchFunction } = await import('@/src/graph/function-executor');
+    const { createDispatchWork } = await import('@/src/graph/work-dispatcher');
+    const { executeNode } = await import('@/src/graph/executor');
+    const { completeScheduleTick, isScheduleTickComplete } = await import('@/src/graph/schedule');
+    const { GraphStore } = await import('@/src/graph/store');
+
+    setInterval(async () => {
+      try {
+        const dispatchFunction = createDispatchFunction();
+        const dispatchWork = createDispatchWork();
+        const result = await pollSchedules({ dispatchFunction, dispatchWork });
+        if (result.tickedGraphIds.length > 0) {
+          console.log(`[schedules] ticked ${result.tickedGraphIds.length} graph(s)`);
+        }
+        if (result.errors.length > 0) {
+          console.error(`[schedules] ${result.errors.length} error(s):`, result.errors.map(e => e.error.message));
+        }
+
+        // Option B: dispatch pending work nodes from schedule-ticked graphs
+        if (result.pendingWork.length > 0) {
+          const store = new GraphStore();
+
+          for (const item of result.pendingWork) {
+            let currentGraph = item.graph;
+            for (const nodeId of item.nodeIds) {
+              try {
+                const execResult = await executeNode(currentGraph, nodeId, {
+                  dispatchFunction,
+                  dispatchWork,
+                });
+                currentGraph = execResult.graph;
+                console.log(`[schedules] dispatched work node "${nodeId}" for graph ${item.taskId}`);
+              } catch (err) {
+                console.error(`[schedules] work dispatch failed for node "${nodeId}":`, err);
+              }
+            }
+
+            // Persist work node results and check tick completion
+            store.updateGraphStructure(currentGraph.id, {
+              nodes: currentGraph.nodes,
+            });
+
+            if (isScheduleTickComplete(currentGraph)) {
+              const completed = completeScheduleTick(currentGraph);
+              store.updateGraphStructure(completed.id, {
+                schedule: completed.schedule,
+              });
+              console.log(`[schedules] tick complete for graph ${item.taskId}`);
+            }
+          }
+        }
+      } catch (err) {
+        console.error('[schedules] poll failed:', err);
+      }
+    }, SCHEDULE_POLL_INTERVAL_MS);
+    console.log(`[schedules] poller started (every ${SCHEDULE_POLL_INTERVAL_MS / 1000}s)`);
   }
 }

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/lib/agent-process-registry.ts

@@ -1,55 +1,140 @@
-import { getSQLiteDb } from "./sqlite-query-adapter";
+import Database from "better-sqlite3";
+import path from "path";
+import os from "os";
+import { mkdirSync, existsSync } from "fs";
+
+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 interface AgentProcessEntry {
+  id: number;
+  workspaceId: string;
   threadId: string;
   agentId: string;
   pid: number;
   state: "spawning" | "running" | "done" | "error" | "killed";
   sinceMessageId: string;
+  responseMessageId: string;
   startedAt: number;
   lastActivity: number;
+  projectSlug: string;
 }
 
 interface Row {
+  id: number;
+  workspace_id: string;
   thread_id: string;
   agent_id: string;
   pid: number;
   state: string;
   since_message_id: string;
+  response_message_id: string;
   started_at: number;
   last_activity: number;
+  project_slug: string;
 }
 
 function toEntry(row: Row): AgentProcessEntry {
   return {
+    id: row.id,
+    workspaceId: row.workspace_id,
     threadId: row.thread_id,
     agentId: row.agent_id,
     pid: row.pid,
     state: row.state as AgentProcessEntry["state"],
     sinceMessageId: row.since_message_id,
+    responseMessageId: row.response_message_id || "",
     startedAt: row.started_at,
     lastActivity: row.last_activity,
+    projectSlug: row.project_slug || "",
   };
 }
 
-export function register(entry: AgentProcessEntry): void {
-  const db = getSQLiteDb();
-  db.prepare(
-    `INSERT OR REPLACE INTO agent_processes (thread_id, agent_id, pid, state, since_message_id, started_at, last_activity)
-     VALUES (?, ?, ?, ?, ?, ?, ?)`
-  ).run(
-    entry.threadId,
-    entry.agentId,
-    entry.pid,
-    entry.state,
-    entry.sinceMessageId,
-    entry.startedAt,
-    entry.lastActivity
-  );
+function getDb(): Database.Database {
+  mkdirSync(HISTORY_DIR, { recursive: true });
+  const db = new Database(DB_PATH);
+  db.pragma("journal_mode = WAL");
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS agent_processes (
+      id           INTEGER PRIMARY KEY AUTOINCREMENT,
+      workspace_id TEXT NOT NULL,
+      thread_id    TEXT NOT NULL DEFAULT '',
+      agent_id     TEXT NOT NULL,
+      pid          INTEGER NOT NULL DEFAULT 0,
+      state        TEXT NOT NULL DEFAULT 'spawning',
+      since_message_id TEXT NOT NULL DEFAULT '',
+      started_at   INTEGER NOT NULL,
+      last_activity INTEGER NOT NULL,
+      project_slug TEXT NOT NULL DEFAULT '',
+      UNIQUE (workspace_id, agent_id)
+    )
+  `);
+  db.exec("CREATE INDEX IF NOT EXISTS idx_agent_processes_state ON agent_processes (state)");
+  db.exec("CREATE INDEX IF NOT EXISTS idx_agent_processes_thread ON agent_processes (thread_id)");
+  db.exec("CREATE INDEX IF NOT EXISTS idx_agent_processes_workspace ON agent_processes (workspace_id)");
+  // Migration: add project_slug column if missing
+  try {
+    db.exec("ALTER TABLE agent_processes ADD COLUMN project_slug TEXT NOT NULL DEFAULT ''");
+  } catch { /* column already exists */ }
+  // Migration: add response_message_id column if missing
+  try {
+    db.exec("ALTER TABLE agent_processes ADD COLUMN response_message_id TEXT NOT NULL DEFAULT ''");
+  } catch { /* column already exists */ }
+  return db;
+}
+
+function withDb<T>(fn: (db: Database.Database) => T): T {
+  const db = getDb();
+  try {
+    return fn(db);
+  } finally {
+    db.close();
+  }
+}
+
+export function register(entry: Omit<AgentProcessEntry, "id">): number {
+  return withDb((db) => {
+    const result = db.prepare(
+      `INSERT INTO agent_processes (workspace_id, thread_id, agent_id, pid, state, since_message_id, response_message_id, started_at, last_activity, project_slug)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(workspace_id, agent_id)
+       DO UPDATE SET
+         thread_id = excluded.thread_id,
+         pid = excluded.pid,
+         state = excluded.state,
+         since_message_id = excluded.since_message_id,
+         response_message_id = excluded.response_message_id,
+         started_at = excluded.started_at,
+         last_activity = excluded.last_activity,
+         project_slug = excluded.project_slug`
+    ).run(
+      entry.workspaceId,
+      entry.threadId,
+      entry.agentId,
+      entry.pid,
+      entry.state,
+      entry.sinceMessageId,
+      entry.responseMessageId || "",
+      entry.startedAt,
+      entry.lastActivity,
+      entry.projectSlug || ""
+    );
+    // On INSERT, lastInsertRowid is the new id.
+    // On UPDATE (conflict), we need to fetch the existing id.
+    if (result.changes === 1 && result.lastInsertRowid) {
+      return Number(result.lastInsertRowid);
+    }
+    const row = db.prepare(
+      "SELECT id FROM agent_processes WHERE workspace_id = ? AND agent_id = ?"
+    ).get(entry.workspaceId, entry.agentId) as { id: number } | undefined;
+    return row?.id ?? 0;
+  });
 }
 
 export function update(
-  threadId: string,
+  workspaceId: string,
   agentId: string,
   patch: Partial<Pick<AgentProcessEntry, "state" | "lastActivity" | "pid">>
 ): void {
@@ -71,55 +156,108 @@ export function update(
 
   if (sets.length === 0) return;
 
-  const db = getSQLiteDb();
-  db.prepare(
-    `UPDATE agent_processes SET ${sets.join(", ")} WHERE thread_id = ? AND agent_id = ?`
-  ).run(...values, threadId, agentId);
+  withDb((db) =>
+    db.prepare(
+      `UPDATE agent_processes SET ${sets.join(", ")} WHERE workspace_id = ? AND agent_id = ?`
+    ).run(...values, workspaceId, agentId)
+  );
 }
 
-export function remove(threadId: string, agentId: string): void {
-  const db = getSQLiteDb();
-  db.prepare("DELETE FROM agent_processes WHERE thread_id = ? AND agent_id = ?").run(
-    threadId,
-    agentId
+export function remove(workspaceId: string, agentId: string): void {
+  withDb((db) =>
+    db.prepare("DELETE FROM agent_processes WHERE workspace_id = ? AND agent_id = ?").run(
+      workspaceId,
+      agentId
+    )
   );
 }
 
 export function getByThread(threadId: string): AgentProcessEntry[] {
-  const db = getSQLiteDb();
-  const rows = db
-    .prepare("SELECT * FROM agent_processes WHERE thread_id = ?")
-    .all(threadId) as Row[];
-  return rows.map(toEntry);
+  return withDb((db) => {
+    const rows = db
+      .prepare("SELECT * FROM agent_processes WHERE thread_id = ?")
+      .all(threadId) as Row[];
+    return rows.map(toEntry);
+  });
+}
+
+export function getByWorkspace(workspaceId: string): AgentProcessEntry[] {
+  return withDb((db) => {
+    const rows = db
+      .prepare("SELECT * FROM agent_processes WHERE workspace_id = ?")
+      .all(workspaceId) as Row[];
+    return rows.map(toEntry);
+  });
 }
 
 export function getAll(): AgentProcessEntry[] {
-  const db = getSQLiteDb();
-  const rows = db.prepare("SELECT * FROM agent_processes").all() as Row[];
-  return rows.map(toEntry);
+  return withDb((db) => {
+    const rows = db.prepare("SELECT * FROM agent_processes").all() as Row[];
+    return rows.map(toEntry);
+  });
 }
 
-export function killByThread(threadId: string): number {
-  const entries = getByThread(threadId).filter(
-    (e) => e.state === "running" || e.state === "spawning"
-  );
+export interface EnrichedProcessEntry extends AgentProcessEntry {
+  threadTitle: string | null;
+}
+
+export function getAllEnriched(): EnrichedProcessEntry[] {
+  return withDb((db) => {
+    const rows = db.prepare(`
+      SELECT ap.*, substr(m.content, 1, 120) AS thread_title
+      FROM agent_processes ap
+      LEFT JOIN messages m ON m.id = ap.thread_id AND m.thread_id = ap.workspace_id
+    `).all() as (Row & { thread_title: string | null })[];
+    return rows.map((r) => ({ ...toEntry(r), threadTitle: r.thread_title }));
+  });
+}
 
+function killEntries(entries: AgentProcessEntry[]): number {
   let killed = 0;
   for (const entry of entries) {
-    try {
-      process.kill(entry.pid, "SIGTERM");
-    } catch {
-      // process may already be dead
+    if (entry.pid > 0) {
+      try {
+        process.kill(entry.pid, "SIGTERM");
+      } catch {
+        // process may already be dead
+      }
     }
     killed++;
   }
+  return killed;
+}
+
+export function killByThread(threadId: string): number {
+  const entries = getByThread(threadId).filter(
+    (e) => e.state === "running" || e.state === "spawning"
+  );
+  const killed = killEntries(entries);
 
   if (killed > 0) {
-    const db = getSQLiteDb();
-    db.prepare(
-      `UPDATE agent_processes SET state = 'killed', last_activity = ?
-       WHERE thread_id = ? AND state IN ('running', 'spawning')`
-    ).run(Date.now(), threadId);
+    withDb((db) =>
+      db.prepare(
+        `UPDATE agent_processes SET state = 'killed', last_activity = ?
+         WHERE thread_id = ? AND state IN ('running', 'spawning')`
+      ).run(Date.now(), threadId)
+    );
+  }
+
+  return killed;
+}
+
+export function killByWorkspace(workspaceId: string): number {
+  const entries = getByWorkspace(workspaceId).filter(
+    (e) => e.state === "running" || e.state === "spawning"
+  );
+  const killed = killEntries(entries);
+
+  if (killed > 0) {
+    withDb((db) =>
+      db.prepare(
+        `UPDATE agent_processes SET state = 'killed', last_activity = ?
+         WHERE workspace_id = ? AND state IN ('running', 'spawning')`
+      ).run(Date.now(), workspaceId)
+    );
   }
 
   return killed;