stagent 0.1.0

package/src/app/api/profiles/import/route.ts

@@ -0,0 +1,108 @@
+import { NextRequest, NextResponse } from "next/server";
+import { createProfile, reloadProfiles } from "@/lib/agents/profiles/registry";
+import { ProfileConfigSchema } from "@/lib/validators/profile";
+import yaml from "js-yaml";
+
+/**
+ * POST /api/profiles/import
+ *
+ * Import a profile from a GitHub URL. Supports:
+ * - Raw GitHub URLs to profile.yaml (fetches adjacent SKILL.md)
+ * - GitHub repo directory URLs (e.g. github.com/user/repo/tree/main/.claude/skills/my-profile)
+ */
+export async function POST(req: NextRequest) {
+  try {
+    const { url } = await req.json();
+
+    if (!url || typeof url !== "string") {
+      return NextResponse.json({ error: "url is required" }, { status: 400 });
+    }
+
+    // Convert GitHub web URL to raw content URL
+    const rawBase = toRawGitHubUrl(url);
+    if (!rawBase) {
+      return NextResponse.json(
+        { error: "Only GitHub URLs are supported (github.com or raw.githubusercontent.com)" },
+        { status: 400 }
+      );
+    }
+
+    // Fetch profile.yaml
+    const yamlUrl = rawBase.endsWith("profile.yaml") ? rawBase : `${rawBase}/profile.yaml`;
+    const yamlRes = await fetch(yamlUrl);
+    if (!yamlRes.ok) {
+      return NextResponse.json(
+        { error: `Failed to fetch profile.yaml: ${yamlRes.status}` },
+        { status: 400 }
+      );
+    }
+    const yamlText = await yamlRes.text();
+    const parsed = yaml.load(yamlText);
+    const result = ProfileConfigSchema.safeParse(parsed);
+    if (!result.success) {
+      return NextResponse.json(
+        { error: `Invalid profile.yaml: ${result.error.issues.map((i) => i.message).join(", ")}` },
+        { status: 400 }
+      );
+    }
+
+    // Fetch SKILL.md (optional — profile works without it)
+    const skillBase = yamlUrl.replace(/profile\.yaml$/, "");
+    const skillUrl = `${skillBase}SKILL.md`;
+    let skillMd = "";
+    try {
+      const skillRes = await fetch(skillUrl);
+      if (skillRes.ok) {
+        skillMd = await skillRes.text();
+      }
+    } catch {
+      // SKILL.md is optional — continue without it
+    }
+
+    // Create profile via registry
+    createProfile(result.data, skillMd);
+    reloadProfiles();
+
+    return NextResponse.json(
+      { ok: true, id: result.data.id, name: result.data.name },
+      { status: 201 }
+    );
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : "Import failed";
+    return NextResponse.json({ error: message }, { status: 400 });
+  }
+}
+
+/**
+ * Convert various GitHub URL formats to raw content base URL.
+ *
+ * Supports:
+ * - https://raw.githubusercontent.com/user/repo/branch/path → as-is
+ * - https://github.com/user/repo/tree/branch/path → raw.githubusercontent.com
+ * - https://github.com/user/repo/blob/branch/path → raw.githubusercontent.com
+ */
+function toRawGitHubUrl(url: string): string | null {
+  try {
+    const u = new URL(url);
+
+    // Already a raw URL
+    if (u.hostname === "raw.githubusercontent.com") {
+      return url.replace(/\/$/, "");
+    }
+
+    if (u.hostname !== "github.com") return null;
+
+    // github.com/user/repo/tree/branch/path or github.com/user/repo/blob/branch/path
+    const match = u.pathname.match(
+      /^\/([^/]+)\/([^/]+)\/(tree|blob)\/([^/]+)\/(.+)/
+    );
+    if (match) {
+      const [, owner, repo, , branch, filePath] = match;
+      return `https://raw.githubusercontent.com/${owner}/${repo}/${branch}/${filePath}`.replace(/\/$/, "");
+    }
+
+    return null;
+  } catch {
+    return null;
+  }
+}

package/src/app/api/profiles/route.ts

