conductor-oss 0.2.15 → 0.2.16

package/web/.next/standalone/packages/web/src/app/api/health/sessions/route.ts

@@ -0,0 +1,77 @@
+import { NextResponse } from "next/server";
+import { getServices } from "@/lib/services";
+import { guardApiAccess } from "@/lib/auth";
+
+export const dynamic = "force-dynamic";
+
+/**
+ * GET /api/health/sessions -- per-session health metrics.
+ *
+ * Returns session-level health: age, spawn duration, activity transitions,
+ * and whether the session is in a healthy operational state.
+ */
+export async function GET(): Promise<NextResponse> {
+  const denied = await guardApiAccess(undefined, "viewer");
+  if (denied) return denied;
+
+  try {
+    const { sessionManager } = await getServices();
+    const sessions = await sessionManager.list();
+
+    const now = Date.now();
+    const metrics = sessions.map((session) => {
+      const createdMs = session.createdAt.getTime();
+      const lastActivityMs = session.lastActivityAt.getTime();
+      const ageMs = now - createdMs;
+      const idleMs = now - lastActivityMs;
+
+      // Determine health state
+      let health: "healthy" | "warning" | "critical" = "healthy";
+      const terminalStatuses = new Set(["killed", "terminated", "done", "cleanup", "merged", "errored"]);
+
+      if (terminalStatuses.has(session.status)) {
+        health = "healthy"; // terminal is expected
+      } else if (session.status === "spawning" && ageMs > 600_000) {
+        health = "critical"; // zombie spawn
+      } else if (session.status === "spawning" && ageMs > 120_000) {
+        health = "warning"; // slow spawn
+      } else if (session.activity === "blocked" && idleMs > 600_000) {
+        health = "critical"; // stuck
+      } else if (session.activity === "waiting_input" && idleMs > 300_000) {
+        health = "warning"; // waiting too long
+      } else if (session.status === "stuck") {
+        health = "critical";
+      } else if (session.status === "needs_input") {
+        health = "warning";
+      }
+
+      return {
+        id: session.id,
+        projectId: session.projectId,
+        status: session.status,
+        activity: session.activity,
+        health,
+        ageMs,
+        idleMs,
+        createdAt: session.createdAt.toISOString(),
+        lastActivityAt: session.lastActivityAt.toISOString(),
+        hasRuntime: session.runtimeHandle !== null,
+        hasPR: session.pr !== null,
+      };
+    });
+
+    const summary = {
+      total: metrics.length,
+      healthy: metrics.filter((m) => m.health === "healthy").length,
+      warning: metrics.filter((m) => m.health === "warning").length,
+      critical: metrics.filter((m) => m.health === "critical").length,
+    };
+
+    return NextResponse.json({ metrics, summary });
+  } catch (err) {
+    return NextResponse.json(
+      { error: err instanceof Error ? err.message : "Failed to get session health" },
+      { status: 500 },
+    );
+  }
+}

package/web/.next/standalone/packages/web/src/app/api/notifications/route.ts

