@peaske7/readit 0.1.7 → 0.2.0

package/src/{cli/index.ts → cli.ts}

@@ -13,11 +13,10 @@ import * as os from "node:os";
 import { join, resolve } from "node:path";
 import { Command } from "commander";
 import open from "open";
-import { getCommentPath, parseCommentFile } from "../lib/comment-storage.js";
-import { getFileType } from "../lib/utils.js";
-import type { FileEntry } from "../server/index.js";
-import { removeServerInfo, startServer } from "../server/index.js";
-import type { DocumentType } from "../types/index.js";
+import { getCommentPath, parseCommentFile } from "./lib/comment-storage.js";
+import { isMarkdownFile } from "./lib/utils.js";
+import type { FileEntry } from "./server.js";
+import { removeServerInfo, startServer } from "./server.js";
 
 const program = new Command();
 
@@ -34,17 +33,113 @@ interface ServerInfo {
   pid: number;
 }
 
-async function discoverServer(): Promise<ServerInfo | null> {
-  const serverInfoPath = join(os.homedir(), ".readit", "server.json");
+interface ServerTarget {
+  kind: "existing" | "started";
+  port: number;
+  url: string;
+  server?: { stop(): void };
+}
+
+const READIT_DIR = join(os.homedir(), ".readit");
+const SERVER_INFO_PATH = join(READIT_DIR, "server.json");
+const SERVER_LOCK_PATH = join(READIT_DIR, "server.lock");
+const SERVER_LOCK_MAX_AGE_MS = 30_000;
+const SERVER_LOCK_TIMEOUT_MS = 10_000;
+const SERVER_LOCK_WAIT_MS = 100;
+
+function isAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function getErrnoCode(err: unknown): string | undefined {
+  return err instanceof Error && "code" in err
+    ? (err as NodeJS.ErrnoException).code
+    : undefined;
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function clearStaleServerLock(): Promise<void> {
+  try {
+    const [stats, content] = await Promise.all([
+      fs.stat(SERVER_LOCK_PATH),
+      fs.readFile(SERVER_LOCK_PATH, "utf-8").catch(() => ""),
+    ]);
+
+    const age = Date.now() - stats.mtimeMs;
+    let pid: number | undefined;
+
+    if (content) {
+      try {
+        const lock = JSON.parse(content) as { pid?: number };
+        pid = lock.pid;
+      } catch {
+        // Ignore malformed lock files and fall back to age-based cleanup.
+      }
+    }
+
+    if (age > SERVER_LOCK_MAX_AGE_MS || (pid !== undefined && !isAlive(pid))) {
+      await fs.unlink(SERVER_LOCK_PATH).catch(() => {});
+    }
+  } catch (err) {
+    if (getErrnoCode(err) !== "ENOENT") throw err;
+  }
+}
+
+async function withServerLock<T>(run: () => Promise<T>): Promise<T> {
+  await fs.mkdir(READIT_DIR, { recursive: true });
+  const start = Date.now();
+
+  while (true) {
+    let handle: fs.FileHandle | undefined;
+
+    try {
+      handle = await fs.open(SERVER_LOCK_PATH, "wx");
+      await handle.writeFile(
+        JSON.stringify({ pid: process.pid, createdAt: Date.now() }),
+        "utf-8",
+      );
+
+      try {
+        return await run();
+      } finally {
+        await handle.close().catch(() => {});
+        await fs.unlink(SERVER_LOCK_PATH).catch(() => {});
+      }
+    } catch (err) {
+      if (handle) {
+        await handle.close().catch(() => {});
+      }
+
+      if (getErrnoCode(err) !== "EEXIST") {
+        throw err;
+      }
+
+      await clearStaleServerLock();
+
+      if (Date.now() - start >= SERVER_LOCK_TIMEOUT_MS) {
+        throw new Error("Timed out waiting for readit server lock");
+      }
 
+      await sleep(SERVER_LOCK_WAIT_MS);
+    }
+  }
+}
+
+async function discoverServer(): Promise<ServerInfo | null> {
   try {
-    const content = readFileSync(serverInfoPath, "utf-8");
+    const content = readFileSync(SERVER_INFO_PATH, "utf-8");
     const info: ServerInfo = JSON.parse(content);
 
     // Verify the process is alive
-    try {
-      process.kill(info.pid, 0);
-    } catch {
+    if (!isAlive(info.pid)) {
       return null;
     }
 
@@ -62,9 +157,65 @@ async function discoverServer(): Promise<ServerInfo | null> {
   }
 }
 
-/**
- * Recursively find all .comments.md files in a directory.
- */
+async function attachFiles(
+  server: ServerInfo,
+  files: { path: string }[],
+): Promise<void> {
+  for (const file of files) {
+    try {
+      const res = await fetch(`http://127.0.0.1:${server.port}/api/documents`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ path: file.path }),
+      });
+
+      if (!res.ok) {
+        const data = await res.json();
+        console.error(`error: failed to add ${file.path}: ${data.error}`);
+        process.exit(1);
+      }
+
+      const data = await res.json();
+      if (data.status === "added") {
+        console.log(`Added: ${data.fileName}`);
+      } else {
+        console.log(`Present: ${data.fileName}`);
+      }
+    } catch (err) {
+      console.error(
+        "error: failed to connect to server:",
+        err instanceof Error ? err.message : err,
+      );
+      process.exit(1);
+    }
+  }
+}
+
+async function getServerTarget(
+  files: FileEntry[],
+  port: number,
+  host: string,
+): Promise<ServerTarget> {
+  return withServerLock(async () => {
+    const server = await discoverServer();
+    if (server) {
+      return {
+        kind: "existing",
+        port: server.port,
+        url: `http://127.0.0.1:${server.port}`,
+      };
+    }
+
+    const started = await startServer({ files, port, host });
+    return {
+      kind: "started",
+      port: started.port,
+      url: started.url,
+      server: started.server,
+    };
+  });
+}
+
 function findCommentFiles(dir: string): string[] {
   const results: string[] = [];
 
@@ -95,9 +246,6 @@ function findCommentFiles(dir: string): string[] {
   return results;
 }
 
-/**
- * Recursively find reviewable files (.md, .markdown, .html, .htm) in a directory.
- */
 function findReviewableFiles(dir: string): FileEntry[] {
   const results: FileEntry[] = [];
 
@@ -113,14 +261,8 @@ function findReviewableFiles(dir: string): FileEntry[] {
         if (lstat.isSymbolicLink()) continue;
         if (lstat.isDirectory()) {
           results.push(...findReviewableFiles(fullPath));
-        } else {
-          const type = getFileType(entry);
-          if (type) {
-            results.push({
-              type,
-              filePath: fullPath,
-            });
-          }
+        } else if (isMarkdownFile(entry)) {
+          results.push({ filePath: fullPath });
         }
       } catch (err) {
         if (isPermissionError(err)) {
@@ -137,9 +279,6 @@ function findReviewableFiles(dir: string): FileEntry[] {
   return results;
 }
 
-/**
- * Resolve CLI arguments into a deduplicated list of FileEntry objects.
- */
 function resolveFiles(args: string[]): FileEntry[] {
   const seen = new Set<string>();
   const files: FileEntry[] = [];
@@ -167,27 +306,21 @@ function resolveFiles(args: string[]): FileEntry[] {
     } else {
       if (seen.has(filePath)) continue;
 
-      const type = getFileType(filePath);
-      if (!type) {
+      if (!isMarkdownFile(filePath)) {
         console.error(
-          `error: unsupported file type: ${arg} (expected .md, .markdown, .html, or .htm)`,
+          `error: unsupported file type: ${arg} (expected .md or .markdown)`,
         );
         process.exit(1);
       }
 
       seen.add(filePath);
-      files.push({
-        type,
-        filePath,
-      });
+      files.push({ filePath });
     }
   }
 
   return files;
 }
 
-// ─── Onboarding ──────────────────────────────────────────────────────
-
 const SETTINGS_PATH = join(os.homedir(), ".readit", "settings.json");
 
 function isOnboarded(): boolean {
@@ -292,14 +425,11 @@ Go ahead and add a few comments to this document. When you're done, export them
 
 const WELCOME_PATH = join(os.homedir(), ".readit", "welcome.md");
 
-// ─── Program ─────────────────────────────────────────────────────────
-
 program
   .name("readit")
-  .description("Review Markdown and HTML documents with inline comments")
+  .description("Review Markdown documents with inline comments")
   .version("0.1.3");
 
-// List command: show all commented files
 program
   .command("list")
   .description("List all files with comments")
@@ -338,7 +468,6 @@ program
     }
   });
 
-// Show command: display comments for a file
 program
   .command("show <file>")
   .description("Show comments for a file")
@@ -382,9 +511,8 @@ program
     }
   });
 
