@logicseek/hello-cc 0.1.5 → 0.1.7

package/lib/core/peers/liveness.mjs

@@ -0,0 +1,90 @@
+const DEFAULT_ACTIVE_PEER_TTL = 600;
+
+function nowSec() {
+  return Math.floor(Date.now() / 1000);
+}
+
+export function taskRelatedLocks(task, locks) {
+  const taskId = Number(task?.id || 0);
+  const owner = task?.owner || '';
+  return (locks || []).filter((lock) => {
+    if (taskId && Number(lock.task_id || 0) === taskId) return true;
+    return Boolean(owner && lock.owner === owner);
+  });
+}
+
+export function taskOwnerLiveness(task, peers, locks, t = nowSec(), activePeerTtl = DEFAULT_ACTIVE_PEER_TTL) {
+  const owner = task?.owner || null;
+  const relatedLocks = taskRelatedLocks(task, locks);
+  if (!owner) {
+    return {
+      owner_known: false,
+      owner_active: null,
+      owner_stale: false,
+      owner_age_sec: null,
+      related_lock_count: relatedLocks.length,
+      takeover_ready: false
+    };
+  }
+  const ownerRow = (peers || []).find((row) => row.id === owner) || null;
+  const ownerAge = ownerRow
+    ? Number(ownerRow.age_sec ?? (t - Number(ownerRow.last_seen_at || 0)))
+    : null;
+  const ownerActive = Boolean(ownerRow && Number.isFinite(ownerAge) && ownerAge <= activePeerTtl);
+  const ownerStale = !ownerActive;
+  const takeoverStatus = ['claimed', 'running', 'review', 'blocked'].includes(task.status);
+  return {
+    owner_known: Boolean(ownerRow),
+    owner_active: ownerActive,
+    owner_stale: ownerStale,
+    owner_age_sec: Number.isFinite(ownerAge) ? ownerAge : null,
+    related_lock_count: relatedLocks.length,
+    takeover_ready: Boolean(takeoverStatus && ownerStale && relatedLocks.length === 0)
+  };
+}
+
+export function annotateTasksWithLiveness(tasks, peers, locks, t = nowSec(), activePeerTtl = DEFAULT_ACTIVE_PEER_TTL) {
+  return (tasks || []).map((task) => ({
+    ...task,
+    ...taskOwnerLiveness(task, peers, locks, t, activePeerTtl)
+  }));
+}
+
+export function taskOwnerStateText(task) {
+  if (!task?.owner) return '';
+  if (task.owner_stale) {
+    if (task.takeover_ready) return 'stale/no-lock';
+    const locks = Number(task.related_lock_count || 0);
+    return locks ? `stale/locks=${locks}` : 'stale';
+  }
+  if (task.owner_active) return 'active';
+  return '';
+}
+
+export function summarizeTask(task) {
+  if (!task) return null;
+  return {
+    id: task.id,
+    title: task.title,
+    status: task.status,
+    owner: task.owner || null,
+    assignee: task.assignee || null,
+    parent_id: task.parent_id || null,
+    team_role: task.team_role || null,
+    priority: task.priority,
+    owner_active: task.owner_active ?? null,
+    owner_stale: Boolean(task.owner_stale),
+    owner_age_sec: task.owner_age_sec ?? null,
+    related_lock_count: Number(task.related_lock_count || 0),
+    takeover_ready: Boolean(task.takeover_ready)
+  };
+}
+
+export function formatOpenTaskLine(task) {
+  const parts = [`#${task.id}`, task.status];
+  if (task.owner) parts.push(`owner=${task.owner}`);
+  if (task.assignee) parts.push(`assignee=${task.assignee}`);
+  const ownerState = taskOwnerStateText(task);
+  if (ownerState) parts.push(`owner_state=${ownerState}`);
+  return `${parts.join(' ')}: ${task.title}`;
+}

package/lib/core/peers/reconcile.mjs