@@ -0,0 +1,91 @@
+import { type NextRequest, NextResponse } from "next/server";
+import { guardApiAccess } from "@/lib/auth";
+import { getEventBus } from "@/lib/event-bus-singleton";
+
+export const dynamic = "force-dynamic";
+
+/**
+ * GET /api/notifications -- pending attention events for the dashboard notification center.
+ *
+ * Query params:
+ *   - project: filter by project ID
+ *   - limit: max events to return (default 20)
+ *   - since: ISO date filter
+ *
+ * POST /api/notifications/ack -- acknowledge an event by ID.
+ */
+export async function GET(request: NextRequest): Promise<NextResponse> {
+  const denied = await guardApiAccess(request, "viewer");
+  if (denied) return denied;
+
+  try {
+    const eventBus = getEventBus();
+    if (!eventBus) {
+      return NextResponse.json({ notifications: [], metrics: null });
+    }
+
+    const searchParams = new URL(request.url).searchParams;
+    const projectId = searchParams.get("project") ?? undefined;
+    const limit = parseInt(searchParams.get("limit") ?? "20", 10);
+    const sinceParam = searchParams.get("since");
+    const since = sinceParam ? new Date(sinceParam) : undefined;
+
+    const pending = eventBus.query({
+      projectId,
+      since,
+      limit,
+    });
+
+    // Sort by timestamp descending (most recent first)
+    const sorted = [...pending].sort(
+      (a, b) => b.timestamp.getTime() - a.timestamp.getTime(),
+    );
+
+    const notifications = sorted.map((e) => ({
+      id: e.id,
+      type: e.type,
+      priority: e.priority,
+      sessionId: e.sessionId,
+      projectId: e.projectId,
+      message: e.message,
+      timestamp: e.timestamp.toISOString(),
+      data: e.data,
+    }));
+
+    return NextResponse.json({
+      notifications,
+      metrics: eventBus.metrics(),
+    });
+  } catch (err) {
+    return NextResponse.json(
+      { error: err instanceof Error ? err.message : "Failed to get notifications" },
+      { status: 500 },
+    );
+  }
+}
+
+export async function POST(request: NextRequest): Promise<NextResponse> {
+  const denied = await guardApiAccess(request, "operator");
+  if (denied) return denied;
+
+  try {
+    const body = (await request.json()) as { action?: string; eventId?: string };
+    const eventBus = getEventBus();
+
+    if (!eventBus) {
+      return NextResponse.json({ error: "Event bus not available" }, { status: 503 });
+    }
+
+    if (body.action === "ack" && body.eventId) {
+      const acked = eventBus.acknowledge(body.eventId);
+      return NextResponse.json({ ok: acked, eventId: body.eventId });
+    }
+
+    return NextResponse.json({ error: "Unknown action" }, { status: 400 });
+  } catch (err) {
+    return NextResponse.json(
+      { error: err instanceof Error ? err.message : "Action failed" },
+      { status: 500 },
+    );
+  }
+}

package/web/.next/standalone/packages/web/src/app/api/preferences/route.ts

