@logicseek/hello-cc 1.0.0 → 1.0.1

package/lib/cli/commands/misc.mjs

@@ -5,6 +5,7 @@ export function createMiscCommands(deps) {
     path, process, CliError, parseOpts, printResult,
     readRuntime, runtimeRequest, runtimePath, globalRuntimePath,
     reclaimRuntimePointerFiles, helpDown, loadSetup,
+    waitForProcessIdentityExit,
     PRODUCT_NAME
   } = deps;
 
@@ -35,6 +36,20 @@ export function createMiscCommands(deps) {
       printResult(ctx, { runtime: localSource }, () => `${PRODUCT_NAME} stale runtime pointer removed`);
       return;
     }
+    if (runtime.source !== 'env') {
+      const processIdentity = runtime.process_identity || runtime.processIdentity || runtime.pid;
+      const stopped = await waitForProcessIdentityExit(processIdentity, {
+        timeoutMs: 5_000,
+        intervalMs: 25
+      });
+      if (stopped.state !== 'dead') {
+        throw new CliError(
+          'RUNTIME_STOP_TIMEOUT',
+          `Runtime accepted the stop request, but process ${runtime.pid || 'unknown'} did not exit within 5s.`,
+          { pid: runtime.pid || null, state: stopped.state }
+        );
+      }
+    }
     printResult(ctx, { runtime: runtime.source || runtime.base_url }, () => `${PRODUCT_NAME} runtime stopped`);
   }
 

package/lib/cli/commands/peer.mjs

@@ -1,5 +1,10 @@
 // Peer management commands extracted from bin/hcc.mjs.
 
+import {
+  RUNTIME_SESSION_MUTATION_TIMEOUT_MS,
+  RUNTIME_SESSION_START_TIMEOUT_MS
+} from '../../runtime/client.mjs';
+
 export function createPeerCommands(deps) {
   const {
     connect, now, tx, addEvent, auditPayload, printResult, CliError, parseOpts,
@@ -83,7 +88,9 @@ async function peerStart(ctx, args) {
     throw e;
   }
 
-  await runtimeRequest(ctx, 'GET', '/api/runtime', null, runtime);
+  await runtimeRequest(ctx, 'GET', '/api/runtime', null, runtime, {
+    timeoutMs: RUNTIME_SESSION_START_TIMEOUT_MS
+  });
   const db = connect(ctx);
   try {
     tx(db, () => {
@@ -136,7 +143,7 @@ async function peerStart(ctx, args) {
     env: childSessionEnv(),
     restartOnEnvChange: Boolean(opts['restart-env']),
     providerForce: Boolean(opts.force)
-  }, runtime);
+  }, runtime, { timeoutMs: RUNTIME_SESSION_START_TIMEOUT_MS });
   printResult(ctx, data.session, (session) =>
     `started ${session.id} (${session.kind}, ${session.role})${session.pane ? ` pane=${session.pane}` : ` pid=${session.pid}`}`);
 }
@@ -159,7 +166,9 @@ async function peerAttach(ctx, args) {
     }
     throw e;
   }
-  await runtimeRequest(ctx, 'GET', '/api/runtime', null, runtime);
+  await runtimeRequest(ctx, 'GET', '/api/runtime', null, runtime, {
+    timeoutMs: RUNTIME_SESSION_START_TIMEOUT_MS
+  });
   const db = connect(ctx);
   try {
     addEvent(db, 'peer.attach.requested', actor, null, auditPayload({
@@ -183,7 +192,7 @@ async function peerAttach(ctx, args) {
     pane,
     cwd,
     force: Boolean(opts.force)
-  }, runtime);
+  }, runtime, { timeoutMs: RUNTIME_SESSION_START_TIMEOUT_MS });
   printResult(ctx, data.session, (session) => `attached ${session.id} (${session.kind}, ${session.role}) pane=${session.pane}`);
 }
 
@@ -206,7 +215,14 @@ async function peerStop(ctx, args) {
     } finally {
       db.close();
     }
