@logicseek/hello-cc 1.0.2 → 1.0.4

package/lib/integrations/hooks.mjs

@@ -1,6 +1,10 @@
+import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { readJsonSafe, writeJsonSafe } from '../shared/json-file.mjs';
+import { commandPath } from '../cli-runtime.mjs';
+import { shellQuoteArg } from '../format.mjs';
+import { CliError } from '../shared/errors.mjs';
+import { writeJsonSafe } from '../shared/json-file.mjs';
 
 const CLAUDE_SETTINGS_PATH = path.join(os.homedir(), '.claude', 'settings.json');
 const CODEX_HOOKS_PATH = path.join(os.homedir(), '.codex', 'hooks.json');
@@ -18,15 +22,15 @@ const CODEX_HOOK_EVENTS = ['SessionStart', 'UserPromptSubmit', 'PreToolUse', 'St
 
 /**
  * Install (or update) hello-cc hooks in ~/.claude/settings.json.
- * Non-destructive: only adds hcc entries, never removes existing ones.
+ * Replaces stale hcc entries while retaining unrelated hooks.
  * Returns the settings file path.
  */
 export function installClaudeHooks(hccBin) {
-  const settings = readJsonSafe(CLAUDE_SETTINGS_PATH) || {};
+  const settings = readHookConfig(CLAUDE_SETTINGS_PATH) || {};
 
   if (!settings.hooks) settings.hooks = {};
 
-  const hookCmd = `${hccBin} hook`;
+  const hookCmd = `${shellQuoteArg(hccBin)} hook`;
 
   for (const event of CLAUDE_HOOK_EVENTS) {
     settings.hooks[event] = mergeHookEntry(
@@ -43,29 +47,31 @@ export function installClaudeHooks(hccBin) {
  * Remove hello-cc hook entries from ~/.claude/settings.json.
  */
 export function uninstallClaudeHooks() {
-  const settings = readJsonSafe(CLAUDE_SETTINGS_PATH);
+  const settings = readHookConfig(CLAUDE_SETTINGS_PATH);
   if (!settings?.hooks) return false;
 
+  let removed = false;
   for (const event of Object.keys(settings.hooks)) {
     if (!Array.isArray(settings.hooks[event])) continue;
-    settings.hooks[event] = settings.hooks[event].filter(entry => {
-      if (!Array.isArray(entry?.hooks)) return true;
-      return !entry.hooks.some(h => isHccHookCmd(h?.command));
-    });
+    const result = removeHccHooks(settings.hooks[event]);
+    settings.hooks[event] = result.entries;
+    removed ||= result.removed;
     if (settings.hooks[event].length === 0) delete settings.hooks[event];
   }
 
-  writeJsonSafe(CLAUDE_SETTINGS_PATH, settings);
-  return true;
+  if (removed) writeJsonSafe(CLAUDE_SETTINGS_PATH, settings);
+  return removed;
 }
 
 /**
  * Returns true if hello-cc hooks are present in ~/.claude/settings.json.
  */
-export function verifyClaudeHooks() {
-  const settings = readJsonSafe(CLAUDE_SETTINGS_PATH);
+export function verifyClaudeHooks(hccBin = commandPath()) {
+  const settings = readHookConfig(CLAUDE_SETTINGS_PATH);
   if (!settings?.hooks) return false;
-  return CLAUDE_HOOK_EVENTS.every(event => hasHookEntry(settings.hooks[event]));
+  const hookCmd = `${shellQuoteArg(hccBin)} hook`;
+  return CLAUDE_HOOK_EVENTS.every(event =>
+    hasHookEntry(settings.hooks[event], `${hookCmd} ${event.toLowerCase()}`));
 }
 
 /**
@@ -75,11 +81,11 @@ export function verifyClaudeHooks() {
  *   { "hooks": { "PreToolUse": [{ "matcher": "Bash", "hooks": [...] }], "Stop": [...] } }
  */
 export function installCodexHooks(hccBin) {
-  const hooks = readJsonSafe(CODEX_HOOKS_PATH) || {};
+  const hooks = readHookConfig(CODEX_HOOKS_PATH) || {};
 
   if (!hooks.hooks) hooks.hooks = {};
 
-  const hookCmd = `${hccBin} hook`;
+  const hookCmd = `${shellQuoteArg(hccBin)} hook`;
 
   // SessionStart: inject initial coordination context on startup/resume.
   hooks.hooks.SessionStart = mergeCodexHookEntry(
@@ -111,56 +117,61 @@ export function installCodexHooks(hccBin) {
 }
 
 export function uninstallCodexHooks() {
-  const hooks = readJsonSafe(CODEX_HOOKS_PATH);
+  const hooks = readHookConfig(CODEX_HOOKS_PATH);
   if (!hooks?.hooks) return false;
 
+  let removed = false;
   for (const event of Object.keys(hooks.hooks)) {
     if (!Array.isArray(hooks.hooks[event])) continue;
-    hooks.hooks[event] = hooks.hooks[event].filter(entry => {
-      if (!Array.isArray(entry?.hooks)) return true;
-      return !entry.hooks.some(h => isHccHookCmd(h?.command));
-    });
+    const result = removeHccHooks(hooks.hooks[event]);
+    hooks.hooks[event] = result.entries;
+    removed ||= result.removed;
     if (hooks.hooks[event].length === 0) delete hooks.hooks[event];
   }
 
-  writeJsonSafe(CODEX_HOOKS_PATH, hooks);
-  return true;
+  if (removed) writeJsonSafe(CODEX_HOOKS_PATH, hooks);
+  return removed;
 }
 
-export function verifyCodexHooks() {
-  const hooks = readJsonSafe(CODEX_HOOKS_PATH);
+export function verifyCodexHooks(hccBin = commandPath()) {
+  const hooks = readHookConfig(CODEX_HOOKS_PATH);
   if (!hooks?.hooks) return false;
-  return CODEX_HOOK_EVENTS.every(event => hasHookEntry(hooks.hooks[event]));
+  const hookCmd = `${shellQuoteArg(hccBin)} hook`;
+  return CODEX_HOOK_EVENTS.every(event =>
+    hasHookEntry(hooks.hooks[event], `${hookCmd} ${event.toLowerCase()}`,
+      event === 'PreToolUse' ? 'Bash' : undefined));
 }
 
 function mergeHookEntry(existing, command) {
-  const entries = Array.isArray(existing) ? [...existing] : [];
-  const alreadyInstalled = entries.some(
-    e => Array.isArray(e?.hooks) && e.hooks.some(h => isHccHookCmd(h?.command))
-  );
-  if (alreadyInstalled) return entries;
+  const entries = removeHccHooks(hookEntries(existing)).entries;
   entries.push({ hooks: [{ type: 'command', command }] });
   return entries;
 }
 
-function hasHookEntry(entries) {
+function hasHookEntry(entries, command, matcher) {
   if (!Array.isArray(entries)) return false;
   return entries.some(e =>
-    Array.isArray(e?.hooks) && e.hooks.some(h => isHccHookCmd(h?.command))
+    (matcher === undefined || e?.matcher === matcher) &&
+    Array.isArray(e?.hooks) && e.hooks.some(h => h?.type === 'command' && h.command === command)
   );
 }
 
 function isHccHookCmd(cmd) {
-  if (typeof cmd !== 'string') return false;
-  return /\bhcc\b.*\bhook\b/.test(cmd) || /hello-cc.*hook/.test(cmd);
+  const words = shellWords(cmd);
+  if (words?.length) {
+    const offset = ['node', 'nodejs', 'node.exe'].includes(path.basename(words[0])) ? 1 : 0;
+    if (['hcc', 'hello-cc', 'hcc.mjs'].includes(path.basename(words[offset] || '')) &&
+        words[offset + 1] === 'hook') return true;
+  }
+  // Older installers wrote the absolute script path without shell quoting.
+  // Match only that entire generated form, not a command that merely mentions hcc.
+  const legacy = typeof cmd === 'string' &&
+    /^(\/[^\r\n;&|<>$`()\\]*\/hcc\.mjs) hook (?:sessionstart|userpromptsubmit|pretooluse|posttooluse|stop)$/i.exec(cmd);
+  return Boolean(legacy && !/\s\//.test(legacy[1]));
 }
 
 function mergeCodexHookEntry(existing, command, matcher) {
-  const entries = Array.isArray(existing) ? [...existing] : [];
-  const alreadyInstalled = entries.some(
-    e => Array.isArray(e?.hooks) && e.hooks.some(h => isHccHookCmd(h?.command))
-  );
-  if (alreadyInstalled) return entries;
+  const entries = removeHccHooks(hookEntries(existing)).entries;
 
   const entry = {
     hooks: [{ type: 'command', command }],
@@ -169,3 +180,84 @@ function mergeCodexHookEntry(existing, command, matcher) {
   entries.push(entry);
   return entries;
 }
+
+function readHookConfig(filePath) {
+  let contents;
+  try { contents = fs.readFileSync(filePath, 'utf8'); }
+  catch (error) {
+    if (error?.code === 'ENOENT') return null;
+    throw error;
+  }
+  let config;
+  try { config = JSON.parse(contents); }
+  catch { throw new CliError('INVALID_HOOK_CONFIG', `Invalid JSON in ${filePath}; hooks were not changed`); }
+  if (!config || typeof config !== 'object' || Array.isArray(config) ||
+      (config.hooks !== undefined && (!config.hooks || typeof config.hooks !== 'object' || Array.isArray(config.hooks)))) {
+    throw new CliError('INVALID_HOOK_CONFIG', `Invalid hooks structure in ${filePath}; hooks were not changed`);
+  }
+  if (config.hooks && Object.values(config.hooks).some(entries => !Array.isArray(entries))) {
+    throw new CliError('INVALID_HOOK_CONFIG', `Invalid hook event in ${filePath}; hooks were not changed`);
+  }
+  return config;
+}
+
+function hookEntries(existing) {
+  if (existing === undefined) return [];
+  if (Array.isArray(existing)) return existing;
+  throw new CliError('INVALID_HOOK_CONFIG', 'Hook event must be an array; hooks were not changed');
+}
+
+function removeHccHooks(entries) {
+  let removed = false;
+  const kept = [];
+  for (const entry of entries) {
+    if (!Array.isArray(entry?.hooks)) {
+      kept.push(entry);
+      continue;
+    }
+    const hooks = entry.hooks.filter(hook => {
+      if (!isHccHookCmd(hook?.command)) return true;
+      removed = true;
+      return false;
+    });
+    if (hooks.length === entry.hooks.length) kept.push(entry);
+    else if (hooks.length) kept.push({ ...entry, hooks });
+  }
+  return { entries: kept, removed };
+}
+
+function shellWords(command) {
+  if (typeof command !== 'string') return null;
+  const words = [];
+  let word = '';
+  let started = false;
+  let quote = null;
+  for (let i = 0; i < command.length; i++) {
+    const char = command[i];
+    if (quote === "'") {
+      if (char === "'") quote = null;
+      else word += char;
+    } else if (quote === '"') {
+      if (char === '"') quote = null;
+      else if (char === '\\') word += command[++i] || '';
+      else if (char === '$' || char === '`') return null;
+      else word += char;
+    } else if (/\s/.test(char)) {
+      if (started) { words.push(word); word = ''; started = false; }
+    } else if (char === "'" || char === '"') {
+      quote = char;
+      started = true;
+    } else if (char === '\\') {
+      word += command[++i] || '';
+      started = true;
+    } else if (';&|<>$`()'.includes(char)) {
+      return null;
+    } else {
+      word += char;
+      started = true;
+    }
+  }
+  if (quote) return null;
+  if (started) words.push(word);
+  return words;
+}

package/lib/integrations/peers/identity.mjs

@@ -105,6 +105,29 @@ function detectCliKindFromProcess(args, env) {
   return null;
 }
 
+function executableCliKind(args) {
+  if (argsLookLikeDsh(args)) return 'dsh';
+  if (!Array.isArray(args) || !args.length) return null;
+  const executable = path.basename(String(args[0] || '')).toLowerCase();
+  if (executable === 'codex') return 'codex';
+  if (executable === 'claude' || executable === 'claude-code') return 'claude';
+  if (!['node', 'nodejs', 'bun'].includes(executable)) return null;
+
+  let index = 1;
+  const valueFlags = new Set(['-r', '--require', '--import', '--loader', '--experimental-loader', '--conditions']);
+  while (index < args.length && String(args[index]).startsWith('-')) {
+    const flag = String(args[index]);
+    if (flag === '--') { index += 1; break; }
+    if (/^-[ep]/.test(flag) || ['--eval', '--print'].some(name => flag === name || flag.startsWith(`${name}=`))) return null;
+    index += valueFlags.has(flag) ? 2 : 1;
+  }
+  const entry = String(args[index] || '').replaceAll('\\', '/').toLowerCase();
+  const basename = path.posix.basename(entry);
+  if (entry.includes('/@openai/codex/') || ['codex', 'codex.js', 'codex.mjs'].includes(basename)) return 'codex';
+  if (entry.includes('/@anthropic-ai/claude-code/') || ['claude', 'claude.js', 'claude.mjs'].includes(basename)) return 'claude';
+  return null;
+}
+
 export function findLinuxAncestorCliInfo(startPid, options = {}) {
   const read = typeof options.read === 'function'
     ? options.read
@@ -115,17 +138,22 @@ export function findLinuxAncestorCliInfo(startPid, options = {}) {
       });
   let pid = Number(startPid);
   const seen = new Set();
+  let fallback = null;
   for (let depth = 0; Number.isInteger(pid) && pid > 1 && depth < 12 && !seen.has(pid); depth += 1) {
     seen.add(pid);
     const row = read(pid);
-    if (!row) return null;
+    if (!row) return fallback;
     const args = Array.isArray(row.args) ? row.args : [];
     const env = row.env && typeof row.env === 'object' && !Array.isArray(row.env) ? row.env : {};
+    const executableKind = executableCliKind(args);
+    if (executableKind && (!options.kind || options.kind === executableKind)) {
+      return { pid, kind: executableKind, args, env };
+    }
     const kind = detectCliKindFromProcess(args, env);
-    if (kind && (!options.kind || options.kind === kind)) return { pid, kind, args, env };
+    if (!fallback && kind && (!options.kind || options.kind === kind)) fallback = { pid, kind, args, env };
     pid = Number(row.parent);
   }
-  return null;
+  return fallback;
 }
 
 export function parseMacAncestorLine(text) {
@@ -153,21 +181,28 @@ export function findMacAncestorCliInfo(startPid, options = {}) {
   const inspect = typeof options.inspect === 'function' ? options.inspect : inspectMacAncestor;
   let pid = Number(startPid);
   const seen = new Set();
+  let fallback = null;
   for (let depth = 0; Number.isInteger(pid) && pid > 1 && depth < 12 && !seen.has(pid); depth += 1) {
     seen.add(pid);
     const parsed = parseMacAncestorLine(inspect(pid));
-    if (!parsed) return null;
+    if (!parsed) return fallback;
     // ps provides a rendered command, not lossless argv. Only tokenize enough
     // to recognize the dsh executable/Node script; resume parsing remains off.
     const commandArgs = parsed.command.match(/"(?:\\.|[^"\\])*"|'[^']*'|\S+/g)?.map((arg) =>
       /^("|')/.test(arg) ? arg.slice(1, -1) : arg) || [];
-    const kind = argsLookLikeDsh(commandArgs) ? 'dsh' : detectCliKindFromProcess([parsed.command], {});
+    const executableKind = executableCliKind(commandArgs);
+    if (executableKind && (!options.kind || options.kind === executableKind)) {
+      return { pid, kind: executableKind, args: [], env: {}, command: parsed.command };
+    }
+    const kind = detectCliKindFromProcess([parsed.command], {});
     // `ps command` is sufficient for provider-kind detection but is not a
     // lossless argv encoding. Do not feed it to resume-ID parsing.
-    if (kind && (!options.kind || options.kind === kind)) return { pid, kind, args: [], env: {}, command: parsed.command };
+    if (!fallback && kind && (!options.kind || options.kind === kind)) {
+      fallback = { pid, kind, args: [], env: {}, command: parsed.command };
+    }
     pid = parsed.ppid;
   }
-  return null;
+  return fallback;
 }
 
 export function readAncestorCliInfo(kindHint = null) {

package/lib/process/identity.mjs

@@ -97,35 +97,52 @@ function parseMacBootToken(text) {
   return `${seconds}:${microseconds}`;
 }
 
-function macIdentity(pid) {
+function parseMacStateStart(text) {
+  const match = /^(\S+)\s+([^\r\n]+)$/.exec(String(text ?? '').trim());
+  // Darwin ps uses X only as a traced/debugged modifier; Z is its exit state.
+  if (!match || !/^[IRSTUZ][+<>AELNSsVWX]*$/.test(match[1])) return null;
+  return { state: match[1][0], startToken: match[2].trim() };
+}
+
+function macObservation(pid) {
+  const unknown = { state: 'unknown', identity: null };
   let boot = run('sysctl', ['-n', 'kern.boottime']);
   // Launchers often omit /usr/sbin from PATH; macOS still provides sysctl here.
   if (boot.error?.code === 'ENOENT') boot = run('/usr/sbin/sysctl', ['-n', 'kern.boottime']);
-  if (boot.error || boot.status !== 0) return null;
+  if (boot.error || boot.status !== 0) return unknown;
   const bootToken = parseMacBootToken(boot.stdout);
-  if (!bootToken) return null;
+  if (!bootToken) return unknown;
 
   const psEnvironment = { ...process.env, TZ: 'UTC', LC_ALL: 'C', LANG: 'C' };
-  const started = run('ps', ['-p', String(pid), '-o', 'lstart='], psEnvironment);
+  // kill(pid, 0) also succeeds for an unreaped zombie on Darwin. Read state
+  // alongside each existing start-time probe, without adding subprocesses.
+  const started = run('ps', ['-p', String(pid), '-o', 'stat=', '-o', 'lstart='], psEnvironment);
+  const first = parseMacStateStart(started.stdout);
+  if (started.error || started.status !== 0 || !first) return unknown;
+  if (first.state === 'Z') return { state: 'dead', identity: null };
   const command = run('ps', ['-p', String(pid), '-o', 'command='], psEnvironment);
-  const confirmedStarted = run('ps', ['-p', String(pid), '-o', 'lstart='], psEnvironment);
-  if (started.error || command.error || confirmedStarted.error) return null;
-  if (started.status !== 0 ||
-      command.status !== 0 || confirmedStarted.status !== 0) return null;
+  const confirmedStarted = run('ps', ['-p', String(pid), '-o', 'stat=', '-o', 'lstart='], psEnvironment);
+  const last = parseMacStateStart(confirmedStarted.stdout);
+  if (confirmedStarted.error || confirmedStarted.status !== 0 || !last) return unknown;
+  if (last.state === 'Z') return { state: 'dead', identity: null };
+  if (command.error || command.status !== 0) return unknown;
 
   const commandOutput = String(command.stdout ?? '').trim();
   const parsed = parsePsStartIdentity(
-    `${String(started.stdout ?? '').trim()}\t${commandOutput}\n`
+    `${first.startToken}\t${commandOutput}\n`
   );
   const confirmed = parsePsStartIdentity(
-    `${String(confirmedStarted.stdout ?? '').trim()}\t${commandOutput}\n`
+    `${last.startToken}\t${commandOutput}\n`
   );
-  if (!parsed || !confirmed || confirmed.startToken !== parsed.startToken) return null;
+  if (!parsed || !confirmed || confirmed.startToken !== parsed.startToken) return unknown;
 
   return {
-    pid,
-    startToken: `${bootToken}:${parsed.startToken}`,
-    commandHash: hashCommand(parsed.command)
+    state: 'live',
+    identity: {
+      pid,
+      startToken: `${bootToken}:${parsed.startToken}`,
+      commandHash: hashCommand(parsed.command)
+    }
   };
 }
 
@@ -204,7 +221,11 @@ export function inspectProcessIdentity(value) {
       if (observed.state === 'dead') return observed;
       identity = observed.identity;
     }
-    else if (process.platform === 'darwin') identity = macIdentity(pid);
+    else if (process.platform === 'darwin') {
+      const observed = macObservation(pid);
+      if (observed.state === 'dead') return observed;
+      identity = observed.identity;
+    }
   } catch {
     identity = null;
   }

package/lib/runtime/client.mjs

@@ -2,6 +2,7 @@ import { CliError } from '../shared/errors.mjs';
 import { readRuntime } from './state.mjs';
 import { runtimeApiUrl, runtimeHttpRequest } from '../web/runtime.mjs';
 import { withRuntimeApiVersionHeader } from '../web/api-version.mjs';
+import { performance } from 'node:perf_hooks';
 
 const DEFAULT_CLI_NAME = 'hcc';
 export const RUNTIME_SESSION_START_TIMEOUT_MS = 60_000;
@@ -56,7 +57,9 @@ export async function runtimeRequest(ctx, method, route, body = null, runtime =
   let res;
   let text;
   const abortScope = requestAbortScope(opts.signal, opts.timeoutMs);
+  const startedAt = performance.now();
   try {
+    abortScope.signal.throwIfAborted();
     res = await waitForAbort(runtimeHttpRequest(rt, route, {
       method,
       headers,
@@ -68,7 +71,12 @@ export async function runtimeRequest(ctx, method, route, body = null, runtime =
   } catch (err) {
     throw new CliError('RUNTIME_UNREACHABLE', `Runtime is not reachable at ${rt.base_url}. Start ${cliName} web again.`, {
       runtime: rt.source || rt.base_url,
-      message: err.message
+      message: err.message,
+      method,
+      path: url.pathname,
+      elapsedMs: Math.round(performance.now() - startedAt),
+      timeoutMs: opts.timeoutMs === undefined ? 8000 : opts.timeoutMs,
+      errorName: err.name || 'Error'
     });
   } finally {
     abortScope.cleanup();