@@ -0,0 +1,50 @@
+import { NextRequest, NextResponse } from "next/server";
+import { listProfiles, createProfile, isBuiltin } from "@/lib/agents/profiles/registry";
+import { ProfileConfigSchema } from "@/lib/validators/profile";
+
+export async function GET() {
+  const profiles = listProfiles().map((p) => ({
+    id: p.id,
+    name: p.name,
+    description: p.description,
+    domain: p.domain,
+    tags: p.tags,
+    skillMd: p.skillMd,
+    allowedTools: p.allowedTools,
+    mcpServers: p.mcpServers,
+    canUseToolPolicy: p.canUseToolPolicy,
+    temperature: p.temperature,
+    maxTurns: p.maxTurns,
+    outputFormat: p.outputFormat,
+    version: p.version,
+    author: p.author,
+    source: p.source,
+    tests: p.tests,
+    supportedRuntimes: p.supportedRuntimes,
+    runtimeOverrides: p.runtimeOverrides,
+    isBuiltin: isBuiltin(p.id),
+  }));
+
+  return NextResponse.json(profiles);
+}
+
+export async function POST(req: NextRequest) {
+  try {
+    const body = await req.json();
+    const { skillMd, ...configFields } = body;
+
+    const result = ProfileConfigSchema.safeParse(configFields);
+    if (!result.success) {
+      return NextResponse.json(
+        { error: result.error.issues.map((i) => i.message).join(", ") },
+        { status: 400 }
+      );
+    }
+
+    createProfile(result.data, skillMd ?? "");
+    return NextResponse.json({ ok: true }, { status: 201 });
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : "Failed to create profile";
+    return NextResponse.json({ error: message }, { status: 400 });
+  }
+}

package/src/app/api/projects/[id]/route.ts

@@ -0,0 +1,72 @@
+import { NextRequest, NextResponse } from "next/server";
+import { db } from "@/lib/db";
+import { projects, tasks } from "@/lib/db/schema";
+import { eq } from "drizzle-orm";
+import { updateProjectSchema } from "@/lib/validators/project";
+
+export async function GET(
+  _req: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+  const [project] = await db
+    .select()
+    .from(projects)
+    .where(eq(projects.id, id));
+
+  if (!project) {
+    return NextResponse.json({ error: "Not found" }, { status: 404 });
+  }
+  return NextResponse.json(project);
+}
+
+export async function PATCH(
+  req: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+  const body = await req.json();
+  const parsed = updateProjectSchema.safeParse(body);
+  if (!parsed.success) {
+    return NextResponse.json({ error: parsed.error.flatten() }, { status: 400 });
+  }
+
+  await db
+    .update(projects)
+    .set({ ...parsed.data, updatedAt: new Date() })
+    .where(eq(projects.id, id));
+
+  const [updated] = await db
+    .select()
+    .from(projects)
+    .where(eq(projects.id, id));
+
+  if (!updated) {
+    return NextResponse.json({ error: "Not found" }, { status: 404 });
+  }
+  return NextResponse.json(updated);
+}
+
+export async function DELETE(
+  _req: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+  const [existing] = await db
+    .select()
+    .from(projects)
+    .where(eq(projects.id, id));
+
+  if (!existing) {
+    return NextResponse.json({ error: "Not found" }, { status: 404 });
+  }
+
+  // Disassociate tasks before deleting project (avoids FK constraint failure)
+  await db
+    .update(tasks)
+    .set({ projectId: null, updatedAt: new Date() })
+    .where(eq(tasks.projectId, id));
+
+  await db.delete(projects).where(eq(projects.id, id));
+  return NextResponse.json({ success: true });
+}

package/src/app/api/projects/route.ts

@@ -0,0 +1,53 @@
+import { NextRequest, NextResponse } from "next/server";
+import { db } from "@/lib/db";
+import { projects, tasks } from "@/lib/db/schema";
+import { eq, count } from "drizzle-orm";
+import { createProjectSchema } from "@/lib/validators/project";
+
+export async function GET() {
+  const result = await db
+    .select({
+      id: projects.id,
+      name: projects.name,
+      description: projects.description,
+      workingDirectory: projects.workingDirectory,
+      status: projects.status,
+      createdAt: projects.createdAt,
+      updatedAt: projects.updatedAt,
+      taskCount: count(tasks.id),
+    })
+    .from(projects)
+    .leftJoin(tasks, eq(tasks.projectId, projects.id))
+    .groupBy(projects.id)
+    .orderBy(projects.createdAt);
+
+  return NextResponse.json(result);
+}
+
+export async function POST(req: NextRequest) {
+  const body = await req.json();
+  const parsed = createProjectSchema.safeParse(body);
+  if (!parsed.success) {
+    return NextResponse.json({ error: parsed.error.flatten() }, { status: 400 });
+  }
+
+  const now = new Date();
+  const id = crypto.randomUUID();
+
+  await db.insert(projects).values({
+    id,
+    name: parsed.data.name,
+    description: parsed.data.description ?? null,
+    workingDirectory: parsed.data.workingDirectory ?? null,
+    status: "active",
+    createdAt: now,
+    updatedAt: now,
+  });
+
+  const [project] = await db
+    .select()
+    .from(projects)
+    .where(eq(projects.id, id));
+
+  return NextResponse.json(project, { status: 201 });
+}

