@seqyuan/annodex 0.1.10 → 0.1.12

package/app/api/search/route.ts

@@ -0,0 +1,122 @@
+import { NextResponse } from "next/server";
+import { listAllSessions, searchCodexSessionEntries } from "@/lib/session-reader";
+import type { SessionEntry, SessionInfo } from "@/lib/types";
+import type { TextContent } from "@/lib/types";
+
+interface SearchMatch {
+  entryId: string;
+  role: "user" | "assistant";
+  timestamp: string;
+  snippet: string;
+}
+
+interface SearchGroup {
+  session: SessionInfo;
+  matches: SearchMatch[];
+  matchCount: number;
+}
+
+const MAX_RESULTS = 80;
+const MAX_MATCHES_PER_SESSION = 8;
+
+function normalizeText(value: string): string {
+  return value.replace(/\s+/g, " ").trim();
+}
+
+function isTextContent(block: unknown): block is TextContent {
+  return !!block && typeof block === "object" && (block as { type?: unknown }).type === "text" && typeof (block as { text?: unknown }).text === "string";
+}
+
+function extractVisibleText(entry: SessionEntry): { role: "user" | "assistant"; text: string } | null {
+  if (entry.type !== "message") return null;
+  const { message } = entry;
+  if (message.role !== "user" && message.role !== "assistant") return null;
+
+  const content = message.content;
+  if (typeof content === "string") {
+    return { role: message.role, text: normalizeText(content) };
+  }
+
+  if (!Array.isArray(content)) return null;
+  const text = (content as unknown[])
+    .filter(isTextContent)
+    .map((block: TextContent) => block.text)
+    .join(" ");
+  return { role: message.role, text: normalizeText(text) };
+}
+
+function buildSnippet(text: string, query: string): string {
+  const lowerText = text.toLowerCase();
+  const lowerQuery = query.toLowerCase();
+  const index = lowerText.indexOf(lowerQuery);
+  if (index < 0) return text.slice(0, 180);
+
+  const start = Math.max(0, index - 70);
+  const end = Math.min(text.length, index + query.length + 110);
+  const prefix = start > 0 ? "... " : "";
+  const suffix = end < text.length ? " ..." : "";
+  return `${prefix}${text.slice(start, end)}${suffix}`;
+}
+
+export async function GET(req: Request) {
+  try {
+    const url = new URL(req.url);
+    const query = normalizeText(url.searchParams.get("q") ?? "");
+    const scope = url.searchParams.get("scope") === "current" ? "current" : "all";
+    const cwd = url.searchParams.get("cwd");
+
+    if (query.length < 2) {
+      return NextResponse.json({ results: [], totalMatches: 0, truncated: false });
+    }
+
+    const sessions = (await listAllSessions())
+      .filter((session) => scope !== "current" || !cwd || session.cwd === cwd)
+      .sort((a, b) => b.modified.localeCompare(a.modified));
+
+    const results: SearchGroup[] = [];
+    let totalMatches = 0;
+    let truncated = false;
+
+    for (const session of sessions) {
+      if (totalMatches >= MAX_RESULTS) {
+        truncated = true;
+        break;
+      }
+
+      const matches: SearchMatch[] = [];
+      let sessionMatchCount = 0;
+
+      try {
+        const entries = await searchCodexSessionEntries(session.id, session.cwd);
+        for (const entry of entries) {
+          const visible = extractVisibleText(entry);
+          if (!visible?.text) continue;
+          if (!visible.text.toLowerCase().includes(query.toLowerCase())) continue;
+
+          sessionMatchCount += 1;
+          if (matches.length < MAX_MATCHES_PER_SESSION && totalMatches < MAX_RESULTS) {
+            matches.push({
+              entryId: entry.id,
+              role: visible.role,
+              timestamp: entry.timestamp,
+              snippet: buildSnippet(visible.text, query),
+            });
+            totalMatches += 1;
+          } else {
+            truncated = true;
+          }
+        }
+      } catch {
+        continue;
+      }
+
+      if (matches.length > 0) {
+        results.push({ session, matches, matchCount: sessionMatchCount });
+      }
+    }
+
+    return NextResponse.json({ results, totalMatches, truncated });
+  } catch (error) {
+    return NextResponse.json({ error: String(error) }, { status: 500 });
+  }
+}

