@khoavu882/doflow 2.0.0-beta.3 → 2.0.0-beta.4

package/src/state/{run-lock.ts → run-lock.js}

@@ -25,40 +25,40 @@ const LOCK_FILE = 'run.lock';
 const CLAIM_PREFIX = `${LOCK_FILE}.claim.`;
 const TEMP_NAME = /^\.run\.lock\.([0-9a-f]{32})\.tmp$/;
 
-function loadVersion(): string {
+function loadVersion()         {
   try { return require('../../package.json').version; } catch { return '0.0.0-installed'; }
 }
 const DOFLOW_VERSION = loadVersion();
 
 /** Holds of this process, by resolved scope root: a nested acquisition counts instead of waiting on itself. */
-const held = new Map<string, { count: number, handle: any }>();
+const held = new Map                                        ();
 
-function runLockPath(scopeRoot: string): string { return path.join(path.resolve(scopeRoot), '.doflow', 'state', LOCK_FILE); }
+function runLockPath(scopeRoot        )         { return path.join(path.resolve(scopeRoot), '.doflow', 'state', LOCK_FILE); }
 
-function atomicsSleep(ms: number): void {
+function atomicsSleep(ms        )       {
   Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
 }
 
 /** Alive when signal 0 reaches it, or it exists but belongs to someone else (EPERM). */
-function defaultIsAlive(pid: any): boolean {
+function defaultIsAlive(pid     )          {
   if (!Number.isInteger(pid) || pid <= 0) return false;
   try {
     process.kill(pid, 0);
     return true;
-  } catch (err: any) {
+  } catch (err     ) {
     return err.code === 'EPERM';
   }
 }
 
-function scopeLabel({ scope, scopeRoot }: { scope: string, scopeRoot: string }): string {
+function scopeLabel({ scope, scopeRoot }                                      )         {
   return scope === 'global' ? `global scope (${scopeRoot})` : `project ${scopeRoot}`;
 }
 
-function holderLabel(holder: any): string {
+function holderLabel(holder     )         {
   return holder ? `pid ${holder.pid}, ${holder.command}, started ${holder.startedAt}` : 'holder unknown';
 }
 
-const STALE_REASONS: Record<string, string> = Object.freeze({ 'not-running': 'that process is not running', expired: 'it is older than 10 minutes' });
+const STALE_REASONS                         = Object.freeze({ 'not-running': 'that process is not running', expired: 'it is older than 10 minutes' });
 
 /**
  * The one text of every run-lock line, so the CLI prints exactly these.
@@ -66,7 +66,7 @@ const STALE_REASONS: Record<string, string> = Object.freeze({ 'not-running': 'th
  * @param {{scope: string, scopeRoot: string, holder?: Object|null, waitMs?: number, reason?: string,
  *   lockPath?: string, waitedMs?: number, code?: string}} details
  */
-function formatRunLockMessage(kind: string, details: any): string {
+function formatRunLockMessage(kind        , details     )         {
   const where = scopeLabel(details);
   switch (kind) {
     case 'waiting':
@@ -85,7 +85,7 @@ function formatRunLockMessage(kind: string, details: any): string {
 }
 
 class RunLockError extends Error {
-  constructor(details: any) {
+  constructor(details     ) {
     super(formatRunLockMessage('error', details));
     this.name = 'RunLockError';
     Object.assign(this, { code: details.code, lockPath: details.lockPath, scopeRoot: details.scopeRoot });
@@ -93,7 +93,7 @@ class RunLockError extends Error {
 }
 
 class RunLockTimeoutError extends Error {
-  constructor(details: any) {
+  constructor(details     ) {
     super(formatRunLockMessage('timeout', details));
     this.name = 'RunLockTimeoutError';
     Object.assign(this, { holder: details.holder, lockPath: details.lockPath, scopeRoot: details.scopeRoot, waitedMs: details.waitedMs });
@@ -101,14 +101,14 @@ class RunLockTimeoutError extends Error {
 }
 
 class RunLockLostError extends Error {
-  constructor(details: any) {
+  constructor(details     ) {
     super(formatRunLockMessage('lost', details));
     this.name = 'RunLockLostError';
     Object.assign(this, { lockPath: details.lockPath, scopeRoot: details.scopeRoot });
   }
 }
 
-function isIdentified(record: any): boolean {
+function isIdentified(record     )          {
   return Boolean(record) && typeof record.token === 'string' && Number.isInteger(record.pid) && typeof record.hostname === 'string';
 }
 
@@ -117,15 +117,15 @@ function isIdentified(record: any): boolean {
  * replaced between the two calls can never pair one instance's record with another's age.
  * @returns {{record: Object|null, stat: fs.Stats, key: string}|null} null when there is no lock
  */
-function readLockFile(fsImpl: any, lockPath: string): { record: any, stat: any, key: string } | null {
-  let fd: any;
+function readLockFile(fsImpl     , lockPath        )                                                 {
+  let fd     ;
   try {
     fd = fsImpl.openSync(lockPath, 'r');
-  } catch (err: any) {
+  } catch (err     ) {
     if (err.code !== 'ENOENT') throw err;
     // A dangling symlink opens as ENOENT yet blocks link(); judge it by its own lstat.
     let stat;
-    try { stat = fsImpl.lstatSync(lockPath); } catch (lstatErr: any) {
+    try { stat = fsImpl.lstatSync(lockPath); } catch (lstatErr     ) {
       if (lstatErr.code === 'ENOENT') return null;
       throw lstatErr;
     }
@@ -142,12 +142,12 @@ function readLockFile(fsImpl: any, lockPath: string): { record: any, stat: any,
   }
 }
 
-function instanceKey(record: any, stat: any): string {
+function instanceKey(record     , stat     )         {
   return record ? record.token : `u-${stat.dev}-${stat.ino}-${Math.floor(stat.mtimeMs)}`;
 }
 
 /** @returns {null|'not-running'|'expired'} */
-function staleReason(found: any, { token, hostname, isAlive, now, staleMs }: any): 'not-running' | 'expired' | null {
+function staleReason(found     , { token, hostname, isAlive, now, staleMs }     )                                   {
   const { record, stat } = found;
   if (record && record.token === token) return null;
   if (record && record.hostname === hostname && (record.pid === process.pid || !isAlive(record.pid))) return 'not-running';
@@ -155,16 +155,16 @@ function staleReason(found: any, { token, hostname, isAlive, now, staleMs }: any
   return null;
 }
 
-function unlinkQuietly(fsImpl: any, file: string): void {
+function unlinkQuietly(fsImpl     , file        )       {
   try { fsImpl.unlinkSync(file); } catch { /* already gone, or the stale rule clears it later */ }
 }
 
-function readRaw(fsImpl: any, file: string): string | null {
+function readRaw(fsImpl     , file        )                {
   try { return fsImpl.readFileSync(file, 'utf8'); } catch { return null; }
 }
 
 /** A claim left by a run that died while clearing: its process is gone, or it is older than claimStaleMs. */
-function isOrphanClaim(fsImpl: any, claimPath: string, { hostname, isAlive, now, claimStaleMs }: any): boolean {
+function isOrphanClaim(fsImpl     , claimPath        , { hostname, isAlive, now, claimStaleMs }     )          {
   let stat;
   try { stat = fsImpl.statSync(claimPath); } catch { return false; }
   if (now() - stat.mtimeMs > claimStaleMs) return true;
@@ -174,12 +174,12 @@ function isOrphanClaim(fsImpl: any, claimPath: string, { hostname, isAlive, now,
 }
 
 /** Creates the claim for one lock instance. @returns {boolean} true when this run now holds it */
-function createClaim(fsImpl: any, claimPath: string, { token, hostname, target }: any): boolean {
+function createClaim(fsImpl     , claimPath        , { token, hostname, target }     )          {
   const body = `${JSON.stringify({ version: RECORD_VERSION, token, pid: process.pid, hostname, at: new Date().toISOString(), target })}\n`;
   try {
     fsImpl.writeFileSync(claimPath, body, { flag: 'wx' });
     return true;
-  } catch (err: any) {
+  } catch (err     ) {
     if (err.code === 'EEXIST') return false;
     throw err;
   }
@@ -191,7 +191,7 @@ function createClaim(fsImpl: any, claimPath: string, { token, hostname, target }
  * back when what was moved is not what was judged, so a fresh claim is never deleted by mistake.
  * @returns {boolean}
  */
-function claimInstance(fsImpl: any, stateDir: string, key: string, options: any): boolean {
+function claimInstance(fsImpl     , stateDir        , key        , options     )          {
   const claimPath = path.join(stateDir, `${CLAIM_PREFIX}${key}`);
   for (let attempt = 0; attempt < 2; attempt += 1) {
     if (createClaim(fsImpl, claimPath, { token: options.token, hostname: options.hostname, target: key })) return true;
@@ -213,7 +213,7 @@ function claimInstance(fsImpl: any, stateDir: string, key: string, options: any)
  * Removes the stale instance `found` under its claim.
  * @returns {'cleared'|'aborted'}
  */
-function takeOver(fsImpl: any, stateDir: string, lockPath: string, found: any, options: any): 'cleared' | 'aborted' {
+function takeOver(fsImpl     , stateDir        , lockPath        , found     , options     )                        {
   if (!claimInstance(fsImpl, stateDir, found.key, options)) return 'aborted';
   const claimPath = path.join(stateDir, `${CLAIM_PREFIX}${found.key}`);
   try {
@@ -222,7 +222,7 @@ function takeOver(fsImpl: any, stateDir: string, lockPath: string, found: any, o
     // Judged again under the claim: a holder whose checkpoint renewed the lock since the first
     // judgment is no longer stale, and its lock stays.
     if (!staleReason(current, options)) return 'aborted';
-    try { fsImpl.unlinkSync(lockPath); } catch (err: any) {
+    try { fsImpl.unlinkSync(lockPath); } catch (err     ) {
       if (err.code !== 'ENOENT') return 'aborted';
     }
     return 'cleared';
@@ -235,7 +235,7 @@ function takeOver(fsImpl: any, stateDir: string, lockPath: string, found: any, o
 
 /** Removes owner temp files left by runs that died while they waited, judged by the stale rule as
  * a lock would be: interrupting a waiting run is the one exit that never reaches its own cleanup. */
-function sweepOrphanTemps(fsImpl: any, stateDir: string, judge: any): void {
+function sweepOrphanTemps(fsImpl     , stateDir        , judge     )       {
   let names;
   try { names = fsImpl.readdirSync(stateDir); } catch { return; }
   for (const name of names) {
@@ -249,7 +249,7 @@ function sweepOrphanTemps(fsImpl: any, stateDir: string, judge: any): void {
 }
 
 /** Removes, innermost first, the directories an acquisition created, stopping at the first non-empty one. */
-function removeCreatedDirs(fsImpl: any, stateDir: string, firstCreated: any): void {
+function removeCreatedDirs(fsImpl     , stateDir        , firstCreated     )       {
   if (!firstCreated) return;
   const top = path.resolve(firstCreated);
   for (let dir = stateDir; ; dir = path.dirname(dir)) {
@@ -267,11 +267,11 @@ function removeCreatedDirs(fsImpl: any, stateDir: string, firstCreated: any): vo
  *   checkpoint: () => void, release: () => void}}
  * @throws {RunLockTimeoutError|RunLockError}
  */
-function acquireRunLock({ scopeRoot, scope, command }: { scopeRoot: string, scope: 'global' | 'project', command: string }, {
+function acquireRunLock({ scopeRoot, scope, command }                                                                     , {
   waitMs = 60_000, pollMs = 250, staleMs = 600_000, claimStaleMs = 30_000,
   now = Date.now, isAlive = defaultIsAlive, hostname = os.hostname(),
-  log = (line: string) => process.stderr.write(`${line}\n`), fsImpl = fs, sleep = atomicsSleep,
-}: any = {}): any {
+  log = (line        ) => process.stderr.write(`${line}\n`), fsImpl = fs, sleep = atomicsSleep,
+}      = {})      {
   const root = path.resolve(scopeRoot);
   const existing = held.get(root);
   if (existing) {
@@ -283,7 +283,7 @@ function acquireRunLock({ scopeRoot, scope, command }: { scopeRoot: string, scop
   const stateDir = path.dirname(lockPath);
   const token = crypto.randomBytes(16).toString('hex');
   const where = { scope, scopeRoot: root, lockPath };
-  const fail = (code: any) => new RunLockError({ ...where, code });
+  const fail = (code     ) => new RunLockError({ ...where, code });
 
   const tempPath = path.join(stateDir, `.${LOCK_FILE}.${token}.tmp`);
   const record = {
@@ -292,20 +292,20 @@ function acquireRunLock({ scopeRoot, scope, command }: { scopeRoot: string, scop
   };
   // A first-ever run that gives up removes the state directory it created. Doing so between this
   // run's mkdir and its temp write surfaces here as ENOENT, so both steps are tried once more.
-  let firstCreated: any;
+  let firstCreated     ;
   for (let attempt = 0; ; attempt += 1) {
-    try { firstCreated = fsImpl.mkdirSync(stateDir, { recursive: true }); } catch (err: any) { throw fail(err.code); }
+    try { firstCreated = fsImpl.mkdirSync(stateDir, { recursive: true }); } catch (err     ) { throw fail(err.code); }
     try {
       fsImpl.writeFileSync(tempPath, `${JSON.stringify(record)}\n`, { flag: 'wx' });
       break;
-    } catch (err: any) {
+    } catch (err     ) {
       if (err.code === 'ENOENT' && attempt === 0) continue;
       unlinkQuietly(fsImpl, tempPath);
       removeCreatedDirs(fsImpl, stateDir, firstCreated);
       throw fail(err.code);
     }
   }
-  const giveUp = (error: any) => {
+  const giveUp = (error     ) => {
     unlinkQuietly(fsImpl, tempPath);
     removeCreatedDirs(fsImpl, stateDir, firstCreated);
     return error;
@@ -314,16 +314,16 @@ function acquireRunLock({ scopeRoot, scope, command }: { scopeRoot: string, scop
   const judge = { token, hostname, isAlive, now, staleMs, claimStaleMs };
   sweepOrphanTemps(fsImpl, stateDir, judge);
   const start = now();
-  const cleared: any[] = [];
-  let lastHolder: any = null;
+  const cleared        = [];
+  let lastHolder      = null;
   let announced = false;
   while (now() - start < waitMs) {
     try {
       fsImpl.linkSync(tempPath, lockPath);
-    } catch (err: any) {
+    } catch (err     ) {
       if (err.code !== 'EEXIST') throw giveUp(fail(err.code));
       let found;
-      try { found = readLockFile(fsImpl, lockPath); } catch (readErr: any) { throw giveUp(fail(readErr.code)); }
+      try { found = readLockFile(fsImpl, lockPath); } catch (readErr     ) { throw giveUp(fail(readErr.code)); }
       if (!found) continue;
       lastHolder = found.record;
       const reason = staleReason(found, judge);
@@ -346,8 +346,8 @@ function acquireRunLock({ scopeRoot, scope, command }: { scopeRoot: string, scop
   throw giveUp(new RunLockTimeoutError({ ...where, holder: lastHolder, waitedMs: now() - start }));
 }
 
-function holdHandle({ fsImpl, root, stateDir, lockPath, token, hostname, firstCreated, where, now, waitedMs, cleared }: any): any {
-  const entry: { count: number, handle: any } = { count: 1, handle: null };
+function holdHandle({ fsImpl, root, stateDir, lockPath, token, hostname, firstCreated, where, now, waitedMs, cleared }     )      {
+  const entry                                 = { count: 1, handle: null };
   let released = false;
 
   const releaseNow = () => {