package/src/app/api/schedules/[id]/route.ts

@@ -0,0 +1,185 @@
+import { NextRequest, NextResponse } from "next/server";
+import { db } from "@/lib/db";
+import { schedules, tasks } from "@/lib/db/schema";
+import { eq, like } from "drizzle-orm";
+import { parseInterval, computeNextFireTime } from "@/lib/schedules/interval-parser";
+import { resolveAgentRuntime } from "@/lib/agents/runtime/catalog";
+import { validateRuntimeProfileAssignment } from "@/lib/agents/profiles/assignment-validation";
+
+export async function GET(
+  _req: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+
+  const [schedule] = await db
+    .select()
+    .from(schedules)
+    .where(eq(schedules.id, id));
+
+  if (!schedule) {
+    return NextResponse.json({ error: "Schedule not found" }, { status: 404 });
+  }
+
+  // Fetch child tasks (firing history) by title pattern match
+  const childTasks = await db
+    .select()
+    .from(tasks)
+    .where(like(tasks.title, `${schedule.name} — firing #%`));
+
+  return NextResponse.json({
+    ...schedule,
+    firingHistory: childTasks.sort(
+      (a, b) =>
+        new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()
+    ),
+  });
+}
+
+export async function PATCH(
+  req: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+  const body = await req.json();
+  const { status, name, prompt, interval, assignedAgent, agentProfile } = body as {
+    status?: string;
+    name?: string;
+    prompt?: string;
+    interval?: string;
+    assignedAgent?: string;
+    agentProfile?: string;
+  };
+
+  const [schedule] = await db
+    .select()
+    .from(schedules)
+    .where(eq(schedules.id, id));
+
+  if (!schedule) {
+    return NextResponse.json({ error: "Schedule not found" }, { status: 404 });
+  }
+
+  const now = new Date();
+  const updates: Record<string, unknown> = { updatedAt: now };
+
+  // Status transitions
+  if (status) {
+    if (status === "paused") {
+      if (schedule.status !== "active") {
+        return NextResponse.json(
+          { error: "Can only pause an active schedule" },
+          { status: 409 }
+        );
+      }
+      updates.status = "paused";
+      updates.nextFireAt = null;
+    } else if (status === "active") {
+      if (schedule.status !== "paused") {
+        return NextResponse.json(
+          { error: "Can only resume a paused schedule" },
+          { status: 409 }
+        );
+      }
+      updates.status = "active";
+      updates.nextFireAt = computeNextFireTime(schedule.cronExpression, now);
+    } else {
+      return NextResponse.json(
+        { error: `Invalid status: ${status}` },
+        { status: 400 }
+      );
+    }
+  }
+
+  // Field updates (only when active or paused)
+  if (name !== undefined) {
+    if (!name.trim()) {
+      return NextResponse.json({ error: "Name cannot be empty" }, { status: 400 });
+    }
+    updates.name = name.trim();
+  }
+
+  if (prompt !== undefined) {
+    if (!prompt.trim()) {
+      return NextResponse.json({ error: "Prompt cannot be empty" }, { status: 400 });
+    }
+    updates.prompt = prompt.trim();
+  }
+
+  if (interval !== undefined) {
+    try {
+      const cronExpression = parseInterval(interval);
+      updates.cronExpression = cronExpression;
+      // Recompute next fire time if schedule is active
+      if ((updates.status ?? schedule.status) === "active") {
+        updates.nextFireAt = computeNextFireTime(cronExpression, now);
+      }
+    } catch (err) {
+      return NextResponse.json(
+        { error: (err as Error).message },
+        { status: 400 }
+      );
+    }
+  }
+
+  if (agentProfile !== undefined) {
+    updates.agentProfile = agentProfile || null;
+  }
+
+  if (assignedAgent !== undefined) {
+    if (assignedAgent) {
+      try {
+        updates.assignedAgent = resolveAgentRuntime(assignedAgent);
+      } catch (error) {
+        return NextResponse.json(
+          { error: error instanceof Error ? error.message : String(error) },
+          { status: 400 }
+        );
+      }
+    } else {
+      updates.assignedAgent = null;
+    }
+  }
+
+  const compatibilityError = validateRuntimeProfileAssignment({
+    profileId:
+      agentProfile !== undefined ? agentProfile || null : schedule.agentProfile,
+    runtimeId:
+      assignedAgent !== undefined
+        ? assignedAgent || null
+        : schedule.assignedAgent,
+    context: "Schedule profile",
+  });
+  if (compatibilityError) {
+    return NextResponse.json({ error: compatibilityError }, { status: 400 });
+  }
+
+  await db.update(schedules).set(updates).where(eq(schedules.id, id));
+
+  const [updated] = await db
+    .select()
+    .from(schedules)
+    .where(eq(schedules.id, id));
+
+  return NextResponse.json(updated);
+}
+
+export async function DELETE(
+  _req: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+
+  const [schedule] = await db
+    .select()
+    .from(schedules)
+    .where(eq(schedules.id, id));
+
+  if (!schedule) {
+    return NextResponse.json({ error: "Schedule not found" }, { status: 404 });
+  }
+
+  await db.delete(schedules).where(eq(schedules.id, id));
+
+  return NextResponse.json({ deleted: true });
+}

