@xenonbyte/da-vinci-workflow 0.1.25 → 0.2.1

package/lib/pencil-lock.js

@@ -1,43 +1,230 @@
 const fs = require("fs");
 const os = require("os");
 const path = require("path");
+const { isPlainObject, pathExists, sleepSync, writeFileExclusiveAtomic } = require("./utils");
 
-const SLEEP_ARRAY = new Int32Array(new SharedArrayBuffer(4));
+const STALE_SESSION_GRACE_MS = 30 * 1000;
+const ACTIVE_SESSION_STALE_MS = 12 * 60 * 60 * 1000;
+const STALE_RECOVERY_LOCK_GRACE_MS = 15 * 1000;
+let warnedSleepFailure = false;
 
 function getLockPath(options = {}) {
   const homeDir = options.homeDir ? path.resolve(options.homeDir) : os.homedir();
   return path.join(homeDir, ".da-vinci", "pencil-mcp.lock");
 }
 
+function getRecoveryLockPath(lockPath) {
+  return `${lockPath}.recover`;
+}
+
 function sleepMs(durationMs) {
   const timeoutMs = Math.max(0, Number(durationMs) || 0);
   if (timeoutMs === 0) {
     return;
   }
 
-  // Use Atomics.wait to block without burning CPU while preserving the current
-  // synchronous CLI call graph and lock semantics.
-  Atomics.wait(SLEEP_ARRAY, 0, 0, timeoutMs);
+  try {
+    sleepSync(timeoutMs, "perform synchronous Pencil lock wait");
+  } catch (error) {
+    if (!warnedSleepFailure) {
+      warnedSleepFailure = true;
+      process.emitWarning(error.message || String(error));
+    }
+    throw error;
+  }
+}
+
+function buildLockHolderLabel(lock) {
+  if (!lock || lock.__invalid) {
+    return "unknown holder";
+  }
+
+  return `${lock.projectPath} (owner: ${lock.owner || "unknown"}, pid: ${lock.pid || "unknown"})`;
+}
+
+function hasWaitTimeRemaining(deadline) {
+  return Date.now() < deadline;
+}
+
+function sleepBeforeRetry(deadline, pollIntervalMs) {
+  const remainingMs = Math.max(0, deadline - Date.now());
+  if (remainingMs === 0) {
+    return false;
+  }
+
+  sleepMs(Math.min(pollIntervalMs, remainingMs));
+  return true;
 }
 
 function readLock(lockPath) {
   const resolvedLockPath = path.resolve(lockPath);
-  if (!fs.existsSync(resolvedLockPath)) {
+  if (!pathExists(resolvedLockPath)) {
     return null;
   }
 
-  return JSON.parse(fs.readFileSync(resolvedLockPath, "utf8"));
+  const raw = fs.readFileSync(resolvedLockPath, "utf8");
+  try {
+    const parsed = JSON.parse(raw);
+    if (!isPlainObject(parsed)) {
+      return {
+        __invalid: true,
+        parseError: "Lock payload is not a JSON object.",
+        raw
+      };
+    }
+    return parsed;
+  } catch (error) {
+    return {
+      __invalid: true,
+      parseError: error && error.message ? error.message : String(error),
+      raw
+    };
+  }
 }
 
 function writeLock(lockPath, payload) {
   const resolvedLockPath = path.resolve(lockPath);
-  fs.mkdirSync(path.dirname(resolvedLockPath), { recursive: true });
-  const handle = fs.openSync(resolvedLockPath, "wx");
+  writeFileExclusiveAtomic(resolvedLockPath, JSON.stringify(payload, null, 2) + "\n");
+}
+
+function getProjectSessionStatePath(projectPath) {
+  const resolvedProjectPath = path.resolve(String(projectPath || ""));
+  return path.join(resolvedProjectPath, ".da-vinci", "state", "pencil-session.json");
+}
+
+function readProjectSession(projectPath) {
+  const sessionStatePath = getProjectSessionStatePath(projectPath);
+  if (!pathExists(sessionStatePath)) {
+    return null;
+  }
 
   try {
-    fs.writeFileSync(handle, JSON.stringify(payload, null, 2) + "\n", "utf8");
+    return JSON.parse(fs.readFileSync(sessionStatePath, "utf8"));
+  } catch (error) {
+    return null;
+  }
+}
+
+function hasActiveProjectSession(projectPath) {
+  const session = readProjectSession(projectPath);
+  return Boolean(session) && session.status === "active";
+}
+
+function hasFreshActiveProjectSession(projectPath) {
+  const session = readProjectSession(projectPath);
+  if (!session || session.status !== "active") {
+    return false;
+  }
+
+  const activityAtMs = Date.parse(String(session.lastActivityAt || session.beganAt || ""));
+  if (!Number.isFinite(activityAtMs)) {
+    return false;
+  }
+
+  return Date.now() - activityAtMs < ACTIVE_SESSION_STALE_MS;
+}
+
+function getProcessLiveness(pidValue) {
+  const pid = Number(pidValue);
+  if (!Number.isInteger(pid) || pid <= 0) {
+    return null;
+  }
+
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    if (error && error.code === "ESRCH") {
+      return false;
+    }
+    if (error && error.code === "EPERM") {
+      return true;
+    }
+    return null;
+  }
+}
+
+function isStaleLock(lock) {
+  if (!lock || lock.__invalid) {
+    return true;
+  }
+  if (typeof lock.projectPath !== "string" || !lock.projectPath.trim()) {
+    return true;
+  }
+
+  if (hasFreshActiveProjectSession(lock.projectPath)) {
+    return false;
+  }
+
+  const ownerAlive = getProcessLiveness(lock.pid);
+  if (ownerAlive === true) {
+    return false;
+  }
+
+  const acquiredAtMs = Date.parse(String(lock.acquiredAt || ""));
+  if (Number.isFinite(acquiredAtMs) && Date.now() - acquiredAtMs < STALE_SESSION_GRACE_MS) {
+    return false;
+  }
+
+  return true;
+}
+
+function isStaleRecoveryLock(lock) {
+  if (!lock || lock.__invalid) {
+    return true;
+  }
+  const acquiredAtMs = Date.parse(String(lock.acquiredAt || ""));
+  if (!Number.isFinite(acquiredAtMs)) {
+    return true;
+  }
+  return Date.now() - acquiredAtMs >= STALE_RECOVERY_LOCK_GRACE_MS;
+}
+
+function recoverStaleLock(lockPath, payload) {
+  const recoveryLockPath = getRecoveryLockPath(lockPath);
+  const recoveryPayload = {
+    schema: 1,
+    owner: payload.owner,
+    projectPath: payload.projectPath,
+    pid: process.pid,
+    acquiredAt: new Date().toISOString()
+  };
+
+  try {
+    writeLock(recoveryLockPath, recoveryPayload);
+  } catch (error) {
+    if (error.code !== "EEXIST") {
+      throw error;
+    }
+    const recoveryLock = readLock(recoveryLockPath);
+    if (recoveryLock && isStaleRecoveryLock(recoveryLock)) {
+      fs.rmSync(recoveryLockPath, { force: true });
+      return {
+        recovered: false,
+        busy: false
+      };
+    }
+    return {
+      recovered: false,
+      busy: true
+    };
+  }
+
+  try {
+    const latest = readLock(lockPath);
+    if (!latest || !isStaleLock(latest)) {
+      return {
+        recovered: false,
+        busy: false
+      };
+    }
+    fs.rmSync(lockPath, { force: true });
+    return {
+      recovered: true,
+      busy: false
+    };
   } finally {
-    fs.closeSync(handle);
+    fs.rmSync(recoveryLockPath, { force: true });
   }
 }
 