-// Main review command (default) — accepts zero or more files/directories
 program
-  .argument("[files...]", "Markdown or HTML files/directories to review")
+  .argument("[files...]", "Markdown files/directories to review")
   .option("-p, --port <number>", "Port to run server on", "4567")
   .option("--host <address>", "Host address to bind to", "127.0.0.1")
   .option("--no-open", "Don't automatically open browser")
@@ -408,7 +536,6 @@ program
           files = [
             {
               content: WELCOME_CONTENT,
-              type: "markdown" as DocumentType,
               filePath: WELCOME_PATH,
             },
           ];
@@ -433,6 +560,17 @@ program
         process.exit(1);
       }
 
+      // Snapshot previous session before startServer() overwrites server.json
+      let previousPort: number | undefined;
+      try {
+        const info = JSON.parse(readFileSync(SERVER_INFO_PATH, "utf-8"));
+        if (!isAlive(info.pid)) {
+          previousPort = info.port;
+        }
+      } catch {
+        // No previous session — will open browser normally
+      }
+
       try {
         const { url, server } = await startServer({
           files,
@@ -453,7 +591,7 @@ readit - Document Review Tool
   Server running. Press Ctrl+C to stop.
 `);
         } else {
-          const fileList = files.map((f) => `  ${f.filePath} (${f.type})`);
+          const fileList = files.map((f) => `  ${f.filePath}`);
 
           console.log(`
 readit - Document Review Tool
@@ -467,7 +605,11 @@ ${fileList.join("\n")}
 `);
         }
 
-        if (options.open) {
+        const browserLikelyOpen =
+          previousPort === preferredPort ||
+          process.env.NODE_ENV === "development";
+
+        if (options.open && !browserLikelyOpen) {
           open(url);
         }
 
@@ -493,17 +635,16 @@ ${fileList.join("\n")}
     },
   );
 
-// Open command: add files to running server or start new one
 program
   .command("open")
-  .argument("<files...>", "Markdown or HTML files to add to running server")
+  .argument("<files...>", "Markdown files to add to running server")
   .description("Add files to a running readit server, or start a new one")
   .option("-p, --port <number>", "Port for new server (if starting)", "4567")
   .option("--host <address>", "Host for new server (if starting)", "127.0.0.1")
   .action(
     async (fileArgs: string[], options: { port: string; host: string }) => {
       // Resolve and validate files
-      const resolvedFiles: { path: string; type: DocumentType }[] = [];
+      const resolvedFiles: { path: string }[] = [];
       for (const arg of fileArgs) {
         const inputPath = resolve(process.cwd(), arg);
 
@@ -514,91 +655,54 @@ program
 
         const filePath = realpathSync(inputPath);
 
-        const type = getFileType(filePath);
-        if (!type) {
+        if (!isMarkdownFile(filePath)) {
           console.error(
-            `error: unsupported file type: ${arg} (expected .md, .markdown, .html, or .htm)`,
+            `error: unsupported file type: ${arg} (expected .md or .markdown)`,
           );
           process.exit(1);
         }
 
-        resolvedFiles.push({ path: filePath, type });
+        resolvedFiles.push({ path: filePath });
       }
 
-      // Try to find running server
-      const server = await discoverServer();
-
-      if (server) {
-        // Send files to running server
-        for (const file of resolvedFiles) {
-          try {
-            const res = await fetch(
-              `http://127.0.0.1:${server.port}/api/documents`,
-              {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({ path: file.path }),
-              },
-            );
-
-            if (!res.ok) {
-              const data = await res.json();
-              console.error(`error: failed to add ${file.path}: ${data.error}`);
-              process.exit(1);
-            }
-
-            const data = await res.json();
-            if (data.status === "added") {
-              console.log(`Added: ${data.fileName} (${data.type})`);
-            } else {
-              console.log(`Present: ${data.fileName} (${data.type})`);
-            }
-          } catch (err) {
-            console.error(
-              "error: failed to connect to server:",
-              err instanceof Error ? err.message : err,
-            );
-            process.exit(1);
-          }
-        }
-
-        console.log(`\nServer: http://127.0.0.1:${server.port}`);
-        return;
-      }
-
-      // No running server — start one
-      console.log("No running server found, starting new one...\n");
-
       const files = resolvedFiles.map((f) => ({
-        type: f.type,
         filePath: f.path,
       }));
 
       const preferredPort = Number.parseInt(options.port, 10);
       try {
-        const { url, server: newServer } = await startServer({
+        const target = await getServerTarget(
           files,
-          port: preferredPort,
-          host: options.host,
-        });
+          preferredPort,
+          options.host,
+        );
 
-        const fileList = files.map((f) => `  ${f.filePath} (${f.type})`);
+        if (target.kind === "existing") {
+          await attachFiles(
+            { port: target.port, pid: process.pid },
+            resolvedFiles,
+          );
+          console.log(`\nServer: ${target.url}`);
+          return;
+        }
+
+        const fileList = files.map((f) => `  ${f.filePath}`);
         console.log(`
 readit - Document Review Tool
 
   ${files.length === 1 ? "File:" : "Files:"}
 ${fileList.join("\n")}
-  URL:  ${url}
+  URL:  ${target.url}
 
   Server running. Close browser tab to stop.
   Press Ctrl+C to force stop.
 `);
 
-        open(url);
+        open(target.url);
 
         process.on("SIGINT", async () => {
           console.log("\n\nShutting down...");
-          newServer.stop();
+          target.server?.stop();
           await removeServerInfo();
           process.exit(0);
         });

package/src/components/ActionsMenu.tsx

@@ -1,17 +1,13 @@
 import {
-  BotMessageSquare,
+  ClipboardCopy,
   FileDown,
   FileText,
-  Maximize2,
-  Minimize2,
   MoreHorizontal,
   RefreshCw,
   Settings,
-  TextQuote,
 } from "lucide-react";
 import { useState } from "react";
-import { useCommentContext } from "../contexts/CommentContext";
-import { useLayoutContext } from "../contexts/LayoutContext";
+import { useCommentData } from "../contexts/CommentContext";
 import { useLocale } from "../contexts/LocaleContext";
 import { RawModal } from "./RawModal";
 import { SettingsModal } from "./SettingsModal";
@@ -26,19 +22,16 @@ import {
 
 interface ActionsMenuProps {
   onCopyAll: () => void;
-  onCopyAllRaw: () => void;
   onExportJson: () => void;
   onReload: () => void;
 }
 
 export function ActionsMenu({
   onCopyAll,
-  onCopyAllRaw,
   onExportJson,
   onReload,
 }: ActionsMenuProps) {
-  const { commentCount } = useCommentContext();
-  const { isFullscreen, toggleLayoutMode } = useLayoutContext();
+  const { commentCount } = useCommentData();
   const { t } = useLocale();
 
   const [menuOpen, setMenuOpen] = useState(false);
@@ -59,10 +52,6 @@ export function ActionsMenu({
           </Button>
         </DropdownMenuTrigger>
         <DropdownMenuContent align="end" className="min-w-[160px]">
-          <DropdownMenuItem onSelect={() => toggleLayoutMode()}>
-            {isFullscreen ? <Minimize2 /> : <Maximize2 />}
-            {isFullscreen ? t("actions.centered") : t("actions.fullscreen")}
-          </DropdownMenuItem>
           <DropdownMenuItem onSelect={() => setSettingsOpen(true)}>
             <Settings />
             {t("actions.settings")}
@@ -74,19 +63,9 @@ export function ActionsMenu({
           </DropdownMenuItem>
           {commentCount > 0 && (
             <>
-              <DropdownMenuItem
-                onSelect={() => onCopyAll()}
-                title={t("actions.copyAllAITitle")}
-              >
-                <BotMessageSquare />
-                {t("actions.copyAllAI")}
-              </DropdownMenuItem>
-              <DropdownMenuItem
-                onSelect={() => onCopyAllRaw()}
-                title={t("actions.copyAllRawTitle")}
-              >
-                <TextQuote />
-                {t("actions.copyAllRaw")}
+              <DropdownMenuItem onSelect={() => onCopyAll()}>
+                <ClipboardCopy />
+                {t("actions.copyAll")}
               </DropdownMenuItem>
               <DropdownMenuItem onSelect={() => onExportJson()}>
                 <FileDown />