-    data = await runtimeRequest(ctx, 'POST', `/api/sessions/${encodeURIComponent(id)}/stop`, {});
+    data = await runtimeRequest(
+      ctx,
+      'POST',
+      `/api/sessions/${encodeURIComponent(id)}/stop`,
+      {},
+      null,
+      { timeoutMs: RUNTIME_SESSION_MUTATION_TIMEOUT_MS }
+    );
   } catch (err) {
     if (err instanceof CliError && err.code === 'RUNTIME_NOT_RUNNING') {
       // No server: just update the DB to mark the peer as exited

package/lib/process/identity.mjs

@@ -152,6 +152,36 @@ export async function waitForLiveProcessIdentity(value, options = {}) {
   }
 }
 
+export async function waitForProcessIdentityExit(value, options = {}) {
+  const inspect = options.inspect || inspectProcessIdentity;
+  const monotonicNow = options.monotonicNow || (() => performance.now());
+  const wait = options.sleep || ((delayMs) => new Promise((resolve) => setTimeout(resolve, delayMs)));
+  const timeoutMs = Math.max(0, Number(options.timeoutMs ?? 5_000));
+  const intervalMs = Math.max(1, Number(options.intervalMs ?? 25));
+  const storedIdentity = isCompleteIdentity(value) ? value : null;
+  const pid = Number(storedIdentity?.pid ?? value);
+  if (!Number.isInteger(pid) || pid <= 0) return { state: 'unknown', identity: null };
+
+  const deadline = monotonicNow() + timeoutMs;
+  let lastObservation = { state: 'unknown', identity: null };
+  while (true) {
+    const observed = inspect(pid);
+    if (observed?.state === 'dead') return { state: 'dead', identity: null };
+    if (observed?.state === 'live' && isCompleteIdentity(observed.identity)) {
+      if (storedIdentity && compareProcessIdentity(storedIdentity, observed.identity) === 'dead') {
+        return { state: 'dead', identity: null };
+      }
+      lastObservation = observed;
+    } else {
+      lastObservation = { state: 'unknown', identity: null };
+    }
+
+    const remainingMs = deadline - monotonicNow();
+    if (remainingMs <= 0) return lastObservation;
+    await wait(Math.min(intervalMs, remainingMs));
+  }
+}
+
 export function inspectProcessIdentity(value) {
   let pid;
   try {

package/lib/runtime/buffer-directory-lease.mjs

@@ -26,7 +26,8 @@ export function withBufferDirectoryLease(directory, fn, options = {}) {
   const lockOptions = {
     ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }),
     ...(options.retryMs === undefined ? {} : { retryMs: options.retryMs }),
-    ...(options.nonblocking === undefined ? {} : { nonblocking: options.nonblocking })
+    ...(options.nonblocking === undefined ? {} : { nonblocking: options.nonblocking }),
+    ...(options.createParent === undefined ? {} : { createParent: options.createParent })
   };
   return withFileLock(target, () => fn(path.dirname(target)), lockOptions);
 }

package/lib/runtime/client.mjs

@@ -4,6 +4,8 @@ import { runtimeApiUrl, runtimeHttpRequest } from '../web/runtime.mjs';
 import { withRuntimeApiVersionHeader } from '../web/api-version.mjs';
 
 const DEFAULT_CLI_NAME = 'hcc';
+export const RUNTIME_SESSION_START_TIMEOUT_MS = 60_000;
+export const RUNTIME_SESSION_MUTATION_TIMEOUT_MS = 30_000;
 
 function requestAbortScope(signal, timeoutMs) {
   const controller = new AbortController();
@@ -59,6 +61,7 @@ export async function runtimeRequest(ctx, method, route, body = null, runtime =
       method,
       headers,
       body: body === null ? null : JSON.stringify(body),
+      timeoutMs: opts.timeoutMs,
       signal: abortScope.signal
     }), abortScope.signal);
     text = res.text;

package/lib/shared/file-lock.mjs

@@ -78,13 +78,13 @@ function startupTimeoutError(key) {
   return error;
 }
 
