stagent 0.9.6 → 0.11.0

package/src/lib/instance/upgrade-poller.ts

@@ -0,0 +1,205 @@
+/**
+ * Upgrade Poller — background service that polls origin/main for new commits.
+ *
+ * Uses `git fetch` locally (not the GitHub REST API) to avoid rate limits
+ * and auth token management. Runs alongside the scheduler via instrumentation.ts.
+ *
+ * Skipped entirely if dev-mode is active or .git is absent — mirrors the
+ * instance bootstrap gating.
+ */
+
+import { existsSync, mkdirSync, writeFileSync, unlinkSync, statSync } from "fs";
+import { join } from "path";
+import { and, eq, isNull } from "drizzle-orm";
+import { db } from "@/lib/db";
+import { notifications } from "@/lib/db/schema";
+import { isDevMode, hasGitDir } from "./detect";
+import { createGitOps } from "./git-ops";
+import { getUpgradeState, setUpgradeState } from "./settings";
+
+const POLL_INTERVAL_MS = 60 * 60 * 1000; // 1 hour
+const LOCK_TTL_MS = 5 * 60 * 1000; // 5 minutes
+const LOCK_FILENAME = ".stagent-upgrade-check.lock";
+const FAILURE_THRESHOLD = 3;
+// Sentinel value in notifications.toolName so we can dedupe / clear the banner.
+const FAILURE_MARKER = "upgrade_check_failing";
+
+let intervalHandle: ReturnType<typeof setInterval> | null = null;
+let ticking = false;
+
+/** Poll once immediately, then on a 1-hour interval. */
+export function startUpgradePoller(): void {
+  if (intervalHandle !== null) return;
+  if (isDevMode() || !hasGitDir()) {
+    console.log(`[upgrade-poller] skipped (dev mode or no .git)`);
+    return;
+  }
+
+  // Kick off an initial poll on boot, then schedule hourly.
+  tick().catch((err) => console.error("[upgrade-poller] initial tick error:", err));
+  intervalHandle = setInterval(() => {
+    tick().catch((err) => console.error("[upgrade-poller] tick error:", err));
+  }, POLL_INTERVAL_MS);
+  console.log(`[upgrade-poller] started — polling every ${POLL_INTERVAL_MS / 1000 / 60}m`);
+}
+
+export function stopUpgradePoller(): void {
+  if (intervalHandle !== null) {
+    clearInterval(intervalHandle);
+    intervalHandle = null;
+  }
+}
+
+/**
+ * Exposed for testing and for the manual `POST /api/instance/upgrade/check`
+ * force-check endpoint. Returns the new state, or null if skipped (lock held,
+ * or dev mode).
+ */
+export async function tick(cwd: string = process.cwd()): Promise<UpgradeTickResult> {
+  if (ticking) return { skipped: "in_progress" };
+  if (isDevMode(cwd) || !hasGitDir(cwd)) return { skipped: "dev_mode_or_no_git" };
+
+  ticking = true;
+  try {
+    // Advisory lock: cross-process safety (subprocess + dev server + manual check)
+    const lockPath = join(cwd, ".git", LOCK_FILENAME);
+    if (!acquireLock(lockPath)) {
+      return { skipped: "lock_held" };
+    }
+
+    try {
+      const git = createGitOps(cwd);
+      const current = getUpgradeState();
+
+      try {
+        git.fetchOrigin();
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const nextFailureCount = current.pollFailureCount + 1;
+        await setUpgradeState({
+          ...current,
+          lastPolledAt: Math.floor(Date.now() / 1000),
+          pollFailureCount: nextFailureCount,
+          lastPollError: message,
+        });
+        if (nextFailureCount >= FAILURE_THRESHOLD) {
+          await ensureFailureNotification(nextFailureCount, message);
+        }
+        return { skipped: "fetch_failed", error: message };
+      }
+
+      const upstreamSha = git.revParse("origin/main");
+      const localMainSha = git.revParse("main");
+      const commitsBehind =
+        upstreamSha && localMainSha ? git.countCommitsAhead("main", "origin/main") : 0;
+
+      const newState = {
+        ...current,
+        lastPolledAt: Math.floor(Date.now() / 1000),
+        lastUpstreamSha: upstreamSha,
+        localMainSha: localMainSha,
+        upgradeAvailable: commitsBehind > 0,
+        commitsBehind,
+        pollFailureCount: 0,
+        lastPollError: null,
+      };
+      await setUpgradeState(newState);
+      if (current.pollFailureCount >= FAILURE_THRESHOLD) {
+        await clearFailureNotification();
+      }
+      return { updated: newState };
+    } finally {
+      releaseLock(lockPath);
+    }
+  } finally {
+    ticking = false;
+  }
+}
+
+export interface UpgradeTickResult {
+  updated?: ReturnType<typeof getUpgradeState>;
+  skipped?: "in_progress" | "dev_mode_or_no_git" | "lock_held" | "fetch_failed";
+  error?: string;
+}
+
+function acquireLock(lockPath: string): boolean {
+  // Ensure .git/ exists (it does in normal repos; belt-and-suspenders)
+  try {
+    mkdirSync(join(lockPath, ".."), { recursive: true });
+  } catch {
+    /* ignore */
+  }
+
+  if (existsSync(lockPath)) {
+    // Stale lock check: if older than TTL, break it
+    try {
+      const age = Date.now() - statSync(lockPath).mtimeMs;
+      if (age > LOCK_TTL_MS) {
+        unlinkSync(lockPath);
+      } else {
+        return false;
+      }
+    } catch {
+      // Stat failed; treat as stale and try to remove
+      try {
+        unlinkSync(lockPath);
+      } catch {
+        return false;
+      }
+    }
+  }
+
+  try {
+    writeFileSync(lockPath, String(process.pid), { flag: "wx" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function releaseLock(lockPath: string): void {
+  try {
+    unlinkSync(lockPath);
+  } catch {
+    /* ignore */
+  }
+}
+
+/**
+ * Insert a persistent "Upgrade check failing" notification, at most one at a time.
+ * Dedup key: `notifications.toolName = FAILURE_MARKER` with no response set.
+ */
+async function ensureFailureNotification(failureCount: number, error: string): Promise<void> {
+  try {
+    const existing = await db
+      .select({ id: notifications.id })
+      .from(notifications)
+      .where(and(eq(notifications.toolName, FAILURE_MARKER), isNull(notifications.respondedAt)))
+      .limit(1);
+    if (existing.length > 0) return;
+
+    await db.insert(notifications).values({
+      id: crypto.randomUUID(),
+      type: "agent_message",
+      title: "Upgrade check failing",
+      body: `Last ${failureCount} upgrade checks failed: ${error.slice(0, 400)}. Open Settings → Instance to retry.`,
+      toolName: FAILURE_MARKER,
+      read: false,
+      createdAt: new Date(),
+    });
+  } catch (err) {
+    console.error("[upgrade-poller] failed to insert failure notification:", err);
+  }
+}
+
+/** Mark any open failure notification as responded so the inbox clears it. */
+async function clearFailureNotification(): Promise<void> {
+  try {
+    await db
+      .update(notifications)
+      .set({ respondedAt: new Date(), read: true })
+      .where(and(eq(notifications.toolName, FAILURE_MARKER), isNull(notifications.respondedAt)));
+  } catch (err) {
+    console.error("[upgrade-poller] failed to clear failure notification:", err);
+  }
+}

package/src/lib/notifications/__tests__/visibility.test.ts

@@ -0,0 +1,51 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  filterDefaultVisibleNotifications,
+  isResolvedLearningNotification,
+} from "@/lib/notifications/visibility";
+
+describe("notification visibility", () => {
+  it("treats responded learning notifications as resolved", () => {
+    expect(
+      isResolvedLearningNotification({
+        type: "context_proposal",
+        response: JSON.stringify({ action: "approved" }),
+        respondedAt: "2026-04-10T00:00:00.000Z",
+      })
+    ).toBe(true);
+
+    expect(
+      isResolvedLearningNotification({
+        type: "context_proposal_batch",
+        response: null,
+        respondedAt: null,
+      })
+    ).toBe(false);
+  });
+
+  it("filters resolved learning notifications but keeps other notification types", () => {
+    const visible = filterDefaultVisibleNotifications([
+      {
+        id: "n1",
+        type: "context_proposal",
+        response: JSON.stringify({ action: "approved" }),
+        respondedAt: "2026-04-10T00:00:00.000Z",
+      },
+      {
+        id: "n2",
+        type: "context_proposal_batch",
+        response: null,
+        respondedAt: null,
+      },
+      {
+        id: "n3",
+        type: "permission_required",
+        response: JSON.stringify({ behavior: "allow" }),
+        respondedAt: "2026-04-10T00:00:00.000Z",
+      },
+    ]);
+
+    expect(visible.map((item) => item.id)).toEqual(["n2", "n3"]);
+  });
+});

package/src/lib/notifications/visibility.ts

@@ -0,0 +1,33 @@
+import { sql } from "drizzle-orm";
+
+import { notifications } from "@/lib/db/schema";
+
+export interface NotificationVisibilityRecord {
+  type: string;
+  response: string | null;
+  respondedAt: string | Date | null;
+}
+
+export function isLearningNotificationType(type: string): boolean {
+  return type === "context_proposal" || type === "context_proposal_batch";
+}
+
+export function isResolvedLearningNotification(
+  notification: NotificationVisibilityRecord
+): boolean {
+  if (!isLearningNotificationType(notification.type)) {
+    return false;
+  }
+
+  return notification.response !== null || notification.respondedAt !== null;
+}
+
+export function filterDefaultVisibleNotifications<T extends NotificationVisibilityRecord>(
+  items: T[]
+): T[] {
+  return items.filter((item) => !isResolvedLearningNotification(item));
+}
+
+export function buildDefaultNotificationVisibilityCondition() {
+  return sql`(${notifications.type} NOT IN ('context_proposal', 'context_proposal_batch') OR (${notifications.response} IS NULL AND ${notifications.respondedAt} IS NULL))`;
+}

package/src/lib/schedules/__tests__/collision-check.test.ts

@@ -0,0 +1,93 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { db } from "@/lib/db";
+import { schedules, projects } from "@/lib/db/schema";
+import { randomUUID } from "crypto";
+import { checkCollision } from "../collision-check";
+
+function seedSchedule(opts: {
+  cron: string;
+  avgTurns: number;
+  projectId: string;
+  status?: "active" | "paused";
+}): string {
+  const id = randomUUID();
+  const now = new Date();
+  db.insert(schedules)
+    .values({
+      id,
+      projectId: opts.projectId,
+      name: `s-${id.slice(0, 4)}`,
+      prompt: "test",
+      cronExpression: opts.cron,
+      status: opts.status ?? "active",
+      type: "scheduled",
+      firingCount: 0,
+      suppressionCount: 0,
+      heartbeatSpentToday: 0,
+      failureStreak: 0,
+      turnBudgetBreachStreak: 0,
+      avgTurnsPerFiring: opts.avgTurns,
+      createdAt: now,
+      updatedAt: now,
+    })
+    .run();
+  return id;
+}
+
+function seedProject(): string {
+  const id = randomUUID();
+  const now = new Date();
+  db.insert(projects)
+    .values({ id, name: "p", status: "active", createdAt: now, updatedAt: now })
+    .run();
+  return id;
+}
+
+describe("checkCollision", () => {
+  beforeEach(() => {
+    db.delete(schedules).run();
+    db.delete(projects).run();
+  });
+
+  it("returns no warnings when no overlap exists", () => {
+    const pid = seedProject();
+    seedSchedule({ cron: "0 3 * * *", avgTurns: 500, projectId: pid });
+    expect(checkCollision("0 15 * * *", 500, pid, null)).toEqual([]);
+  });
+
+  it("detects overlap when two heavy schedules share a 5-min bucket", () => {
+    const pid = seedProject();
+    seedSchedule({ cron: "2 * * * *", avgTurns: 2000, projectId: pid });
+    const warnings = checkCollision("0 * * * *", 2000, pid, null);
+    expect(warnings.length).toBe(1);
+    expect(warnings[0].type).toBe("cron_collision");
+    expect(warnings[0].estimatedConcurrentSteps).toBeGreaterThanOrEqual(4000);
+  });
+
+  it("ignores paused schedules", () => {
+    const pid = seedProject();
+    seedSchedule({
+      cron: "2 * * * *",
+      avgTurns: 2000,
+      projectId: pid,
+      status: "paused",
+    });
+    expect(checkCollision("0 * * * *", 2000, pid, null)).toEqual([]);
+  });
+
+  it("excludes the excludeScheduleId (for PUT updates)", () => {
+    const pid = seedProject();
+    const existing = seedSchedule({
+      cron: "0 * * * *",
+      avgTurns: 3000,
+      projectId: pid,
+    });
+    expect(checkCollision("0 * * * *", 3000, pid, existing)).toEqual([]);
+  });
+
+  it("does not warn when combined steps are below the threshold", () => {
+    const pid = seedProject();
+    seedSchedule({ cron: "2 * * * *", avgTurns: 500, projectId: pid });
+    expect(checkCollision("0 * * * *", 500, pid, null)).toEqual([]);
+  });
+});

package/src/lib/schedules/__tests__/config.test.ts

@@ -0,0 +1,62 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { db } from "@/lib/db";
+import { settings } from "@/lib/db/schema";
+import { eq } from "drizzle-orm";
+import {
+  getScheduleMaxConcurrent,
+  getScheduleMaxRunDurationSec,
+  getScheduleChatPressureDelaySec,
+} from "../config";
+
+describe("schedule config", () => {
+  beforeEach(() => {
+    db.delete(settings).where(eq(settings.key, "schedule.maxConcurrent")).run();
+    db.delete(settings).where(eq(settings.key, "schedule.maxRunDurationSec")).run();
+    db.delete(settings).where(eq(settings.key, "schedule.chatPressureDelaySec")).run();
+  });
+
+  it("returns default max concurrent of 2 when setting is absent", () => {
+    expect(getScheduleMaxConcurrent()).toBe(2);
+  });
+
+  it("reads max concurrent from settings when set", () => {
+    db.insert(settings)
+      .values({
+        key: "schedule.maxConcurrent",
+        value: "3",
+        updatedAt: new Date(),
+      })
+      .run();
+    expect(getScheduleMaxConcurrent()).toBe(3);
+  });
+
+  it("reads max concurrent from SCHEDULE_MAX_CONCURRENT env var", () => {
+    const original = process.env.SCHEDULE_MAX_CONCURRENT;
+    process.env.SCHEDULE_MAX_CONCURRENT = "5";
+    try {
+      expect(getScheduleMaxConcurrent()).toBe(5);
+    } finally {
+      if (original === undefined) delete process.env.SCHEDULE_MAX_CONCURRENT;
+      else process.env.SCHEDULE_MAX_CONCURRENT = original;
+    }
+  });
+
+  it("falls back to default when env var is NaN", () => {
+    const original = process.env.SCHEDULE_MAX_CONCURRENT;
+    process.env.SCHEDULE_MAX_CONCURRENT = "abc";
+    try {
+      expect(getScheduleMaxConcurrent()).toBe(2);
+    } finally {
+      if (original === undefined) delete process.env.SCHEDULE_MAX_CONCURRENT;
+      else process.env.SCHEDULE_MAX_CONCURRENT = original;
+    }
+  });
+
+  it("returns default max run duration of 1200s", () => {
+    expect(getScheduleMaxRunDurationSec()).toBe(1200);
+  });
+
+  it("returns default chat pressure delay of 30s", () => {
+    expect(getScheduleChatPressureDelaySec()).toBe(30);
+  });
+});

package/src/lib/schedules/__tests__/firing-metrics.test.ts

@@ -0,0 +1,99 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { db } from "@/lib/db";
+import {
+  tasks,
+  schedules,
+  projects,
+  scheduleFiringMetrics,
+  agentLogs,
+} from "@/lib/db/schema";
+import { eq } from "drizzle-orm";
+import { randomUUID } from "crypto";
+import { recordFiringMetrics } from "../scheduler";
+
+describe("schedule_firing_metrics insertion", () => {
+  beforeEach(() => {
+    db.delete(scheduleFiringMetrics).run();
+    db.delete(agentLogs).run();
+    db.delete(tasks).run();
+    db.delete(schedules).run();
+    db.delete(projects).run();
+  });
+
+  it("inserts a row for every firing with slot_wait_ms and duration_ms", async () => {
+    const pid = randomUUID();
+    const sid = randomUUID();
+    const tid = randomUUID();
+    const firedAt = new Date(Date.now() - 5000);
+    const slotClaimedAt = new Date(Date.now() - 4000);
+    const completedAt = new Date(Date.now() - 100);
+
+    db.insert(projects)
+      .values({
+        id: pid,
+        name: "p",
+        status: "active",
+        createdAt: firedAt,
+        updatedAt: firedAt,
+      })
+      .run();
+    db.insert(schedules)
+      .values({
+        id: sid,
+        projectId: pid,
+        name: "test",
+        prompt: "x",
+        cronExpression: "* * * * *",
+        status: "active",
+        type: "scheduled",
+        firingCount: 1,
+        suppressionCount: 0,
+        heartbeatSpentToday: 0,
+        failureStreak: 0,
+        turnBudgetBreachStreak: 0,
+        maxTurns: 50,
+        createdAt: firedAt,
+        updatedAt: firedAt,
+      })
+      .run();
+    db.insert(tasks)
+      .values({
+        id: tid,
+        scheduleId: sid,
+        title: "firing",
+        status: "completed",
+        priority: 2,
+        sourceType: "scheduled",
+        resumeCount: 0,
+        slotClaimedAt,
+        createdAt: firedAt,
+        updatedAt: completedAt,
+      })
+      .run();
+    for (let i = 0; i < 7; i++) {
+      db.insert(agentLogs)
+        .values({
+          id: randomUUID(),
+          taskId: tid,
+          agentType: "test",
+          event: "assistant_message",
+          timestamp: new Date(),
+        })
+        .run();
+    }
+
+    await recordFiringMetrics(sid, tid);
+
+    const rows = db
+      .select()
+      .from(scheduleFiringMetrics)
+      .where(eq(scheduleFiringMetrics.scheduleId, sid))
+      .all();
+
+    expect(rows.length).toBe(1);
+    expect(rows[0].turnCount).toBe(7);
+    expect(rows[0].maxTurnsAtFiring).toBe(50);
+    expect(rows[0].slotWaitMs).toBeGreaterThan(0);
+    expect(rows[0].durationMs).toBeGreaterThan(0);
+  });
+});

package/src/lib/schedules/__tests__/integration.test.ts

@@ -0,0 +1,82 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { db } from "@/lib/db";
+import {
+  tasks,
+  schedules,
+  projects,
+  settings,
+  scheduleFiringMetrics,
+  agentLogs,
+} from "@/lib/db/schema";
+import { eq } from "drizzle-orm";
+import { randomUUID } from "crypto";
+import { tickScheduler } from "../scheduler";
+import { countRunningScheduledSlots } from "../slot-claim";
+
+vi.mock("@/lib/agents/runtime", () => ({
+  executeTaskWithRuntime: vi.fn(async () => {
+    // Simulate a short-running task
+    await new Promise((r) => setTimeout(r, 20));
+  }),
+}));
+
+describe("schedule orchestration end-to-end", () => {
+  beforeEach(() => {
+    db.delete(scheduleFiringMetrics).run();
+    db.delete(agentLogs).run();
+    db.delete(tasks).run();
+    db.delete(schedules).run();
+    db.delete(projects).run();
+    db.delete(settings).where(eq(settings.key, "schedule.maxConcurrent")).run();
+    db.insert(settings)
+      .values({ key: "schedule.maxConcurrent", value: "2", updatedAt: new Date() })
+      .run();
+  });
+
+  it("5 schedules firing at once → exactly 2 run, 3 queue", async () => {
+    const pid = randomUUID();
+    const now = new Date();
+    db.insert(projects)
+      .values({ id: pid, name: "p", status: "active", createdAt: now, updatedAt: now })
+      .run();
+
+    const past = new Date(now.getTime() - 10_000);
+    for (let i = 0; i < 5; i++) {
+      db.insert(schedules)
+        .values({
+          id: randomUUID(),
+          projectId: pid,
+          name: `sched-${i}`,
+          prompt: "test",
+          cronExpression: "* * * * *",
+          status: "active",
+          type: "scheduled",
+          firingCount: 0,
+          suppressionCount: 0,
+          heartbeatSpentToday: 0,
+          failureStreak: 0,
+          turnBudgetBreachStreak: 0,
+          nextFireAt: past,
+          createdAt: now,
+          updatedAt: now,
+        })
+        .run();
+    }
+
+    await tickScheduler();
+
+    expect(countRunningScheduledSlots()).toBe(2);
+    const running = db
+      .select()
+      .from(tasks)
+      .where(eq(tasks.status, "running"))
+      .all();
+    expect(running.length).toBe(2);
+    const queued = db
+      .select()
+      .from(tasks)
+      .where(eq(tasks.status, "queued"))
+      .all();
+    expect(queued.length).toBe(3);
+  });
+});