package/app/api/sessions/[id]/context/route.ts

@@ -0,0 +1,23 @@
+import { NextResponse } from "next/server";
+import { loadCodexSessionContext, resolveSessionPath } from "@/lib/session-reader";
+
+export async function GET(
+  req: Request,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+  const url = new URL(req.url);
+  const leafId = url.searchParams.get("leafId") ?? undefined;
+
+  try {
+    const cwd = await resolveSessionPath(id);
+    if (!cwd) {
+      return NextResponse.json({ error: "Session not found" }, { status: 404 });
+    }
+
+    const { context } = await loadCodexSessionContext(id, cwd, leafId);
+    return NextResponse.json({ context });
+  } catch (error) {
+    return NextResponse.json({ error: String(error) }, { status: 500 });
+  }
+}

package/app/api/sessions/[id]/route.ts

@@ -0,0 +1,124 @@
+import { NextResponse } from "next/server";
+import { existsSync } from "fs";
+import {
+  resolveSessionPath,
+  invalidateSessionPathCache,
+  loadCodexSessionContext,
+  getSessionInfoById,
+} from "@/lib/session-reader";
+import { getRpcSession } from "@/lib/rpc-manager";
+import { getOrCreateCodexServer, releaseCodexServerConnection } from "@/lib/codex-server";
+import { deleteSessionRuntime } from "@/lib/session-runtime";
+
+// GET /api/sessions/[id] — Read session details + context
+export async function GET(
+  req: Request,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+  try {
+    // Look up the session in the registry
+    const info = getSessionInfoById(id);
+
+    if (!info) {
+      return NextResponse.json({ error: "Session not found" }, { status: 404 });
+    }
+
+    const loaded = await loadCodexSessionContext(id, info.cwd).catch(() => null);
+    const context = loaded?.context ?? { messages: [], entryIds: [], thinkingLevel: "off", model: null, subagentRuns: [] };
+    const tree = loaded?.tree ?? [];
+    const leafId = loaded?.leafId ?? null;
+
+    // Query agent state if running
+    const url = new URL(req.url);
+    let agentState: { running: boolean; state?: unknown } | undefined;
+    if (url.searchParams.has("includeState")) {
+      const rpc = getRpcSession(id);
+      if (rpc?.isAlive()) {
+        const state = await rpc.send({ type: "get_state" });
+        agentState = { running: rpc.isBusy(), state };
+      } else {
+        agentState = { running: false };
+      }
+    }
+
+    return NextResponse.json({
+      sessionId: id,
+      filePath: "",
+      info: { ...info, cwdExists: info.cwd ? existsSync(info.cwd) : false },
+      tree,
+      leafId,
+      context,
+      ...(agentState !== undefined ? { agentState } : {}),
+    });
+  } catch (error) {
+    return NextResponse.json({ error: String(error) }, { status: 500 });
+  }
+}
+
+// PATCH /api/sessions/[id] — Rename session
+export async function PATCH(
+  req: Request,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+  try {
+    const { name } = await req.json() as { name?: string };
+    if (typeof name !== "string") {
+      return NextResponse.json({ error: "name is required" }, { status: 400 });
+    }
+
+    // Try to rename via codex server
+    try {
+      const cwd = await resolveSessionPath(id);
+      if (cwd) {
+        const codexSession = getRpcSession(id);
+        if (codexSession) {
+          await codexSession.inner.rename(name.trim());
+        } else {
+          const connection = await getOrCreateCodexServer(cwd);
+          try {
+            await connection.request("thread/name/set", {
+              threadId: id,
+              name: name.trim(),
+            });
+          } finally {
+            releaseCodexServerConnection(connection);
+          }
+        }
+      }
+    } catch {
+      // Fall back to registry-only update
+    }
+
+    return NextResponse.json({ ok: true });
+  } catch (error) {
+    return NextResponse.json({ error: String(error) }, { status: 500 });
+  }
+}
+
+// DELETE /api/sessions/[id]
+export async function DELETE(
+  _req: Request,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+  try {
+    // Destroy running session if any
+    getRpcSession(id)?.destroy();
+    const cwd = await resolveSessionPath(id);
+    if (cwd) {
+      const connection = await getOrCreateCodexServer(cwd);
+      try {
+        await connection.request("thread/archive", { threadId: id }).catch(() => {});
+      } finally {
+        releaseCodexServerConnection(connection);
+      }
+    }
+    invalidateSessionPathCache(id);
+    deleteSessionRuntime(id);
+    return NextResponse.json({ ok: true });
+  } catch (error) {
+    return NextResponse.json({ error: String(error) }, { status: 500 });
+  }
+}