@@ -0,0 +1,238 @@
+import path from 'node:path';
+import { providerSessionParts } from './session.mjs';
+import {
+  bindingHasProviderSession,
+  bindingProviderSessionValue
+} from './bindings.mjs';
+
+function defaultNow() {
+  return Math.floor(Date.now() / 1000);
+}
+
+function noopEvent() {}
+
+function normalizedRoot(root) {
+  return root ? path.resolve(root) : '';
+}
+
+function runtimePaneMatches(row, pane) {
+  return Boolean(row?.runtime_target && pane?.pane && row.runtime_target === pane.pane);
+}
+
+function runtimePidMatches(row, pane) {
+  return Boolean(row?.pid && pane?.pid && Number(row.pid) === Number(pane.pid));
+}
+
+function runtimeCwdMatches(root, row, pane) {
+  const paneCwd = normalizedRoot(pane?.cwd);
+  if (!paneCwd) return false;
+  const worktree = normalizedRoot(row?.worktree);
+  const projectRoot = normalizedRoot(root);
+  return Boolean((worktree && paneCwd === worktree) || (projectRoot && paneCwd === projectRoot));
+}
+
+function commandEvidence(row) {
+  const value = row?.resume_arg || null;
+  if (!value || value === '--last' || String(value).startsWith('%')) return null;
+  if (!['resume', 'session', 'detected', 'named'].includes(row?.resume_mode)) return null;
+  return {
+    provider: row.provider || row.kind || null,
+    value,
+    source: `binding.${row.resume_mode}`
+  };
+}
+
+function processEvidence(row, inspectProcess) {
+  if (typeof inspectProcess !== 'function' || !row?.pid) return null;
+  const info = inspectProcess(Number(row.pid), row.provider || row.kind || null);
+  if (!info?.provider_session) return null;
+  return {
+    provider: info.kind || row.provider || row.kind || null,
+    value: info.provider_session,
+    source: info.source || 'process'
+  };
+}
+
+function tmuxEvidence(row, pane, opts) {
+  const provider = row.provider || row.kind || null;
+  const byEvent = eventEvidence(row, opts);
+  if (byEvent) return byEvent;
+  const byProcess = processEvidence(row, opts.inspectProcess);
+  if (byProcess) return byProcess;
+  const byCommand = commandEvidence(row);
+  if (!byCommand) return null;
+  if (!runtimePaneMatches(row, pane) && !runtimePidMatches(row, pane)) return null;
+  return {
+    ...byCommand,
+    provider
+  };
+}
+
+function eventEvidence(row, opts) {
+  if (typeof opts.latestProviderSessionForPeer !== 'function') return null;
+  const value = opts.latestProviderSessionForPeer(row.peer, row.provider || row.kind || null);
+  if (!value) return null;
+  return {
+    provider: row.provider || row.kind || null,
+    value,
+    source: 'events.hook'
+  };
+}
+
+function existingProviderSessionConflict(db, row, session, provider = row?.provider) {
+  if (!session?.provider_session_id && !session?.provider_session_name) return null;
+  if (!provider) return null;
+  if (session.provider_session_id) {
+    return db.prepare(`
+      SELECT *
+      FROM peer_bindings
+      WHERE provider = ?
+        AND peer <> ?
+        AND provider_session_id = ?
+      LIMIT 1
+    `).get(provider, row.peer, session.provider_session_id) || null;
+  }
+  return db.prepare(`
+    SELECT *
+    FROM peer_bindings
+    WHERE provider = ?
+      AND peer <> ?
+      AND provider_session_name = ?
+    LIMIT 1
+  `).get(provider, row.peer, session.provider_session_name) || null;
+}
+
+function updatePeerProviderSession(db, row, candidate, opts) {
+  const t = opts.now();
+  const provider = candidate.provider || row.provider;
+  const session = providerSessionParts(candidate.value);
+  const conflict = existingProviderSessionConflict(db, row, session, provider);
+  if (conflict) {
+    return {
+      peer: row.peer,
+      provider,
+      action: 'skipped',
+      reason: 'provider_session_conflict',
+      conflict_peer: conflict.peer,
+      provider_session: bindingProviderSessionValue(session)
+    };
+  }
+
+  try {
+    db.prepare(`
+      UPDATE peer_bindings
+      SET provider = ?,
+          provider_session_id = ?,
+          provider_session_name = ?,
+          resume_mode = CASE
+            WHEN resume_mode IN ('unknown', 'attached', 'auto', 'command') THEN ?
+            ELSE resume_mode
+          END,
+          resume_arg = COALESCE(NULLIF(resume_arg, runtime_target), ?),
+          updated_at = ?
+      WHERE peer = ?
+    `).run(
+      provider,
+      session.provider_session_id || null,
+      session.provider_session_name || null,
+      candidate.source === 'binding.session' ? 'session' : 'detected',
+      candidate.value,
+      t,
+      row.peer
+    );
+  } catch (err) {
+    const text = `${err?.code || ''} ${err?.message || ''} ${err?.errstr || ''}`;
+    if (!/UNIQUE constraint failed/i.test(text)) throw err;
+    const conflict = existingProviderSessionConflict(db, row, session, provider);
+    return {
+      peer: row.peer,
+      provider,
+      action: 'skipped',
+      reason: 'provider_session_conflict',
+      conflict_peer: conflict?.peer || null,
+      provider_session: bindingProviderSessionValue(session)
+    };
+  }
+  opts.addEvent(db, 'provider.session.backfilled', row.peer, null, {
+    provider,
+    provider_session: candidate.value,
+    source: candidate.source,
+    runtime_target: row.runtime_target || null
+  });
+  return {
+    peer: row.peer,
+    provider,
+    action: 'backfilled',
+    source: candidate.source,
+    provider_session: candidate.value,
+    runtime_target: row.runtime_target || null
+  };
+}
+
+export function reconcileRunningPeerBindings(db, projectCtx = {}, options = {}) {
+  const opts = {
+    now: typeof options.now === 'function' ? options.now : defaultNow,
+    addEvent: typeof options.addEvent === 'function' ? options.addEvent : noopEvent,
+    inspectProcess: options.inspectProcess || null,
+    latestProviderSessionForPeer: options.latestProviderSessionForPeer || null,
+    panes: Array.isArray(options.panes) ? options.panes : []
+  };
+  const paneByTarget = new Map(opts.panes.filter((pane) => pane?.pane).map((pane) => [pane.pane, pane]));
+  const paneByPid = new Map();
+  for (const pane of opts.panes) {
+    if (pane?.pid && !paneByPid.has(Number(pane.pid))) paneByPid.set(Number(pane.pid), pane);
+  }
+
+  const rows = db.prepare(`
+    SELECT p.id AS peer, p.kind, p.status, p.worktree, p.pid, p.last_seen_at,
+           b.provider, b.provider_session_id, b.provider_session_name,
+           b.resume_mode, b.resume_arg, b.command, b.transport,
+           b.runtime_session_id, b.runtime_target, b.updated_at
+    FROM peer_bindings b
+    JOIN peers p ON p.id = b.peer
+    WHERE b.transport = 'tmux'
+      AND b.runtime_target IS NOT NULL
+      AND p.status IN ('running', 'working', 'busy')
+    ORDER BY p.last_seen_at DESC, b.updated_at DESC
+  `).all();
+
+  const results = [];
+  for (const row of rows) {
+    if (bindingHasProviderSession(row)) {
+      results.push({
+        peer: row.peer,
+        provider: row.provider,
+        action: 'skipped',
+        reason: 'provider_session_known',
+        provider_session: bindingProviderSessionValue(row)
+      });
+      continue;
+    }
+
+    const pane = paneByTarget.get(row.runtime_target) || paneByPid.get(Number(row.pid));
+    if (!pane) {
+      results.push({ peer: row.peer, provider: row.provider, action: 'skipped', reason: 'no_live_tmux_pane' });
+      continue;
+    }
+    if (!runtimePaneMatches(row, pane)) {
+      results.push({ peer: row.peer, provider: row.provider, action: 'skipped', reason: 'runtime_target_mismatch' });
+      continue;
+    }
+    if (!runtimePidMatches(row, pane) && !runtimeCwdMatches(projectCtx.root, row, pane)) {
+      results.push({ peer: row.peer, provider: row.provider, action: 'skipped', reason: 'weak_runtime_evidence' });
+      continue;
+    }
+
+    const candidate = tmuxEvidence(row, pane, opts);
+    if (!candidate?.value) {
+      results.push({ peer: row.peer, provider: row.provider, action: 'skipped', reason: 'no_strong_provider_evidence' });
+      continue;
+    }
+    results.push(updatePeerProviderSession(db, row, candidate, opts));
+  }
+  return {
+    checked: rows.length,
+    backfilled: results.filter((result) => result.action === 'backfilled').length,
+    results
+  };
+}