@@ -0,0 +1,194 @@
+import { type NextRequest, NextResponse } from "next/server";
+import { readFile, writeFile } from "node:fs/promises";
+import { parse, stringify } from "yaml";
+import { syncWorkspaceSupportFiles, type UserPreferences } from "@conductor-oss/core";
+import { getServices, invalidateServicesCache } from "@/lib/services";
+import { guardApiAccess, guardApiActionAccess } from "@/lib/auth";
+import { normalizeModelAccessPreferences } from "@/lib/modelAccess";
+import { normalizeRootProjectPaths, syncAllProjectLocalConfigs } from "@/lib/projectConfigSync";
+
+export const dynamic = "force-dynamic";
+
+type MutableConfig = Record<string, unknown>;
+
+type PreferencesPatchBody = {
+  onboardingAcknowledged?: unknown;
+  codingAgent?: unknown;
+  ide?: unknown;
+  remoteSshHost?: unknown;
+  remoteSshUser?: unknown;
+  markdownEditor?: unknown;
+  modelAccess?: unknown;
+  notifications?: unknown;
+};
+
+function asNonEmptyString(value: unknown): string | null {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+function toObject(value: unknown): Record<string, unknown> {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  return { ...(value as Record<string, unknown>) };
+}
+
+function normalizePreferences(
+  value: unknown,
+  fallbackAgent: string,
+): UserPreferences {
+  const root = toObject(value);
+  const notifications = toObject(root["notifications"]);
+  const soundFile = notifications["soundFile"];
+  const remoteSshHost = asNonEmptyString(root["remoteSshHost"]);
+  const remoteSshUser = asNonEmptyString(root["remoteSshUser"]);
+
+  return {
+    onboardingAcknowledged: root["onboardingAcknowledged"] === true,
+    codingAgent: asNonEmptyString(root["codingAgent"]) ?? fallbackAgent,
+    ide: asNonEmptyString(root["ide"]) ?? "vscode",
+    ...(remoteSshHost ? { remoteSshHost } : {}),
+    ...(remoteSshUser ? { remoteSshUser } : {}),
+    markdownEditor: asNonEmptyString(root["markdownEditor"]) ?? "obsidian",
+    modelAccess: normalizeModelAccessPreferences(root["modelAccess"]),
+    notifications: {
+      soundEnabled: notifications["soundEnabled"] !== false,
+      soundFile: soundFile === null
+        ? null
+        : asNonEmptyString(soundFile) ?? "abstract-sound-4",
+    },
+  };
+}
+
+export async function GET() {
+  const denied = await guardApiAccess(undefined, "viewer");
+  if (denied) return denied;
+
+  try {
+    const { config } = await getServices();
+    const fallbackAgent = config.defaults.agent;
+    const preferences = normalizePreferences(config.preferences, fallbackAgent);
+    return NextResponse.json({ preferences });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Failed to load preferences";
+    return NextResponse.json({ error: message }, { status: 500 });
+  }
+}
+
+export async function PUT(request: NextRequest) {
+  const denied = await guardApiAccess(request, "operator");
+  if (denied) return denied;
+  const deniedAction = guardApiActionAccess(request);
+  if (deniedAction) return deniedAction;
+
+  const body = (await request.json().catch(() => null)) as PreferencesPatchBody | null;
+  if (!body || typeof body !== "object") {
+    return NextResponse.json({ error: "Invalid JSON body" }, { status: 400 });
+  }
+
+  try {
+    const { config } = await getServices();
+    const configPath = config.configPath;
+    if (!configPath) {
+      return NextResponse.json(
+        { error: "Unable to resolve conductor config path" },
+        { status: 500 },
+      );
+    }
+
+    const originalConfigRaw = await readFile(configPath, "utf8");
+    const parsed = (parse(originalConfigRaw) ?? {}) as MutableConfig;
+    const nextRoot: MutableConfig =
+      parsed && typeof parsed === "object" && !Array.isArray(parsed)
+        ? { ...parsed }
+        : {};
+
+    const nextPreferences = normalizePreferences(
+      nextRoot["preferences"],
+      config.defaults.agent,
+    );
+
+    if (typeof body.onboardingAcknowledged === "boolean") {
+      nextPreferences.onboardingAcknowledged = body.onboardingAcknowledged;
+    }
+
+    if (body.codingAgent !== undefined) {
+      const value = asNonEmptyString(body.codingAgent);
+      if (value) nextPreferences.codingAgent = value;
+    }
+
+    if (body.ide !== undefined) {
+      const value = asNonEmptyString(body.ide);
+      if (value) nextPreferences.ide = value;
+    }
+
+    if (body.remoteSshHost !== undefined) {
+      const value = asNonEmptyString(body.remoteSshHost);
+      if (value) {
+        nextPreferences.remoteSshHost = value;
+      } else {
+        delete nextPreferences.remoteSshHost;
+      }
+    }
+
+    if (body.remoteSshUser !== undefined) {
+      const value = asNonEmptyString(body.remoteSshUser);
+      if (value) {
+        nextPreferences.remoteSshUser = value;
+      } else {
+        delete nextPreferences.remoteSshUser;
+      }
+    }
+
+    if (body.markdownEditor !== undefined) {
+      const value = asNonEmptyString(body.markdownEditor);
+      if (value) nextPreferences.markdownEditor = value;
+    }
+
+    if (body.modelAccess !== undefined) {
+      nextPreferences.modelAccess = normalizeModelAccessPreferences(body.modelAccess);
+    }
+
+    if (body.notifications !== undefined) {
+      const notificationsPatch = toObject(body.notifications);
+      if (typeof notificationsPatch["soundEnabled"] === "boolean") {
+        nextPreferences.notifications.soundEnabled = notificationsPatch["soundEnabled"];
+      }
+      if (notificationsPatch["soundFile"] === null) {
+        nextPreferences.notifications.soundFile = null;
+      } else {
+        const soundFile = asNonEmptyString(notificationsPatch["soundFile"]);
+        if (soundFile) {
+          nextPreferences.notifications.soundFile = soundFile;
+        }
+      }
+    }
+
+    nextRoot["preferences"] = nextPreferences;
+    await normalizeRootProjectPaths(nextRoot);
+
+    const updatedYaml = stringify(nextRoot, {
+      lineWidth: 0,
+    });
+
+    await writeFile(configPath, updatedYaml, "utf8");
+
+    try {
+      invalidateServicesCache("preferences updated");
+      const { config: refreshedConfig, registry } = await getServices();
+      await syncAllProjectLocalConfigs(refreshedConfig as unknown as Record<string, unknown>);
+      syncWorkspaceSupportFiles(refreshedConfig, {
+        agentNames: registry.list("agent").map((agent) => agent.name),
+      });
+    } catch (err) {
+      await writeFile(configPath, originalConfigRaw, "utf8");
+      invalidateServicesCache("preferences update rollback");
+      throw err;
+    }
+
+    return NextResponse.json({ preferences: nextPreferences });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Failed to update preferences";
+    return NextResponse.json({ error: message }, { status: 500 });
+  }
+}