@logicseek/hello-cc 1.0.2 → 1.0.3

package/lib/web/native-sessions.mjs

@@ -1,5 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { isDeepStrictEqual } from 'node:util';
 import { CliError } from '../shared/errors.mjs';
 import { redactSecrets } from '../shared/redact.mjs';
 import { tx } from '../db/schema.mjs';
@@ -29,10 +30,17 @@ export function createNativeSessions({ sessions, sessionKey, connectWebProject,
     return redactSecrets({ code: error.code || 'NATIVE_RUNTIME_OFFLINE',
       message: error.message || 'Native runtime is disconnected' });
   }
+  function publishState(session, state) {
+    // Event cursors do not cover approvals, delivery receipts or capabilities.
+    // Compare the complete normalized state; validation and lease revocation
+    // still run on every read, including reads that need no new UI frame.
+    const changed = !isDeepStrictEqual(session.nativeState, state);
+    session.nativeState = state;
+    if (changed) broadcast(session, { type: 'native_state', state: session.nativeSnapshot() });
+  }
   function disconnect(session, error, retire = false) {
     session.status = 'disconnected';
-    session.nativeState = { ...session.nativeState, connected: false, status: 'disconnected', error: errorInfo(error) };
-    broadcast(session, { type: 'native_state', state: session.nativeSnapshot() });
+    publishState(session, { ...session.nativeState, connected: false, status: 'disconnected', error: errorInfo(error) });
     if (retire && !session.nativeRetired) {
       session.nativeRetired = true;
       closeSessionClients(session);
@@ -100,7 +108,7 @@ export function createNativeSessions({ sessions, sessionKey, connectWebProject,
     const turnId = value.snapshot.turnId || value.snapshot.activeTurnId || value.active_delivery?.turn_id || null;
     session.binding = binding;
     session.cwd = value.cwd;
-    session.nativeState = redactSecrets({ backend: 'native', connected: true, root: value.root,
+    const state = redactSecrets({ backend: 'native', connected: true, root: value.root,
       peer: value.peer, provider: value.provider, generation: value.generation, owner: value.owner,
       executorId: value.owner, sessionId: value.snapshot.sessionId || null, turnId,
       status: value.snapshot.status, cwd: value.cwd, capabilities: value.snapshot.capabilities || {}, pendingApprovals: value.snapshot.pendingApprovals || [],
@@ -111,7 +119,7 @@ export function createNativeSessions({ sessions, sessionKey, connectWebProject,
     session.status = CLOSED.has(value.snapshot.status) ? 'exited'
       : value.snapshot.status === 'disconnected' ? 'disconnected' : 'running';
     if (session.status === 'exited') session.exitedAt = now();
-    broadcast(session, { type: 'native_state', state: session.nativeSnapshot() });
+    publishState(session, state);
     return session.nativeSnapshot();
   }
   function makeSession(ctx, checked) {
@@ -261,8 +269,7 @@ export function createNativeSessions({ sessions, sessionKey, connectWebProject,
       if (action === 'respond') { await readState(session); current(session); }
       if (action === 'close') {
         session.status = 'exited'; session.exitedAt = now();
-        session.nativeState = { ...session.nativeState, connected: false, status: 'closed', closing: false };
-        broadcast(session, { type: 'native_state', state: session.nativeSnapshot() });
+        publishState(session, { ...session.nativeState, connected: false, status: 'closed', closing: false });
         closeSessionClients(session);
         session.actionTokens.clear();
       }

package/lib/web/peer-actions.mjs

@@ -3,10 +3,12 @@ import process from 'node:process';
 import { intOpt, positiveSafeIntOpt, required } from '../cli-args.mjs';
 import { CliError } from '../shared/errors.mjs';
 import {
+  findRequestedLock,
   lockLabel,
   lockScope,
   locksConflict,
-  scopedLockResource
+  scopedLockResource,
+  upsertRequestedLock
 } from '../core/coordination/locks.mjs';
 import { normalizeStateResources } from '../ui/state-render.mjs';
 import {
@@ -103,23 +105,31 @@ export function createWebPeerActions(deps = {}) {
   function webPeerRegister(projectCtx, peer, input = {}) {
     webMutationPeer(peer, input);
     const db = connect(projectCtx);
-    const row = {
-      id: peer,
-      kind: input.kind || 'other',
-      role: input.role || 'peer',
-      worktree: path.resolve(input.worktree || projectCtx.cwd),
-      branch: input.branch || detectBranch(projectCtx.cwd),
-      pid: intOpt(input, 'pid', process.ppid),
-      status: input.status || 'idle',
-      capabilities: Array.isArray(input.cap) ? input.cap.join(',') : (input.cap || input.capabilities || 'web')
-    };
     try {
+      const existing = db.prepare('SELECT * FROM peers WHERE id = ?').get(peer) || null;
+      const explicitPid = Object.hasOwn(input, 'pid');
+      const row = {
+        id: peer,
+        kind: input.kind || existing?.kind || 'other',
+        role: input.role || existing?.role || 'peer',
+        worktree: path.resolve(input.worktree || existing?.worktree || projectCtx.cwd),
+        branch: input.branch || existing?.branch || detectBranch(projectCtx.cwd),
+        pid: explicitPid ? intOpt(input, 'pid') : (existing?.pid ?? null),
+        ...(!explicitPid ? { processIdentity: existing ? {
+          pid: existing.pid,
+          startToken: existing.pid_start_token,
+          commandHash: existing.pid_command_hash
+        } : null } : {}),
+        status: input.status || existing?.status || 'idle',
+        capabilities: Array.isArray(input.cap) ? input.cap.join(',') :
+          (input.cap || input.capabilities || existing?.capabilities || 'web')
+      };
       upsertPeer(db, row);
       addEvent(db, 'peer.registered', peer, null, webAuditPayload(peer, input, row));
+      return { peer: row, summary: `registered ${row.id} (${row.kind}${row.role ? `, ${row.role}` : ''})` };
     } finally {
       db.close();
     }
-    return { peer: row, summary: `registered ${row.id} (${row.kind}${row.role ? `, ${row.role}` : ''})` };
   }
 
   function webPeerHeartbeat(projectCtx, peer, input = {}) {
@@ -294,21 +304,11 @@ export function createWebPeerActions(deps = {}) {
         }
         const existing = subject.locks.find((row) => row.resource === requested.resource) || null;
         const expiresAt = leaseDeadline(t, ttl);
-        db.prepare(`
-          INSERT INTO locks(resource, base_resource, scope, owner, task_id, reason, expires_at, created_at, ttl_sec)
-          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-          ON CONFLICT(resource) DO UPDATE SET
-            base_resource = excluded.base_resource,
-            scope = excluded.scope,
-            owner = excluded.owner,
-            task_id = excluded.task_id,
-            reason = excluded.reason,
-            expires_at = excluded.expires_at,
-            created_at = excluded.created_at,
-            ttl_sec = excluded.ttl_sec
-        `).run(requested.resource, requested.base_resource, requested.scope, peer, taskId, reason, expiresAt, t, ttl);
+        const acquired = upsertRequestedLock(db, requested, {
+          owner: peer, task_id: taskId, reason, expires_at: expiresAt, created_at: t, ttl_sec: ttl
+        });
         addEvent(db, 'lock.acquired', peer, taskId, webAuditPayload(peer, input, { resource: requested.base_resource, lock_resource: requested.resource, scope: requested.scope, ttl, previous_owner: existing ? existing.owner : null }));
-        return { lock: db.prepare('SELECT * FROM locks WHERE resource = ?').get(requested.resource) };
+        return { lock: acquired };
         }
       });
       if (outcome.error) throw outcome.error;
@@ -327,7 +327,7 @@ export function createWebPeerActions(deps = {}) {
     try {
       touchPeer(db, peer, null);
       const result = tx(db, () => {
-        const existing = db.prepare('SELECT * FROM locks WHERE resource = ?').get(requested.resource);
+        const existing = findRequestedLock(db, requested);
         if (!existing) return { released: false, ...requested };
         if (existing.owner !== peer) {
           throw new CliError('LOCK_OWNED', `Lock is owned by ${existing.owner}`, { owner: existing.owner });

package/lib/web/runtime-main.mjs

@@ -97,7 +97,8 @@ import {
   requestOriginMatches,
   sendFile,
   sendJson,
-  tokenMatches
+  tokenMatches,
+  tokenlessRequestAllowed
 } from '../web/http.mjs';
 import {
   API_VERSION,
@@ -488,14 +489,30 @@ const {
     ACTIVE_PEER_TTL, DETECTED_PEER_MAX_AGE, PRODUCT_NAME, VERSION
   });
 
+  const dispatchHttp = (req, res) => {
+    void handleWebRequest(req, res).catch((error) => {
+      try {
+        console.error(redactedLogText(`HTTP request failed: ${error.code || 'UNKNOWN'}`));
+        if (!res.headersSent) sendJson(res, 500, { ok: false, error: { code: 'SERVER_ERROR', message: 'internal server error' } });
+        else res.destroy();
+      } catch {
+        try { res.destroy(); } catch {}
+      }
+    });
+  };
   const server = useTls
-    ? https.createServer({ key: tlsCredentials.key, cert: tlsCredentials.cert }, handleWebRequest)
-    : http.createServer(handleWebRequest);
+    ? https.createServer({ key: tlsCredentials.key, cert: tlsCredentials.cert }, dispatchHttp)
+    : http.createServer(dispatchHttp);
 
   const wss = new WebSocketServer({ noServer: true });
   server.on('upgrade', (req, socket, head) => {
     try {
     const url = requestUrl(req);
+    if (!token && !tokenlessRequestAllowed(req, { trustProxy, proxyOrigin })) {
+      socket.write('HTTP/1.1 403 Forbidden\r\n\r\n');
+      socket.destroy();
+      return;
+    }
     if (!readWebSocketApiVersion(url).ok) {
       const body = JSON.stringify(apiVersionUnsupportedBody());
       socket.end([

package/lib/web/runtime.mjs

@@ -14,8 +14,12 @@ export function runtimeConnectHost(host) {
   return host;
 }
 
+function urlHost(host) {
+  return host.includes(':') && !host.startsWith('[') ? `[${host}]` : host;
+}
+
 export function runtimeBaseUrl(host, port, tls = false) {
-  return `${tls ? 'https' : 'http'}://${runtimeConnectHost(host)}:${port}`;
+  return `${tls ? 'https' : 'http'}://${urlHost(runtimeConnectHost(host))}:${port}`;
 }
 
 export function runtimeApiUrl(runtime, route) {
@@ -24,7 +28,17 @@ export function runtimeApiUrl(runtime, route) {
 }
 
 export function requestUrl(req) {
-  return new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
+  try {
+    const base = new URL(`http://${req.headers.host || 'localhost'}`);
+    if (base.username || base.password || base.pathname !== '/' || base.search || base.hash) {
+      throw new Error('Invalid Host authority');
+    }
+    const url = new URL(req.url || '/', base);
+    if (url.origin !== base.origin) throw new Error('Request target changes authority');
+    return url;
+  } catch {
+    throw new CliError('BAD_REQUEST', 'Invalid request URL or Host header');
+  }
 }
 
 export function isLoopbackHost(host) {
@@ -84,13 +98,13 @@ export function publicRuntimeUrl(runtime, projectRoot = null) {
     ? '<machine-ip>'
     : runtime.host || runtimeConnectHost(runtime.host || '127.0.0.1');
   const scheme = runtime.tls ? 'https' : 'http';
-  return `${scheme}://${host}:${runtime.port}/${runtimeUrlQuery(runtime, projectRoot)}`;
+  return `${scheme}://${urlHost(host)}:${runtime.port}/${runtimeUrlQuery(runtime, projectRoot)}`;
 }
 
 export function localRuntimeUrl(runtime, projectRoot = null) {
   const host = runtimeConnectHost(runtime.host || '127.0.0.1');
   const scheme = runtime.tls ? 'https' : 'http';
-  return `${scheme}://${host}:${runtime.port}/${runtimeUrlQuery(runtime, projectRoot)}`;
+  return `${scheme}://${urlHost(host)}:${runtime.port}/${runtimeUrlQuery(runtime, projectRoot)}`;
 }
 
 // Issue a request to a runtime API route. Returns { ok, status, text }.

package/lib/web/session-serialize.mjs

@@ -105,7 +105,7 @@ export function createSessionSerialize({
         : session.type === 'native' ? ['chat', 'delivery-receipts', 'results',
           ...(session.nativeState?.capabilities?.interrupt ? ['turn-control'] : [])] : ['terminal', 'results'],
       local_clients: session.type === 'tmux' ? localClientObservation(session) : null,
-      executor_id: session.adapter?.snapshot().executorId || session.nativeState?.executorId || null,
+      executor_id: session.executorId || session.adapter?.snapshot().executorId || session.nativeState?.executorId || null,
       native_connected: session.type === 'native' ? Boolean(session.nativeState?.connected) : null,
       created_at: session.createdAt,
       exited_at: session.exitedAt || null,

package/lib/web/startup.mjs

@@ -5,6 +5,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import process from 'node:process';
+import { createHash, randomUUID } from 'node:crypto';
 import { URL } from 'node:url';
 import { spawn, spawnSync } from 'node:child_process';
 import { setTimeout as sleep } from 'node:timers/promises';
@@ -13,10 +14,13 @@ import { redactCliArgs } from '../shared/redact.mjs';
 import { intOpt, parseOpts, splitGlobalArgs, validateOpts } from '../cli-args.mjs';
 import { printResult } from '../format.mjs';
 import { commandPath, tailFile } from '../cli-runtime.mjs';
+import { compareProcessIdentity, inspectProcessIdentity } from '../process/identity.mjs';
 import { registerProject } from '../runtime/projects.mjs';
-import { runtimePath, globalRuntimePath, webLogPath } from '../runtime/paths.mjs';
+import { runtimePath, globalRuntimePath, globalStateDir, webLogPath } from '../runtime/paths.mjs';
 import { readHealthyGlobalRuntime, writeRuntime } from '../runtime/state.mjs';
 import { runtimeRequest } from '../runtime/client.mjs';
+import { withFileLock } from '../shared/file-lock.mjs';
+import { writeJsonSafe } from '../shared/json-file.mjs';
 import {
   expectedWebHost,
   isLoopbackHost,
@@ -32,6 +36,56 @@ import { API_VERSION } from '../web/api-version.mjs';
 import { ensureTmuxAvailable } from '../tmux.mjs';
 
 export const WEB_RUNTIME_START_TIMEOUT_MS = 60_000;
+const WEB_START_LOCK_WAIT_MS = WEB_RUNTIME_START_TIMEOUT_MS + 30_000;
+
+function webStartOwnerAlive(owner) {
+  const pid = owner?.pid;
+  if (!Number.isInteger(pid) || pid <= 0) return true;
+  const observed = inspectProcessIdentity(pid);
+  if (observed.state === 'dead') return false;
+  if (owner.process_identity && observed.state === 'live') {
+    return compareProcessIdentity(owner.process_identity, observed.identity) !== 'dead';
+  }
+  return true;
+}
+
+async function withWebStartLock(fn) {
+  const lockFile = path.join(globalStateDir(), 'web-start.lock');
+  const owner = {
+    pid: process.pid,
+    process_identity: inspectProcessIdentity(process.pid).identity,
+    nonce: randomUUID()
+  };
+  const deadline = performance.now() + WEB_START_LOCK_WAIT_MS;
+  while (true) {
+    const acquired = withFileLock(lockFile, (lockedFile) => {
+      if (fs.existsSync(lockedFile)) {
+        let previous = null;
+        try { previous = JSON.parse(fs.readFileSync(lockedFile, 'utf8')); } catch {}
+        if (!previous || webStartOwnerAlive(previous)) return false;
+      }
+      writeJsonSafe(lockedFile, owner, { mode: 0o600 });
+      return true;
+    });
+    if (acquired) break;
+    if (performance.now() >= deadline) {
+      throw new CliError('WEB_START_LOCK_TIMEOUT',
+        'Timed out waiting for another web startup to finish.');
+    }
+    await sleep(100);
+  }
+  try {
+    return await fn();
+  } finally {
+    withFileLock(lockFile, (lockedFile) => {
+      let current = null;
+      try { current = JSON.parse(fs.readFileSync(lockedFile, 'utf8')); } catch {}
+      if (current?.nonce === owner.nonce && current.pid === owner.pid) {
+        fs.rmSync(lockedFile, { force: true });
+      }
+    });
+  }
+}
 
 export function createWebStartup(deps) {
   const {
@@ -84,25 +138,41 @@ async function stopOrphanWebRuntimes(ctx, keepPid = null) {
     const ppid = Number.parseInt(match[2], 10);
     if (!Number.isFinite(pid)) continue;
     if (Number.isFinite(ppid)) ppidByPid.set(pid, ppid);
-    rows.push({ pid, args: match[3] });
+    rows.push({ pid, ppid, args: match[3] });
   }
 
   const ancestorPids = currentProcessAncestorPids(ppidByPid);
-  const pids = [];
+  const candidates = [];
   for (const row of rows) {
+    // A live parent still owns its web command. In particular, another CLI
+    // invocation waiting for the startup lock is not an orphan runtime.
+    if (row.ppid !== 1) continue;
     if (row.pid === process.pid || row.pid === keepPid || ancestorPids.has(row.pid)) continue;
-    if (hccWebProcessMatches(row.args, ctx)) pids.push(row.pid);
+    if (!hccWebProcessMatches(row.args, ctx)) continue;
+    const observed = inspectProcessIdentity(row.pid);
+    if (observed.state === 'live' &&
+        observed.identity.commandHash === createHash('sha256').update(row.args.trim()).digest('hex')) {
+      candidates.push(observed.identity);
+    }
   }
-  if (!pids.length) return;
+  if (!candidates.length) return;
+
+  const stillSameProcess = (identity) => {
+    const observed = inspectProcessIdentity(identity.pid);
+    return observed.state === 'live' &&
+      compareProcessIdentity(identity, observed.identity) === 'live' &&
+      identity.commandHash === observed.identity.commandHash;
+  };
 
-  for (const pid of pids) {
-    try { process.kill(pid, 'SIGTERM'); } catch {}
+  for (const identity of candidates) {
+    if (!stillSameProcess(identity)) continue;
+    try { process.kill(identity.pid, 'SIGTERM'); } catch {}
   }
   await sleep(250);
-  for (const pid of pids) {
+  for (const identity of candidates) {
+    if (!stillSameProcess(identity)) continue;
     try {
-      process.kill(pid, 0);
-      process.kill(pid, 'SIGKILL');
+      process.kill(identity.pid, 'SIGKILL');
     } catch {}
   }
 }
@@ -160,6 +230,10 @@ async function startWebBackground(ctx, args) {
   assertWebTokenForHost(requestedHost, !opts['no-token']);
   if (!isLoopbackHost(requestedHost)) console.error(redactedLogText(webExposureWarning(requestedHost, intOpt(opts, 'port', 8787)) + (opts.tls ? '' : ' Consider --tls to encrypt this connection.')));
   ensureTmuxAvailable({ autoInstall: true });
+  return withWebStartLock(() => startWebBackgroundLocked(ctx, args, opts));
+}
+
+async function startWebBackgroundLocked(ctx, args, opts) {
   const setup = await prepareLocalBus(ctx, {
     ...opts,
     installShims: process.env.HCC_SKIP_SHIM_INSTALL === '1' ? false : true

package/lib/web/task-results.mjs

@@ -2,6 +2,7 @@ import { createHash } from 'node:crypto';
 import { selectCurrentTask } from '../core/coordination/automation.mjs';
 import { listTaskResults, recordTaskResult, summarizeTaskResults } from '../core/coordination/results.mjs';
 import { CliError } from '../shared/errors.mjs';
+import { redactSecrets } from '../shared/redact.mjs';
 
 export function createTaskResults({ connectWebProject, resolveSessionPeerId, now, addEvent }) {
   const turnScopes = new WeakMap();
@@ -31,7 +32,7 @@ export function createTaskResults({ connectWebProject, resolveSessionPeerId, now
     } finally { db.close(); }
   }
   function observeCodexResults(session, state) {
-    if (!session.binding?.provider_session_id || state.executorId !== session.adapter?.snapshot().executorId) return;
+    if (!session.binding?.provider_session_id || state.executorId !== (session.executorId || session.adapter?.snapshot().executorId)) return;
     const thread = state.threads?.find(t => t.id === session.binding.provider_session_id);
     if (!thread?.turns?.length) return;
     const db = connectWebProject(session.ctx);
@@ -54,14 +55,16 @@ export function createTaskResults({ connectWebProject, resolveSessionPeerId, now
           const exitCode = item.exitCode;
           const status = exitCode === 0 && item.status === 'completed' ? 'passed'
             : item.status === 'failed' || item.status === 'declined' || (Number.isSafeInteger(exitCode) && exitCode !== 0) ? 'failed' : 'pending';
+          const command = redactSecrets(String(item.command || ''));
+          const output = redactSecrets(String(item.aggregatedOutput || ''));
           recordTaskResult(db, { ...common, itemId: item.id, kind: 'command', status, exitCode,
             resultKey: `${state.executorId}:${turn.id}:${item.id}:command`,
-            title: String(item.command || 'Command execution').slice(0, 300),
-            command: String(item.command || '').slice(0, 64000),
-            details: String(item.aggregatedOutput || '').slice(0, 64000), evidence: [] }, { now, addEvent });
+            title: (command || 'Command execution').slice(0, 300),
+            command: command.slice(0, 64000),
+            details: output.slice(0, 64000), evidence: [] }, { now, addEvent });
         }
         if (turn.diff && ['completed', 'failed', 'interrupted'].includes(turn.status)) {
-          const diff = String(turn.diff).slice(0, 64000);
+          const diff = redactSecrets(String(turn.diff)).slice(0, 64000);
           recordTaskResult(db, { ...common, kind: 'diff', status: 'pending', title: 'Turn changes awaiting review', diff,
             resultKey: `${state.executorId}:${turn.id}:diff:${createHash('sha256').update(diff).digest('hex')}` }, { now, addEvent });
         }

package/lib/web/terminal-assets.mjs

@@ -0,0 +1,18 @@
+import path from 'node:path';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const packages = Object.freeze({
+  'xterm.js': '@xterm/xterm',
+  'xterm.css': '@xterm/xterm',
+  'addon-fit.js': '@xterm/addon-fit',
+  'addon-search.js': '@xterm/addon-search'
+});
+
+// npm may place dependencies above the HCC package directory. Resolve from
+// this module's installation rather than assuming a nested node_modules.
+export function terminalAssetPath(name) {
+  if (!Object.hasOwn(packages, name)) throw new TypeError('Unknown terminal asset');
+  const entry = require.resolve(packages[name]);
+  return name === 'xterm.css' ? path.resolve(path.dirname(entry), '..', 'css', name) : entry;
+}

package/lib/web/tmux-stream.mjs

@@ -7,12 +7,12 @@ import path from 'node:path';
 import { spawnSync } from 'node:child_process';
 import { runTmux, tmuxCapturePane, tmuxCursorInfo, tmuxCursorPayload } from '../terminal/tmux.mjs';
 import { CliError } from '../shared/errors.mjs';
+import { ensurePrivateProjectBufferDirectory } from '../runtime/project-path.mjs';
 
 export function createTmuxStream({
   broadcast,
   now,
   refreshPeerIoHeartbeat,
-  bufferDirectory,
   withBufferDirectoryLease,
   shellQuoteArg,
   ctx
@@ -69,8 +69,7 @@ export function createTmuxStream({
   function startTmuxStream(session) {
     const safePane = String(session.pane).replace(/[^A-Za-z0-9_-]/g, '');
     const safeId = String(session.id).replace(/[^A-Za-z0-9_.-]/g, '_');
-    const streamDirectory = bufferDirectory(session.ctx || ctx);
-    fs.mkdirSync(streamDirectory, { recursive: true });
+    const streamDirectory = ensurePrivateProjectBufferDirectory((session.ctx || ctx).root);
     const pipeFile = path.join(streamDirectory, `tmux-${safePane}-${safeId}.pipe`);
     session.pipeFile = pipeFile;
     try { runTmux(['pipe-pane', '-t', session.pane]); } catch {}
@@ -89,7 +88,7 @@ export function createTmuxStream({
           const message = (mkfifo.stderr || mkfifo.stdout || '').trim() || 'mkfifo failed';
           throw new CliError('TMUX_STREAM_ERROR', message);
         }
-        try { fs.chmodSync(pipeFile, 0o600); } catch {}
+        fs.chmodSync(pipeFile, 0o600);
         session.streamFd = fs.openSync(pipeFile, fs.constants.O_RDONLY | fs.constants.O_NONBLOCK);
       });
     } catch (err) {