package/app/api/sessions/new/route.ts

@@ -0,0 +1,5 @@
+// This route is no longer used — new sessions are created fully client-side.
+// Kept as a no-op for reference.
+export async function POST() {
+  return new Response("Not used", { status: 410 });
+}

package/app/api/sessions/route.ts

@@ -0,0 +1,16 @@
+import { NextResponse } from "next/server";
+import { listAllSessions } from "@/lib/session-reader";
+
+export async function GET(req: Request) {
+  try {
+    const url = new URL(req.url);
+    const cwd = url.searchParams.get("cwd");
+    const sessions = await listAllSessions({ cwd });
+    return NextResponse.json({ sessions });
+  } catch (error) {
+    return NextResponse.json(
+      { error: String(error) },
+      { status: 500 }
+    );
+  }
+}

package/app/api/settings/route.ts

@@ -0,0 +1,51 @@
+/**
+ * Settings API — reads/writes ~/.config/annodex/providers.json + generativeUI
+ */
+
+import { NextResponse } from "next/server";
+import { readMergedConfig, readProvidersFile as readProviders, writeProvidersFile as writeProviders } from "@/lib/annodex-config";
+
+export const dynamic = "force-dynamic";
+
+export async function GET() {
+  const data = readProviders();
+  const merged = readMergedConfig();
+  return NextResponse.json({
+    settings: {
+      generativeUI: data.generativeUI !== false,
+      providers: data.providers.map((p) => ({
+        id: p.id, name: p.name, baseUrl: p.baseUrl,
+        hasKey: !!p.apiKey, models: p.models,
+      })),
+      defaultProvider: merged.defaultProvider,
+      defaultModel: merged.defaultModel,
+    },
+  });
+}
+
+export async function PUT(req: Request) {
+  try {
+    const body = await req.json() as {
+      settings?: {
+        generativeUI?: boolean;
+        defaultProvider?: string;
+        defaultModel?: string;
+      };
+    };
+    const s = body.settings;
+    if (!s || typeof s !== "object") {
+      return NextResponse.json({ error: "Invalid settings" }, { status: 400 });
+    }
+
+    const data = readProviders();
+    if (!data.exists) data.providers = [];
+    if (typeof s.generativeUI === "boolean") data.generativeUI = s.generativeUI;
+    delete data.defaultProvider;
+    delete data.defaultModel;
+    writeProviders(data);
+
+    return NextResponse.json({ success: true });
+  } catch (error) {
+    return NextResponse.json({ error: String(error) }, { status: 500 });
+  }
+}

package/app/api/skills/install/route.ts