package/src/app/api/schedules/route.ts

@@ -0,0 +1,117 @@
+import { NextRequest, NextResponse } from "next/server";
+import { db } from "@/lib/db";
+import { schedules } from "@/lib/db/schema";
+import { desc, eq } from "drizzle-orm";
+import { parseInterval, computeNextFireTime } from "@/lib/schedules/interval-parser";
+import { resolveAgentRuntime } from "@/lib/agents/runtime/catalog";
+import { validateRuntimeProfileAssignment } from "@/lib/agents/profiles/assignment-validation";
+
+export async function GET() {
+  const result = await db
+    .select()
+    .from(schedules)
+    .orderBy(desc(schedules.createdAt));
+
+  return NextResponse.json(result);
+}
+
+export async function POST(req: NextRequest) {
+  const body = await req.json();
+  const {
+    name,
+    prompt,
+    interval,
+    projectId,
+    assignedAgent,
+    agentProfile,
+    recurs,
+    maxFirings,
+    expiresInHours,
+  } =
+    body as {
+      name?: string;
+      prompt?: string;
+      interval?: string;
+      projectId?: string;
+      assignedAgent?: string;
+      agentProfile?: string;
+      recurs?: boolean;
+      maxFirings?: number;
+      expiresInHours?: number;
+    };
+
+  if (!name?.trim()) {
+    return NextResponse.json({ error: "Name is required" }, { status: 400 });
+  }
+  if (!prompt?.trim()) {
+    return NextResponse.json({ error: "Prompt is required" }, { status: 400 });
+  }
+  if (!interval?.trim()) {
+    return NextResponse.json({ error: "Interval is required" }, { status: 400 });
+  }
+
+  // Parse interval into cron expression
+  let cronExpression: string;
+  try {
+    cronExpression = parseInterval(interval);
+  } catch (err) {
+    return NextResponse.json(
+      { error: (err as Error).message },
+      { status: 400 }
+    );
+  }
+
+  if (assignedAgent !== undefined && assignedAgent !== null && assignedAgent !== "") {
+    try {
+      resolveAgentRuntime(assignedAgent);
+    } catch (error) {
+      return NextResponse.json(
+        { error: error instanceof Error ? error.message : String(error) },
+        { status: 400 }
+      );
+    }
+  }
+
+  const compatibilityError = validateRuntimeProfileAssignment({
+    profileId: agentProfile,
+    runtimeId: assignedAgent,
+    context: "Schedule profile",
+  });
+  if (compatibilityError) {
+    return NextResponse.json({ error: compatibilityError }, { status: 400 });
+  }
+
+  const id = crypto.randomUUID();
+  const now = new Date();
+  const nextFireAt = computeNextFireTime(cronExpression, now);
+  const shouldRecur = recurs !== false; // default to true
+
+  const expiresAt = expiresInHours
+    ? new Date(now.getTime() + expiresInHours * 60 * 60 * 1000)
+    : null;
+
+  await db.insert(schedules).values({
+    id,
+    name: name.trim(),
+    prompt: prompt.trim(),
+    cronExpression,
+    projectId: projectId || null,
+    assignedAgent: assignedAgent || null,
+    agentProfile: agentProfile || null,
+    recurs: shouldRecur,
+    status: "active",
+    maxFirings: maxFirings ?? null,
+    firingCount: 0,
+    expiresAt,
+    nextFireAt,
+    createdAt: now,
+    updatedAt: now,
+  });
+
+  const [created] = await db
+    .select()
+    .from(schedules)
+    .where(eq(schedules.id, id));
+
+  return NextResponse.json(created, { status: 201 });
+}