@@ -55,6 +242,7 @@ function acquirePencilLock(options = {}) {
     pid: process.pid,
     acquiredAt: new Date().toISOString()
   };
+  let staleLockRecovered = false;
 
   while (true) {
     try {
@@ -63,6 +251,7 @@ function acquirePencilLock(options = {}) {
         lockPath,
         acquired: true,
         alreadyHeld: false,
+        staleLockRecovered,
         lock: payload
       };
     } catch (error) {
@@ -71,23 +260,28 @@ function acquirePencilLock(options = {}) {
       }
 
       const current = readLock(lockPath);
-      if (current && current.projectPath === projectPath) {
-        return {
-          lockPath,
-          acquired: true,
-          alreadyHeld: true,
-          lock: current
-        };
+      if (current && isStaleLock(current)) {
+        const recovery = recoverStaleLock(lockPath, payload);
+        if (recovery.recovered) {
+          staleLockRecovered = true;
+          continue;
+        }
+        if (recovery.busy) {
+          if (!hasWaitTimeRemaining(deadline)) {
+            throw new Error(
+              `Pencil MCP lock recovery is already in progress while the lock is still held by ${buildLockHolderLabel(current)}.`
+            );
+          }
+          sleepBeforeRetry(deadline, pollIntervalMs);
+          continue;
+        }
+        continue;
       }
-
-      if (Date.now() >= deadline) {
-        const holder = current
-          ? `${current.projectPath} (owner: ${current.owner || "unknown"}, pid: ${current.pid || "unknown"})`
-          : "unknown holder";
-        throw new Error(`Pencil MCP lock is already held by ${holder}.`);
+      if (!hasWaitTimeRemaining(deadline)) {
+        throw new Error(`Pencil MCP lock is already held by ${buildLockHolderLabel(current)}.`);
       }
 
-      sleepMs(pollIntervalMs);
+      sleepBeforeRetry(deadline, pollIntervalMs);
     }
   }
 }
@@ -106,6 +300,17 @@ function releasePencilLock(options = {}) {
     };
   }
 
