@mndrk/agx 2.0.32 → 2.0.34

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

@@ -5,10 +5,11 @@ import {
   deleteAgent,
   setAgentSkills,
 } from "@/lib/db";
+import { setAgentSkillBindings } from "@/lib/agent-skill-bindings";
 import { getSQLiteDb } from "@/lib/sqlite-query-adapter";
 import { LOCAL_USER } from "@/lib/auth-mode";
 import { loadDbParticipants } from "@/lib/agent-participants";
-import type { ChatProvider, Participant, Skill } from "@/lib/types";
+import type { ChatProvider, Participant, Skill, SkillBinding } from "@/lib/types";
 import { ensureAgent } from "@/lib/mesh-core/agent";
 
 export const runtime = "nodejs";
@@ -27,11 +28,13 @@ export async function GET() {
 interface ParticipantPayload {
   id?: unknown;
   name?: unknown;
+  title?: unknown;
   provider?: unknown;
   model?: unknown;
   identity?: unknown;
   identityFile?: unknown;
   skills?: unknown;
+  skillBindings?: unknown;
   variables?: unknown;
   color?: unknown;
   // New agent-level fields
@@ -71,6 +74,22 @@ function toSkills(value: unknown): Skill[] | undefined {
   return skills.length > 0 ? skills : undefined;
 }
 
+function toSkillBindings(value: unknown): SkillBinding[] | undefined {
+  if (!Array.isArray(value)) return undefined;
+  const bindings: SkillBinding[] = value
+    .map((item: unknown) => {
+      if (!item || typeof item !== "object" || Array.isArray(item)) return null;
+      const obj = item as Record<string, unknown>;
+      const repo = String(obj.repo ?? "").trim();
+      const skillId = String(obj.skillId ?? obj.skill_id ?? "").trim();
+      if (!repo || !skillId) return null;
+      const condition = String(obj.condition ?? "").trim();
+      return { repo, skillId, ...(condition ? { condition } : {}) };
+    })
+    .filter((binding): binding is SkillBinding => Boolean(binding));
+  return bindings.length > 0 ? bindings : undefined;
+}
+
 function toParticipant(body: ParticipantPayload, fallbackId?: string): Participant | null {
   const name = toOptionalString(body.name);
   const provider = toOptionalString(body.provider) as ChatProvider | undefined;
@@ -81,9 +100,11 @@ function toParticipant(body: ParticipantPayload, fallbackId?: string): Participa
     return null;
   }
 
+  const title = toOptionalString(body.title);
   const identity = toOptionalString(body.identity);
   const identityFile = toOptionalString(body.identityFile);
   const skills = toSkills(body.skills);
+  const skillBindings = toSkillBindings(body.skillBindings);
   const color = toOptionalString(body.color) ?? "#6B7280";
 
   let variables: Record<string, string> | undefined;
@@ -102,9 +123,13 @@ function toParticipant(body: ParticipantPayload, fallbackId?: string): Participa
     provider,
     model,
     color,
+    ...(title ? { title } : {}),
     ...(identity ? { identity } : {}),
+    ...(toOptionalString(body.voice) ? { voice: toOptionalString(body.voice) } : {}),
+    ...(toOptionalString(body.seed) ? { seed: toOptionalString(body.seed) } : {}),
     ...(identityFile ? { identityFile } : {}),
     ...(skills ? { skills } : {}),
+    ...(skillBindings ? { skillBindings } : {}),
     ...(variables ? { variables } : {}),
   };
 }