@@ -0,0 +1,249 @@
+import { NextResponse } from "next/server";
+import { runNpx, spawnNpx } from "@/lib/npx";
+
+export const dynamic = "force-dynamic";
+export const runtime = "nodejs";
+
+const SKILLS_INSTALL_TIMEOUT_MS = 10 * 60 * 1000;
+const ANSI_RE = /\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~]|\][^\x07]*(?:\x07|\x1B\\))/g;
+const MAX_STREAM_OUTPUT_CHARS = 1024 * 1024;
+
+type InstallRequest = {
+  package?: string;
+  scope?: string;
+  cwd?: string;
+  stream?: boolean;
+};
+
+type ProgressPattern = {
+  key: string;
+  stage: string;
+  regex: RegExp;
+  line: string | ((match: RegExpMatchArray) => string);
+};
+
+const PROGRESS_PATTERNS: ProgressPattern[] = [
+  {
+    key: "source",
+    stage: "Source resolved",
+    regex: /Source:\s*([^\n]+)/,
+    line: (match) => `Source: ${match[1].trim()}`,
+  },
+  { key: "fetch", stage: "Fetching skills", regex: /Fetching skills/, line: "Fetching skills" },
+  { key: "clone", stage: "Cloning repository", regex: /Cloning repository/, line: "Cloning repository" },
+  { key: "cloned", stage: "Repository cloned", regex: /Repository cloned/, line: "Repository cloned" },
+  { key: "discover", stage: "Discovering skills", regex: /Discovering skills/, line: "Discovering skills" },
+  {
+    key: "found",
+    stage: "Skills discovered",
+    regex: /(Found\s+\d+\s+skills?)/,
+    line: (match) => match[1],
+  },
+  {
+    key: "selected",
+    stage: "Skill selected",
+    regex: /(Selected\s+\d+\s+skills?:?\s*[^\n]*)/,
+    line: (match) => match[1],
+  },
+  { key: "summary", stage: "Preparing install", regex: /Installation Summary/, line: "Preparing install" },
+  { key: "risk", stage: "Checking risk report", regex: /Security Risk Assessments/, line: "Checking risk report" },
+  { key: "complete", stage: "Installation complete", regex: /Installation complete/, line: "Installation complete" },
+  {
+    key: "installed",
+    stage: "Installed",
+    regex: /(Installed\s+\d+\s+skills?)/,
+    line: (match) => match[1],
+  },
+  { key: "done", stage: "Done", regex: /Done!/, line: "Done" },
+  { key: "clone-failed", stage: "Clone failed", regex: /Failed to clone repository/, line: "Failed to clone repository" },
+  { key: "failed", stage: "Installation failed", regex: /Installation failed|Failed to install/, line: "Installation failed" },
+];
+
+function cleanOutput(raw: string): string {
+  return raw
+    .replace(ANSI_RE, "")
+    .replace(/\r/g, "\n")
+    .split("\n")
+    .map((line) => line.replace(/\s+/g, " ").trim())
+    .filter(Boolean)
+    .filter((line, index, lines) => index === 0 || line !== lines[index - 1])
+    .join("\n");
+}
+
+function tailOutput(output: string): string {
+  return output.split("\n").slice(-20).join("\n");
+}
+
+function progressEvents(raw: string): Array<{ key: string; stage: string; line: string }> {
+  const clean = cleanOutput(raw);
+  const events: Array<{ key: string; stage: string; line: string }> = [];
+  for (const pattern of PROGRESS_PATTERNS) {
+    const match = clean.match(pattern.regex);
+    if (!match) continue;
+    const line = typeof pattern.line === "function" ? pattern.line(match) : pattern.line;
+    events.push({ key: pattern.key, stage: pattern.stage, line });
+  }
+  return events;
+}
+
+function isSuccessfulInstall(output: string): boolean {
+  return /Installation complete|Installed \d+ skill/.test(output);
+}
+
+function killProcessTree(child: ReturnType<typeof spawnNpx>) {
+  if (child.exitCode !== null || child.signalCode !== null) return;
+  try {
+    if (process.platform !== "win32" && child.pid) process.kill(-child.pid, "SIGTERM");
+    else child.kill("SIGTERM");
+  } catch {
+    child.kill("SIGTERM");
+  }
+  setTimeout(() => {
+    if (child.exitCode !== null || child.signalCode !== null) return;
+    try {
+      if (process.platform !== "win32" && child.pid) process.kill(-child.pid, "SIGKILL");
+      else child.kill("SIGKILL");
+    } catch {
+      // Process is already gone.
+    }
+  }, 5000).unref();
+}
+
+function streamInstall(req: Request, args: string[], cwd: string | undefined): Response {
+  const encoder = new TextEncoder();
+  let child: ReturnType<typeof spawnNpx> | null = null;
+
+  const stream = new ReadableStream({
+    start(controller) {
+      let output = "";
+      let settled = false;
+      const seenProgress = new Set<string>();
+
+      const send = (event: unknown) => {
+        controller.enqueue(encoder.encode(`${JSON.stringify(event)}\n`));
+      };
+
+      const cleanup = () => {
+        clearTimeout(timeout);
+        req.signal.removeEventListener("abort", abort);
+      };
+
+      const finish = (event: unknown) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        try {
+          send(event);
+        } finally {
+          controller.close();
+        }
+      };
+
+      const fail = (message: string) => {
+        const clean = cleanOutput(output);
+        finish({ type: "error", error: message, output: clean });
+      };
+
+      const abort = () => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        if (child) killProcessTree(child);
+        try {
+          controller.close();
+        } catch {
+          // Client already disconnected.
+        }
+      };
+
+      const timeout = setTimeout(() => {
+        if (child) killProcessTree(child);
+        const clean = cleanOutput(output);
+        fail(`Skill installation timed out after ${Math.round(SKILLS_INSTALL_TIMEOUT_MS / 60000)} minutes while cloning or installing. Last output:\n${tailOutput(clean)}`);
+      }, SKILLS_INSTALL_TIMEOUT_MS);
+
+      req.signal.addEventListener("abort", abort);
+      child = spawnNpx(args, {
+        cwd,
+        env: { ...process.env, FORCE_COLOR: "0" },
+        detached: process.platform !== "win32",
+      });
+
+      send({ type: "progress", stage: "Starting installer", line: "Starting installer" });
+
+      const handleOutput = (chunk: Buffer) => {
+        const raw = chunk.toString("utf8");
+        output = (output + raw).slice(-MAX_STREAM_OUTPUT_CHARS);
+        for (const event of progressEvents(output)) {
+          const key = `${event.key}:${event.line}`;
+          if (seenProgress.has(key)) continue;
+          seenProgress.add(key);
+          send({ type: "progress", stage: event.stage, line: event.line });
+        }
+      };
+
+      child.stdout.on("data", handleOutput);
+      child.stderr.on("data", handleOutput);
+      child.on("error", (err) => {
+        fail(err.message);
+      });
+      child.on("close", (code, signal) => {
+        if (settled) return;
+        const clean = cleanOutput(output);
+        if (isSuccessfulInstall(clean)) {
+          finish({ type: "done", success: true, output: clean });
+          return;
+        }
+        const suffix = code !== null ? `exit code ${code}` : `signal ${signal ?? "unknown"}`;
+        fail(`${tailOutput(clean) || "Install failed"}\nInstaller exited with ${suffix}.`);
+      });
+    },
+    cancel() {
+      if (child) killProcessTree(child);
+    },
+  });
+
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "application/x-ndjson; charset=utf-8",
+      "Cache-Control": "no-store, no-transform",
+      "X-Accel-Buffering": "no",
+    },
+  });
+}
+
+// POST /api/skills/install  body: { package: string; scope: "global" | "project"; cwd?: string }
+export async function POST(req: Request) {
+  try {
+    const { package: pkg, scope, cwd, stream } = await req.json() as InstallRequest;
+    if (!pkg?.trim()) return NextResponse.json({ error: "package required" }, { status: 400 });
+
+    const isGlobal = scope !== "project";
+    const args = ["--yes", "skills", "add", pkg.trim(), "-y", "--agent", "codex"];
+    if (isGlobal) args.push("-g");
+
+    console.log(`[skills/install] running: npx ${args.join(" ")}`);
+    if (stream) return streamInstall(req, args, !isGlobal && cwd ? cwd : undefined);
+
+    const { stdout, stderr } = await runNpx(args, {
+      timeout: SKILLS_INSTALL_TIMEOUT_MS,
+      cwd: !isGlobal && cwd ? cwd : undefined,
+      env: { ...process.env, FORCE_COLOR: "0" },
+    });
+
+    const output = cleanOutput(stdout + stderr);
+    const success = isSuccessfulInstall(output);
+    if (!success) {
+      return NextResponse.json({ error: tailOutput(output) || "Install failed", output }, { status: 500 });
+    }
+    return NextResponse.json({ success: true, output });
+  } catch (e: unknown) {
+    const err = e as { stdout?: string; stderr?: string; message?: string; signal?: string; killed?: boolean };
+    const output = cleanOutput((err.stdout ?? "") + (err.stderr ?? ""));
+    const timedOut = err.killed || err.signal === "SIGTERM" || /timed out|timeout/i.test(err.message ?? "");
+    const message = timedOut
+      ? `Skill installation timed out after ${Math.round(SKILLS_INSTALL_TIMEOUT_MS / 60000)} minutes while cloning or installing. Last output:\n${tailOutput(output)}`
+      : tailOutput(output) || (err.message ?? String(e));
+    return NextResponse.json({ error: message, output }, { status: 500 });
+  }
+}