+  if (current.__invalid) {
+    fs.rmSync(lockPath, { force: true });
+    return {
+      lockPath,
+      released: true,
+      hadLock: true,
+      lock: current,
+      recoveredInvalidLock: true
+    };
+  }
+
   if (projectPath && current.projectPath !== projectPath && !options.force) {
     throw new Error(
       `Pencil MCP lock is held by a different project: ${current.projectPath}`
@@ -131,9 +336,16 @@ function getPencilLockStatus(options = {}) {
 
 module.exports = {
   getLockPath,
+  getProjectSessionStatePath,
   readLock,
   sleepMs,
+  hasActiveProjectSession,
+  hasFreshActiveProjectSession,
+  isStaleLock,
+  getProcessLiveness,
   acquirePencilLock,
   releasePencilLock,
-  getPencilLockStatus
+  getPencilLockStatus,
+  STALE_SESSION_GRACE_MS,
+  ACTIVE_SESSION_STALE_MS
 };

package/lib/pencil-preflight.js

@@ -1,6 +1,7 @@
 const fs = require("fs");
 const path = require("path");
 const vm = require("vm");
+const { isPlainObject } = require("./utils");
 
 const PASS = "PASS";
 const WARN = "WARN";
@@ -73,10 +74,6 @@ function isValidNumericOrVariable(value) {
   return (typeof value === "number" && Number.isFinite(value)) || isVariableReference(value);
 }
 
-function isPlainObject(value) {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-
 function normalizeLines(operations) {
   return String(operations || "")
     .split(/\r?\n/)
@@ -87,22 +84,62 @@ function normalizeLines(operations) {
 function stripQuotedLiterals(sourceText) {
   const source = String(sourceText || "");
   let result = "";
-  let quote = null;
+  let state = "code";
   let escaped = false;
 
   for (let index = 0; index < source.length; index += 1) {
     const char = source[index];
+    const next = source[index + 1];
 
-    if (!quote) {
-      if (char === "'" || char === '"' || char === "`") {
-        quote = char;
+    if (state === "line-comment") {
+      if (char === "\n") {
+        state = "code";
+        result += "\n";
+      } else {
         result += " ";
+      }
+      continue;
+    }
+
+    if (state === "block-comment") {
+      if (char === "*" && next === "/") {
+        state = "code";
+        result += "  ";
+        index += 1;
+      } else if (char === "\n") {
+        result += "\n";
       } else {
-        result += char;
+        result += " ";
       }
       continue;
     }
 
+    if (state === "code") {
+      if (char === "/" && next === "/") {
+        state = "line-comment";
+        result += "  ";
+        index += 1;
+        continue;
+      }
+
+      if (char === "/" && next === "*") {
+        state = "block-comment";
+        result += "  ";
+        index += 1;
+        continue;
+      }
+
+      if (char === "'" || char === '"' || char === "`") {
+        state = char;
+        escaped = false;
+        result += " ";
+        continue;
+      }
+
+      result += char;
+      continue;
+    }
+
     if (escaped) {
       escaped = false;
       result += " ";
@@ -115,19 +152,201 @@ function stripQuotedLiterals(sourceText) {
       continue;
     }
 
-    if (char === quote) {
-      quote = null;
+    if (char === state) {
+      state = "code";
       result += " ";
       continue;
     }
 
-    result += " ";
+    result += char === "\n" ? "\n" : " ";
   }
 
   return result;
 }
 
+function isIdentifierStart(char) {
+  return /^[A-Za-z_$]$/.test(char);
+}
+
+function isIdentifierPart(char) {
+  return /^[A-Za-z0-9_$]$/.test(char);
+}
+
+function skipWhitespace(text, startIndex) {
+  let index = startIndex;
+  while (index < text.length && /\s/.test(text[index])) {
+    index += 1;
+  }
+  return index;
+}
+
+function validateOperationLineShape(line) {
+  const source = String(line || "");
+  const allowedCallees = new Set(["I", "C", "U", "R", "M", "D", "G"]);
+  let index = skipWhitespace(source, 0);
+  const expressionStart = index;
+
+  // Optional binding assignment: `name = <op-call>(...)`
+  if (index < source.length && isIdentifierStart(source[index])) {
+    index += 1;
+    while (index < source.length && isIdentifierPart(source[index])) {
+      index += 1;
+    }
+    const afterIdentifier = skipWhitespace(source, index);
+    if (source[afterIdentifier] === "=") {
+      index = skipWhitespace(source, afterIdentifier + 1);
+    } else {
+      index = expressionStart;
+    }
+  }
+
+  const callee = source[index];
+  if (!allowedCallees.has(callee)) {
+    return {
+      valid: false,
+      message:
+        "Each non-empty line must be a single declarative operation call (`I/C/U/R/M/D/G`) with optional binding assignment."
+    };
+  }
+  index += 1;
+  index = skipWhitespace(source, index);
+  if (source[index] !== "(") {
+    return {
+      valid: false,
+      message:
+        "Each non-empty line must be a single declarative operation call (`I/C/U/R/M/D/G`) with optional binding assignment."
+    };
+  }
+
+  let depth = 0;
+  let state = "code";
+  let escaped = false;
+  let endIndex = -1;
+
+  for (; index < source.length; index += 1) {
+    const char = source[index];
+    const next = source[index + 1];
+
+    if (state === "line-comment") {
+      if (char === "\n") {
+        state = "code";
+      }
+      continue;
+    }
+
+    if (state === "block-comment") {
+      if (char === "*" && next === "/") {
+        state = "code";
+        index += 1;
+      }
+      continue;
+    }
+
+    if (state === "code") {
+      if (char === "/" && next === "/") {
+        state = "line-comment";
+        index += 1;
+        continue;
+      }
+
+      if (char === "/" && next === "*") {
+        state = "block-comment";
+        index += 1;
+        continue;
+      }
+
+      if (char === "'" || char === '"') {
+        state = char;
+        escaped = false;
+        continue;
+      }
+
+      if (char === "`") {
+        return {
+          valid: false,
+          message:
+            "Template literals are not allowed in Pencil operations. Use single or double quoted strings."
+        };
+      }
+
+      if (char === "(") {
+        depth += 1;
+        continue;
+      }
+
+      if (char === ")") {
+        depth -= 1;
+        if (depth < 0) {
+          return {
+            valid: false,
+            message:
+              "Each non-empty line must be a single declarative operation call (`I/C/U/R/M/D/G`) with optional binding assignment."
+          };
+        }
+
+        if (depth === 0) {
+          endIndex = index + 1;
+          break;
+        }
+      }
+
+      continue;
+    }
+
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+
+    if (char === "\\") {
+      escaped = true;
+      continue;
+    }
+
+    if (char === state) {
+      state = "code";
+    }
+  }
+
+  if (endIndex < 0 || depth !== 0) {
+    return {
+      valid: false,
+      message:
+        "Each non-empty line must be a single declarative operation call (`I/C/U/R/M/D/G`) with optional binding assignment."
+    };
+  }
+
+  const trailing = source.slice(endIndex).trim();
+  if (trailing.length > 0) {
+    return {
+      valid: false,
+      message:
+        "Each non-empty line must contain exactly one operation expression with no trailing statements."
+    };
+  }
+
+  return { valid: true, message: "" };
+}
+
+function collectLineShapeIssues(lines, issues) {
+  lines.forEach((line, index) => {
+    const result = validateOperationLineShape(line);
+    if (!result.valid) {
+      issues.push(
+        createIssue(
+          "FAIL",
+          `Line ${index + 1}: ${result.message}`
+        )
+      );
+    }
+  });
+}
+
 function detectUnsafeOperationSource(operations) {
+  if (String(operations || "").includes("`")) {
+    return "Template literals are not allowed in Pencil operations. Use single or double quoted strings.";
+  }
+
   const sanitizedSource = stripQuotedLiterals(operations);
   for (const rule of UNSAFE_OPERATION_PATTERNS) {
     if (rule.pattern.test(sanitizedSource)) {
@@ -485,6 +704,8 @@ function preflightPencilBatch(operations, options = {}) {
     );
   }
 
+  collectLineShapeIssues(nonEmptyLines, issues);
+
   const unsafeSourceMessage = detectUnsafeOperationSource(normalizedOps);
   if (unsafeSourceMessage) {
     issues.push(createIssue("FAIL", unsafeSourceMessage));