@@ -131,6 +156,7 @@ export async function POST(request: NextRequest) {
     createdAgent = await createAgent(LOCAL_USER.id, {
       id: participant.id,
       name: participant.name,
+      title: participant.title,
       style: "balanced",
       description: participant.identity,
       model: participant.model ?? undefined,
@@ -140,6 +166,7 @@ export async function POST(request: NextRequest) {
       seed: toOptionalString(body.seed),
     });
     await setAgentSkills(createdAgent.id, participant.skills ?? []);
+    await setAgentSkillBindings(createdAgent.id, participant.skillBindings ?? []);
     ensureAgent(createdAgent.id, {
       voice: toOptionalString(body.voice),
       seed: toOptionalString(body.seed),
@@ -152,13 +179,23 @@ export async function POST(request: NextRequest) {
   const created: Participant = {
     id: createdAgent.id,
     name: createdAgent.name,
+    ...(createdAgent.title || participant.title
+      ? { title: createdAgent.title || participant.title }
+      : {}),
     provider: (createdAgent.provider || participant.provider || "claude") as ChatProvider,
     model: createdAgent.model || participant.model || null,
     color: createdAgent.color || participant.color || "#6B7280",
     ...(createdAgent.description || participant.identity
       ? { identity: createdAgent.description || participant.identity }
       : {}),
+    ...(createdAgent.voice || participant.voice
+      ? { voice: createdAgent.voice || participant.voice }
+      : {}),
+    ...(createdAgent.seed || participant.seed
+      ? { seed: createdAgent.seed || participant.seed }
+      : {}),
     ...(participant.skills?.length ? { skills: participant.skills } : {}),
+    ...(participant.skillBindings?.length ? { skillBindings: participant.skillBindings } : {}),
   };
 
   // Auto-assign to project if projectId provided (teamId kept as legacy alias).
@@ -190,6 +227,7 @@ export async function PATCH(request: NextRequest) {
   try {
     updatedAgent = await updateDbAgent(participant.id, LOCAL_USER.id, {
       name: participant.name,
+      title: participant.title,
       description: participant.identity,
       model: participant.model ?? undefined,
       provider: participant.provider,
@@ -198,6 +236,7 @@ export async function PATCH(request: NextRequest) {
       seed: toOptionalString(body.seed),
     });
     await setAgentSkills(participant.id, participant.skills ?? []);
+    await setAgentSkillBindings(participant.id, participant.skillBindings ?? []);
     ensureAgent(participant.id, {
       voice: toOptionalString(body.voice),
       seed: toOptionalString(body.seed),
@@ -214,13 +253,23 @@ export async function PATCH(request: NextRequest) {
   const updated: Participant = {
     id: updatedAgent.id,
     name: updatedAgent.name,
+    ...(updatedAgent.title || participant.title
+      ? { title: updatedAgent.title || participant.title }
+      : {}),
     provider: (updatedAgent.provider || participant.provider || "claude") as ChatProvider,
     model: updatedAgent.model || participant.model || null,
     color: updatedAgent.color || participant.color || "#6B7280",
     ...(updatedAgent.description || participant.identity
       ? { identity: updatedAgent.description || participant.identity }
       : {}),
+    ...(updatedAgent.voice || participant.voice
+      ? { voice: updatedAgent.voice || participant.voice }
+      : {}),
+    ...(updatedAgent.seed || participant.seed
+      ? { seed: updatedAgent.seed || participant.seed }
+      : {}),
     ...(participant.skills?.length ? { skills: participant.skills } : {}),
+    ...(participant.skillBindings?.length ? { skillBindings: participant.skillBindings } : {}),
   };
 
   return Response.json(updated);

package/cloud-runtime/standalone/app/api/prompt-jobs/[id]/cancel/route.ts

@@ -0,0 +1,44 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getPromptJobStore } from '@/src/prompt-scheduler/get-store';
+
+export const runtime = 'nodejs';
+export const dynamic = 'force-dynamic';
+
+/**
+ * POST /api/prompt-jobs/[id]/cancel
+ * Find the active run (running or queued) for the job and mark it cancelled.
+ * Returns 404 if no active run exists.
+ */
+export async function POST(_req: NextRequest, { params }: { params: Promise<{ id: string }> }) {
+  try {
+    const { id } = await params;
+    const store = getPromptJobStore();
+
+    const job = store.getJob(id);
+    if (!job) {
+      return NextResponse.json({ error: 'Job not found' }, { status: 404 });
+    }
+
+    // Find active run (running or queued)
+    const runs = store.listRuns(id);
+    const activeRun = runs.find((r) => r.status === 'running' || r.status === 'queued');
+
+    if (!activeRun) {
+      return NextResponse.json({ error: 'No active run found for this job' }, { status: 404 });
+    }
+
+    const cancelledAt = new Date().toISOString();
+    const updatedRun = store.updateRun(activeRun.id, {
+      status: 'cancelled',
+      cancelledAt,
+    });
+
+    return NextResponse.json({ run: updatedRun });
+  } catch (error) {
+    console.error('Failed to cancel prompt run:', error);
+    return NextResponse.json(
+      { error: 'Failed to cancel prompt run', message: error instanceof Error ? error.message : String(error) },
+      { status: 500 },
+    );
+  }
+}

package/cloud-runtime/standalone/app/api/prompt-jobs/[id]/route.ts

@@ -0,0 +1,94 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getPromptJobStore } from '@/src/prompt-scheduler/get-store';
+import { parseCadence } from '@/src/prompt-scheduler/cron';
+
+export const runtime = 'nodejs';
+export const dynamic = 'force-dynamic';
+
+/**
+ * GET /api/prompt-jobs/[id]
+ * Get a single prompt job by id.
+ */
+export async function GET(_req: NextRequest, { params }: { params: Promise<{ id: string }> }) {
+  try {
+    const { id } = await params;
+    const store = getPromptJobStore();
+    const job = store.getJob(id);
+    if (!job) {
+      return NextResponse.json({ error: 'Job not found' }, { status: 404 });
+    }
+    return NextResponse.json({ job });
+  } catch (error) {
+    console.error('Failed to get prompt job:', error);
+    return NextResponse.json(
+      { error: 'Failed to get prompt job', message: error instanceof Error ? error.message : String(error) },
+      { status: 500 },
+    );
+  }
+}
+
+/**
+ * PATCH /api/prompt-jobs/[id]
+ * Update a prompt job. If cadence is provided, re-parse and update cronExpr + nextRunAt.
+ */
+export async function PATCH(req: NextRequest, { params }: { params: Promise<{ id: string }> }) {
+  try {
+    const { id } = await params;
+    const store = getPromptJobStore();
+
+    const existing = store.getJob(id);
+    if (!existing) {
+      return NextResponse.json({ error: 'Job not found' }, { status: 404 });
+    }
+
+    const body = await req.json();
+    const { cadence, ...rest } = body;
+
+    const updates: Record<string, unknown> = { ...rest };
+
+    if (cadence !== undefined) {
+      const parsed = parseCadence(cadence);
+      if (!parsed) {
+        return NextResponse.json(
+          { error: `Could not parse cadence: "${cadence}". Provide a valid cron expression or natural language schedule.` },
+          { status: 400 },
+        );
+      }
+      updates.cadence = parsed.cadence;
+    }
+
+    const job = store.updateJob(id, updates);
+    return NextResponse.json({ job });
+  } catch (error) {
+    console.error('Failed to update prompt job:', error);
+    return NextResponse.json(
+      { error: 'Failed to update prompt job', message: error instanceof Error ? error.message : String(error) },
+      { status: 500 },
+    );
+  }
+}
+
+/**
+ * DELETE /api/prompt-jobs/[id]
+ * Delete a prompt job.
+ */
+export async function DELETE(_req: NextRequest, { params }: { params: Promise<{ id: string }> }) {
+  try {
+    const { id } = await params;
+    const store = getPromptJobStore();
+
+    const existing = store.getJob(id);
+    if (!existing) {
+      return NextResponse.json({ error: 'Job not found' }, { status: 404 });
+    }
+
+    store.deleteJob(id);
+    return NextResponse.json({ success: true });
+  } catch (error) {
+    console.error('Failed to delete prompt job:', error);
+    return NextResponse.json(
+      { error: 'Failed to delete prompt job', message: error instanceof Error ? error.message : String(error) },
+      { status: 500 },
+    );
+  }
+}

package/cloud-runtime/standalone/app/api/prompt-jobs/[id]/runs/route.ts

@@ -0,0 +1,30 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getPromptJobStore } from '@/src/prompt-scheduler/get-store';
+
+export const runtime = 'nodejs';
+export const dynamic = 'force-dynamic';
+
+/**
+ * GET /api/prompt-jobs/[id]/runs
+ * List runs for a given prompt job.
+ */
+export async function GET(_req: NextRequest, { params }: { params: Promise<{ id: string }> }) {
+  try {
+    const { id } = await params;
+    const store = getPromptJobStore();
+
+    const job = store.getJob(id);
+    if (!job) {
+      return NextResponse.json({ error: 'Job not found' }, { status: 404 });
+    }
+
+    const runs = store.listRuns(id);
+    return NextResponse.json({ count: runs.length, runs });
+  } catch (error) {
+    console.error('Failed to list prompt runs:', error);
+    return NextResponse.json(
+      { error: 'Failed to list prompt runs', message: error instanceof Error ? error.message : String(error) },
+      { status: 500 },
+    );
+  }
+}

package/cloud-runtime/standalone/app/api/prompt-jobs/agents/route.ts

@@ -0,0 +1,25 @@
+import { NextResponse } from 'next/server';
+import { getAgents } from '@/lib/db';
+import { LOCAL_USER } from '@/lib/auth-mode';
+
+export const runtime = 'nodejs';
+export const dynamic = 'force-dynamic';
+
+/** GET /api/prompt-jobs/agents — list available agents for the picker */
+export async function GET() {
+  try {
+    const agents = await getAgents(LOCAL_USER.id);
+    const items = agents.map((a) => ({
+      id: a.id,
+      name: a.name,
+      provider: a.provider || 'claude',
+      model: a.model || null,
+      color: a.color || '#6B7280',
+      title: a.title || null,
+    }));
+    return NextResponse.json({ agents: items });
+  } catch (error) {
+    console.error('Failed to list agents:', error);
+    return NextResponse.json({ error: 'Failed to list agents' }, { status: 500 });
+  }
+}

package/cloud-runtime/standalone/app/api/prompt-jobs/poll/route.ts

@@ -0,0 +1,232 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { getPromptJobStore } from '@/src/prompt-scheduler/get-store';
+import { pollDueJobs } from '@/src/prompt-scheduler/engine';
+import { getAgent, getAgentSkills } from '@/lib/db';
+import { LOCAL_USER } from '@/lib/auth-mode';
+import { runCliResponse } from '@/lib/cli-runner';
+import type { ChatProvider } from '@/lib/types';
+import { computeNextRun } from '@/src/prompt-scheduler/cron';
+import type { PromptJob, PromptRun } from '@/src/prompt-scheduler/types';
+
+export const runtime = 'nodejs';
+export const dynamic = 'force-dynamic';
+
+const AGENTS_DIR = join(homedir(), '.agx', 'agents');
+
+/** Hydrate agent context — identity, self.md, skills */
+async function hydrateAgent(agentId: string): Promise<{
+  provider: ChatProvider;
+  model: string | null;
+  identity: string | undefined;
+  self: string | undefined;
+  skills: string | undefined;
+}> {
+  const agent = await getAgent(agentId, LOCAL_USER.id);
+  if (!agent) return { provider: 'claude', model: null, identity: undefined, self: undefined, skills: undefined };
+
+  const agentDir = join(AGENTS_DIR, agentId);
+
+  // Identity (description + voice)
+  let identity: string | undefined;
+  const parts: string[] = [];
+  if (agent.name) parts.push(`Name: ${agent.name}`);
+  if (agent.description) parts.push(agent.description);
+  if (agent.voice) parts.push(`Voice: ${agent.voice}`);
+  if (parts.length > 0) identity = parts.join('\n');
+
+  // Self.md (evolving bio)
+  let self: string | undefined;
+  const selfPath = join(agentDir, 'self.md');
+  if (existsSync(selfPath)) {
+    const raw = readFileSync(selfPath, 'utf-8');
+    const match = raw.match(/^---[\s\S]*?---\s*\n?([\s\S]*)$/);
+    self = match ? match[1].trim() : raw.trim();
+    if (!self) self = undefined;
+  }
+
+  // Skills
+  let skills: string | undefined;
+  const agentSkills = await getAgentSkills(agentId);
+  if (agentSkills.length > 0) {
+    const skillTexts: string[] = [];
+    for (const skill of agentSkills) {
+      const skillPath = skill.file.startsWith('/') ? skill.file : join(agentDir, skill.file);
+      if (existsSync(skillPath)) {
+        try {
+          const content = readFileSync(skillPath, 'utf-8');
+          skillTexts.push(`## ${skill.file}\n${content}`);
+        } catch {}
+      }
+    }
+    if (skillTexts.length > 0) skills = skillTexts.join('\n\n');
+  }
+
+  return {
+    provider: (agent.provider || 'claude') as ChatProvider,
+    model: agent.model || null,
+    identity,
+    self,
+    skills,
+  };
+}
+
+/** Resolve job to execution context */
+async function resolveJobContext(job: PromptJob): Promise<{
+  provider: ChatProvider;
+  model: string | null;
+  identity: string | undefined;
+  self: string | undefined;
+  skills: string | undefined;
+}> {
+  if (job.agentId) {
+    return hydrateAgent(job.agentId);
+  }
+  return {
+    provider: (job.provider || 'claude') as ChatProvider,
+    model: job.model || null,
+    identity: undefined,
+    self: undefined,
+    skills: undefined,
+  };
+}
+
+/** Execute a prompt using runCliResponse (routes through agx/provider with identity) */
+async function executePrompt(opts: {
+  provider: ChatProvider;
+  model: string | null;
+  prompt: string;
+  identity?: string;
+  self?: string;
+  skills?: string;
+  cliArgs?: string;
+}): Promise<{ output: string; error: string; durationMs: number; status: 'success' | 'failed' }> {
+  const startMs = Date.now();
+  let output = '';
+  let error = '';
+
+  try {
+    await runCliResponse({
+      provider: opts.provider,
+      model: opts.model,
+      prompt: opts.prompt,
+      identity: opts.identity,
+      self: opts.self,
+      skills: opts.skills,
+      passthroughArgs: opts.cliArgs ? opts.cliArgs.split(/\s+/).filter(Boolean) : undefined,
+      onDelta: (chunk) => { output += chunk; },
+    });
+    // On success, don't report stderr as error — it's just CLI debug output
+    return { output, error: '', durationMs: Date.now() - startMs, status: 'success' };
+  } catch (err) {
+    return { output, error: err instanceof Error ? err.message : String(err), durationMs: Date.now() - startMs, status: 'failed' };
+  }
+}
+
+/** Fire a condition gate → if yes → run action prompt */
+async function fireConditionGate(job: PromptJob, run: PromptRun) {
+  const store = getPromptJobStore();
+  const ctx = await resolveJobContext(job);
+  const gatePrompt = `You are a condition evaluator. Evaluate whether the following condition is currently true. Respond with ONLY "yes" or "no" (lowercase, nothing else).\n\nCondition: ${job.condition}`;
+
+  store.updateRun(run.id, { status: 'running', startedAt: new Date().toISOString() });
+
+  const gateResult = await executePrompt({ ...ctx, prompt: gatePrompt, cliArgs: job.cliArgs });
+  const answer = gateResult.output.trim().toLowerCase();
+  const passed = answer.startsWith('yes');
+
+  if (gateResult.status !== 'success' || !passed) {
+    store.updateRun(run.id, {
+      status: 'success',
+      output: `Gate: ${answer}\n(condition not met — skipped action)`,
+      durationMs: gateResult.durationMs,
+      finishedAt: new Date().toISOString(),
+    });
+    store.updateJob(job.id, { lastOutcome: 'success', lastRunAt: Date.now() });
+    return;
+  }
+
+  // Gate passed — execute action prompt with full agent context
+  store.updateRun(run.id, { output: `Gate: yes\nExecuting action prompt...` });
+  const actionResult = await executePrompt({ ...ctx, prompt: job.prompt, cliArgs: job.cliArgs });
+
+  store.updateRun(run.id, {
+    status: actionResult.status,
+    output: `Gate: yes\n---\n${actionResult.output}`,
+    error: actionResult.error || undefined,
+    durationMs: gateResult.durationMs + actionResult.durationMs,
+    finishedAt: new Date().toISOString(),
+  });
+  store.updateJob(job.id, { lastOutcome: actionResult.status, lastRunAt: Date.now() });
+}
+
+/** Fire a simple scheduled run with full agent context */
+async function fireRun(job: PromptJob, run: PromptRun) {
+  const store = getPromptJobStore();
+  const ctx = await resolveJobContext(job);
+
+  store.updateRun(run.id, { status: 'running', startedAt: new Date().toISOString() });
+  const result = await executePrompt({ ...ctx, prompt: job.prompt, cliArgs: job.cliArgs });
+
+  store.updateRun(run.id, {
+    status: result.status,
+    output: result.output,
+    error: result.error || undefined,
+    durationMs: result.durationMs,
+    finishedAt: new Date().toISOString(),
+  });
+  const nextRunAt = job.triggerType === 'condition'
+    ? Date.now() + job.checkEveryMs
+    : computeNextRun(job.cronExpr) ?? null;
+  store.updateJob(job.id, { lastOutcome: result.status, lastRunAt: Date.now(), nextRunAt });
+}
+
+/** Dispatch — fire and forget (don't block the HTTP response) */
+function dispatchRun(job: PromptJob, run: PromptRun) {
+  const fn = job.triggerType === 'condition' && job.condition ? fireConditionGate : fireRun;
+  fn(job, run).catch((err) => {
+    const store = getPromptJobStore();
+    store.updateRun(run.id, {
+      status: 'failed',
+      error: `Dispatch error: ${err instanceof Error ? err.message : String(err)}`,
+      finishedAt: new Date().toISOString(),
+    });
+    store.updateJob(job.id, { lastOutcome: 'failed' });
+  });
+}
+
+/**
+ * POST /api/prompt-jobs/poll
+ */
+export async function POST(req: NextRequest) {
+  try {
+    const store = getPromptJobStore();
+    let body: { jobId?: string } = {};
+    try { body = await req.json(); } catch {}
+
+    if (body.jobId) {
+      const job = store.getJob(body.jobId);
+      if (!job) return NextResponse.json({ error: 'Job not found' }, { status: 404 });
+      const run = store.createRun(job.id);
+      dispatchRun(job, run);
+      return NextResponse.json({ queued: [run], skipped: [] });
+    }
+
+    const result = pollDueJobs(store);
+    for (const run of result.queued) {
+      const job = store.getJob(run.jobId);
+      if (!job) continue;
+      dispatchRun(job, run);
+    }
+
+    return NextResponse.json({ queued: result.queued, skipped: result.skipped });
+  } catch (error) {
+    console.error('Failed to poll prompt jobs:', error);
+    return NextResponse.json(
+      { error: 'Failed to poll prompt jobs', message: error instanceof Error ? error.message : String(error) },
+      { status: 500 },
+    );
+  }
+}