stagent 0.1.0

package/src/lib/schedules/scheduler.ts

@@ -0,0 +1,220 @@
+/**
+ * Poll-based scheduler engine.
+ *
+ * Runs on a configurable interval (default 60s), checking for schedules whose
+ * `nextFireAt` has passed. For each due schedule it creates a child task and
+ * fires it via the provider runtime pipeline.
+ *
+ * Lifecycle:
+ *   - `startScheduler()` — call once at server boot (idempotent)
+ *   - `stopScheduler()`  — call on graceful shutdown
+ *   - `tickScheduler()`  — exposed for testing; runs one poll cycle
+ */
+
+import { db } from "@/lib/db";
+import { schedules, tasks } from "@/lib/db/schema";
+import { eq, and, lte, like, inArray, sql } from "drizzle-orm";
+import { computeNextFireTime } from "./interval-parser";
+import { executeTaskWithRuntime } from "@/lib/agents/runtime";
+
+const POLL_INTERVAL_MS = 60_000; // 60 seconds
+
+let intervalHandle: ReturnType<typeof setInterval> | null = null;
+
+/**
+ * Start the scheduler singleton. Safe to call multiple times — subsequent
+ * calls are no-ops if already running.
+ */
+export function startScheduler(): void {
+  if (intervalHandle !== null) return;
+
+  // Bootstrap: recompute nextFireAt for any active schedules that are missing it
+  bootstrapNextFireTimes();
+
+  intervalHandle = setInterval(() => {
+    tickScheduler().catch((err) => {
+      console.error("[scheduler] tick error:", err);
+    });
+  }, POLL_INTERVAL_MS);
+
+  console.log("[scheduler] started — polling every 60s");
+}
+
+/**
+ * Stop the scheduler.
+ */
+export function stopScheduler(): void {
+  if (intervalHandle !== null) {
+    clearInterval(intervalHandle);
+    intervalHandle = null;
+    console.log("[scheduler] stopped");
+  }
+}
+
+/**
+ * Run one poll cycle: find due schedules and fire them.
+ */
+export async function tickScheduler(): Promise<void> {
+  const now = new Date();
+
+  const dueSchedules = await db
+    .select()
+    .from(schedules)
+    .where(
+      and(
+        eq(schedules.status, "active"),
+        lte(schedules.nextFireAt, now)
+      )
+    );
+
+  for (const schedule of dueSchedules) {
+    try {
+      // Atomic claim: attempt to update nextFireAt to null as a lock.
+      // Only the first tick to succeed (.changes > 0) proceeds with firing.
+      const claimResult = db
+        .update(schedules)
+        .set({ nextFireAt: null, updatedAt: now })
+        .where(
+          and(
+            eq(schedules.id, schedule.id),
+            eq(schedules.status, "active"),
+            lte(schedules.nextFireAt, now)
+          )
+        )
+        .run();
+
+      if (claimResult.changes === 0) {
+        // Another tick already claimed this schedule
+        continue;
+      }
+
+      await fireSchedule(schedule, now);
+    } catch (err) {
+      console.error(`[scheduler] failed to fire schedule ${schedule.id}:`, err);
+    }
+  }
+}
+
+async function fireSchedule(
+  schedule: typeof schedules.$inferSelect,
+  now: Date
+): Promise<void> {
+  // Concurrency guard: skip if a child task from this schedule is still running.
+  // Escape SQL LIKE metacharacters (%, _) in schedule name to prevent false matches.
+  const escapedName = schedule.name
+    .replace(/\\/g, "\\\\")
+    .replace(/%/g, "\\%")
+    .replace(/_/g, "\\_");
+  const runningChildren = await db
+    .select({ id: tasks.id })
+    .from(tasks)
+    .where(
+      and(
+        sql`${tasks.title} LIKE ${`${escapedName} — firing #%`} ESCAPE '\\'`,
+        inArray(tasks.status, ["queued", "running"])
+      )
+    );
+  if (runningChildren.length > 0) {
+    console.log(`[scheduler] skipping ${schedule.id} — previous firing still running`);
+    return;
+  }
+
+  // Check expiry
+  if (schedule.expiresAt && schedule.expiresAt <= now) {
+    await db
+      .update(schedules)
+      .set({ status: "expired", updatedAt: now })
+      .where(eq(schedules.id, schedule.id));
+    return;
+  }
+
+  // Check max firings
+  if (schedule.maxFirings && schedule.firingCount >= schedule.maxFirings) {
+    await db
+      .update(schedules)
+      .set({ status: "expired", updatedAt: now })
+      .where(eq(schedules.id, schedule.id));
+    return;
+  }
+
+  // Create child task
+  const taskId = crypto.randomUUID();
+  const firingNumber = schedule.firingCount + 1;
+
+  await db.insert(tasks).values({
+    id: taskId,
+    projectId: schedule.projectId,
+    workflowId: null,
+    scheduleId: schedule.id,
+    title: `${schedule.name} — firing #${firingNumber}`,
+    description: schedule.prompt,
+    status: "queued",
+    assignedAgent: schedule.assignedAgent,
+    agentProfile: schedule.agentProfile,
+    priority: 2,
+    createdAt: now,
+    updatedAt: now,
+  });
+
+  // Update schedule counters
+  const isOneShot = !schedule.recurs;
+  const reachedMax =
+    schedule.maxFirings !== null && firingNumber >= schedule.maxFirings;
+
+  const nextStatus = isOneShot
+    ? "completed"
+    : reachedMax
+      ? "expired"
+      : "active";
+
+  const nextFireAt =
+    nextStatus === "active"
+      ? computeNextFireTime(schedule.cronExpression, now)
+      : null;
+
+  await db
+    .update(schedules)
+    .set({
+      firingCount: firingNumber,
+      lastFiredAt: now,
+      nextFireAt,
+      status: nextStatus,
+      updatedAt: now,
+    })
+    .where(eq(schedules.id, schedule.id));
+
+  // Fire-and-forget task execution
+  executeTaskWithRuntime(taskId).catch((err) => {
+    console.error(
+      `[scheduler] task execution failed for schedule ${schedule.id}, task ${taskId}:`,
+      err
+    );
+  });
+
+  console.log(
+    `[scheduler] fired schedule "${schedule.name}" → task ${taskId} (firing #${firingNumber})`
+  );
+}
+
+/**
+ * Recompute nextFireAt for active schedules that have it set to null.
+ * Called once at startup to recover from unclean shutdowns.
+ */
+function bootstrapNextFireTimes(): void {
+  const activeSchedules = db
+    .select()
+    .from(schedules)
+    .where(eq(schedules.status, "active"))
+    .all();
+
+  const now = new Date();
+  for (const schedule of activeSchedules) {
+    if (!schedule.nextFireAt) {
+      const nextFire = computeNextFireTime(schedule.cronExpression, now);
+      db.update(schedules)
+        .set({ nextFireAt: nextFire, updatedAt: now })
+        .where(eq(schedules.id, schedule.id))
+        .run();
+    }
+  }
+}

