@logicseek/hello-cc 0.1.5 → 0.1.6

package/lib/integrations/peers/identity.mjs

@@ -0,0 +1,208 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+import { spawnSync } from 'node:child_process';
+import {
+  autoPeerBasis as coreAutoPeerBasis,
+  autoPeerId as coreAutoPeerId,
+  autoPeerKind as coreAutoPeerKind,
+  autoPeerProviderSession as coreAutoPeerProviderSession,
+  autoPeerResumeId as coreAutoPeerResumeId,
+  autoPeerSessionId as coreAutoPeerSessionId,
+  currentPeer as coreCurrentPeer,
+  resolveCurrentPeer as coreResolveCurrentPeer,
+  sanitizePeerPart,
+  shortHash
+} from '../../core/peers/identity.mjs';
+
+export { sanitizePeerPart, shortHash } from '../../core/peers/identity.mjs';
+
+export function currentTtyName() {
+  if (process.env.TTY) return process.env.TTY;
+  const result = spawnSync('tty', [], {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'ignore']
+  });
+  if (result.status !== 0) return '';
+  const tty = result.stdout.trim();
+  return tty && tty !== 'not a tty' ? tty : '';
+}
+
+let ancestorCliInfoCache = undefined;
+
+function readProcCmdline(pid) {
+  if (process.platform !== 'linux' || !pid) return [];
+  try {
+    return fs.readFileSync(`/proc/${pid}/cmdline`, 'utf8').split('\0').filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+function readProcEnv(pid) {
+  const env = {};
+  if (process.platform !== 'linux' || !pid) return env;
+  try {
+    for (const entry of fs.readFileSync(`/proc/${pid}/environ`, 'utf8').split('\0')) {
+      const eq = entry.indexOf('=');
+      if (eq > 0) env[entry.slice(0, eq)] = entry.slice(eq + 1);
+    }
+  } catch {}
+  return env;
+}
+
+function readProcParentPid(pid) {
+  if (process.platform !== 'linux' || !pid) return null;
+  try {
+    const status = fs.readFileSync(`/proc/${pid}/status`, 'utf8');
+    const match = status.match(/^PPid:\s+(\d+)/m);
+    return match ? Number.parseInt(match[1], 10) : null;
+  } catch {
+    return null;
+  }
+}
+
+function argsLookLikeCli(args, kind) {
+  return args.some((arg) => {
+    const text = String(arg || '').toLowerCase();
+    const base = path.basename(text);
+    if (kind === 'codex') return base === 'codex' || text.includes('/codex') || text.includes('@openai/codex');
+    if (kind === 'claude') return base === 'claude' || base === 'claude-code' || text.includes('/claude') || text.includes('@anthropic-ai/claude-code');
+    return false;
+  });
+}
+
+function detectCliKindFromProcess(args, env) {
+  if (env.CLAUDE_CODE_SESSION_ID || env.CLAUDECODE === '1' || argsLookLikeCli(args, 'claude')) return 'claude';
+  if (
+    env.CODEX_SESSION_ID ||
+    env.CODEX_THREAD_ID ||
+    env.CODEX_MANAGED_BY_NPM === '1' ||
+    env.CODEX_MANAGED_BY_BUN === '1' ||
+    argsLookLikeCli(args, 'codex')
+  ) return 'codex';
+  return null;
+}
+
+export function readAncestorCliInfo() {
+  if (ancestorCliInfoCache !== undefined) return ancestorCliInfoCache;
+  if (process.platform !== 'linux') {
+    ancestorCliInfoCache = null;
+    return ancestorCliInfoCache;
+  }
+
+  let pid = process.ppid;
+  const seen = new Set();
+  for (let depth = 0; pid && pid > 1 && depth < 12 && !seen.has(pid); depth += 1) {
+    seen.add(pid);
+    const args = readProcCmdline(pid);
+    const env = readProcEnv(pid);
+    const kind = detectCliKindFromProcess(args, env);
+    if (kind) {
+      ancestorCliInfoCache = { pid, kind, args, env };
+      return ancestorCliInfoCache;
+    }
+    pid = readProcParentPid(pid);
+  }
+
+  ancestorCliInfoCache = null;
+  return ancestorCliInfoCache;
+}
+
+export function resumeIdFromArgs(kind, args) {
+  if (!Array.isArray(args)) return null;
+  if (kind === 'claude') {
+    if (args.includes('--fork-session')) return null;
+    for (let i = 0; i < args.length; i += 1) {
+      const arg = args[i];
+      if ((arg === '--resume' || arg === '-r') && args[i + 1]) return args[i + 1];
+      if (arg.startsWith('--resume=')) return arg.slice('--resume='.length);
+    }
+  }
+  if (kind === 'codex') {
+    const idx = args.indexOf('resume');
+    if (idx >= 0) {
+      for (let i = idx + 1; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === '--last') return null;
+        if (arg.startsWith('-')) continue;
+        return arg;
+      }
+    }
+  }
+  return null;
+}
+
+function peerObservation(kind = null) {
+  const ancestor = readAncestorCliInfo();
+  const ancestorEnv = ancestor?.kind === kind ? ancestor.env || {} : {};
+  const sessionId = kind === 'claude'
+    ? (process.env.CLAUDE_CODE_SESSION_ID || ancestorEnv.CLAUDE_CODE_SESSION_ID || '')
+    : kind === 'codex'
+      ? (process.env.CODEX_SESSION_ID || process.env.CODEX_THREAD_ID || ancestorEnv.CODEX_SESSION_ID || ancestorEnv.CODEX_THREAD_ID || '')
+      : '';
+  const resumeId = ancestor?.kind === kind ? resumeIdFromArgs(kind, ancestor.args) : null;
+  return {
+    ancestor,
+    env: process.env,
+    ppid: process.ppid,
+    resumeId,
+    sessionId,
+    tmuxPane: process.env.TMUX_PANE || '',
+    tty: currentTtyName()
+  };
+}
+
+export function autoPeerProviderSession(kind) {
+  return coreAutoPeerProviderSession(kind, peerObservation(kind));
+}
+
+export function autoPeerSessionId(kind) {
+  return coreAutoPeerSessionId(kind, peerObservation(kind));
+}
+
+export function autoPeerResumeId(kind) {
+  return coreAutoPeerResumeId(kind, peerObservation(kind));
+}
+
+export function autoPeerKind(kindHint = 'shell') {
+  const ancestor = readAncestorCliInfo();
+  let kind = '';
+  if (process.env.CLAUDE_CODE_SESSION_ID || process.env.CLAUDECODE === '1') kind = 'claude';
+  else if (
+    process.env.CODEX_SESSION_ID ||
+    process.env.CODEX_THREAD_ID ||
+    process.env.CODEX_MANAGED_BY_NPM === '1' ||
+    process.env.CODEX_MANAGED_BY_BUN === '1'
+  ) kind = 'codex';
+  else kind = ancestor?.kind || '';
+  return coreAutoPeerKind(kindHint, { kind });
+}
+
+export function autoPeerBasis(kind = null) {
+  return coreAutoPeerBasis(kind, peerObservation(kind));
+}
+
+export function autoPeerId(ctx, kindHint = 'shell') {
+  const kind = autoPeerKind(kindHint);
+  return coreAutoPeerId(ctx, kindHint, {
+    ...peerObservation(kind),
+    kind
+  });
+}
+
+export function resolveCurrentPeer(ctx, opts = {}, key = 'peer', kindHint = 'shell') {
+  const kind = autoPeerKind(kindHint);
+  return coreResolveCurrentPeer(ctx, opts, key, kindHint, {
+    ...peerObservation(kind),
+    kind
+  });
+}
+
+export function currentPeer(ctx, opts = {}, key = 'peer', kindHint = 'shell') {
+  const kind = autoPeerKind(kindHint);
+  return coreCurrentPeer(ctx, opts, key, kindHint, {
+    ...peerObservation(kind),
+    kind
+  });
+}

package/lib/integrations/peers/processes.mjs

@@ -0,0 +1,151 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { resumeIdFromArgs } from './identity.mjs';
+
+function readProcCmdline(pid) {
+  if (process.platform !== 'linux' || !pid) return [];
+  try {
+    return fs.readFileSync(`/proc/${pid}/cmdline`, 'utf8').split('\0').filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+function readProcEnv(pid) {
+  const env = {};
+  if (process.platform !== 'linux' || !pid) return env;
+  try {
+    for (const entry of fs.readFileSync(`/proc/${pid}/environ`, 'utf8').split('\0')) {
+      const eq = entry.indexOf('=');
+      if (eq > 0) env[entry.slice(0, eq)] = entry.slice(eq + 1);
+    }
+  } catch {}
+  return env;
+}
+
+function readProcParentPid(pid) {
+  if (process.platform !== 'linux' || !pid) return null;
+  try {
+    const status = fs.readFileSync(`/proc/${pid}/status`, 'utf8');
+    const match = status.match(/^PPid:\s+(\d+)/m);
+    return match ? Number.parseInt(match[1], 10) : null;
+  } catch {
+    return null;
+  }
+}
+
+function readProcChildren(pid) {
+  if (process.platform !== 'linux' || !pid) return [];
+  try {
+    return fs.readFileSync(`/proc/${pid}/task/${pid}/children`, 'utf8')
+      .trim()
+      .split(/\s+/)
+      .filter(Boolean)
+      .map((value) => Number.parseInt(value, 10))
+      .filter((value) => Number.isFinite(value) && value > 1);
+  } catch {
+    return [];
+  }
+}
+
+function argsLookLikeCli(args, kind) {
+  return args.some((arg) => {
+    const text = String(arg || '').toLowerCase();
+    const base = path.basename(text);
+    if (kind === 'codex') return base === 'codex' || text.includes('/codex') || text.includes('@openai/codex');
+    if (kind === 'claude') return base === 'claude' || base === 'claude-code' || text.includes('/claude') || text.includes('@anthropic-ai/claude-code');
+    return false;
+  });
+}
+
+function detectKind(args, env, kindHint = null) {
+  if (kindHint && argsLookLikeCli(args, kindHint)) return kindHint;
+  if (env.CLAUDE_CODE_SESSION_ID || env.CLAUDECODE === '1' || argsLookLikeCli(args, 'claude')) return 'claude';
+  if (
+    env.CODEX_SESSION_ID ||
+    env.CODEX_THREAD_ID ||
+    env.CODEX_MANAGED_BY_NPM === '1' ||
+    env.CODEX_MANAGED_BY_BUN === '1' ||
+    argsLookLikeCli(args, 'codex')
+  ) return 'codex';
+  return null;
+}
+
+function sessionFromEnv(kind, env) {
+  if (kind === 'claude') return env.CLAUDE_CODE_SESSION_ID || '';
+  if (kind === 'codex') return env.CODEX_SESSION_ID || env.CODEX_THREAD_ID || '';
+  return '';
+}
+
+export function inspectProviderProcess(pid, kindHint = null, opts = {}) {
+  if (process.platform !== 'linux' || !pid) return null;
+  const maxDepth = Number.isFinite(opts.maxDepth) ? opts.maxDepth : 8;
+  const queue = [{ pid: Number(pid), depth: 0 }];
+  const seen = new Set();
+
+  while (queue.length) {
+    const current = queue.shift();
+    const currentPid = current?.pid;
+    const depth = current?.depth || 0;
+    if (!currentPid || currentPid <= 1 || depth > maxDepth || seen.has(currentPid)) continue;
+    seen.add(currentPid);
+    const args = readProcCmdline(currentPid);
+    const env = readProcEnv(currentPid);
+    const kind = detectKind(args, env, kindHint);
+    if (kind) {
+      const envSession = sessionFromEnv(kind, env);
+      if (envSession) {
+        return {
+          pid: currentPid,
+          kind,
+          provider_session: envSession,
+          source: `process.env.${kind}`
+        };
+      }
+      const resumeId = resumeIdFromArgs(kind, args);
+      if (resumeId) {
+        return {
+          pid: currentPid,
+          kind,
+          provider_session: resumeId,
+          source: `process.argv.${kind}`
+        };
+      }
+    }
+    for (const childPid of readProcChildren(currentPid)) {
+      queue.push({ pid: childPid, depth: depth + 1 });
+    }
+  }
+
+  let currentPid = Number(pid);
+  seen.clear();
+
+  for (let depth = 0; currentPid && currentPid > 1 && depth <= maxDepth && !seen.has(currentPid); depth += 1) {
+    seen.add(currentPid);
+    const args = readProcCmdline(currentPid);
+    const env = readProcEnv(currentPid);
+    const kind = detectKind(args, env, kindHint);
+    if (kind) {
+      const envSession = sessionFromEnv(kind, env);
+      if (envSession) {
+        return {
+          pid: currentPid,
+          kind,
+          provider_session: envSession,
+          source: `process.env.${kind}`
+        };
+      }
+      const resumeId = resumeIdFromArgs(kind, args);
+      if (resumeId) {
+        return {
+          pid: currentPid,
+          kind,
+          provider_session: resumeId,
+          source: `process.argv.${kind}`
+        };
+      }
+    }
+    currentPid = readProcParentPid(currentPid);
+  }
+  return null;
+}

package/lib/integrations/providers.mjs

@@ -0,0 +1,282 @@
+import { CliError } from '../shared/errors.mjs';
+import { shellQuoteArg } from '../format.mjs';
+import { providerSessionParts } from '../core/peers/session.mjs';
+
+export {
+  providerSessionParts,
+  providerSessionPeerId
+} from '../core/peers/session.mjs';
+
+function shellCommand(args) {
+  return args.map(shellQuoteArg).join(' ');
+}
+
+export function inferPeerKind(id, explicitKind, firstCommand) {
+  if (explicitKind) return explicitKind;
+  if (['codex', 'claude'].includes(firstCommand)) return firstCommand;
+  if (String(id).startsWith('codex')) return 'codex';
+  if (String(id).startsWith('claude')) return 'claude';
+  return 'shell';
+}
+
+export function hasResumeOpts(opts) {
+  return opts.resume !== undefined || Boolean(opts.last) || Boolean(opts.continue) || Boolean(opts.fork) || opts.session !== undefined;
+}
+
+export function defaultSessionCommand(kind) {
+  if (kind === 'codex') return 'codex';
+  if (kind === 'claude') return 'claude';
+  return process.env.SHELL || 'bash';
+}
+
+export function buildPeerCommand(id, kind, opts, cmdArgs) {
+  const explicitCommand = opts.command || cmdArgs.length > 0;
+  if (explicitCommand && hasResumeOpts(opts)) {
+    throw new CliError('BAD_ARGS', 'Use resume options without an explicit -- COMMAND');
+  }
+  if (explicitCommand) {
+    const command = opts.command || shellCommand(cmdArgs);
+    return {
+      command,
+      binding: {
+        peer: id,
+        provider: kind,
+        resume_mode: 'command',
+        resume_arg: null,
+        command
+      }
+    };
+  }
+  if (kind === 'codex') return buildCodexCommand(id, opts);
+  if (kind === 'claude') return buildClaudeCommand(id, opts);
+  if (hasResumeOpts(opts)) throw new CliError('BAD_ARGS', `Resume options are only supported for codex and claude peers`);
+  const command = defaultSessionCommand(kind);
+  return {
+    command,
+    binding: {
+      peer: id,
+      provider: kind,
+      resume_mode: 'new',
+      resume_arg: null,
+      command
+    }
+  };
+}
+
+export function buildCodexCommand(id, opts) {
+  let command;
+  let resumeMode = 'new';
+  let resumeArg = null;
+  let session = { provider_session_id: null, provider_session_name: null };
+  if (opts.fork) {
+    resumeMode = opts.last ? 'fork-last' : 'fork';
+    if (opts.last) {
+      command = 'codex fork --last';
+      resumeArg = '--last';
+    } else if (opts.resume) {
+      command = `codex fork ${shellQuoteArg(opts.resume)}`;
+      resumeArg = opts.resume;
+    } else {
+      command = 'codex fork';
+    }
+  } else if (opts.last) {
+    command = 'codex resume --last';
+    resumeMode = 'last';
+    resumeArg = '--last';
+  } else if (opts.resume) {
+    command = `codex resume ${shellQuoteArg(opts.resume)}`;
+    resumeMode = 'resume';
+    resumeArg = opts.resume;
+    session = providerSessionParts(opts.resume);
+  } else {
+    command = 'codex';
+  }
+  return {
+    command,
+    binding: {
+      peer: id,
+      provider: 'codex',
+      ...session,
+      resume_mode: resumeMode,
+      resume_arg: resumeArg,
+      command
+    }
+  };
+}
+
+export function buildClaudeCommand(id, opts) {
+  let command = 'claude';
+  let resumeMode = 'new';
+  let resumeArg = null;
+  let session = { provider_session_id: null, provider_session_name: null };
+  if (opts.continue) {
+    command += ' --continue';
+    resumeMode = opts.fork ? 'fork-continue' : 'continue';
+    resumeArg = '--continue';
+  } else if (opts.resume) {
+    command += ` --resume ${shellQuoteArg(opts.resume)}`;
+    resumeMode = opts.fork ? 'fork-resume' : 'resume';
+    resumeArg = opts.resume;
+    if (!opts.fork) session = providerSessionParts(opts.resume);
+  } else if (opts.session) {
+    command += ` --session-id ${shellQuoteArg(opts.session)}`;
+    resumeMode = 'session';
+    resumeArg = opts.session;
+    session = { provider_session_id: opts.session, provider_session_name: null };
+  }
+  if (opts.fork && (opts.continue || opts.resume)) command += ' --fork-session';
+  if (opts.name) command += ` --name ${shellQuoteArg(opts.name)}`;
+  return {
+    command,
+    binding: {
+      peer: id,
+      provider: 'claude',
+      ...session,
+      resume_mode: resumeMode,
+      resume_arg: resumeArg,
+      command
+    }
+  };
+}
+
+export function bindingFromRun(id, kind, command, commandArgs, transport) {
+  const cmdline = [command, ...commandArgs];
+  const provider = kind || 'other';
+  let resumeMode = 'command';
+  let resumeArg = null;
+  let session = { provider_session_id: null, provider_session_name: null };
+  if (provider === 'codex') {
+    const parsed = parseCodexCommandArgs(cmdline);
+    resumeMode = parsed.resume_mode;
+    resumeArg = parsed.resume_arg;
+    session = parsed.session;
+  } else if (provider === 'claude') {
+    const parsed = parseClaudeCommandArgs(cmdline);
+    resumeMode = parsed.resume_mode;
+    resumeArg = parsed.resume_arg;
+    session = parsed.session;
+  }
+  return {
+    peer: id,
+    provider,
+    ...session,
+    resume_mode: resumeMode,
+    resume_arg: resumeArg,
+    command: cmdline.join(' '),
+    transport,
+    runtime_session_id: id
+  };
+}
+
+function optionValue(args, names) {
+  const nameSet = new Set(names);
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (nameSet.has(arg) && args[i + 1]) return args[i + 1];
+    for (const name of names) {
+      if (name.startsWith('--') && arg.startsWith(`${name}=`)) return arg.slice(name.length + 1);
+    }
+  }
+  return null;
+}
+
+function hasFlag(args, names) {
+  const nameSet = new Set(names);
+  return args.some((arg) => nameSet.has(arg));
+}
+
+export function parseClaudeCommandArgs(args) {
+  const resumeId = optionValue(args, ['--resume', '-r']);
+  const sessionId = optionValue(args, ['--session-id']);
+  const name = optionValue(args, ['--name', '-n']);
+  const continuing = hasFlag(args, ['--continue', '-c']);
+  const fork = hasFlag(args, ['--fork-session']);
+  let resumeMode = 'command';
+  let resumeArg = null;
+  let session = { provider_session_id: null, provider_session_name: null };
+
+  if (sessionId) {
+    resumeMode = 'session';
+    resumeArg = sessionId;
+    session = { provider_session_id: sessionId, provider_session_name: null };
+  } else if (resumeId) {
+    resumeMode = fork ? 'fork-resume' : 'resume';
+    resumeArg = resumeId;
+    if (!fork) session = providerSessionParts(resumeId);
+  } else if (continuing) {
+    resumeMode = fork ? 'fork-continue' : 'continue';
+    resumeArg = '--continue';
+  } else if (fork) {
+    resumeMode = 'fork';
+  } else if (name) {
+    resumeMode = 'named';
+    resumeArg = name;
+  }
+
+  return { resume_mode: resumeMode, resume_arg: resumeArg, session };
+}
+
+function codexOptionTakesValue(arg) {
+  if (!arg || arg.includes('=')) return false;
+  return new Set([
+    '-c', '--config',
+    '--remote',
+    '--remote-auth-token-env',
+    '--enable',
+    '--disable',
+    '-i', '--image',
+    '-m', '--model',
+    '--local-provider',
+    '-p', '--profile',
+    '-s', '--sandbox',
+    '-C', '--cd',
+    '--add-dir',
+    '-a', '--ask-for-approval'
+  ]).has(arg);
+}
+
+function firstCodexSessionArg(args, startIndex) {
+  for (let i = startIndex; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === '--last') continue;
+    if (arg.startsWith('-')) {
+      if (codexOptionTakesValue(arg)) i += 1;
+      continue;
+    }
+    return arg;
+  }
+  return null;
+}
+
+export function parseCodexCommandArgs(args) {
+  const subIndex = args.findIndex((arg) => arg === 'resume' || arg === 'fork');
+  if (subIndex < 0) {
+    return {
+      resume_mode: 'command',
+      resume_arg: null,
+      session: { provider_session_id: null, provider_session_name: null }
+    };
+  }
+
+  const subcommand = args[subIndex];
+  const last = args.slice(subIndex + 1).includes('--last');
+  const sessionArg = firstCodexSessionArg(args, subIndex + 1);
+  let resumeMode = subcommand;
+  let resumeArg = sessionArg || null;
+  let session = { provider_session_id: null, provider_session_name: null };
+
+  if (subcommand === 'resume') {
+    if (last && !sessionArg) {
+      resumeMode = 'last';
+      resumeArg = '--last';
+    } else if (sessionArg) {
+      resumeMode = 'resume';
+      session = providerSessionParts(sessionArg);
+    }
+  } else if (subcommand === 'fork') {
+    resumeMode = last && !sessionArg ? 'fork-last' : 'fork';
+    resumeArg = sessionArg || (last ? '--last' : null);
+  }
+
+  return { resume_mode: resumeMode, resume_arg: resumeArg, session };
+}