hotsheet 0.18.1-beta.1 → 0.18.1-beta.3

package/dist/cli.js

@@ -15681,10 +15681,16 @@ __export(fsyncWrap_exports, {
   fsyncDbDir: () => fsyncDbDir,
   fsyncDbDirAsync: () => fsyncDbDirAsync,
   fsyncDir: () => fsyncDir,
-  fsyncDirAsync: () => fsyncDirAsync
+  fsyncDirAsync: () => fsyncDirAsync,
+  isUnsupportedFsyncError: () => isUnsupportedFsyncError
 });
 import { closeSync, existsSync as existsSync2, fsyncSync, openSync, promises as fsp2, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
 import { join as join2 } from "path";
+function isUnsupportedFsyncError(err, platform2 = process.platform) {
+  if (platform2 !== "win32") return false;
+  const code = err?.code;
+  return code !== void 0 && WIN32_UNFLUSHABLE_CODES.has(code);
+}
 function fsyncDir(path, fsyncFn = fsyncSync) {
   if (!existsSync2(path)) return { filesFlushed: 0, errors: 0 };
   const counters = { filesFlushed: 0, errors: 0 };
@@ -15719,8 +15725,10 @@ function walkAndFsync(dir, counters, fsyncFn) {
         fsyncFn(fd);
         counters.filesFlushed++;
       } catch (err) {
-        console.error(`[fsyncWrap] fsync ${p} failed:`, err);
-        counters.errors++;
+        if (!isUnsupportedFsyncError(err)) {
+          console.error(`[fsyncWrap] fsync ${p} failed:`, err);
+          counters.errors++;
+        }
       } finally {
         if (fd !== null) {
           try {
@@ -15769,8 +15777,10 @@ async function walkAndFsyncAsync(dir, counters, fsyncFn) {
         await fsyncFn(handle);
         counters.filesFlushed++;
       } catch (err) {
-        console.error(`[fsyncWrap] fsync ${p} failed:`, err);
-        counters.errors++;
+        if (!isUnsupportedFsyncError(err)) {
+          console.error(`[fsyncWrap] fsync ${p} failed:`, err);
+          counters.errors++;
+        }
       } finally {
         if (handle !== null) {
           try {
@@ -15785,10 +15795,11 @@ async function walkAndFsyncAsync(dir, counters, fsyncFn) {
 async function fsyncDbDirAsync(dataDir, fsyncFn = defaultAsyncFsyncFn) {
   return fsyncDirAsync(join2(dataDir, "db"), fsyncFn);
 }
-var defaultAsyncFsyncFn;
+var WIN32_UNFLUSHABLE_CODES, defaultAsyncFsyncFn;
 var init_fsyncWrap = __esm({
   "src/db/fsyncWrap.ts"() {
     "use strict";
+    WIN32_UNFLUSHABLE_CODES = /* @__PURE__ */ new Set(["EPERM", "EACCES", "ENOTSUP", "EINVAL"]);
     defaultAsyncFsyncFn = (handle) => handle.sync();
   }
 });
@@ -16361,13 +16372,40 @@ function clearRecoveryMarker(dataDir) {
   } catch {
   }
 }
+function pendingRecoveryPath(dataDir) {
+  return join7(dataDir, PENDING_RECOVERY_FILENAME);
+}
+function readPendingRecovery(dataDir) {
+  const path = pendingRecoveryPath(dataDir);
+  if (!existsSync6(path)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync3(path, "utf8"));
+    const result = external_exports.object({ attempts: external_exports.number() }).loose().safeParse(parsed);
+    return { attempts: result.success ? result.data.attempts : 1 };
+  } catch {
+    return { attempts: 1 };
+  }
+}
+function writePendingRecovery(dataDir, attempts) {
+  try {
+    writeFileSync2(pendingRecoveryPath(dataDir), JSON.stringify({ attempts, requestedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2));
+  } catch (writeErr) {
+    console.error("Could not write pending-recovery marker:", getErrorMessage(writeErr));
+  }
+}
+function clearPendingRecovery(dataDir) {
+  try {
+    rmSync2(pendingRecoveryPath(dataDir), { force: true });
+  } catch {
+  }
+}
 function runWithDataDir(dataDir, fn) {
   return requestDataDir.run(dataDir, fn);
 }
 function getDataDir() {
   const contextDataDir = requestDataDir.getStore();
   if (contextDataDir !== void 0) return contextDataDir;
-  if (defaultDbPath !== null) return defaultDbPath.replace(/\/db$/, "");
+  if (defaultDbPath !== null) return defaultDbPath.replace(/[\\/]db$/, "");
   throw new Error("Data directory not available. Call setDataDir() or use runWithDataDir().");
 }
 function setDataDir(dataDir) {
@@ -16439,6 +16477,8 @@ async function getDbForDir(dataDir) {
 async function getDbByPath(dbPath) {
   const existing = databases.get(dbPath);
   if (existing) return existing;
+  const recovered = await completeDeferredRecovery(dbPath);
+  if (recovered !== null) return recovered;
   let db;
   try {
     db = await openAndCacheDb(dbPath);
@@ -16461,8 +16501,16 @@ async function getDbByPath(dbPath) {
 }
 async function openAndCacheDb(dbPath, loadDataDir) {
   const db = createPglite(dbPath, loadDataDir !== void 0 ? { loadDataDir } : {});
-  await db.waitReady;
-  await initSchema(db);
+  try {
+    await db.waitReady;
+    await initSchema(db);
+  } catch (err) {
+    try {
+      await db.close();
+    } catch {
+    }
+    throw err;
+  }
   databases.set(dbPath, db);
   return db;
 }
@@ -16506,6 +16554,57 @@ async function tryRestoreFromSources(dbPath, dataDir) {
   }
   return null;
 }
+async function renameDirWithRetry(from, to) {
+  const maxAttempts = 5;
+  for (let attempt = 1; ; attempt++) {
+    try {
+      renameSync(from, to);
+      return;
+    } catch (renameErr) {
+      const code = renameErr.code;
+      const retryable = code === "EPERM" || code === "EBUSY" || code === "EACCES" || code === "ENOTEMPTY";
+      if (!retryable || attempt >= maxAttempts) throw renameErr;
+      await new Promise((resolve11) => setTimeout(resolve11, 100 * attempt));
+    }
+  }
+}
+async function completeDeferredRecovery(dbPath) {
+  const dataDir = dbPath.replace(/[\\/]db$/, "");
+  const pending = readPendingRecovery(dataDir);
+  if (pending === null) return null;
+  if (pending.attempts > MAX_DEFERRED_RECOVERY_ATTEMPTS) {
+    console.error(`[db] deferred recovery gave up after ${String(pending.attempts)} attempts; leaving the corrupt cluster for manual rescue.`);
+    clearPendingRecovery(dataDir);
+    return null;
+  }
+  if (!existsSync6(dbPath)) {
+    clearPendingRecovery(dataDir);
+    return null;
+  }
+  console.error("[db] completing deferred recovery \u2014 a prior launch could not move the corrupt database aside in-process (Windows handle lock)\u2026");
+  const corruptPath = `${dbPath}-corrupt-${Date.now()}`;
+  try {
+    await renameDirWithRetry(dbPath, corruptPath);
+  } catch (renameErr) {
+    writePendingRecovery(dataDir, pending.attempts + 1);
+    console.error(`[db] deferred recovery could not move db/ yet: ${getErrorMessage(renameErr)}`);
+    return null;
+  }
+  const restored = await tryRestoreFromSources(dbPath, dataDir);
+  writeRecoveryMarker(dataDir, {
+    corruptPath,
+    recoveredAt: (/* @__PURE__ */ new Date()).toISOString(),
+    errorMessage: "Database was corrupt and could not be preserved in-process (Windows handle lock); recovered on the next restart.",
+    ...restored !== null ? { restoredFrom: restored.label, restoredTicketCount: restored.ticketCount } : {}
+  });
+  clearPendingRecovery(dataDir);
+  if (restored !== null) {
+    console.error(`[db] deferred recovery restored from ${restored.label} (${String(restored.ticketCount)} tickets).`);
+    return restored.db;
+  }
+  console.error("[db] deferred recovery: no snapshot/backup could be loaded; starting with a fresh empty database.");
+  return null;
+}
 async function recoverFromOpenFailure(dbPath, err, forceRecover) {
   const message = getErrorMessage(err);
   const stack = err instanceof Error ? err.stack : void 0;
@@ -16530,16 +16629,18 @@ async function recoverFromOpenFailure(dbPath, err, forceRecover) {
       }
     }
   }
+  const dataDir = dbPath.replace(/[\\/]db$/, "");
   const corruptPath = `${dbPath}-corrupt-${Date.now()}`;
   console.error(`Database appears to be corrupt. Preserving as ${corruptPath} ...`);
   try {
-    renameSync(dbPath, corruptPath);
+    await renameDirWithRetry(dbPath, corruptPath);
   } catch (renameErr) {
     const renameMessage = getErrorMessage(renameErr);
-    console.error(`Could not preserve corrupt database directory: ${renameMessage}. Aborting auto-recreate to avoid data loss.`);
+    const prev = readPendingRecovery(dataDir);
+    writePendingRecovery(dataDir, (prev?.attempts ?? 0) + 1);
+    console.error(`Could not preserve corrupt database directory in-process: ${renameMessage}. Wrote a pending-recovery marker \u2014 Hot Sheet will auto-recover from the latest snapshot on the next restart.`);
     throw err;
   }
-  const dataDir = dbPath.replace(/[\\/]db$/, "");
   const restored = await tryRestoreFromSources(dbPath, dataDir);
   if (restored !== null) {
     writeRecoveryMarker(dataDir, {
@@ -16808,7 +16909,7 @@ async function migrateNoteIds(db) {
     }
   }
 }
-var SCHEMA_VERSION, RECOVERY_MARKER_FILENAME, databases, defaultDbPath, requestDataDir;
+var SCHEMA_VERSION, RECOVERY_MARKER_FILENAME, PENDING_RECOVERY_FILENAME, MAX_DEFERRED_RECOVERY_ATTEMPTS, databases, defaultDbPath, requestDataDir;
 var init_connection = __esm({
   "src/db/connection.ts"() {
     "use strict";
@@ -16817,6 +16918,8 @@ var init_connection = __esm({
     init_pglite();
     SCHEMA_VERSION = 4;
     RECOVERY_MARKER_FILENAME = ".db-recovery-marker.json";
+    PENDING_RECOVERY_FILENAME = ".db-pending-recovery.json";
+    MAX_DEFERRED_RECOVERY_ATTEMPTS = 3;
     databases = /* @__PURE__ */ new Map();
     defaultDbPath = null;
     requestDataDir = new AsyncLocalStorage();
@@ -20394,7 +20497,7 @@ function claudeAllowRulePattern(dataDir) {
   return `mcp__${getMcpServerKey(dataDir)}__*`;
 }
 function projectRoot(dataDir) {
-  return dataDir.replace(/\/\.hotsheet\/?$/, "");
+  return dataDir.replace(/[\\/]\.hotsheet[\\/]?$/, "");
 }
 function claudeDir(dataDir) {
   return join18(projectRoot(dataDir), ".claude");
@@ -20514,7 +20617,7 @@ function getChannelServerPath() {
   return { command: process.execPath, args: [distPath] };
 }
 function projectRoot2(dataDir) {
-  return dataDir.replace(/\/.hotsheet\/?$/, "");
+  return dataDir.replace(/[\\/]\.hotsheet[\\/]?$/, "");
 }
 function registerChannel(dataDir) {
   const root2 = projectRoot2(dataDir);
@@ -33197,18 +33300,18 @@ function isDemoMode() {
 import { execFileSync as execFileSync4 } from "child_process";
 var SHELL_PATH_TIMEOUT_MS = 2e3;
 function mergePaths(currentPath, shellPath) {
-  const sep = ":";
-  const existing = currentPath.split(sep).filter((s) => s !== "");
+  const sep2 = ":";
+  const existing = currentPath.split(sep2).filter((s) => s !== "");
   const existingSet = new Set(existing);
   const additions = [];
-  for (const dir of shellPath.split(sep)) {
+  for (const dir of shellPath.split(sep2)) {
     const trimmed = dir.trim();
     if (trimmed === "" || existingSet.has(trimmed)) continue;
     existingSet.add(trimmed);
     additions.push(trimmed);
   }
   if (additions.length === 0) return currentPath;
-  return [...additions, ...existing].join(sep);
+  return [...additions, ...existing].join(sep2);
 }
 function readLoginShellPath(execOverride) {
   const shell = process.env.SHELL;
@@ -33280,7 +33383,7 @@ init_helpers();
 init_notify();
 import { existsSync as existsSync19, mkdirSync as mkdirSync11, readFileSync as readFileSync14, rmSync as rmSync7, writeFileSync as writeFileSync13 } from "fs";
 import { Hono as Hono2 } from "hono";
-import { basename as basename3, extname, join as join26, resolve as resolve7 } from "path";
+import { basename as basename3, extname, join as join26, resolve as resolve7, sep } from "path";
 var attachmentRoutes = new Hono2();
 attachmentRoutes.post("/tickets/:id/attachments", async (c) => {
   const id = parseIntParam(c, "id");
@@ -33367,7 +33470,7 @@ attachmentRoutes.get("/attachments/file/*", (c) => {
   const dataDir = c.get("dataDir");
   const attachDir = resolve7(join26(dataDir, "attachments"));
   const fullPath = resolve7(join26(attachDir, filePath));
-  if (!fullPath.startsWith(attachDir + "/") && fullPath !== attachDir) {
+  if (!fullPath.startsWith(attachDir + sep) && fullPath !== attachDir) {
     return c.json({ error: "Invalid path" }, 403);
   }
   if (!existsSync19(fullPath)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hotsheet",
-  "version": "0.18.1-beta.1",
+  "version": "0.18.1-beta.3",
   "description": "A lightweight local project management tool. Create, categorize, and prioritize tickets with a fast bullet-list interface, then export an Up Next worklist for AI tools.",
   "type": "module",
   "license": "MIT",
@@ -30,7 +30,7 @@
   "scripts": {
     "dev": "npm run build:client && npm run build:plugins && tsx --tsconfig tsconfig.json src/cli.ts --replace",
     "build": "tsup",
-    "build:client": "mkdir -p dist/client/assets && cp src/client/assets/* dist/client/assets/ && npx esbuild src/client/app.tsx --bundle --format=iife --outfile=dist/client/app.global.js --target=es2020 --jsx=automatic --jsx-import-source=#jsx --alias:#jsx/jsx-runtime=./src/jsx-runtime.ts --define:__PLUGINS_ENABLED__=${PLUGINS_ENABLED:-true} --sourcemap && npx sass src/client/styles.scss dist/client/styles.css --style compressed --no-source-map && cat node_modules/@xterm/xterm/css/xterm.css >> dist/client/styles.css",
+    "build:client": "node scripts/build-client.mjs",
     "build:plugins": "for d in plugins/*/; do if [ -f \"$d/manifest.json\" ]; then name=$(basename $d); mkdir -p dist/plugins/$name && npx esbuild $d/src/index.ts --bundle --format=esm --outfile=dist/plugins/$name/index.js --platform=node --target=node20 && cp $d/manifest.json dist/plugins/$name/; fi; done",
     "test": "vitest run --coverage",
     "test:watch": "vitest",