-function canonicalTarget(value) {
+function canonicalTarget(value, { createParent = true } = {}) {
   if (typeof value !== 'string' || value.length === 0) {
     throw new TypeError('file lock target must be a non-empty path');
   }
   const supplied = path.resolve(value);
   const suppliedParent = path.dirname(supplied);
-  fs.mkdirSync(suppliedParent, { recursive: true, mode: 0o700 });
+  if (createParent) fs.mkdirSync(suppliedParent, { recursive: true, mode: 0o700 });
   const canonicalParent = fs.realpathSync.native(suppliedParent);
   const parentIdentity = fs.statSync(canonicalParent);
   if (!parentIdentity.isDirectory()) {
@@ -330,8 +330,12 @@ export function createFileLock({ workerFactory = defaultWorkerFactory } = {}) {
   return function withConfiguredFileLock(
     target,
     fn,
-    { timeoutMs = 5000, retryMs = 25, nonblocking = false } = {}
+    options = {}
   ) {
+    const timeoutMs = options.timeoutMs === undefined ? 5000 : options.timeoutMs;
+    const retryMs = options.retryMs === undefined ? 25 : options.retryMs;
+    const nonblocking = options.nonblocking === undefined ? false : options.nonblocking;
+    const createParent = options.createParent === undefined ? true : options.createParent;
     if (typeof fn !== 'function') throw new TypeError('file lock callback must be a function');
     if (!Number.isFinite(timeoutMs) || timeoutMs < 0) {
       throw new RangeError('file lock timeoutMs must be a non-negative finite number');
@@ -342,11 +346,14 @@ export function createFileLock({ workerFactory = defaultWorkerFactory } = {}) {
     if (typeof nonblocking !== 'boolean') {
       throw new TypeError('file lock nonblocking must be a boolean');
     }
+    if (typeof createParent !== 'boolean') {
+      throw new TypeError('file lock createParent must be a boolean');
+    }
     if (fn.constructor?.name === 'AsyncFunction') {
       throw new TypeError('withFileLock requires a synchronous callback');
     }
 
-    const location = canonicalTarget(target);
+    const location = canonicalTarget(target, { createParent });
     const resources = acquireWorker(location, { timeoutMs, retryMs, nonblocking }, workerFactory);
     let result;
     let primary = NO_ERROR;

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

@@ -10,9 +10,12 @@ export function runSocketLockWorker(workerData) {
   const state = new Int32Array(workerData.stateBuffer);
   const states = workerData.states;
   const targets = workerData.targets;
+  const acceptedSockets = new Set();
   let servers = [];
+  let closeOperation = null;
   let contentionDeadline = null;
   let releasing = false;
+  let terminalFailureRequested = false;
   let finished = false;
   let generation = 0;
 
@@ -24,37 +27,69 @@ export function runSocketLockWorker(workerData) {
 
   function finish(status, detail = 0) {
     if (finished) return;
+    if (terminalFailureRequested) {
+      status = states.FAILED;
+      detail = 1;
+    }
     finished = true;
     publish(status, detail);
     parentPort.close();
   }
 
   function closeServers(callback) {
-    const closing = servers;
-    servers = [];
-    if (closing.length === 0) {
-      callback(null);
+    if (closeOperation !== null) {
+      closeOperation.callbacks.push(callback);
+      if (closeOperation.cleanupStarted) destroyAcceptedSockets();
       return;
     }
-    let remaining = closing.length;
-    let firstError = null;
+    const closing = servers;
+    servers = [];
+    const operation = {
+      callbacks: [callback],
+      cleanupStarted: false,
+      closing,
+      completed: false,
+      firstError: null,
+      remaining: closing.length
+    };
+    closeOperation = operation;
+    const complete = () => {
+      if (operation.completed || !operation.cleanupStarted || operation.remaining !== 0) return;
+      operation.completed = true;
+      closeOperation = null;
+      const callbacks = operation.callbacks;
+      operation.callbacks = [];
+      operation.closing = [];
+      for (const waiting of callbacks) waiting(operation.firstError);
+    };
     const closed = (error = null) => {
-      if (error && !firstError) firstError = error;
-      remaining -= 1;
-      if (remaining === 0) callback(firstError);
+      if (error && !operation.firstError) operation.firstError = error;
+      operation.remaining -= 1;
+      complete();
     };
-    for (const server of closing) {
+    for (const server of operation.closing) {
+      let settled = false;
+      const serverClosed = (error = null) => {
+        if (settled) return;
+        settled = true;
+        closed(error);
+      };
       try {
-        server.close(closed);
+        server.close(serverClosed);
       } catch (error) {
-        closed(error);
+        serverClosed(error);
       }
     }
+    destroyAcceptedSockets();
+    operation.cleanupStarted = true;
+    complete();
   }
 
-  function closeAndFinish(status, detail = 0) {
+  function requestTerminalFailure() {
+    if (finished) return;
+    terminalFailureRequested = true;
     generation += 1;
-    closeServers((error) => finish(error ? states.FAILED : status, error ? 1 : detail));
+    closeServers(() => finish(states.FAILED, 1));
   }
 
   function retryAfterContention() {
@@ -77,8 +112,8 @@ export function runSocketLockWorker(workerData) {
     if (finished || attemptGeneration !== generation) return;
     generation += 1;
     closeServers((error) => {
-      if (error) finish(states.FAILED, 1);
-      else retryAfterContention();
+      if (error) requestTerminalFailure();
+      else if (!terminalFailureRequested) retryAfterContention();
     });
   }
 
@@ -86,6 +121,19 @@ export function runSocketLockWorker(workerData) {
     return `${PROTOCOL_PREFIX}${identity}\n`;
   }
 
+  function serveLock(socket, identity) {
+    acceptedSockets.add(socket);
+    socket.once('close', () => acceptedSockets.delete(socket));
+    socket.on('error', () => {});
+    socket.end(lockBanner(identity));
+  }
+
+  function destroyAcceptedSockets() {
+    for (const socket of acceptedSockets) {
+      try { socket.destroy(); } catch {}
+    }
+  }
+
   function probeOccupant(port, identity, callback) {
     const expected = lockBanner(identity);
     let received = '';
@@ -129,12 +177,11 @@ export function runSocketLockWorker(workerData) {
     const port = target.ports[candidateIndex];
     let candidate;
     try {
-      candidate = net.createServer((socket) => socket.end(lockBanner(target.identity)));
+      candidate = net.createServer((socket) => serveLock(socket, target.identity));
       const bindError = (error) => {
         if (finished || attemptGeneration !== generation) return;
         if (error?.code !== 'EADDRINUSE') {
-          generation += 1;
-          closeServers(() => finish(states.FAILED, 1));
+          requestTerminalFailure();
           return;
         }
         probeOccupant(port, target.identity, (matching) => {
@@ -150,13 +197,12 @@ export function runSocketLockWorker(workerData) {
           return;
         }
         candidate.off('error', bindError);
-        candidate.on('error', () => closeAndFinish(states.FAILED, 1));
+        candidate.on('error', requestTerminalFailure);
         servers.push(candidate);
         bindCandidate(targetIndex, candidateIndex + 1, boundForTarget + 1, attemptGeneration);
       });
     } catch {
-      generation += 1;
-      closeServers(() => finish(states.FAILED, 1));
+      requestTerminalFailure();
     }
   }
 
@@ -184,7 +230,10 @@ export function runSocketLockWorker(workerData) {
         Atomics.load(state, STATE_INDEX) !== states.ACQUIRED) return;
     releasing = true;
     generation += 1;
-    closeServers((error) => finish(error ? states.RELEASE_FAILED : states.RELEASED, error ? 1 : 0));
+    closeServers((error) => {
+      if (terminalFailureRequested) finish(states.FAILED, 1);
+      else finish(error ? states.RELEASE_FAILED : states.RELEASED, error ? 1 : 0);
+    });
   });
 
   try {
@@ -196,6 +245,6 @@ export function runSocketLockWorker(workerData) {
     }
     attemptAll();
   } catch {
-    closeAndFinish(states.FAILED, 1);
+    requestTerminalFailure();
   }
 }

package/lib/terminal/tmux.mjs

@@ -36,14 +36,20 @@ export function runTmux(args, opts = {}) {
   return result.stdout || '';
 }
 
-function tmuxInstallHint() {
-  if (process.platform === 'darwin') return 'Install tmux with: brew install tmux';
-  if (process.platform === 'linux') {
-    if (fs.existsSync('/etc/debian_version')) return 'Install tmux with: sudo apt-get update && sudo apt-get install -y tmux';
-    if (fs.existsSync('/etc/alpine-release')) return 'Install tmux with: sudo apk add tmux';
-    if (fs.existsSync('/etc/arch-release')) return 'Install tmux with: sudo pacman -S --noconfirm tmux';
-    if (fs.existsSync('/etc/fedora-release')) return 'Install tmux with: sudo dnf install -y tmux';
-    return 'Install tmux with your system package manager.';
+export function tmuxInstallHint({
+  platform = process.platform,
+  pathExists = fs.existsSync
+} = {}) {
+  if (platform === 'darwin') return 'Install tmux with: brew install tmux';
+  if (platform === 'linux') {
+    if (pathExists('/etc/debian_version')) return 'Install tmux with: sudo apt-get update && sudo apt-get install -y tmux';
+    if (pathExists('/etc/alpine-release')) return 'Install tmux with: sudo apk add tmux';
+    if (pathExists('/etc/arch-release')) return 'Install tmux with: sudo pacman -S --noconfirm tmux';
+    if (pathExists('/etc/fedora-release') || pathExists('/etc/redhat-release')) {
+      return 'Install tmux with: sudo dnf install -y tmux (or sudo yum install -y tmux on older systems)';
+    }
+    if (pathExists('/etc/SuSE-release')) return 'Install tmux with: sudo zypper --non-interactive install tmux';
+    return 'Install tmux with your Linux system package manager (apt/apt-get, dnf/yum, apk, pacman, or zypper).';
   }
   return 'Install tmux and make sure it is on PATH.';
 }
@@ -54,6 +60,36 @@ function commandExists(name) {
   }).status === 0;
 }
 
+export function tmuxInstallPlan({
+  platform = process.platform,
+  commandAvailable = commandExists,
+  isRoot = typeof process.getuid === 'function' && process.getuid() === 0
+} = {}) {
+  if (platform === 'darwin') {
+    return commandAvailable('brew')
+      ? { manager: 'brew', commands: ['brew install tmux'] }
+      : null;
+  }
+  if (platform !== 'linux') return null;
+
+  if (!isRoot && !commandAvailable('sudo')) return null;
+  const sudo = isRoot ? '' : 'sudo ';
+  if (commandAvailable('apt-get')) {
+    return {
+      manager: 'apt-get',
+      commands: [`${sudo}apt-get update`, `${sudo}apt-get install -y tmux`]
+    };
+  }
+  if (commandAvailable('dnf')) return { manager: 'dnf', commands: [`${sudo}dnf install -y tmux`] };
+  if (commandAvailable('yum')) return { manager: 'yum', commands: [`${sudo}yum install -y tmux`] };
+  if (commandAvailable('apk')) return { manager: 'apk', commands: [`${sudo}apk add tmux`] };
+  if (commandAvailable('pacman')) return { manager: 'pacman', commands: [`${sudo}pacman -S --noconfirm tmux`] };
+  if (commandAvailable('zypper')) {
+    return { manager: 'zypper', commands: [`${sudo}zypper --non-interactive install tmux`] };
+  }
+  return null;
+}
+
 function runInstallCommand(command) {
   const result = spawnSync('sh', ['-lc', command], {
     encoding: 'utf8',
@@ -70,22 +106,16 @@ export function tryInstallTmux() {
   if (process.env.HCC_NO_AUTO_INSTALL_TMUX === '1') {
     return { ok: false, output: 'automatic tmux installation disabled by HCC_NO_AUTO_INSTALL_TMUX=1' };
   }
-  const sudo = typeof process.getuid === 'function' && process.getuid() === 0 ? '' : (commandExists('sudo') ? 'sudo ' : '');
-  if (process.platform === 'darwin' && commandExists('brew')) {
-    return runInstallCommand('brew install tmux');
-  }
-  if (process.platform === 'linux') {
-    if (commandExists('apt-get')) {
-      const update = runInstallCommand(`${sudo}apt-get update`);
-      if (!update.ok) return update;
-      return runInstallCommand(`${sudo}apt-get install -y tmux`);
-    }
-    if (commandExists('dnf')) return runInstallCommand(`${sudo}dnf install -y tmux`);
-    if (commandExists('yum')) return runInstallCommand(`${sudo}yum install -y tmux`);
-    if (commandExists('apk')) return runInstallCommand(`${sudo}apk add tmux`);
-    if (commandExists('pacman')) return runInstallCommand(`${sudo}pacman -S --noconfirm tmux`);
+  const plan = tmuxInstallPlan();
+  if (!plan) return { ok: false, output: 'no supported package manager with sufficient privileges found' };
+
+  const output = [];
+  for (const command of plan.commands) {
+    const result = runInstallCommand(command);
+    if (result.output) output.push(result.output);
+    if (!result.ok) return { ok: false, output: output.join('\n') };
   }
-  return { ok: false, output: 'no supported package manager found' };
+  return { ok: true, output: output.join('\n') };
 }
 
 export function ensureTmuxAvailable({ autoInstall = true } = {}) {

package/lib/web/buffer-gc-runtime.mjs

@@ -147,8 +147,8 @@ export function createBufferGcRuntime(deps) {
             olderThanDays: 14,
             dryRun: false,
             scope: 'auto',
-            collectBufferEvidenceNow: () => collectRuntimeBufferEvidence([
-              bufferDirectory(projectCtx)
+            collectBufferEvidenceNow: (directory) => collectRuntimeBufferEvidence([
+              directory
             ])
           });
           const appliedDatabaseRows = result.expired_locks + result.old_events;

package/lib/web/project-contexts.mjs

@@ -5,6 +5,7 @@
 
 import path from 'node:path';
 import { randomBytes } from 'node:crypto';
+import WebSocket from 'ws';
 import { CliError } from '../shared/errors.mjs';
 import { contextForProject } from '../runtime/paths.mjs';
 import { resolveProjectDatabase } from '../runtime/project-path.mjs';
@@ -145,7 +146,11 @@ export function createProjectContexts(deps) {
     }
     const provided = readActionToken(input, req);
     const authorized = Boolean(provided) && [...(session.actionTokens || [])]
-      .some((candidate) => tokenMatches(provided, candidate));
+      .some((candidate) => {
+        if (!tokenMatches(provided, candidate)) return false;
+        const socket = session.actionTokenSockets?.get(candidate);
+        return socket?.readyState === WebSocket.OPEN;
+      });
     if (!authorized) {
       throw new CliError("PEER_IDENTITY_REQUIRED", "Web peer action for " + peer + " requires the managed session action token", { peer });
     }

package/lib/web/runtime-main.mjs

@@ -499,7 +499,9 @@ const {
         return;
       }
       session.actionTokens ||= new Set();
+      session.actionTokenSockets ||= new Map();
       session.actionTokens.add(connectionActionToken);
+      session.actionTokenSockets.set(connectionActionToken, ws);
       ws.send(JSON.stringify({ type: 'snapshot', data: refreshTmuxSnapshot(session), action_token: connectionActionToken }));
       ws.on('message', (raw) => {
         try {
@@ -523,6 +525,7 @@ const {
       ws.on('close', () => {
         session.clients.delete(ws);
         session.actionTokens.delete(connectionActionToken);
+        session.actionTokenSockets.delete(connectionActionToken);
         if (cookieAuth) cookieAuth.session.sockets.delete(ws);
       });
     });

package/lib/web/startup.mjs

@@ -31,6 +31,8 @@ import { WEB_CHILD_ENV } from '../core/sessions/launch.mjs';
 import { API_VERSION } from '../web/api-version.mjs';
 import { ensureTmuxAvailable } from '../tmux.mjs';
 
+export const WEB_RUNTIME_START_TIMEOUT_MS = 60_000;
+
 export function createWebStartup(deps) {
   const {
     splitProcessArgs, sameResolvedPath,
@@ -257,7 +259,7 @@ async function waitForStartedRuntime(ctx, child, logFile) {
     exitInfo = { code, signal };
   });
 
-  const deadline = Date.now() + 15000;
+  const deadline = Date.now() + WEB_RUNTIME_START_TIMEOUT_MS;
   while (Date.now() < deadline) {
     const runtime = await readHealthyGlobalRuntime();
     if (runtime) return runtime;
@@ -278,7 +280,7 @@ async function waitForStartedRuntime(ctx, child, logFile) {
   } catch {}
   const detail = redactedLogText(tailFile(logFile));
   throw new CliError('RUNTIME_START_TIMEOUT',
-    `${PRODUCT_NAME} runtime did not become healthy within 15s.` +
+    `${PRODUCT_NAME} runtime did not become healthy within ${WEB_RUNTIME_START_TIMEOUT_MS / 1000}s.` +
     `${detail ? `\n\nLast log lines:\n${detail}` : ''}`,
     { log: logFile });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logicseek/hello-cc",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Local control plane for coordinating Claude Code, Codex, and other coding CLI sessions.",
   "type": "module",
   "bin": {
@@ -56,7 +56,7 @@
   "dependencies": {
     "@xterm/addon-fit": "^0.11.0",
     "@xterm/xterm": "^6.0.0",
-    "node-pty": "^1.1.0",
+    "node-pty": "1.2.0-beta.15",
     "ws": "^8.21.0"
   },
   "license": "Apache-2.0"