@logicseek/hello-cc 1.1.0-rc.9 → 1.1.1

package/lib/integrations/native/jsonrpc.mjs

@@ -34,6 +34,7 @@ export class JsonRpcProcess {
     this.buffer = '';
     this.closed = false;
     this.child = null;
+    this.childClosed = false;
     this.closePromise = null;
     this.lastCloseError = null;
   }
@@ -45,6 +46,8 @@ export class JsonRpcProcess {
     this.child = spawnPinnedCwdProcess(binary, args, {
       cwd: cwd || process.cwd(), env, expectedIdentity, shell: false, stdio: ['pipe', 'pipe', 'pipe']
     });
+    // Keep the close receipt even when close() is called after direct exit.
+    this.child.once('close', () => { this.childClosed = true; });
     this.child.stdout.setEncoding('utf8');
     this.child.stdout.on('data', (chunk) => this.read(chunk));
     // Drain stderr without putting credentials or unbounded provider logs into
@@ -164,27 +167,47 @@ export class JsonRpcProcess {
     this.fail(new CliError('NATIVE_TRANSPORT_CLOSED', 'Native provider connection closed', { uncertain: true }));
     const child = this.child;
     // A failed spawn has no PID and emits close/error, but never exit.
-    if (!child?.pid || child.exitCode !== null || child.signalCode !== null) {
+    if (!child?.pid || this.childClosed) {
       this.closePromise = Promise.resolve();
       return this.closePromise;
     }
     this.closePromise = new Promise((resolve, reject) => {
+      let eofTimer;
       let termTimer;
       let killTimer;
+      let stdioTimer;
+      let settled = false;
+      const hasExited = () => child.exitCode !== null || child.signalCode !== null;
       const cleanup = () => {
+        clearTimeout(eofTimer);
         clearTimeout(termTimer);
         clearTimeout(killTimer);
+        clearTimeout(stdioTimer);
         child.removeListener('exit', exited);
+        child.removeListener('close', finished);
         child.removeListener('error', failed);
       };
-      const exited = () => { cleanup(); resolve(); };
+      const finished = () => {
+        if (settled) return;
+        settled = true; cleanup(); resolve();
+      };
       const failed = (error) => {
+        if (settled) return;
+        settled = true;
         cleanup();
         this.lastCloseError = new CliError('NATIVE_CLOSE_FAILED', 'Cannot confirm native provider process termination', {
           pid: child.pid, uncertain: true, cause: error.code || error.message
         });
         reject(this.lastCloseError);
       };
+      const exited = () => {
+        clearTimeout(eofTimer); clearTimeout(termTimer); clearTimeout(killTimer);
+        if (this.childClosed) return finished();
+        // Never signal an exited PID or guess ownership of descendants. Keep
+        // an unclosed inherited pipe visible as incomplete transport cleanup.
+        if (!stdioTimer) stdioTimer = setTimeout(() => failed(new CliError('NATIVE_STDIO_CLOSE_TIMEOUT',
+          'Native provider exited but its stdio did not close')), this.options.closeKillTimeoutMs ?? 2000);
+      };
       const signal = (name) => {
         try {
           if (!child.kill(name)) {
@@ -195,16 +218,27 @@ export class JsonRpcProcess {
         } catch (error) { failed(error); return false; }
       };
       child.once('exit', exited);
+      child.once('close', finished);
       child.once('error', failed);
-      termTimer = setTimeout(() => {
-        if (child.exitCode !== null || child.signalCode !== null) return exited();
-        // Sending SIGKILL is not an exit receipt. Continue waiting for exit.
-        killTimer = setTimeout(() => failed(new CliError('NATIVE_EXIT_TIMEOUT',
-          'Native provider did not report exit after SIGKILL')), this.options.closeKillTimeoutMs ?? 2000);
-        signal('SIGKILL');
-      }, this.options.closeGraceMs ?? 2000);
-      try { child.stdin.end(); } catch {}
-      signal('SIGTERM');
+      if (hasExited()) return exited();
+      const terminate = () => {
+        if (settled) return;
+        clearTimeout(eofTimer);
+        if (hasExited()) return exited();
+        termTimer = setTimeout(() => {
+          if (hasExited()) return exited();
+          // Sending SIGKILL is not a close receipt. Continue waiting for exit
+          // and closed stdio, with a separate bounded wait after direct exit.
+          killTimer = setTimeout(() => failed(new CliError('NATIVE_EXIT_TIMEOUT',
+            'Native provider did not report exit after SIGKILL')), this.options.closeKillTimeoutMs ?? 2000);
+          signal('SIGKILL');
+        }, this.options.closeGraceMs ?? 2000);
+        signal('SIGTERM');
+      };
+      // Let the provider handle EOF and reap its own ordinary subprocesses
+      // before escalating. closeGraceMs retains its SIGTERM-to-SIGKILL meaning.
+      eofTimer = setTimeout(terminate, this.options.closeEofGraceMs ?? 1000);
+      try { child.stdin.end(); } catch { terminate(); }
     });
     const closing = this.closePromise;
     void closing.catch(() => {

package/lib/runtime/native/cli-submissions.mjs

@@ -124,6 +124,9 @@ function optionalRecord(directory, name) {
 function validatePrepared(record, id, root, meshDbRelative) {
   if (record?.version !== 1 || record.submission_id !== id ||
       record.root !== root || record.mesh_db_relative !== meshDbRelative ||
+      typeof record.mesh_db_relative !== 'string' || !record.mesh_db_relative ||
+      path.isAbsolute(record.mesh_db_relative) || path.win32.isAbsolute(record.mesh_db_relative) ||
+      record.mesh_db_relative.split(/[\\/]/).includes('..') ||
       typeof record.peer !== 'string' || !record.peer || typeof record.from !== 'string' || !record.from ||
       !(record.task_id === null || (Number.isSafeInteger(record.task_id) && record.task_id > 0)) ||
       !/^[a-f0-9]{64}$/.test(record.body_sha256) ||
@@ -200,7 +203,12 @@ export function listCliSubmissions(ctx, { peer = null } = {}) {
   for (const name of fs.readdirSync(directory)) {
     const match = name.match(PREPARED);
     if (!match) continue;
-    const record = validatePrepared(readRecord(directory, name), match[1], root, meshDbRelative);
+    // Journals are shared by all coordination databases in this project. Check
+    // the saved binding before filtering; retry lookup still requires the
+    // currently selected database so an ID cannot be replayed across them.
+    const saved = readRecord(directory, name);
+    const record = validatePrepared(saved, match[1], root, saved?.mesh_db_relative);
+    if (record.mesh_db_relative !== meshDbRelative) continue;
     if (peer && record.peer !== peer) continue;
     const receiptName = `receipt-${record.submission_id}.json`;
     let receipt = optionalRecord(directory, receiptName);

package/lib/runtime/native/service.mjs

@@ -90,6 +90,9 @@ export async function startNativeService(ctx, deps, options = {}) {
         ? 'An ownership listener has no identity handshake and may belong to an older native runtime. Stop that runtime before retrying.'
         : 'A native runtime already owns this project, or all ownership ports are unavailable.');
     }
+    if (error?.code === 'ERR_FILE_LOCK_WORKER_START_FAILED' && error.listener) {
+      throw new CliError('NATIVE_OWNERSHIP_UNAVAILABLE', 'Cannot start the native runtime ownership listener', error.listener);
+    }
     throw error;
   }
   let store;

package/lib/shared/file-lock.mjs

@@ -3,6 +3,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { Worker } from 'node:worker_threads';
 import { aggregateCleanupFailure } from './cleanup-error.mjs';
+import { readSocketLockFailure, SOCKET_LOCK_STATE_LENGTH } from './socket-lock-diagnostics.mjs';
 
 const NO_ERROR = Symbol('no-file-lock-error');
 const STATE_INDEX = 0;
@@ -193,7 +194,10 @@ function injectedFailure(worker, state, phase, key) {
   } catch (error) {
     return workerError(key, phase, error);
   }
-  return workerError(key, phase);
+  const error = workerError(key, phase);
+  const listener = readSocketLockFailure(state);
+  if (listener) error.listener = listener;
+  return error;
 }
 
 function terminateWorker(worker, primary, key) {
@@ -241,7 +245,7 @@ function acquisitionError(status, resources) {
 }
 
 function acquireWorker(location, options, workerFactory) {
-  const buffer = new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT * 2);
+  const buffer = new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT * SOCKET_LOCK_STATE_LENGTH);
   const state = new Int32Array(buffer);
   const endpoints = endpointsForLocation(location);
   const targets = lockTargetsForLocation(location);

package/lib/shared/socket-lock-diagnostics.mjs

@@ -0,0 +1,31 @@
+// Only bounded numeric fields cross the synchronous worker boundary. Never
+// copy a listener error's message, path, address, or arbitrary properties.
+export const SOCKET_LOCK_STATE_LENGTH = 6;
+const CODE_INDEX = 2;
+const ERRNO_INDEX = 3;
+const SYSCALL_INDEX = 4;
+const PORT_INDEX = 5;
+const CODES = Object.freeze([null, 'EACCES', 'EPERM', 'EMFILE', 'ENFILE', 'ENOBUFS',
+  'ENOMEM', 'EADDRNOTAVAIL', 'EAFNOSUPPORT', 'EINVAL', 'ENOTSOCK', 'EBADF', 'EADDRINUSE']);
+const SYSCALLS = Object.freeze([null, 'listen', 'bind', 'accept', 'close']);
+
+export function writeSocketLockFailure(state, error, port) {
+  if (state.length < SOCKET_LOCK_STATE_LENGTH) return;
+  Atomics.store(state, CODE_INDEX, Math.max(0, CODES.indexOf(error?.code)));
+  const errno = error?.errno;
+  Atomics.store(state, ERRNO_INDEX, Number.isInteger(errno) && Math.abs(errno) <= 65535 ? errno : 0);
+  Atomics.store(state, SYSCALL_INDEX, Math.max(0, SYSCALLS.indexOf(error?.syscall)));
+  Atomics.store(state, PORT_INDEX, Number.isInteger(port) && port > 0 && port <= 65535 ? port : 0);
+}
+
+export function readSocketLockFailure(state) {
+  if (state.length < SOCKET_LOCK_STATE_LENGTH) return null;
+  const port = Atomics.load(state, PORT_INDEX);
+  if (port < 1 || port > 65535) return null;
+  return {
+    cause: { code: CODES[Atomics.load(state, CODE_INDEX)] ?? null,
+      errno: Atomics.load(state, ERRNO_INDEX) || null,
+      syscall: SYSCALLS[Atomics.load(state, SYSCALL_INDEX)] ?? null },
+    endpoint: { host: '127.0.0.1', port }
+  };
+}

package/lib/shared/socket-lock-worker.mjs

@@ -1,5 +1,6 @@
 import net from 'node:net';
 import { parentPort } from 'node:worker_threads';
+import { writeSocketLockFailure } from './socket-lock-diagnostics.mjs';
 
 const STATE_INDEX = 0;
 const DETAIL_INDEX = 1;
@@ -85,8 +86,9 @@ export function runSocketLockWorker(workerData) {
     complete();
   }
 
-  function requestTerminalFailure() {
+  function requestTerminalFailure(error = null, port = 0) {
     if (finished) return;
+    if (!terminalFailureRequested) writeSocketLockFailure(state, error, port);
     terminalFailureRequested = true;
     generation += 1;
     closeServers(() => finish(states.FAILED, 1));
@@ -184,7 +186,7 @@ export function runSocketLockWorker(workerData) {
       const bindError = (error) => {
         if (finished || attemptGeneration !== generation) return;
         if (error?.code !== 'EADDRINUSE') {
-          requestTerminalFailure();
+          requestTerminalFailure(error, port);
           return;
         }
         probeOccupant(port, target.identity, (matching, legacy) => {
@@ -206,12 +208,12 @@ export function runSocketLockWorker(workerData) {
           return;
         }
         candidate.off('error', bindError);
-        candidate.on('error', requestTerminalFailure);
+        candidate.on('error', error => requestTerminalFailure(error, port));
         servers.push(candidate);
         bindCandidate(targetIndex, candidateIndex + 1, boundForTarget + 1, attemptGeneration);
       });
-    } catch {
-      requestTerminalFailure();
+    } catch (error) {
+      requestTerminalFailure(error, port);
     }
   }
 

package/lib/web/context-files.mjs

@@ -1,10 +1,8 @@
-import fs from 'node:fs/promises';
 import path from 'node:path';
-import process from 'node:process';
 import { CliError } from '../shared/errors.mjs';
 import { captureSelectedCwdIdentity } from '../process/selected-cwd-identity.mjs';
 import { privateComponent, PROJECT_PRIVATE_COMPONENT_WORKER_SOURCE,
-  runPinnedDirectoryWorker } from './project-files.mjs';
+  runPinnedDirectoryWorker, assertProjectFileReadsAvailable } from './project-files.mjs';
 
 const contextIgnored = new Set(['.git', 'node_modules', '.hcc', '.hello-cc', '.codex', '.claude', '.dsh', '.ssh', '.aws', 'dist', 'build', 'coverage', '.next']);
 
@@ -17,90 +15,6 @@ function assertBoundRoot(rootIdentity) {
   rootIdentity.assertUnchanged();
 }
 
-function sameDirectory(left, right) {
-  return left.isDirectory() && right.isDirectory() && left.dev === right.dev &&
-    left.ino === right.ino && left.mode === right.mode && left.size === right.size &&
-    left.mtimeNs === right.mtimeNs && left.ctimeNs === right.ctimeNs;
-}
-
-// Windows cannot use the POSIX pinned helper, so keep the existing read-only
-// traversal there. Its transient ancestor-replacement risk is not closed here.
-async function listContextFilesByPath(root, query, { limit, maxEntries, timeBudgetMs, now, rootIdentity }) {
-  assertBoundRoot(rootIdentity);
-  const base = await fs.realpath(root), pending = [''], paths = [], needle = query.toLocaleLowerCase();
-  const directorySnapshots = [];
-  if (rootIdentity) {
-    const parent = path.dirname(base);
-    directorySnapshots.push({ directory: parent, stat: await fs.lstat(parent, { bigint: true }) });
-    const initial = await fs.lstat(base, { bigint: true });
-    assertBoundRoot(rootIdentity);
-    if (rootIdentity.identity.dev !== initial.dev.toString() ||
-        rootIdentity.identity.ino !== initial.ino.toString() ||
-        rootIdentity.identity.birthtimeNs !== (initial.birthtimeNs?.toString() || null)) throw changed();
-    directorySnapshots.push({ directory: base, stat: initial });
-  }
-  const exact = await exactContextFile(base, query, rootIdentity);
-  if (exact) paths.push(exact);
-  let seen = 0, truncated = false;
-  const deadline = now() + timeBudgetMs;
-  outer: while (pending.length) {
-    if (now() >= deadline || seen >= maxEntries || paths.length >= limit) { truncated = true; break; }
-    assertBoundRoot(rootIdentity);
-    const relative = pending.shift(), directory = path.join(base, relative);
-    try {
-      const before = await fs.lstat(directory, { bigint: true });
-      if (before.isSymbolicLink() || !before.isDirectory()) continue;
-      if (rootIdentity) directorySnapshots.push({ directory, stat: before });
-      const resolved = await fs.realpath(directory), fromRoot = path.relative(base, resolved);
-      if (fromRoot === '..' || fromRoot.startsWith('..' + path.sep) || path.isAbsolute(fromRoot)) continue;
-      const handle = await fs.opendir(directory);
-      for await (const item of handle) {
-        seen++;
-        if (seen > maxEntries || now() >= deadline) { truncated = true; break outer; }
-        if (item.isSymbolicLink() || contextIgnored.has(item.name) || privateComponent(item.name) ||
-            /[\\:\x00-\x1f\x7f]/.test(item.name)) continue;
-        const name = relative ? relative + '/' + item.name : item.name;
-        if (item.isDirectory()) pending.push(name);
-        else if (item.isFile() && name !== exact && name.toLocaleLowerCase().includes(needle)) {
-          paths.push(name);
-          if (paths.length >= limit) { truncated = true; break outer; }
-        }
-      }
-      if (rootIdentity && !sameDirectory(before, await fs.lstat(directory, { bigint: true }))) throw changed();
-    } catch (error) { if (!['ENOENT', 'ENOTDIR', 'EACCES', 'EPERM'].includes(error.code)) throw error; }
-  }
-  assertBoundRoot(rootIdentity);
-  if (rootIdentity) {
-    for (const { directory, stat } of directorySnapshots) {
-      if (!sameDirectory(stat, await fs.lstat(directory, { bigint: true }))) throw changed();
-    }
-  }
-  return { paths: paths.sort(), truncated };
-}
-
-async function exactContextFile(base, query, rootIdentity) {
-  const parts = query.split('/');
-  if (!query || parts.some(part => !part || part === '.' || contextIgnored.has(part) || privateComponent(part))) return null;
-  let directory = base;
-  try {
-    for (let index = 0; index < parts.length; index++) {
-      assertBoundRoot(rootIdentity);
-      const target = path.join(directory, parts[index]), stat = await fs.lstat(target);
-      if (stat.isSymbolicLink() || (index < parts.length - 1 ? !stat.isDirectory() : !stat.isFile())) return null;
-      const resolved = await fs.realpath(target), relative = path.relative(base, resolved);
-      if (relative === '..' || relative.startsWith('..' + path.sep) || path.isAbsolute(relative) ||
-          relative.split(path.sep).some(part => contextIgnored.has(part) || privateComponent(part))) return null;
-      // Recheck the named entry after resolving it and discard any observed
-      // link or entry replacement before offering the filename.
-      const confirmed = await fs.lstat(target);
-      if (confirmed.isSymbolicLink() || confirmed.dev !== stat.dev || confirmed.ino !== stat.ino) return null;
-      directory = resolved;
-      if (index === parts.length - 1) return relative.split(path.sep).join('/');
-    }
-  } catch (error) { if (!['ENOENT', 'ENOTDIR', 'EACCES', 'EPERM'].includes(error.code)) throw error; }
-  return null;
-}
-
 function contextListWorker() {
   const fs = require('node:fs');
   const { query, limit, maxEntries, timeBudgetMs } = JSON.parse(process.argv[1]);
@@ -206,8 +120,7 @@ export async function listContextFiles(root, query = '', { limit = 80, maxEntrie
   if (!Number.isSafeInteger(limit) || limit < 1 || !Number.isSafeInteger(maxEntries) || maxEntries < 1 || !Number.isFinite(timeBudgetMs) || timeBudgetMs < 0 || typeof now !== 'function') {
     throw new TypeError('Invalid context file listing budget');
   }
-  if (process.platform === 'win32') return listContextFilesByPath(root, query,
-    { limit, maxEntries, timeBudgetMs, now, rootIdentity });
+  assertProjectFileReadsAvailable();
   const ownedIdentity = rootIdentity ? null : captureSelectedCwdIdentity(root);
   const identity = rootIdentity || ownedIdentity;
   try {

package/lib/web/http-routes.mjs

@@ -235,12 +235,12 @@ export function createHttpRoutes(deps) {
       const safeMethod = ['GET', 'HEAD', 'OPTIONS'].includes(req.method || '');
       // Cookie-authenticated writes require affirmative same-origin evidence;
       // a missing Origin is not sufficient. Token-authenticated CLI requests
-      // without cookies remain origin-free, as do tokenless loopback CLI
-      // requests; a supplied Origin on the tokenless runtime must still match.
+      // without cookies may omit Origin, as may tokenless loopback CLI
+      // requests. Any supplied Origin must match, including with a Bearer token.
       const cookieAuthenticated = authMode === 'cookie' || cookieSessionOk(req);
-      const originRequired = cookieAuthenticated || (!token && Boolean(req.headers.origin));
+      const originRequired = cookieAuthenticated || Boolean(req.headers.origin);
       if (!safeMethod && originRequired && !requestOriginMatches(req, { trustProxy, proxyOrigin })) {
-        sendJson(res, 403, { ok: false, error: { code: 'CSRF_ORIGIN', message: 'Cookie-authenticated writes require a same-origin request' } });
+        sendJson(res, 403, { ok: false, error: { code: 'CSRF_ORIGIN', message: 'Writes with cookies or Origin require a same-origin request' } });
         return;
       }
       if (req.method === 'POST' && url.pathname === '/logout') {

package/lib/web/native-sessions.mjs

@@ -591,7 +591,16 @@ export function createNativeSessions({ sessions, sessionKey, connectWebProject,
             }
             let saved;
             try { saved = JSON.parse(previous.payload); } catch { /* Reject below. */ }
-            if (!saved || Object.keys(pending).some(key => saved[key] !== pending[key])) {
+            // A fresh Claude query receives its session ID on its first input.
+            // The initial durable intent can therefore precede that ID. A
+            // fenced read above has confirmed the current provider session;
+            // allow this one-way confirmation only for the same owned executor.
+            // All other identity/body fields still have to match exactly.
+            const initializedClaude = saved?.provider === 'claude' && pending.provider === 'claude' &&
+              saved.provider_session_id === null && typeof pending.provider_session_id === 'string' &&
+              pending.provider_session_id.length > 0;
+            if (!saved || Object.keys(pending).some(key => saved[key] !== pending[key] &&
+                !(key === 'provider_session_id' && initializedClaude))) {
               throw new CliError('NATIVE_SUBMISSION_MISMATCH', 'Retry must keep the original worker, executor and message');
             }
           } else {

package/lib/web/project-files.mjs

@@ -30,11 +30,22 @@ const media = new Map([['.png', 'image/png'], ['.jpg', 'image/jpeg'], ['.jpeg',
 const errorStatus = new Map([['PROJECT_FILE_BAD_PATH', 400], ['PROJECT_FILE_FORBIDDEN', 403],
   ['PROJECT_FILE_NOT_FOUND', 404], ['PROJECT_FILE_CHANGED', 409], ['PROJECT_FILE_TOO_LARGE', 413],
   ['PROJECT_FILE_CONFLICT', 409], ['PROJECT_FILE_EXISTS', 409],
+  ['PROJECT_FILE_READ_UNAVAILABLE', 503],
   ['PROJECT_FILE_WRITE_UNCONFIRMED', 503], ['PROJECT_FILE_WRITE_UNAVAILABLE', 503],
   ['PROJECT_FILE_NOT_DIRECTORY', 400], ['PROJECT_FILE_NOT_REGULAR', 400], ['PROJECT_FILE_UNAVAILABLE', 500]]);
 
 export function projectFileErrorStatus(error) { return errorStatus.get(error?.code); }
 
+// Native Windows is unsupported (use WSL). Its path-based fallback cannot
+// protect against transient ancestor replacement. Refuse before any lookup,
+// including callers that supply an already-captured project identity.
+export function assertProjectFileReadsAvailable() {
+  if (!['darwin', 'linux'].includes(process.platform) || !constants.O_NOFOLLOW || !constants.O_DIRECTORY) {
+    throw new CliError('PROJECT_FILE_READ_UNAVAILABLE',
+      'Safe project file access requires Linux or macOS; on Windows run HCC inside WSL');
+  }
+}
+
 export function privateComponent(name) {
   const lower = name.toLowerCase();
   return ignored.has(lower) || privateNames.has(lower) || /^\.hcc-file-write-/.test(lower) || /^(?:\.?env)(?:[._-]|$)/.test(lower) ||
@@ -154,30 +165,6 @@ export const PROJECT_PRIVATE_COMPONENT_WORKER_SOURCE = `const ignored = new Set(
 const PROJECT_LIST_WORKER_SOURCE = PROJECT_PRIVATE_COMPONENT_WORKER_SOURCE +
   `(${projectListWorker.toString()})()`;
 
-// Windows has no trusted pinned-cwd launch. Keep its existing read-only
-// listing behavior; transient ancestor replacement remains outside this POSIX fix.
-async function listProjectFilesByPath(snapshot) {
-  let directory;
-  try {
-    directory = await fs.opendir(snapshot.absolute);
-    const entries = [];
-    let scanned = 0, truncated = false;
-    for await (const item of directory) {
-      if (++scanned > PROJECT_FILE_LIMITS.scannedEntries) { truncated = true; break; }
-      if (privateComponent(item.name) || /[\\:\x00-\x1f\x7f]/.test(item.name) || item.isSymbolicLink()) continue;
-      if (!item.isDirectory() && !item.isFile()) continue;
-      let stat;
-      try { stat = await fs.lstat(path.join(snapshot.absolute, item.name), { bigint: true }); }
-      catch (error) { if (error.code === 'ENOENT') throw changed(); throw error; }
-      if (stat.isSymbolicLink() || (!stat.isDirectory() && (!stat.isFile() || stat.nlink !== 1n))) continue;
-      entries.push({ name: item.name, type: stat.isDirectory() ? 'directory' : 'file',
-        ...(stat.isFile() ? { size: Number(stat.size) } : {}) });
-    }
-    directory = null;
-    return { entries, truncated };
-  } finally { await directory?.close().catch(() => {}); }
-}
-
 async function inspectPath(root, parts, directory, rootIdentity) {
   assertBoundRoot(rootIdentity);
   const base = await fs.realpath(root), chain = [];
@@ -215,6 +202,7 @@ export async function verifyProjectFileParent(snapshot, handle) { await verifyPa
 export async function prepareProjectFileParent(root, relative, { rootIdentity } = {}) {
   try {
     const parts = relativePath(relative, false);
+    assertProjectFileReadsAvailable();
     const snapshot = await inspectPath(root, parts.slice(0, -1), true, rootIdentity);
     const handle = await openChecked(snapshot, true);
     return { snapshot, handle, name: parts.at(-1) };
@@ -237,19 +225,16 @@ export async function listProjectFiles(root, relative = '', { rootIdentity } = {
   let handle, ownedIdentity;
   try {
     const parts = relativePath(relative, true);
+    assertProjectFileReadsAvailable();
     ownedIdentity = rootIdentity ? null : captureSelectedCwdIdentity(root);
     const identity = rootIdentity || ownedIdentity;
     const snapshot = await inspectPath(root, parts, true, identity);
     handle = await openChecked(snapshot, true);
-    let listing;
-    if (process.platform === 'win32') listing = await listProjectFilesByPath(snapshot);
-    else {
-      const expectedIdentity = { canonical: snapshot.absolute, identity: {
-        dev: snapshot.stat.dev.toString(), ino: snapshot.stat.ino.toString(),
-        birthtimeNs: snapshot.stat.birthtimeNs?.toString() || null } };
-      listing = await runPinnedDirectoryWorker(snapshot.absolute, expectedIdentity,
-        PROJECT_LIST_WORKER_SOURCE, { scannedEntries: PROJECT_FILE_LIMITS.scannedEntries });
-    }
+    const expectedIdentity = { canonical: snapshot.absolute, identity: {
+      dev: snapshot.stat.dev.toString(), ino: snapshot.stat.ino.toString(),
+      birthtimeNs: snapshot.stat.birthtimeNs?.toString() || null } };
+    const listing = await runPinnedDirectoryWorker(snapshot.absolute, expectedIdentity,
+      PROJECT_LIST_WORKER_SOURCE, { scannedEntries: PROJECT_FILE_LIMITS.scannedEntries });
     const entries = listing.entries.map(item => ({ ...item,
       path: relative ? relative + '/' + item.name : item.name }));
     await verifyPath(snapshot, handle);
@@ -304,7 +289,9 @@ function validMedia(bytes, mime) {
 export async function previewProjectFile(root, relative, { rootIdentity } = {}) {
   let handle;
   try {
-    const parts = relativePath(relative, false), snapshot = await inspectPath(root, parts, false, rootIdentity);
+    const parts = relativePath(relative, false);
+    assertProjectFileReadsAvailable();
+    const snapshot = await inspectPath(root, parts, false, rootIdentity);
     handle = await openChecked(snapshot, false);
     const name = parts.at(-1), size = Number(snapshot.stat.size), extension = path.extname(name).toLowerCase();
     const result = { path: relative, name, size, kind: 'unsupported', mime: 'application/octet-stream', encoding: 'base64', content: '', editable: false };
@@ -338,7 +325,9 @@ export async function previewProjectFile(root, relative, { rootIdentity } = {})
 export async function inspectProjectFileStatus(root, relative, { rootIdentity } = {}) {
   let handle;
   try {
-    const parts = relativePath(relative, false), snapshot = await inspectPath(root, parts, false, rootIdentity);
+    const parts = relativePath(relative, false);
+    assertProjectFileReadsAvailable();
+    const snapshot = await inspectPath(root, parts, false, rootIdentity);
     handle = await openChecked(snapshot, false);
     const size = Number(snapshot.stat.size);
     if (size > PROJECT_FILE_LIMITS.mediaBytes) throw new CliError('PROJECT_FILE_TOO_LARGE', 'File status reads are limited to 10 MiB');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logicseek/hello-cc",
-  "version": "1.1.0-rc.9",
+  "version": "1.1.1",
   "description": "Local control plane for coordinating Claude Code, Codex, and other coding CLI sessions.",
   "type": "module",
   "bin": {