package/src/lib/settings/auth.ts

@@ -0,0 +1,98 @@
+import { db } from "@/lib/db";
+import { settings } from "@/lib/db/schema";
+import { eq } from "drizzle-orm";
+import { encrypt, decrypt } from "@/lib/utils/crypto";
+import { SETTINGS_KEYS, type AuthMethod, type ApiKeySource } from "@/lib/constants/settings";
+import type { UpdateAuthSettingsInput } from "@/lib/validators/settings";
+import { getSetting, setSetting } from "./helpers";
+
+export interface AuthSettings {
+  method: AuthMethod;
+  hasKey: boolean;
+  apiKeySource: ApiKeySource;
+}
+
+/**
+ * Get current auth settings. Never returns the raw API key.
+ */
+export async function getAuthSettings(): Promise<AuthSettings> {
+  const method = ((await getSetting(SETTINGS_KEYS.AUTH_METHOD)) as AuthMethod) ?? "oauth";
+  const encryptedKey = await getSetting(SETTINGS_KEYS.AUTH_API_KEY);
+  const storedSource = (await getSetting(SETTINGS_KEYS.AUTH_API_KEY_SOURCE)) as ApiKeySource | null;
+
+  const hasDbKey = encryptedKey !== null;
+  const hasEnvKey = !!process.env.ANTHROPIC_API_KEY;
+
+  let apiKeySource: ApiKeySource;
+  if (storedSource) {
+    apiKeySource = storedSource;
+  } else if (hasDbKey) {
+    apiKeySource = "db";
+  } else if (hasEnvKey) {
+    apiKeySource = "env";
+  } else if (method === "oauth") {
+    apiKeySource = "oauth";
+  } else {
+    apiKeySource = "unknown";
+  }
+
+  return {
+    method,
+    hasKey: hasDbKey || hasEnvKey,
+    apiKeySource,
+  };
+}
+
+/**
+ * Save auth settings. Encrypts API key before storing.
+ */
+export async function setAuthSettings(input: UpdateAuthSettingsInput): Promise<void> {
+  await setSetting(SETTINGS_KEYS.AUTH_METHOD, input.method);
+
+  if (input.apiKey) {
+    await setSetting(SETTINGS_KEYS.AUTH_API_KEY, encrypt(input.apiKey));
+    await setSetting(SETTINGS_KEYS.AUTH_API_KEY_SOURCE, "db");
+  } else if (input.method === "oauth") {
+    // Clear stored key when switching to OAuth
+    const existingKey = await getSetting(SETTINGS_KEYS.AUTH_API_KEY);
+    if (existingKey !== null) {
+      await db.delete(settings)
+        .where(eq(settings.key, SETTINGS_KEYS.AUTH_API_KEY));
+    }
+    await setSetting(SETTINGS_KEYS.AUTH_API_KEY_SOURCE, "oauth");
+  }
+}
+
+/**
+ * Get the environment variables to pass to the Agent SDK.
+ * Priority: DB-stored key > process.env > undefined (SDK falls back to OAuth).
+ */
+export async function getAuthEnv(): Promise<Record<string, string> | undefined> {
+  const method = ((await getSetting(SETTINGS_KEYS.AUTH_METHOD)) as AuthMethod) ?? "oauth";
+
+  // If OAuth is selected, don't inject any key — let SDK handle it
+  if (method === "oauth") {
+    return undefined;
+  }
+
+  // Try DB-stored key first
+  const encryptedKey = await getSetting(SETTINGS_KEYS.AUTH_API_KEY);
+  if (encryptedKey) {
+    try {
+      const key = decrypt(encryptedKey);
+      return { ANTHROPIC_API_KEY: key };
+    } catch {
+      // If decryption fails, fall through to env
+    }
+  }
+
+  // Fall back to env var (already in process.env, no need to inject)
+  return undefined;
+}
+
+/**
+ * Update the last-known API key source after SDK initialization.
+ */
+export async function updateAuthStatus(source: ApiKeySource): Promise<void> {
+  await setSetting(SETTINGS_KEYS.AUTH_API_KEY_SOURCE, source);
+}