conductor-oss 0.2.15 → 0.2.16

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

@@ -0,0 +1,140 @@
+import { guardApiAccess, guardApiActionAccess } from "@/lib/auth";
+import { type NextRequest, NextResponse } from "next/server";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { readdirSync, readFileSync, existsSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+const execFileAsync = promisify(execFile);
+const VALID_SESSION_ID = /^[a-zA-Z0-9_-]+$/;
+
+/** Parse a simple key=value metadata file into a record. */
+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 safeReadMetadata(filePath: string): Record<string, string> | null {
+  try {
+    return parseMetadata(readFileSync(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+function safeEntries(dir: string): string[] {
+  try {
+    return readdirSync(dir);
+  } catch {
+    return [];
+  }
+}
+
+/** Resolve tmux session name by scanning conductor metadata. */
+function resolveTmuxName(sessionId: string): string | null {
+  const conductorDir = join(homedir(), ".conductor");
+  if (!existsSync(conductorDir)) return null;
+
+  for (const projectDir of safeEntries(conductorDir)) {
+    const sessionsDir = join(conductorDir, projectDir, "sessions");
+    if (!existsSync(sessionsDir)) continue;
+    try {
+      if (!statSync(sessionsDir).isDirectory()) continue;
+    } catch {
+      continue;
+    }
+
+    const activeFile = join(sessionsDir, sessionId);
+    if (existsSync(activeFile)) {
+      const meta = safeReadMetadata(activeFile);
+      if (!meta) continue;
+      if (meta["tmuxName"]) return meta["tmuxName"];
+      if (meta["runtimeHandle"]) {
+        try {
+          const handle = JSON.parse(meta["runtimeHandle"]) as { id?: string };
+          if (handle.id) return handle.id;
+        } catch { /* ignore */ }
+      }
+    }
+  }
+
+  return null;
+}
+
+/** Allowed special key names for tmux send-keys. */
+const ALLOWED_SPECIAL_KEYS = new Set([
+  "Enter", "Escape", "Tab", "BSpace", "DC", "Up", "Down", "Left", "Right",
+  "Home", "End", "PageUp", "PageDown", "Space",
+  "C-c", "C-d", "C-u", "C-l", "C-a", "C-e", "C-k", "C-w", "C-z",
+]);
+
+/**
+ * POST /api/sessions/:id/keys -- Send raw keys to the session's tmux pane.
+ *
+ * Body: { keys: string }
+ *   - For text: sends literal characters via tmux send-keys -l
+ *   - For special keys: use names like "Enter", "C-c", "Escape"
+ *
+ * Body: { special: string }
+ *   - Sends a tmux special key (Enter, C-c, Escape, etc.)
+ */
+export async function POST(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> },
+): Promise<NextResponse> {
+  const denied = await guardApiAccess(request, "operator");
+  if (denied) return denied;
+  const deniedAction = guardApiActionAccess(request);
+  if (deniedAction) return deniedAction;
+
+  const { id } = await params;
+
+  if (!id || id.trim().length === 0) {
+    return NextResponse.json({ error: "Session ID is required" }, { status: 400 });
+  }
+  if (!VALID_SESSION_ID.test(id)) {
+    return NextResponse.json({ error: "Invalid session ID" }, { status: 400 });
+  }
+
+  const body = (await request.json().catch(() => null)) as Record<string, unknown> | null;
+  if (!body) {
+    return NextResponse.json({ error: "Request body required" }, { status: 400 });
+  }
+
+  const tmuxName = resolveTmuxName(id);
+  if (!tmuxName) {
+    return NextResponse.json({ error: "Session not found or no tmux session" }, { status: 404 });
+  }
+
+  try {
+    if (typeof body.special === "string") {
+      // Send a special key (Enter, C-c, Escape, etc.)
+      const key = body.special;
+      if (!ALLOWED_SPECIAL_KEYS.has(key)) {
+        return NextResponse.json({ error: `Invalid special key: ${key}` }, { status: 400 });
+      }
+      await execFileAsync("tmux", ["send-keys", "-t", tmuxName, key], { timeout: 5000 });
+    } else if (typeof body.keys === "string") {
+      // Send literal text characters
+      const keys = body.keys;
+      if (keys.length > 5000) {
+        return NextResponse.json({ error: "Keys too long (max 5000)" }, { status: 400 });
+      }
+      await execFileAsync("tmux", ["send-keys", "-t", tmuxName, "-l", keys], { timeout: 5000 });
+    } else {
+      return NextResponse.json({ error: "keys (string) or special (string) is required" }, { status: 400 });
+    }
+
+    return NextResponse.json({ ok: true, sessionId: id });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "Failed to send keys";
+    return NextResponse.json({ error: msg }, { status: 500 });
+  }
+}

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

@@ -0,0 +1,45 @@
+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";
+
+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 (error) {
+    return NextResponse.json({ error: "Malformed session id" }, { status: 400 });
+  }
+  if (!sessionId) {
+    return NextResponse.json({ error: "Session id is required" }, { status: 400 });
+  }
+
+  try {
+    const { sessionManager } = await getServices();
+    await sessionManager.kill(sessionId);
+    return NextResponse.json({ ok: true });
+  } catch (err) {
+    if (
+      err instanceof Error &&
+      err.message.toLowerCase().includes("not found")
+    ) {
+      return NextResponse.json({ error: err instanceof Error ? err.message : "Session not found" }, { status: 404 });
+    }
+    return NextResponse.json(
+      { error: err instanceof Error ? err.message : "Failed to kill session" },
+      { status: 500 },
+    );
+  }
+}

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

@@ -0,0 +1,262 @@
+import type { NextRequest } from "next/server";
+import { NextResponse } from "next/server";
+import { existsSync, readdirSync, readFileSync, statSync, type Dirent } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { homedir } from "node:os";
+import { getServices } from "@/lib/services";
+import { guardApiAccess } from "@/lib/auth";
+
+export const dynamic = "force-dynamic";
+
+type SessionSnapshot = {
+  filePath: string;
+  values: Record<string, string>;
+};
+
+function parseMetadataFile(content: string): Record<string, string> {
+  const values: Record<string, string> = {};
+  for (const rawLine of content.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) continue;
+    const eq = line.indexOf("=");
+    if (eq <= 0) continue;
+    const key = line.slice(0, eq).trim();
+    const value = line.slice(eq + 1).trim();
+    if (key) values[key] = value;
+  }
+  return values;
+}
+
+function tailText(content: string, lines: number): string {
+  const chunks = content.split(/\r?\n/);
+  return chunks.slice(-Math.max(lines, 1)).join("\n").trimEnd();
+}
+
+function resolveHomePath(value: string): string {
+  if (value.startsWith("~/")) {
+    return resolve(homedir(), value.slice(2));
+  }
+  return resolve(value);
+}
+
+function isReadableFile(path: string): boolean {
+  try {
+    return statSync(path).isFile();
+  } catch {
+    return false;
+  }
+}
+
+function findSnapshotPaths(sessionId: string): string[] {
+  const conductorRoot = resolve(homedir(), ".conductor");
+  if (!existsSync(conductorRoot)) return [];
+
+  const candidates: string[] = [];
+  let roots: Dirent[];
+  try {
+    roots = readdirSync(conductorRoot, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+
+  for (const entry of roots) {
+    if (!entry.isDirectory()) continue;
+    const sessionsDir = join(conductorRoot, entry.name, "sessions");
+    if (!existsSync(sessionsDir)) continue;
+
+    const live = join(sessionsDir, sessionId);
+    if (isReadableFile(live)) {
+      candidates.push(live);
+    }
+
+    const archiveDir = join(sessionsDir, "archive");
+    if (!existsSync(archiveDir)) continue;
+    let archiveEntries: string[];
+    try {
+      archiveEntries = readdirSync(archiveDir);
+    } catch {
+      continue;
+    }
+
+    for (const fileName of archiveEntries) {
+      if (fileName === sessionId || fileName.startsWith(`${sessionId}_`)) {
+        const path = join(archiveDir, fileName);
+        if (isReadableFile(path)) {
+          candidates.push(path);
+        }
+      }
+    }
+  }
+
+  return candidates.sort((left, right) => {
+    try {
+      return statSync(right).mtimeMs - statSync(left).mtimeMs;
+    } catch {
+      return 0;
+    }
+  });
+}
+
+function readLatestSessionSnapshot(sessionId: string): SessionSnapshot | null {
+  for (const path of findSnapshotPaths(sessionId)) {
+    try {
+      const raw = readFileSync(path, "utf8");
+      const values = parseMetadataFile(raw);
+      return { filePath: path, values };
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+
+function buildFallbackLogCandidates(sessionId: string, snapshot: SessionSnapshot): string[] {
+  const values = snapshot.values;
+  const tmuxName = values["tmuxName"]?.trim();
+  const worktree = values["worktree"]?.trim();
+
+  const paths = new Set<string>();
+  const addPath = (path: string | undefined): void => {
+    if (!path) return;
+    const trimmed = path.trim();
+    if (!trimmed) return;
+    paths.add(resolveHomePath(trimmed));
+  };
+
+  for (const key of [
+    "sessionLog",
+    "outputLog",
+    "terminalLog",
+    "transcript",
+    "history",
+    "historyFile",
+    "devServerLog",
+  ]) {
+    addPath(values[key]);
+  }
+
+  if (worktree) {
+    const normalizedWorktree = resolveHomePath(worktree);
+    for (const id of [sessionId, tmuxName].filter(Boolean)) {
+      addPath(join(normalizedWorktree, ".conductor", "logs", `${id}.log`));
+      addPath(join(normalizedWorktree, ".conductor", "state", `${id}.log`));
+    }
+    addPath(join(normalizedWorktree, ".conductor", "session.log"));
+    addPath(join(normalizedWorktree, ".codex", "history.jsonl"));
+    addPath(join(normalizedWorktree, ".codex", "log", "codex-tui.log"));
+    addPath(join(normalizedWorktree, ".claude", "logs", `${sessionId}.log`));
+  }
+
+  const snapshotDir = dirname(snapshot.filePath);
+  addPath(join(snapshotDir, `${sessionId}.log`));
+  if (tmuxName) {
+    addPath(join(snapshotDir, `${tmuxName}.log`));
+  }
+  if (snapshotDir.endsWith(`${join("sessions", "archive")}`)) {
+    const sessionsDir = dirname(snapshotDir);
+    addPath(join(sessionsDir, sessionId));
+    addPath(join(sessionsDir, `${sessionId}.log`));
+    if (tmuxName) {
+      addPath(join(sessionsDir, `${tmuxName}.log`));
+    }
+  }
+
+  addPath(snapshot.filePath);
+
+  return [...paths];
+}
+
+function readFallbackOutput(sessionId: string, lines: number): string | null {
+  const snapshot = readLatestSessionSnapshot(sessionId);
+  if (!snapshot) return null;
+
+  const candidates = buildFallbackLogCandidates(sessionId, snapshot);
+  const snapshotPath = resolve(snapshot.filePath);
+
+  for (const candidatePath of candidates) {
+    if (resolve(candidatePath) === snapshotPath) continue;
+    if (!isReadableFile(candidatePath)) continue;
+    try {
+      const content = readFileSync(candidatePath, "utf8");
+      if (!content.trim()) continue;
+      return tailText(content, lines);
+    } catch {
+      continue;
+    }
+  }
+
+  if (isReadableFile(snapshot.filePath)) {
+    try {
+      const content = readFileSync(snapshot.filePath, "utf8");
+      if (content.trim()) {
+        return tailText(content, lines);
+      }
+    } catch {
+      // Ignore and use synthesized output.
+    }
+  }
+
+  const status = snapshot.values["status"] ?? "unknown";
+  const summary = snapshot.values["summary"] ?? "";
+  const branch = snapshot.values["branch"] ?? "";
+  const worktree = snapshot.values["worktree"] ?? "";
+  const metadataDump = Object.entries(snapshot.values)
+    .map(([key, value]) => `${key}=${value}`)
+    .join("\n");
+
+  const fallback = [
+    `[session output fallback] Runtime output unavailable for ${sessionId}.`,
+    `status=${status}`,
+    branch ? `branch=${branch}` : "",
+    worktree ? `worktree=${worktree}` : "",
+    summary ? `summary=${summary}` : "",
+    "",
+    metadataDump,
+  ].filter(Boolean).join("\n");
+
+  return tailText(fallback, lines);
+}
+
+export async function GET(
+  request: NextRequest,
+  context: { params: Promise<{ id: string }> },
+) {
+  const denied = await guardApiAccess(undefined, "viewer");
+  if (denied) return denied;
+
+  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 searchParams = new URL(request.url).searchParams;
+  const rawLines = searchParams.get("lines");
+  const parsedLines = rawLines ? Number.parseInt(rawLines, 10) : 500;
+  const lines = Number.isFinite(parsedLines) && parsedLines > 0 ? Math.min(parsedLines, 5000) : 500;
+
+  try {
+    const { sessionManager } = await getServices();
+    try {
+      const output = await sessionManager.getOutput(sessionId, lines);
+      return NextResponse.json({ output });
+    } catch (runtimeErr) {
+      const fallbackOutput = readFallbackOutput(sessionId, lines);
+      if (fallbackOutput !== null) {
+        return NextResponse.json({ output: fallbackOutput, source: "fallback-log" });
+      }
+
+      throw runtimeErr;
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Failed to load output";
+    const status = message.toLowerCase().includes("not found") ? 404 : 500;
+    return NextResponse.json({ error: message }, { status });
+  }
+}

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

@@ -0,0 +1,111 @@
+import type { NextRequest } from "next/server";
+import { getServices } from "@/lib/services";
+import { guardApiAccess } from "@/lib/auth";
+
+export const dynamic = "force-dynamic";
+
+function parseLines(raw: string | null): number {
+  const parsed = raw ? Number.parseInt(raw, 10) : 500;
+  if (!Number.isFinite(parsed) || parsed <= 0) return 500;
+  return Math.min(parsed, 5000);
+}
+
+export async function GET(
+  request: NextRequest,
+  context: { params: Promise<{ id: string }> },
+): Promise<Response> {
+  const denied = await guardApiAccess(request, "viewer");
+  if (denied) return denied;
+
+  const params = await context.params;
+  const rawId = params?.id ?? "";
+  let sessionId: string;
+  try {
+    sessionId = decodeURIComponent(rawId).trim();
+  } catch {
+    return new Response("Invalid session id", { status: 400 });
+  }
+  if (!sessionId) return new Response("Session id is required", { status: 400 });
+
+  const lines = parseLines(new URL(request.url).searchParams.get("lines"));
+
+  const encoder = new TextEncoder();
+  let heartbeat: ReturnType<typeof setInterval> | undefined;
+  let updates: ReturnType<typeof setInterval> | undefined;
+  let inFlight = false;
+  let closed = false;
+  let lastOutput = "";
+
+  function cleanup(): void {
+    closed = true;
+    if (heartbeat) clearInterval(heartbeat);
+    if (updates) clearInterval(updates);
+  }
+
+  function safeSend(controller: ReadableStreamDefaultController, chunk: string): boolean {
+    if (closed) return false;
+    try {
+      controller.enqueue(encoder.encode(chunk));
+      return true;
+    } catch {
+      cleanup();
+      return false;
+    }
+  }
+
+  async function sendOutput(
+    controller: ReadableStreamDefaultController,
+    force = false,
+  ): Promise<void> {
+    try {
+      const { sessionManager } = await getServices();
+      const output = await sessionManager.getOutput(sessionId, lines);
+      if (force || output !== lastOutput) {
+        lastOutput = output;
+        safeSend(controller, `data: ${JSON.stringify({ type: "output", output })}\n\n`);
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Failed to stream output";
+      safeSend(controller, `data: ${JSON.stringify({ type: "error", error: message })}\n\n`);
+    }
+  }
+
+  const stream = new ReadableStream({
+    start(controller) {
+      request.signal.addEventListener("abort", () => {
+        cleanup();
+        try {
+          controller.close();
+        } catch {
+          // Ignore already-closed stream errors.
+        }
+      });
+
+      void sendOutput(controller, true);
+
+      heartbeat = setInterval(() => {
+        if (!safeSend(controller, ": heartbeat\n\n")) cleanup();
+      }, 15_000);
+
+      updates = setInterval(() => {
+        if (closed || inFlight) return;
+        inFlight = true;
+        void sendOutput(controller).finally(() => {
+          inFlight = false;
+        });
+      }, 1000);
+    },
+    cancel() {
+      cleanup();
+    },
+  });
+
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive",
+      "X-Accel-Buffering": "no",
+    },
+  });
+}

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

@@ -0,0 +1,49 @@
+import type { NextRequest } from "next/server";
+import { NextResponse } from "next/server";
+import { SessionNotRestorableError, WorkspaceMissingError } from "@conductor-oss/core/types";
+import { getServices } from "@/lib/services";
+import { guardApiAccess, guardApiActionAccess } from "@/lib/auth";
+
+export const dynamic = "force-dynamic";
+
+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 });
+  }
+
+  try {
+    const { sessionManager } = await getServices();
+    const session = await sessionManager.restore(sessionId);
+    return NextResponse.json({ ok: true, sessionId: session.id });
+  } catch (err) {
+    if (err instanceof Error && /not found/i.test(err.message)) {
+      return NextResponse.json({ error: err.message }, { status: 404 });
+    }
+    if (err instanceof SessionNotRestorableError || err instanceof WorkspaceMissingError) {
+      return NextResponse.json(
+        { error: err.message },
+        { status: 409 },
+      );
+    }
+    return NextResponse.json(
+      { error: err instanceof Error ? err.message : "Failed to restore session" },
+      { status: 500 },
+    );
+  }
+}