package/lib/core/peers/session.mjs

@@ -0,0 +1,14 @@
+import { sanitizePeerPart, shortHash } from './format.mjs';
+
+export function providerSessionPeerId(kind, providerId) {
+  return `${kind}-${sanitizePeerPart(String(providerId || '').slice(0, 8), shortHash(providerId))}`;
+}
+
+export function providerSessionParts(value) {
+  if (!value) return { provider_session_id: null, provider_session_name: null };
+  const text = String(value);
+  const uuidLike = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(text);
+  return uuidLike
+    ? { provider_session_id: text, provider_session_name: null }
+    : { provider_session_id: null, provider_session_name: text };
+}

package/lib/core/sessions/launch.mjs

@@ -0,0 +1,89 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+import { shortHash } from '../peers/format.mjs';
+
+export const WEB_CHILD_ENV = 'HCC_WEB_CHILD';
+export const LAUNCH_FINGERPRINT_ENV = 'HCC_LAUNCH_FINGERPRINT';
+export const PROVIDER_STATE_ENV = 'HCC_PROVIDER_STATE';
+
+const LAUNCH_ENV_IGNORED_KEYS = new Set([
+  '_',
+  'COLUMNS',
+  'HCC_DB',
+  'HCC_NO_AUTO_INSTALL_TMUX',
+  'HCC_PEER',
+  'HCC_ROOT',
+  PROVIDER_STATE_ENV,
+  'HCC_SHIM_ENSURED',
+  'HCC_SHIM_NO_ATTACH',
+  'HCC_WEB_TOKEN',
+  LAUNCH_FINGERPRINT_ENV,
+  'LINES',
+  'OLDPWD',
+  'PROMPT_COMMAND',
+  'PS1',
+  'PS2',
+  'PS4',
+  'PWD',
+  'SHLVL',
+  'TERM',
+  'TERMCAP',
+  'TMUX',
+  'TMUX_PANE',
+  'WINDOWID'
+]);
+
+export function childSessionEnv(extra = {}, baseEnv = process.env) {
+  const env = { ...(baseEnv || {}), ...extra };
+  delete env[WEB_CHILD_ENV];
+  return env;
+}
+
+export function launchEnvironmentFingerprint(env) {
+  const entries = Object.entries(env || {})
+    .filter(([key, value]) =>
+      value !== undefined &&
+      value !== null &&
+      !LAUNCH_ENV_IGNORED_KEYS.has(key) &&
+      /^[A-Za-z_][A-Za-z0-9_]*$/.test(key)
+    )
+    .map(([key, value]) => [key, String(value)])
+    .sort(([a], [b]) => a.localeCompare(b));
+  return shortHash(JSON.stringify(entries));
+}
+
+export function launchFingerprint({ command, cwd, env }) {
+  return shortHash(JSON.stringify({
+    command: command || '',
+    cwd: cwd || '',
+    env: launchEnvironmentFingerprint(env || {})
+  }));
+}
+
+export function isLikelyShellCommand(command) {
+  const base = path.basename(String(command || '')).replace(/^-/, '');
+  return new Set(['bash', 'dash', 'fish', 'ksh', 'mksh', 'sh', 'zsh']).has(base);
+}
+
+export function isProviderFallbackWrapper(command) {
+  const text = String(command || '');
+  return text.includes(PROVIDER_STATE_ENV) || /\bexec\s+(?:bash|dash|fish|ksh|mksh|sh|zsh)\b/.test(text);
+}
+
+export function isRelaunchableProviderSession(kind, command, binding = {}) {
+  const provider = binding.provider || kind;
+  return ['claude', 'codex'].includes(provider) && isProviderFallbackWrapper(command);
+}
+
+export function isolatedEnvCommandArgs(env) {
+  const envBin = fs.existsSync('/usr/bin/env') ? '/usr/bin/env' : 'env';
+  const args = [envBin, '-i'];
+  for (const [key, value] of Object.entries(env || {})) {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) continue;
+    if (['TMUX', 'TMUX_PANE'].includes(key)) continue;
+    if (value === undefined || value === null) continue;
+    args.push(`${key}=${String(value)}`);
+  }
+  return args;
+}