@claude-sessions/web 0.1.0

package/build/server/chunks/index2-B0dUKYN8.js

@@ -0,0 +1,716 @@
+import * as path4 from 'path';
+import * as os from 'os';
+import { Effect, pipe, Array as Array$1, Option } from 'effect';
+import * as fs3 from 'fs/promises';
+
+var getSessionsDir = () => path4.join(os.homedir(), ".claude", "projects");
+var getTodosDir = () => path4.join(os.homedir(), ".claude", "todos");
+var folderNameToDisplayPath = (folderName) => {
+  return folderName.replace(/^-/, "/").replace(/--/g, "/.").replace(/-/g, "/");
+};
+var extractTextContent = (message) => {
+  if (!message) return "";
+  const content = message.content;
+  if (!content) return "";
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.filter((item) => typeof item === "object" && item?.type === "text").map((item) => item.text ?? "").join("");
+  }
+  return "";
+};
+var extractTitle = (text) => {
+  if (!text) return "Untitled";
+  let cleaned = text.replace(/<ide_[^>]*>[\s\S]*?<\/ide_[^>]*>/g, "").trim();
+  if (!cleaned) return "Untitled";
+  if (cleaned.includes("\n\n")) {
+    cleaned = cleaned.split("\n\n")[0];
+  } else if (cleaned.includes("\n")) {
+    cleaned = cleaned.split("\n")[0];
+  }
+  if (cleaned.length > 100) {
+    return cleaned.slice(0, 100) + "...";
+  }
+  return cleaned || "Untitled";
+};
+var isInvalidApiKeyMessage = (msg) => {
+  const text = extractTextContent(msg.message);
+  return text.includes("Invalid API key");
+};
+var isContinuationSummary = (msg) => {
+  if (msg.isCompactSummary === true) return true;
+  if (msg.type !== "user") return false;
+  const message = msg.message;
+  const content = message?.content ?? "";
+  return content.startsWith("This session is being continued from");
+};
+var findLinkedAgents = (projectName, sessionId) => Effect.gen(function* () {
+  const projectPath = path4.join(getSessionsDir(), projectName);
+  const files = yield* Effect.tryPromise(() => fs3.readdir(projectPath));
+  const agentFiles = files.filter((f) => f.startsWith("agent-") && f.endsWith(".jsonl"));
+  const linkedAgents = [];
+  for (const agentFile of agentFiles) {
+    const filePath = path4.join(projectPath, agentFile);
+    const content = yield* Effect.tryPromise(() => fs3.readFile(filePath, "utf-8"));
+    const firstLine = content.split("\n")[0];
+    if (firstLine) {
+      try {
+        const parsed = JSON.parse(firstLine);
+        if (parsed.sessionId === sessionId) {
+          linkedAgents.push(agentFile.replace(".jsonl", ""));
+        }
+      } catch {
+      }
+    }
+  }
+  return linkedAgents;
+});
+var findOrphanAgents = (projectName) => Effect.gen(function* () {
+  const projectPath = path4.join(getSessionsDir(), projectName);
+  const files = yield* Effect.tryPromise(() => fs3.readdir(projectPath));
+  const sessionIds = new Set(
+    files.filter((f) => !f.startsWith("agent-") && f.endsWith(".jsonl")).map((f) => f.replace(".jsonl", ""))
+  );
+  const agentFiles = files.filter((f) => f.startsWith("agent-") && f.endsWith(".jsonl"));
+  const orphanAgents = [];
+  for (const agentFile of agentFiles) {
+    const filePath = path4.join(projectPath, agentFile);
+    const content = yield* Effect.tryPromise(() => fs3.readFile(filePath, "utf-8"));
+    const firstLine = content.split("\n")[0];
+    if (firstLine) {
+      try {
+        const parsed = JSON.parse(firstLine);
+        if (parsed.sessionId && !sessionIds.has(parsed.sessionId)) {
+          orphanAgents.push({
+            agentId: agentFile.replace(".jsonl", ""),
+            sessionId: parsed.sessionId
+          });
+        }
+      } catch {
+      }
+    }
+  }
+  return orphanAgents;
+});
+var deleteOrphanAgents = (projectName) => Effect.gen(function* () {
+  const projectPath = path4.join(getSessionsDir(), projectName);
+  const orphans = yield* findOrphanAgents(projectName);
+  const backupDir = path4.join(projectPath, ".bak");
+  yield* Effect.tryPromise(() => fs3.mkdir(backupDir, { recursive: true }));
+  const deletedAgents = [];
+  for (const orphan of orphans) {
+    const agentPath = path4.join(projectPath, `${orphan.agentId}.jsonl`);
+    const agentBackupPath = path4.join(backupDir, `${orphan.agentId}.jsonl`);
+    yield* Effect.tryPromise(() => fs3.rename(agentPath, agentBackupPath));
+    deletedAgents.push(orphan.agentId);
+  }
+  return { success: true, deletedAgents, count: deletedAgents.length };
+});
+var sessionHasTodos = (sessionId, agentIds) => Effect.gen(function* () {
+  const todosDir = getTodosDir();
+  const exists = yield* Effect.tryPromise(
+    () => fs3.access(todosDir).then(() => true).catch(() => false)
+  );
+  if (!exists) return false;
+  const sessionTodoPath = path4.join(todosDir, `${sessionId}.json`);
+  const sessionTodoExists = yield* Effect.tryPromise(
+    () => fs3.access(sessionTodoPath).then(() => true).catch(() => false)
+  );
+  if (sessionTodoExists) {
+    const content = yield* Effect.tryPromise(() => fs3.readFile(sessionTodoPath, "utf-8"));
+    try {
+      const todos = JSON.parse(content);
+      if (todos.length > 0) return true;
+    } catch {
+    }
+  }
+  for (const agentId of agentIds) {
+    const shortAgentId = agentId.replace("agent-", "");
+    const agentTodoPath = path4.join(todosDir, `${sessionId}-agent-${shortAgentId}.json`);
+    const agentTodoExists = yield* Effect.tryPromise(
+      () => fs3.access(agentTodoPath).then(() => true).catch(() => false)
+    );
+    if (agentTodoExists) {
+      const content = yield* Effect.tryPromise(() => fs3.readFile(agentTodoPath, "utf-8"));
+      try {
+        const todos = JSON.parse(content);
+        if (todos.length > 0) return true;
+      } catch {
+      }
+    }
+  }
+  return false;
+});
+var deleteLinkedTodos = (sessionId, agentIds) => Effect.gen(function* () {
+  const todosDir = getTodosDir();
+  const exists = yield* Effect.tryPromise(
+    () => fs3.access(todosDir).then(() => true).catch(() => false)
+  );
+  if (!exists) return { deletedCount: 0 };
+  const backupDir = path4.join(todosDir, ".bak");
+  yield* Effect.tryPromise(() => fs3.mkdir(backupDir, { recursive: true }));
+  let deletedCount = 0;
+  const sessionTodoPath = path4.join(todosDir, `${sessionId}.json`);
+  const sessionTodoExists = yield* Effect.tryPromise(
+    () => fs3.access(sessionTodoPath).then(() => true).catch(() => false)
+  );
+  if (sessionTodoExists) {
+    const backupPath = path4.join(backupDir, `${sessionId}.json`);
+    yield* Effect.tryPromise(() => fs3.rename(sessionTodoPath, backupPath));
+    deletedCount++;
+  }
+  for (const agentId of agentIds) {
+    const shortAgentId = agentId.replace("agent-", "");
+    const agentTodoPath = path4.join(todosDir, `${sessionId}-agent-${shortAgentId}.json`);
+    const agentTodoExists = yield* Effect.tryPromise(
+      () => fs3.access(agentTodoPath).then(() => true).catch(() => false)
+    );
+    if (agentTodoExists) {
+      const backupPath = path4.join(backupDir, `${sessionId}-agent-${shortAgentId}.json`);
+      yield* Effect.tryPromise(() => fs3.rename(agentTodoPath, backupPath));
+      deletedCount++;
+    }
+  }
+  return { deletedCount };
+});
+var findOrphanTodos = () => Effect.gen(function* () {
+  const todosDir = getTodosDir();
+  const sessionsDir = getSessionsDir();
+  const [todosExists, sessionsExists] = yield* Effect.all([
+    Effect.tryPromise(
+      () => fs3.access(todosDir).then(() => true).catch(() => false)
+    ),
+    Effect.tryPromise(
+      () => fs3.access(sessionsDir).then(() => true).catch(() => false)
+    )
+  ]);
+  if (!todosExists || !sessionsExists) return [];
+  const todoFiles = yield* Effect.tryPromise(() => fs3.readdir(todosDir));
+  const jsonFiles = todoFiles.filter((f) => f.endsWith(".json"));
+  const validSessionIds = /* @__PURE__ */ new Set();
+  const projectEntries = yield* Effect.tryPromise(
+    () => fs3.readdir(sessionsDir, { withFileTypes: true })
+  );
+  for (const entry of projectEntries) {
+    if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+    const projectPath = path4.join(sessionsDir, entry.name);
+    const files = yield* Effect.tryPromise(() => fs3.readdir(projectPath));
+    for (const f of files) {
+      if (f.endsWith(".jsonl") && !f.startsWith("agent-")) {
+        validSessionIds.add(f.replace(".jsonl", ""));
+      }
+    }
+  }
+  const orphans = [];
+  for (const todoFile of jsonFiles) {
+    const match = todoFile.match(/^([a-f0-9-]+)(?:-agent-[a-f0-9]+)?\.json$/);
+    if (match) {
+      const sessionId = match[1];
+      if (!validSessionIds.has(sessionId)) {
+        orphans.push(todoFile);
+      }
+    }
+  }
+  return orphans;
+});
+var deleteOrphanTodos = () => Effect.gen(function* () {
+  const todosDir = getTodosDir();
+  const orphans = yield* findOrphanTodos();
+  if (orphans.length === 0) return { success: true, deletedCount: 0 };
+  const backupDir = path4.join(todosDir, ".bak");
+  yield* Effect.tryPromise(() => fs3.mkdir(backupDir, { recursive: true }));
+  let deletedCount = 0;
+  for (const orphan of orphans) {
+    const filePath = path4.join(todosDir, orphan);
+    const backupPath = path4.join(backupDir, orphan);
+    yield* Effect.tryPromise(() => fs3.rename(filePath, backupPath));
+    deletedCount++;
+  }
+  return { success: true, deletedCount };
+});
+var listProjects = Effect.gen(function* () {
+  const sessionsDir = getSessionsDir();
+  const exists = yield* Effect.tryPromise(
+    () => fs3.access(sessionsDir).then(() => true).catch(() => false)
+  );
+  if (!exists) {
+    return [];
+  }
+  const entries = yield* Effect.tryPromise(() => fs3.readdir(sessionsDir, { withFileTypes: true }));
+  const projects = yield* Effect.all(
+    entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map(
+      (entry) => Effect.gen(function* () {
+        const projectPath = path4.join(sessionsDir, entry.name);
+        const files = yield* Effect.tryPromise(() => fs3.readdir(projectPath));
+        const sessionFiles = files.filter((f) => f.endsWith(".jsonl") && !f.startsWith("agent-"));
+        return {
+          name: entry.name,
+          displayName: folderNameToDisplayPath(entry.name),
+          path: projectPath,
+          sessionCount: sessionFiles.length
+        };
+      })
+    ),
+    { concurrency: 10 }
+  );
+  return projects;
+});
+var listSessions = (projectName) => Effect.gen(function* () {
+  const projectPath = path4.join(getSessionsDir(), projectName);
+  const files = yield* Effect.tryPromise(() => fs3.readdir(projectPath));
+  const sessionFiles = files.filter((f) => f.endsWith(".jsonl") && !f.startsWith("agent-"));
+  const sessions = yield* Effect.all(
+    sessionFiles.map(
+      (file) => Effect.gen(function* () {
+        const filePath = path4.join(projectPath, file);
+        const content = yield* Effect.tryPromise(() => fs3.readFile(filePath, "utf-8"));
+        const lines = content.trim().split("\n").filter(Boolean);
+        const messages = lines.map((line) => JSON.parse(line));
+        const sessionId = file.replace(".jsonl", "");
+        const userAssistantMessages = messages.filter(
+          (m) => m.type === "user" || m.type === "assistant"
+        );
+        const hasSummary = messages.some((m) => m.type === "summary");
+        const firstMessage = userAssistantMessages[0];
+        const lastMessage = userAssistantMessages[userAssistantMessages.length - 1];
+        const title = pipe(
+          messages,
+          Array$1.findFirst((m) => m.type === "user"),
+          Option.map((m) => {
+            const text = extractTextContent(m.message);
+            return extractTitle(text);
+          }),
+          Option.getOrElse(() => hasSummary ? "[Summary Only]" : `Session ${sessionId.slice(0, 8)}`)
+        );
+        return {
+          id: sessionId,
+          projectName,
+          title,
+          // If session has summary but no user/assistant messages, count as 1
+          messageCount: userAssistantMessages.length > 0 ? userAssistantMessages.length : hasSummary ? 1 : 0,
+          createdAt: firstMessage?.timestamp,
+          updatedAt: lastMessage?.timestamp
+        };
+      })
+    ),
+    { concurrency: 10 }
+  );
+  return sessions.sort((a, b) => {
+    const dateA = a.updatedAt ? new Date(a.updatedAt).getTime() : 0;
+    const dateB = b.updatedAt ? new Date(b.updatedAt).getTime() : 0;
+    return dateB - dateA;
+  });
+});
+var readSession = (projectName, sessionId) => Effect.gen(function* () {
+  const filePath = path4.join(getSessionsDir(), projectName, `${sessionId}.jsonl`);
+  const content = yield* Effect.tryPromise(() => fs3.readFile(filePath, "utf-8"));
+  const lines = content.trim().split("\n").filter(Boolean);
+  return lines.map((line) => JSON.parse(line));
+});
+var deleteMessage = (projectName, sessionId, messageUuid) => Effect.gen(function* () {
+  const filePath = path4.join(getSessionsDir(), projectName, `${sessionId}.jsonl`);
+  const content = yield* Effect.tryPromise(() => fs3.readFile(filePath, "utf-8"));
+  const lines = content.trim().split("\n").filter(Boolean);
+  const messages = lines.map((line) => JSON.parse(line));
+  const targetIndex = messages.findIndex(
+    (m) => m.uuid === messageUuid || m.messageId === messageUuid
+  );
+  if (targetIndex === -1) {
+    return { success: false, error: "Message not found" };
+  }
+  const deletedMsg = messages[targetIndex];
+  const deletedUuid = deletedMsg?.uuid ?? deletedMsg?.messageId;
+  const parentUuid = deletedMsg?.parentUuid;
+  for (const msg of messages) {
+    if (msg.parentUuid === deletedUuid) {
+      msg.parentUuid = parentUuid;
+    }
+  }
+  messages.splice(targetIndex, 1);
+  const newContent = messages.map((m) => JSON.stringify(m)).join("\n") + "\n";
+  yield* Effect.tryPromise(() => fs3.writeFile(filePath, newContent, "utf-8"));
+  return { success: true };
+});
+var deleteSession = (projectName, sessionId) => Effect.gen(function* () {
+  const sessionsDir = getSessionsDir();
+  const projectPath = path4.join(sessionsDir, projectName);
+  const filePath = path4.join(projectPath, `${sessionId}.jsonl`);
+  const linkedAgents = yield* findLinkedAgents(projectName, sessionId);
+  const stat2 = yield* Effect.tryPromise(() => fs3.stat(filePath));
+  if (stat2.size === 0) {
+    yield* Effect.tryPromise(() => fs3.unlink(filePath));
+    const agentBackupDir2 = path4.join(projectPath, ".bak");
+    yield* Effect.tryPromise(() => fs3.mkdir(agentBackupDir2, { recursive: true }));
+    for (const agentId of linkedAgents) {
+      const agentPath = path4.join(projectPath, `${agentId}.jsonl`);
+      const agentBackupPath = path4.join(agentBackupDir2, `${agentId}.jsonl`);
+      yield* Effect.tryPromise(() => fs3.rename(agentPath, agentBackupPath).catch(() => {
+      }));
+    }
+    yield* deleteLinkedTodos(sessionId, linkedAgents);
+    return { success: true, deletedAgents: linkedAgents.length };
+  }
+  const backupDir = path4.join(sessionsDir, ".bak");
+  yield* Effect.tryPromise(() => fs3.mkdir(backupDir, { recursive: true }));
+  const agentBackupDir = path4.join(projectPath, ".bak");
+  yield* Effect.tryPromise(() => fs3.mkdir(agentBackupDir, { recursive: true }));
+  for (const agentId of linkedAgents) {
+    const agentPath = path4.join(projectPath, `${agentId}.jsonl`);
+    const agentBackupPath = path4.join(agentBackupDir, `${agentId}.jsonl`);
+    yield* Effect.tryPromise(() => fs3.rename(agentPath, agentBackupPath).catch(() => {
+    }));
+  }
+  const todosResult = yield* deleteLinkedTodos(sessionId, linkedAgents);
+  const backupPath = path4.join(backupDir, `${projectName}_${sessionId}.jsonl`);
+  yield* Effect.tryPromise(() => fs3.rename(filePath, backupPath));
+  return {
+    success: true,
+    backupPath,
+    deletedAgents: linkedAgents.length,
+    deletedTodos: todosResult.deletedCount
+  };
+});
+var renameSession = (projectName, sessionId, newTitle) => Effect.gen(function* () {
+  const filePath = path4.join(getSessionsDir(), projectName, `${sessionId}.jsonl`);
+  const content = yield* Effect.tryPromise(() => fs3.readFile(filePath, "utf-8"));
+  const lines = content.trim().split("\n").filter(Boolean);
+  if (lines.length === 0) {
+    return { success: false, error: "Empty session" };
+  }
+  const messages = lines.map((line) => JSON.parse(line));
+  const firstUserIdx = messages.findIndex((m) => m.type === "user");
+  if (firstUserIdx === -1) {
+    return { success: false, error: "No user message found" };
+  }
+  const firstMsg = messages[firstUserIdx];
+  if (firstMsg?.message?.content && Array.isArray(firstMsg.message.content)) {
+    const textIdx = firstMsg.message.content.findIndex(
+      (item) => typeof item === "object" && item?.type === "text" && !item.text?.trim().startsWith("<ide_")
+    );
+    if (textIdx >= 0) {
+      const item = firstMsg.message.content[textIdx];
+      const oldText = item.text ?? "";
+      const cleanedText = oldText.replace(/^[^\n]+\n\n/, "");
+      item.text = `${newTitle}
+
+${cleanedText}`;
+    }
+  }
+  const newContent = messages.map((m) => JSON.stringify(m)).join("\n") + "\n";
+  yield* Effect.tryPromise(() => fs3.writeFile(filePath, newContent, "utf-8"));
+  return { success: true };
+});
+var getSessionFiles = (projectName, sessionId) => Effect.gen(function* () {
+  const messages = yield* readSession(projectName, sessionId);
+  const fileChanges = [];
+  const seenFiles = /* @__PURE__ */ new Set();
+  for (const msg of messages) {
+    if (msg.type === "file-history-snapshot") {
+      const snapshot = msg;
+      const backups = snapshot.snapshot?.trackedFileBackups;
+      if (backups && typeof backups === "object") {
+        for (const filePath of Object.keys(backups)) {
+          if (!seenFiles.has(filePath)) {
+            seenFiles.add(filePath);
+            fileChanges.push({
+              path: filePath,
+              action: "modified",
+              timestamp: snapshot.snapshot?.timestamp,
+              messageUuid: snapshot.messageId ?? msg.uuid
+            });
+          }
+        }
+      }
+    }
+    if (msg.type === "assistant" && msg.message?.content) {
+      const content = msg.message.content;
+      if (Array.isArray(content)) {
+        for (const item of content) {
+          if (item && typeof item === "object" && "type" in item && item.type === "tool_use") {
+            const toolUse = item;
+            if ((toolUse.name === "Write" || toolUse.name === "Edit") && toolUse.input?.file_path) {
+              const filePath = toolUse.input.file_path;
+              if (!seenFiles.has(filePath)) {
+                seenFiles.add(filePath);
+                fileChanges.push({
+                  path: filePath,
+                  action: toolUse.name === "Write" ? "created" : "modified",
+                  timestamp: msg.timestamp,
+                  messageUuid: msg.uuid
+                });
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  return {
+    sessionId,
+    projectName,
+    files: fileChanges,
+    totalChanges: fileChanges.length
+  };
+});
+var moveSession = (sourceProject, sessionId, targetProject) => Effect.gen(function* () {
+  const sessionsDir = getSessionsDir();
+  const sourcePath = path4.join(sessionsDir, sourceProject);
+  const targetPath = path4.join(sessionsDir, targetProject);
+  const sourceFile = path4.join(sourcePath, `${sessionId}.jsonl`);
+  const targetFile = path4.join(targetPath, `${sessionId}.jsonl`);
+  const sourceExists = yield* Effect.tryPromise(
+    () => fs3.access(sourceFile).then(() => true).catch(() => false)
+  );
+  if (!sourceExists) {
+    return { success: false, error: "Source session not found" };
+  }
+  const targetExists = yield* Effect.tryPromise(
+    () => fs3.access(targetFile).then(() => true).catch(() => false)
+  );
+  if (targetExists) {
+    return { success: false, error: "Session already exists in target project" };
+  }
+  yield* Effect.tryPromise(() => fs3.mkdir(targetPath, { recursive: true }));
+  const linkedAgents = yield* findLinkedAgents(sourceProject, sessionId);
+  yield* Effect.tryPromise(() => fs3.rename(sourceFile, targetFile));
+  for (const agentId of linkedAgents) {
+    const sourceAgentFile = path4.join(sourcePath, `${agentId}.jsonl`);
+    const targetAgentFile = path4.join(targetPath, `${agentId}.jsonl`);
+    const agentExists = yield* Effect.tryPromise(
+      () => fs3.access(sourceAgentFile).then(() => true).catch(() => false)
+    );
+    if (agentExists) {
+      yield* Effect.tryPromise(() => fs3.rename(sourceAgentFile, targetAgentFile));
+    }
+  }
+  return { success: true };
+});
+var splitSession = (projectName, sessionId, splitAtMessageUuid) => Effect.gen(function* () {
+  const projectPath = path4.join(getSessionsDir(), projectName);
+  const filePath = path4.join(projectPath, `${sessionId}.jsonl`);
+  const content = yield* Effect.tryPromise(() => fs3.readFile(filePath, "utf-8"));
+  const lines = content.trim().split("\n").filter(Boolean);
+  const allMessages = lines.map((line) => JSON.parse(line));
+  const splitIndex = allMessages.findIndex((m) => m.uuid === splitAtMessageUuid);
+  if (splitIndex === -1) {
+    return { success: false, error: "Message not found" };
+  }
+  if (splitIndex === 0) {
+    return { success: false, error: "Cannot split at first message" };
+  }
+  const newSessionId = crypto.randomUUID();
+  const splitMessage = allMessages[splitIndex];
+  const shouldDuplicate = isContinuationSummary(splitMessage);
+  let remainingMessages;
+  const movedMessages = allMessages.slice(splitIndex);
+  if (shouldDuplicate) {
+    const duplicatedMessage = {
+      ...splitMessage,
+      uuid: crypto.randomUUID(),
+      sessionId
+      // Keep original session ID
+    };
+    remainingMessages = [...allMessages.slice(0, splitIndex), duplicatedMessage];
+  } else {
+    remainingMessages = allMessages.slice(0, splitIndex);
+  }
+  const updatedMovedMessages = movedMessages.map((msg, index) => {
+    const updated = { ...msg, sessionId: newSessionId };
+    if (index === 0) {
+      updated.parentUuid = null;
+    }
+    return updated;
+  });
+  const remainingContent = remainingMessages.map((m) => JSON.stringify(m)).join("\n") + "\n";
+  yield* Effect.tryPromise(() => fs3.writeFile(filePath, remainingContent, "utf-8"));
+  const newFilePath = path4.join(projectPath, `${newSessionId}.jsonl`);
+  const newContent = updatedMovedMessages.map((m) => JSON.stringify(m)).join("\n") + "\n";
+  yield* Effect.tryPromise(() => fs3.writeFile(newFilePath, newContent, "utf-8"));
+  const agentFiles = yield* Effect.tryPromise(() => fs3.readdir(projectPath));
+  const agentJsonlFiles = agentFiles.filter((f) => f.startsWith("agent-") && f.endsWith(".jsonl"));
+  for (const agentFile of agentJsonlFiles) {
+    const agentPath = path4.join(projectPath, agentFile);
+    const agentContent = yield* Effect.tryPromise(() => fs3.readFile(agentPath, "utf-8"));
+    const agentLines = agentContent.trim().split("\n").filter(Boolean);
+    if (agentLines.length === 0) continue;
+    const firstAgentMsg = JSON.parse(agentLines[0]);
+    if (firstAgentMsg.sessionId === sessionId) {
+      const agentId = agentFile.replace("agent-", "").replace(".jsonl", "");
+      const isRelatedToMoved = movedMessages.some(
+        (msg) => msg.agentId === agentId
+      );
+      if (isRelatedToMoved) {
+        const updatedAgentMessages = agentLines.map((line) => {
+          const msg = JSON.parse(line);
+          return JSON.stringify({ ...msg, sessionId: newSessionId });
+        });
+        const updatedAgentContent = updatedAgentMessages.join("\n") + "\n";
+        yield* Effect.tryPromise(() => fs3.writeFile(agentPath, updatedAgentContent, "utf-8"));
+      }
+    }
+  }
+  return {
+    success: true,
+    newSessionId,
+    newSessionPath: newFilePath,
+    movedMessageCount: movedMessages.length,
+    duplicatedSummary: shouldDuplicate
+  };
+});
+var cleanInvalidMessages = (projectName, sessionId) => Effect.gen(function* () {
+  const filePath = path4.join(getSessionsDir(), projectName, `${sessionId}.jsonl`);
+  const content = yield* Effect.tryPromise(() => fs3.readFile(filePath, "utf-8"));
+  const lines = content.trim().split("\n").filter(Boolean);
+  if (lines.length === 0) return { removedCount: 0, remainingCount: 0 };
+  const messages = lines.map((line) => JSON.parse(line));
+  const invalidIndices = [];
+  messages.forEach((msg, idx) => {
+    if (isInvalidApiKeyMessage(msg)) {
+      invalidIndices.push(idx);
+    }
+  });
+  if (invalidIndices.length === 0) {
+    const userAssistantCount = messages.filter(
+      (m) => m.type === "user" || m.type === "assistant"
+    ).length;
+    const hasSummary2 = messages.some((m) => m.type === "summary");
+    const remainingCount2 = userAssistantCount > 0 ? userAssistantCount : hasSummary2 ? 1 : 0;
+    return { removedCount: 0, remainingCount: remainingCount2 };
+  }
+  const filtered = [];
+  let lastValidUuid = null;
+  for (let i = 0; i < messages.length; i++) {
+    if (invalidIndices.includes(i)) {
+      continue;
+    }
+    const msg = messages[i];
+    if (msg.parentUuid && invalidIndices.some((idx) => messages[idx]?.uuid === msg.parentUuid)) {
+      msg.parentUuid = lastValidUuid;
+    }
+    filtered.push(msg);
+    lastValidUuid = msg.uuid;
+  }
+  const newContent = filtered.length > 0 ? filtered.map((m) => JSON.stringify(m)).join("\n") + "\n" : "";
+  yield* Effect.tryPromise(() => fs3.writeFile(filePath, newContent, "utf-8"));
+  const remainingUserAssistant = filtered.filter(
+    (m) => m.type === "user" || m.type === "assistant"
+  ).length;
+  const hasSummary = filtered.some((m) => m.type === "summary");
+  const remainingCount = remainingUserAssistant > 0 ? remainingUserAssistant : hasSummary ? 1 : 0;
+  return { removedCount: invalidIndices.length, remainingCount };
+});
+var previewCleanup = (projectName) => Effect.gen(function* () {
+  const projects = yield* listProjects;
+  const targetProjects = projectName ? projects.filter((p) => p.name === projectName) : projects;
+  const orphanTodos = yield* findOrphanTodos();
+  const orphanTodoCount = orphanTodos.length;
+  const results = yield* Effect.all(
+    targetProjects.map(
+      (project) => Effect.gen(function* () {
+        const sessions = yield* listSessions(project.name);
+        const emptySessions = sessions.filter((s) => s.messageCount === 0);
+        const invalidSessions = sessions.filter(
+          (s) => s.title?.includes("Invalid API key") || s.title?.includes("API key")
+        );
+        let emptyWithTodosCount = 0;
+        for (const session of emptySessions) {
+          const linkedAgents = yield* findLinkedAgents(project.name, session.id);
+          const hasTodos = yield* sessionHasTodos(session.id, linkedAgents);
+          if (hasTodos) {
+            emptyWithTodosCount++;
+          }
+        }
+        const orphanAgents = yield* findOrphanAgents(project.name);
+        return {
+          project: project.name,
+          emptySessions,
+          invalidSessions,
+          emptyWithTodosCount,
+          orphanAgentCount: orphanAgents.length,
+          orphanTodoCount: 0
+          // Will set for first project only
+        };
+      })
+    ),
+    { concurrency: 5 }
+  );
+  if (results.length > 0) {
+    results[0] = { ...results[0], orphanTodoCount };
+  }
+  return results;
+});
+var clearSessions = (options) => Effect.gen(function* () {
+  const {
+    projectName,
+    clearEmpty = true,
+    clearInvalid = true,
+    skipWithTodos = true,
+    clearOrphanAgents = false,
+    clearOrphanTodos = false
+  } = options;
+  const projects = yield* listProjects;
+  const targetProjects = projectName ? projects.filter((p) => p.name === projectName) : projects;
+  let deletedSessionCount = 0;
+  let removedMessageCount = 0;
+  let deletedOrphanAgentCount = 0;
+  let deletedOrphanTodoCount = 0;
+  const sessionsToDelete = [];
+  if (clearInvalid) {
+    for (const project of targetProjects) {
+      const projectPath = path4.join(getSessionsDir(), project.name);
+      const files = yield* Effect.tryPromise(() => fs3.readdir(projectPath));
+      const sessionFiles = files.filter((f) => f.endsWith(".jsonl") && !f.startsWith("agent-"));
+      for (const file of sessionFiles) {
+        const sessionId = file.replace(".jsonl", "");
+        const result = yield* cleanInvalidMessages(project.name, sessionId);
+        removedMessageCount += result.removedCount;
+        if (result.remainingCount === 0) {
+          sessionsToDelete.push({ project: project.name, sessionId });
+        }
+      }
+    }
+  }
+  if (clearEmpty) {
+    for (const project of targetProjects) {
+      const sessions = yield* listSessions(project.name);
+      for (const session of sessions) {
+        if (session.messageCount === 0) {
+          const alreadyMarked = sessionsToDelete.some(
+            (s) => s.project === project.name && s.sessionId === session.id
+          );
+          if (!alreadyMarked) {
+            if (skipWithTodos) {
+              const linkedAgents = yield* findLinkedAgents(project.name, session.id);
+              const hasTodos = yield* sessionHasTodos(session.id, linkedAgents);
+              if (hasTodos) continue;
+            }
+            sessionsToDelete.push({ project: project.name, sessionId: session.id });
+          }
+        }
+      }
+    }
+  }
+  for (const { project, sessionId } of sessionsToDelete) {
+    yield* deleteSession(project, sessionId);
+    deletedSessionCount++;
+  }
+  if (clearOrphanAgents) {
+    for (const project of targetProjects) {
+      const result = yield* deleteOrphanAgents(project.name);
+      deletedOrphanAgentCount += result.count;
+    }
+  }
+  if (clearOrphanTodos) {
+    const result = yield* deleteOrphanTodos();
+    deletedOrphanTodoCount = result.deletedCount;
+  }
+  return {
+    success: true,
+    deletedCount: deletedSessionCount,
+    removedMessageCount,
+    deletedOrphanAgentCount,
+    deletedOrphanTodoCount
+  };
+});
+
+export { listSessions as a, deleteSession as b, clearSessions as c, deleteMessage as d, getSessionFiles as e, renameSession as f, getSessionsDir as g, listProjects as l, moveSession as m, previewCleanup as p, readSession as r, splitSession as s };
+//# sourceMappingURL=index2-B0dUKYN8.js.map