package/src/app/api/settings/budgets/route.ts

@@ -0,0 +1,24 @@
+import { NextRequest, NextResponse } from "next/server";
+import {
+  getBudgetGuardrailSnapshot,
+  setBudgetPolicy,
+} from "@/lib/settings/budget-guardrails";
+import { updateBudgetPolicySchema } from "@/lib/validators/settings";
+
+export async function GET() {
+  const snapshot = await getBudgetGuardrailSnapshot();
+  return NextResponse.json(snapshot);
+}
+
+export async function POST(req: NextRequest) {
+  const body = await req.json();
+  const parsed = updateBudgetPolicySchema.safeParse(body);
+
+  if (!parsed.success) {
+    return NextResponse.json({ error: parsed.error.flatten() }, { status: 400 });
+  }
+
+  await setBudgetPolicy(parsed.data);
+  const snapshot = await getBudgetGuardrailSnapshot();
+  return NextResponse.json(snapshot);
+}

package/src/app/api/settings/openai/route.ts

@@ -0,0 +1,24 @@
+import { NextRequest, NextResponse } from "next/server";
+import {
+  getOpenAIAuthSettings,
+  setOpenAIAuthSettings,
+} from "@/lib/settings/openai-auth";
+import { updateOpenAISettingsSchema } from "@/lib/validators/settings";
+
+export async function GET() {
+  const settings = await getOpenAIAuthSettings();
+  return NextResponse.json(settings);
+}
+
+export async function POST(req: NextRequest) {
+  const body = await req.json();
+  const parsed = updateOpenAISettingsSchema.safeParse(body);
+
+  if (!parsed.success) {
+    return NextResponse.json({ error: parsed.error.flatten() }, { status: 400 });
+  }
+
+  await setOpenAIAuthSettings(parsed.data);
+  const updated = await getOpenAIAuthSettings();
+  return NextResponse.json(updated);
+}

package/src/app/api/settings/route.ts

@@ -0,0 +1,21 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getAuthSettings, setAuthSettings } from "@/lib/settings/auth";
+import { updateAuthSettingsSchema } from "@/lib/validators/settings";
+
+export async function GET() {
+  const settings = await getAuthSettings();
+  return NextResponse.json(settings);
+}
+
+export async function POST(req: NextRequest) {
+  const body = await req.json();
+  const parsed = updateAuthSettingsSchema.safeParse(body);
+
+  if (!parsed.success) {
+    return NextResponse.json({ error: parsed.error.flatten() }, { status: 400 });
+  }
+
+  await setAuthSettings(parsed.data);
+  const updated = await getAuthSettings();
+  return NextResponse.json(updated);
+}

package/src/app/api/settings/test/route.ts

@@ -0,0 +1,26 @@
+import { NextResponse } from "next/server";
+import { DEFAULT_AGENT_RUNTIME } from "@/lib/agents/runtime/catalog";
+import { getRuntimeSummary, testRuntimeConnection } from "@/lib/agents/runtime";
+
+export async function POST(req: Request) {
+  try {
+    const body = (await req.json().catch(() => ({}))) as {
+      runtime?: string;
+    };
+    const runtimeId = body.runtime ?? DEFAULT_AGENT_RUNTIME;
+    const result = await testRuntimeConnection(runtimeId);
+    const summary = getRuntimeSummary(runtimeId);
+    return NextResponse.json({
+      ...result,
+      runtime: summary.runtime.id,
+      capabilities: summary.capabilities,
+    });
+  } catch (error: unknown) {
+    const message = error instanceof Error ? error.message : String(error);
+
+    return NextResponse.json(
+      { connected: false, error: message },
+      { status: 200 } // 200 so the client can read the error
+    );
+  }
+}