conductor-oss 0.2.15 → 0.2.16

package/web/.next/standalone/packages/web/src/app/api/sessions/[id]/route.ts

@@ -0,0 +1,206 @@
+import { type NextRequest, NextResponse } from "next/server";
+import { readdirSync, readFileSync, existsSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { getServices } from "@/lib/services";
+import { guardApiAccess } from "@/lib/auth";
+import { sessionToDashboard, normalizeSummary } from "@/lib/serialize";
+import type { DashboardSession } from "@/lib/types";
+
+const VALID_SESSION_ID = /^[a-zA-Z0-9_-]+$/;
+
+/** Parse key=value metadata file. */
+function parseMetadata(content: string): Record<string, string> {
+  const result: Record<string, string> = {};
+  for (const line of content.split("\n")) {
+    const idx = line.indexOf("=");
+    if (idx > 0) {
+      result[line.slice(0, idx)] = line.slice(idx + 1);
+    }
+  }
+  return result;
+}
+
+function readMetadataFile(filePath: string): Record<string, string> | null {
+  try {
+    return parseMetadata(readFileSync(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+function safeSessionDirs(projectDir: string): string[] {
+  try {
+    return readdirSync(projectDir);
+  } catch {
+    return [];
+  }
+}
+
+function buildArchivedSummary(meta: Record<string, string>): string | null {
+  const existing = normalizeSummary(meta["summary"]);
+  if (existing) return existing;
+  if (!meta["pr"]) return null;
+
+  const prNumber = parseInt(meta["pr"].match(/\/(\d+)$/)?.[1] ?? "0", 10);
+  const prTitle = meta["prTitle"] ?? "";
+  const prState = meta["prState"] ?? "open";
+  const ciStatus = meta["ciStatus"] ?? "none";
+  const reviewDecision = meta["reviewDecision"] ?? "none";
+  return `PR #${Number.isFinite(prNumber) && prNumber > 0 ? prNumber : "?"}${prTitle ? ` — ${prTitle}` : ""} · state: ${prState} · CI: ${ciStatus} · review: ${reviewDecision}`;
+}
+
+function parsePRFromMeta(meta: Record<string, string>): DashboardSession["pr"] {
+  const prUrl = meta["pr"];
+  if (!prUrl) return null;
+
+  const num = parseInt(prUrl.match(/\/(\d+)$/)?.[1] ?? "0", 10);
+  let mergeability: NonNullable<DashboardSession["pr"]>["mergeability"] = {
+    mergeable: false,
+    ciPassing: false,
+    approved: false,
+    noConflicts: true,
+    blockers: [],
+  };
+
+  if (meta["mergeReadiness"]) {
+    try {
+      const parsed = JSON.parse(meta["mergeReadiness"]) as Record<string, unknown>;
+      mergeability = {
+        mergeable: Boolean(parsed["mergeable"]),
+        ciPassing: Boolean(parsed["ciPassing"]),
+        approved: Boolean(parsed["approved"]),
+        noConflicts: parsed["noConflicts"] !== false,
+        blockers: Array.isArray(parsed["blockers"]) ? (parsed["blockers"] as string[]) : [],
+      };
+    } catch {
+      // ignore malformed JSON
+    }
+  }
+
+  return {
+    number: Number.isFinite(num) && num > 0 ? num : 0,
+    url: prUrl,
+    title: meta["prTitle"] ?? "",
+    branch: meta["prHeadRef"] ?? meta["branch"] ?? "",
+    baseBranch: meta["prBaseRef"] ?? "",
+    isDraft: meta["prDraft"] === "1" || meta["prDraft"] === "true",
+    state: (meta["prState"] as NonNullable<DashboardSession["pr"]>["state"]) || "open",
+    ciStatus: (meta["ciStatus"] as NonNullable<DashboardSession["pr"]>["ciStatus"]) || "none",
+    reviewDecision: (meta["reviewDecision"] as NonNullable<DashboardSession["pr"]>["reviewDecision"]) || "none",
+    mergeability,
+    previewUrl: meta["previewUrl"] ?? null,
+  };
+}
+
+/** Build a DashboardSession from raw metadata (for archived sessions). */
+function metadataToDashboard(id: string, meta: Record<string, string>, filePath: string): DashboardSession {
+  const createdAt = meta["createdAt"] ?? new Date().toISOString();
+  let lastActivityAt = createdAt;
+  try {
+    const st = statSync(filePath);
+    lastActivityAt = st.mtime.toISOString();
+  } catch {
+    /* ignore */
+  }
+
+  return {
+    id,
+    projectId: meta["project"] ?? "unknown",
+    status: (meta["status"] ?? "unknown") as DashboardSession["status"],
+    activity: null,
+    branch: meta["branch"] ?? null,
+    issueId: null,
+    summary: buildArchivedSummary(meta),
+    createdAt,
+    lastActivityAt,
+    pr: parsePRFromMeta(meta),
+    metadata: meta,
+  };
+}
+
+/** Find session by scanning ~/.conductor directories (active + archive). */
+function findSessionDirect(sessionId: string): DashboardSession | null {
+  const conductorDir = join(homedir(), ".conductor");
+  if (!existsSync(conductorDir)) return null;
+
+  const projectDirs = safeSessionDirs(conductorDir);
+  for (const projectDir of projectDirs) {
+    const sessionsDir = join(conductorDir, projectDir, "sessions");
+    if (!existsSync(sessionsDir)) continue;
+
+    let sessionStat: { isDirectory: () => boolean } | null = null;
+    try {
+      sessionStat = statSync(sessionsDir);
+    } catch {
+      continue;
+    }
+    if (!sessionStat?.isDirectory()) continue;
+
+    // Active session
+    const activeFile = join(sessionsDir, sessionId);
+    if (existsSync(activeFile)) {
+      const meta = readMetadataFile(activeFile);
+      if (meta) {
+        return metadataToDashboard(sessionId, meta, activeFile);
+      }
+    }
+
+    // Archived session
+    const archiveDir = join(sessionsDir, "archive");
+    if (!existsSync(archiveDir)) continue;
+
+    const archiveFiles = safeSessionDirs(archiveDir)
+      .filter((f) => f.startsWith(sessionId + "_"))
+      .sort()
+      .reverse();
+
+    if (archiveFiles.length > 0) {
+      const filePath = join(archiveDir, archiveFiles[0]!);
+      const meta = readMetadataFile(filePath);
+      if (meta) {
+        return metadataToDashboard(sessionId, meta, filePath);
+      }
+    }
+  }
+
+  return null;
+}
+
+/** GET /api/sessions/:id -- Get a single session. */
+export async function GET(
+  _request: NextRequest,
+  { params }: { params: Promise<{ id: string }> },
+) {
+  try {
+    const denied = await guardApiAccess(undefined, "viewer");
+    if (denied) return denied;
+    const { id } = await params;
+    const sessionId = id.trim();
+
+    if (!sessionId) {
+      return NextResponse.json({ error: "Session ID is required" }, { status: 400 });
+    }
+    if (!VALID_SESSION_ID.test(sessionId)) {
+      return NextResponse.json({ error: "Invalid session ID" }, { status: 400 });
+    }
+
+    // Try active sessions first via session manager
+    const { sessionManager } = await getServices();
+    const session = await sessionManager.get(sessionId);
+    if (session) {
+      return NextResponse.json(sessionToDashboard(session));
+    }
+
+    // Fallback: direct filesystem scan (finds archived sessions too)
+    const direct = findSessionDirect(sessionId);
+    if (direct) {
+      return NextResponse.json(direct);
+    }
+
+    return NextResponse.json({ error: "Session not found" }, { status: 404 });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "Failed to load session";
+    return NextResponse.json({ error: msg }, { status: 500 });
+  }
+}

package/web/.next/standalone/packages/web/src/app/api/sessions/[id]/send/route.ts

@@ -0,0 +1,58 @@
+import type { NextRequest } from "next/server";
+import { NextResponse } from "next/server";
+import { getServices } from "@/lib/services";
+import { guardApiAccess, guardApiActionAccess } from "@/lib/auth";
+
+export const dynamic = "force-dynamic";
+
+type SendBody = { message?: string };
+
+export async function POST(
+  request: NextRequest,
+  context: { params: Promise<{ id: string }> },
+) {
+  const denied = await guardApiAccess(request, "operator");
+  if (denied) return denied;
+  const deniedAction = guardApiActionAccess(request);
+  if (deniedAction) return deniedAction;
+
+  const params = await context.params;
+  const rawId = params?.id ?? "";
+  let sessionId: string;
+  try {
+    sessionId = decodeURIComponent(rawId).trim();
+  } catch {
+    return NextResponse.json({ error: "Invalid session id" }, { status: 400 });
+  }
+  if (!sessionId) {
+    return NextResponse.json({ error: "Session id is required" }, { status: 400 });
+  }
+
+  const body = (await request.json().catch(() => null)) as SendBody | null;
+  if (typeof body?.message !== "string") {
+    return NextResponse.json(
+      { error: "message is required and must be non-empty" },
+      { status: 400 },
+    );
+  }
+
+  const messageStr = body.message;
+  const message = messageStr.trim();
+  if (!message) {
+    return NextResponse.json(
+      { error: "message is required and must be non-empty" },
+      { status: 400 },
+    );
+  }
+
+  try {
+    const { sessionManager } = await getServices();
+    await sessionManager.send(sessionId, message);
+    return NextResponse.json({ ok: true });
+  } catch (err) {
+    return NextResponse.json(
+      { error: err instanceof Error ? err.message : "Failed to send message" },
+      { status: 500 },
+    );
+  }
+}

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

@@ -0,0 +1,105 @@
+import type { NextRequest } from "next/server";
+import { NextResponse } from "next/server";
+import { getServices } from "@/lib/services";
+import { guardApiAccess } from "@/lib/auth";
+import { computeStats, sessionToDashboard } from "@/lib/serialize";
+
+export const dynamic = "force-dynamic";
+
+/**
+ * GET /api/sessions -- list current sessions for the dashboard.
+ *
+ * Query params:
+ *   - project: filter by project ID
+ *   - filter: attention filter (needs_input, blocked, errored, active, all)
+ *   - compact: "true" for mobile-optimized minimal response
+ */
+export async function GET(request: NextRequest) {
+  const denied = await guardApiAccess(undefined, "viewer");
+  if (denied) return denied;
+
+  try {
+    const { sessionManager } = await getServices();
+
+    const searchParams = new URL(request.url).searchParams;
+    const projectId = searchParams.get("project");
+    const filter = searchParams.get("filter");
+    const compact = searchParams.get("compact") === "true";
+    const normalizedProjectId = projectId?.trim() ?? "";
+
+    const sessions = normalizedProjectId
+      ? await sessionManager.list(normalizedProjectId)
+      : await sessionManager.list();
+    let dashboardSessions = sessions.map((session) => sessionToDashboard(session));
+
+    // Apply attention filter
+    if (filter) {
+      const needsAttentionStatuses = new Set(["needs_input", "stuck", "errored"]);
+      const needsAttentionActivities = new Set(["waiting_input", "blocked"]);
+
+      switch (filter) {
+        case "needs_input":
+        case "respond":
+          dashboardSessions = dashboardSessions.filter(
+            (s) => needsAttentionStatuses.has(s.status) || needsAttentionActivities.has(s.activity ?? ""),
+          );
+          break;
+        case "blocked":
+          dashboardSessions = dashboardSessions.filter(
+            (s) => s.activity === "blocked" || s.status === "stuck",
+          );
+          break;
+        case "errored":
+          dashboardSessions = dashboardSessions.filter(
+            (s) => s.status === "errored" || s.status === "ci_failed",
+          );
+          break;
+        case "active":
+        case "working":
+          dashboardSessions = dashboardSessions.filter(
+            (s) => s.activity === "active" || s.status === "working" || s.status === "spawning",
+          );
+          break;
+        case "review":
+          dashboardSessions = dashboardSessions.filter(
+            (s) => s.status === "ci_failed" || s.status === "changes_requested" || s.status === "review_pending",
+          );
+          break;
+        case "merge":
+          dashboardSessions = dashboardSessions.filter(
+            (s) => s.status === "mergeable" || s.status === "approved",
+          );
+          break;
+        // "all" or unknown: no filter
+      }
+    }
+
+    // Compact mode: minimal response for mobile
+    if (compact) {
+      const compactSessions = dashboardSessions.map((s) => ({
+        id: s.id,
+        p: s.projectId,
+        s: s.status,
+        a: s.activity,
+        sum: s.summary ? s.summary.slice(0, 80) : null,
+        pr: s.pr ? { n: s.pr.number, u: s.pr.url, ci: s.pr.ciStatus } : null,
+        age: s.createdAt,
+        idle: s.lastActivityAt,
+      }));
+      return NextResponse.json({
+        sessions: compactSessions,
+        stats: computeStats(dashboardSessions),
+      });
+    }
+
+    return NextResponse.json({
+      sessions: dashboardSessions,
+      stats: computeStats(dashboardSessions),
+    });
+  } catch (err) {
+    return NextResponse.json(
+      { error: err instanceof Error ? err.message : "Failed to list sessions" },
+      { status: 500 },
+    );
+  }
+}

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

@@ -0,0 +1,216 @@
+import { type NextRequest, NextResponse } from "next/server";
+import { readFile, writeFile } from "node:fs/promises";
+import { parse, stringify } from "yaml";
+import { normalizeProjectConfigMap, syncWorkspaceSupportFiles } from "@conductor-oss/core";
+import { getServices, invalidateServicesCache } from "@/lib/services";
+import { guardApiAccess, guardApiActionAccess } from "@/lib/auth";
+import { sessionToDashboard } from "@/lib/serialize";
+import { normalizeRootProjectPaths, syncProjectLocalConfig } from "@/lib/projectConfigSync";
+
+/** POST /api/spawn -- Spawn a new agent session. */
+
+type MutableConfig = Record<string, unknown>;
+
+function toObject(value: unknown): Record<string, unknown> {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return {};
+  }
+  return { ...(value as Record<string, unknown>) };
+}
+
+async function persistSpawnAgentSelection(configPath: string, projectId: string, agent: string): Promise<void> {
+  const originalConfigRaw = await readFile(configPath, "utf8");
+  const parsed = (parse(originalConfigRaw) ?? {}) as MutableConfig;
+  const nextRoot: MutableConfig =
+    parsed && typeof parsed === "object" && !Array.isArray(parsed)
+      ? { ...parsed }
+      : {};
+
+  const nextProjects = normalizeProjectConfigMap(nextRoot["projects"]);
+  const existingProject = toObject(nextProjects[projectId]);
+  nextProjects[projectId] = {
+    ...existingProject,
+    agent,
+  };
+  nextRoot["projects"] = nextProjects;
+
+  const nextPreferences = toObject(nextRoot["preferences"]);
+  nextRoot["preferences"] = {
+    ...nextPreferences,
+    codingAgent: agent,
+  };
+  await normalizeRootProjectPaths(nextRoot);
+
+  const updatedYaml = stringify(nextRoot, { lineWidth: 0 });
+  await writeFile(configPath, updatedYaml, "utf8");
+
+  try {
+    invalidateServicesCache("spawn agent selection updated");
+    const { config: refreshedConfig, registry } = await getServices();
+    await syncProjectLocalConfig(refreshedConfig as unknown as Record<string, unknown>, projectId);
+    syncWorkspaceSupportFiles(refreshedConfig, {
+      agentNames: registry.list("agent").map((agent) => agent.name),
+    });
+  } catch (err) {
+    await writeFile(configPath, originalConfigRaw, "utf8");
+    invalidateServicesCache("spawn agent selection rollback");
+    throw err;
+  }
+}
+
+export async function POST(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 Record<string, unknown> | null;
+  if (!body) {
+    return NextResponse.json({ error: "Invalid JSON body" }, { status: 400 });
+  }
+
+  const projectId = body.projectId;
+  if (typeof projectId !== "string" || projectId.trim().length === 0) {
+    return NextResponse.json(
+      { error: "projectId is required and must be a non-empty string" },
+      { status: 400 },
+    );
+  }
+
+  const issueId = body.issueId;
+  if (issueId !== undefined && issueId !== null && typeof issueId !== "string") {
+    return NextResponse.json(
+      { error: "issueId must be a string if provided" },
+      { status: 400 },
+    );
+  }
+
+  const prompt = body.prompt;
+  if (prompt !== undefined && prompt !== null && typeof prompt !== "string") {
+    return NextResponse.json(
+      { error: "prompt must be a string if provided" },
+      { status: 400 },
+    );
+  }
+
+  const agent = body.agent;
+  if (agent !== undefined && agent !== null && typeof agent !== "string") {
+    return NextResponse.json(
+      { error: "agent must be a string if provided" },
+      { status: 400 },
+    );
+  }
+
+  const model = body.model;
+  if (model !== undefined && model !== null && typeof model !== "string") {
+    return NextResponse.json(
+      { error: "model must be a string if provided" },
+      { status: 400 },
+    );
+  }
+
+  const reasoningEffort = body.reasoningEffort;
+  if (reasoningEffort !== undefined && reasoningEffort !== null && typeof reasoningEffort !== "string") {
+    return NextResponse.json(
+      { error: "reasoningEffort must be a string if provided" },
+      { status: 400 },
+    );
+  }
+
+  const profile = body.profile;
+  if (profile !== undefined && profile !== null && typeof profile !== "string") {
+    return NextResponse.json(
+      { error: "profile must be a string if provided" },
+      { status: 400 },
+    );
+  }
+
+  const branch = body.branch;
+  if (branch !== undefined && branch !== null && typeof branch !== "string") {
+    return NextResponse.json(
+      { error: "branch must be a string if provided" },
+      { status: 400 },
+    );
+  }
+
+  const baseBranch = body.baseBranch;
+  if (baseBranch !== undefined && baseBranch !== null && typeof baseBranch !== "string") {
+    return NextResponse.json(
+      { error: "baseBranch must be a string if provided" },
+      { status: 400 },
+    );
+  }
+
+  const normalizedProjectId = projectId.trim();
+  const normalizedIssueId = typeof issueId === "string" && issueId.trim().length > 0
+    ? issueId.trim()
+    : undefined;
+  const normalizedPrompt = typeof prompt === "string" && prompt.trim().length > 0
+    ? prompt.trim()
+    : undefined;
+  const normalizedAgent = typeof agent === "string" && agent.trim().length > 0
+    ? agent.trim()
+    : undefined;
+  const normalizedModel = typeof model === "string" && model.trim().length > 0
+    ? model.trim()
+    : undefined;
+  const normalizedReasoningEffort = typeof reasoningEffort === "string" && reasoningEffort.trim().length > 0
+    ? reasoningEffort.trim().toLowerCase()
+    : undefined;
+  const normalizedProfile = typeof profile === "string" && profile.trim().length > 0
+    ? profile.trim()
+    : undefined;
+  const normalizedBranch = typeof branch === "string" && branch.trim().length > 0
+    ? branch.trim()
+    : undefined;
+  const normalizedBaseBranch = typeof baseBranch === "string" && baseBranch.trim().length > 0
+    ? baseBranch.trim()
+    : undefined;
+
+  try {
+    const { sessionManager, config } = await getServices();
+    if (!config.projects[normalizedProjectId]) {
+      return NextResponse.json(
+        { error: `Unknown project: ${normalizedProjectId}` },
+        { status: 404 },
+      );
+    }
+
+    if (!normalizedPrompt && !normalizedIssueId) {
+      return NextResponse.json(
+        { error: "Either prompt or issueId is required to create a workspace" },
+        { status: 400 },
+      );
+    }
+
+    if (normalizedAgent && config.configPath) {
+      const currentProjectAgent = config.projects[normalizedProjectId]?.agent;
+      const currentPreferredAgent = config.preferences?.codingAgent;
+      if (normalizedAgent !== currentProjectAgent || normalizedAgent !== currentPreferredAgent) {
+        await persistSpawnAgentSelection(config.configPath, normalizedProjectId, normalizedAgent);
+      }
+    }
+
+    const session = await sessionManager.spawn({
+      projectId: normalizedProjectId,
+      issueId: normalizedIssueId,
+      prompt: normalizedPrompt,
+      agent: normalizedAgent,
+      model: normalizedModel,
+      reasoningEffort: normalizedReasoningEffort,
+      profile: normalizedProfile,
+      branch: normalizedBranch,
+      baseBranch: normalizedBaseBranch,
+    });
+
+    return NextResponse.json(
+      { session: sessionToDashboard(session) },
+      { status: 201 },
+    );
+  } catch (err) {
+    return NextResponse.json(
+      { error: err instanceof Error ? err.message : "Failed to spawn session" },
+      { status: 500 },
+    );
+  }
+}