@logicseek/hello-cc 0.1.4 → 0.1.6

package/lib/integrations/shims.mjs

@@ -0,0 +1,106 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { spawnSync } from 'node:child_process';
+import { generateShim } from './shims/script.mjs';
+
+export const SHIM_DIR = path.join(os.homedir(), '.hcc-shims');
+
+/**
+ * Install shim scripts for `claude` and `codex` into SHIM_DIR.
+ * Returns { shimDir, installed: [paths], changed: [paths], skipped: [names] }.
+ */
+export function installShims(hccBin) {
+  fs.mkdirSync(SHIM_DIR, { recursive: true });
+
+  const tools = [
+    { name: 'claude', kind: 'claude', resumeFlag: '--resume' },
+    { name: 'codex',  kind: 'codex',  resumeSubcmd: 'resume' },
+  ];
+
+  const installed = [];
+  const changed = [];
+  const skipped = [];
+
+  for (const tool of tools) {
+    const realBin = findRealBinary(tool.name);
+    if (!realBin) {
+      skipped.push(`${tool.name} (not found on PATH)`);
+      continue;
+    }
+    const shimPath = path.join(SHIM_DIR, tool.name);
+    const content = generateShim(hccBin, realBin, tool);
+    let previous = null;
+    try { previous = fs.readFileSync(shimPath, 'utf8'); } catch {}
+    if (previous !== content) {
+      fs.writeFileSync(shimPath, content, { mode: 0o755 });
+      changed.push(shimPath);
+    } else {
+      try { fs.chmodSync(shimPath, 0o755); } catch {}
+    }
+    installed.push(shimPath);
+  }
+
+  return { shimDir: SHIM_DIR, installed, changed, skipped };
+}
+
+/**
+ * Remove shim scripts.
+ */
+export function uninstallShims() {
+  const removed = [];
+  for (const name of ['claude', 'codex']) {
+    const p = path.join(SHIM_DIR, name);
+    try { fs.unlinkSync(p); removed.push(p); } catch {}
+  }
+  try { fs.rmdirSync(SHIM_DIR); } catch {}
+  return removed;
+}
+
+/**
+ * Returns true if at least one shim is installed and in an HCC shim dir.
+ */
+export function verifyShims() {
+  return ['claude', 'codex'].some(name =>
+    fsExists(path.join(SHIM_DIR, name))
+  );
+}
+
+/**
+ * Find the real binary for `name`, skipping the SHIM_DIR.
+ * Checks PATH, then npm global bin, then common install locations.
+ */
+export function findRealBinary(name) {
+  // which -a lists all matches; pick first one outside SHIM_DIR
+  const r = spawnSync('which', ['-a', name], { encoding: 'utf8', timeout: 3000 });
+  if (r.status === 0) {
+    for (const p of r.stdout.trim().split('\n')) {
+      const resolved = p.trim();
+      if (resolved && !resolved.startsWith(SHIM_DIR)) return resolved;
+    }
+  }
+
+  // Try npm global bin
+  const npmR = spawnSync('npm', ['root', '-g'], { encoding: 'utf8', timeout: 3000 });
+  if (npmR.status === 0) {
+    const npmBin = path.join(path.dirname(npmR.stdout.trim()), 'bin', name);
+    if (fsExists(npmBin)) return npmBin;
+  }
+
+  // Common locations
+  for (const dir of [
+    '/usr/local/bin',
+    '/usr/bin',
+    path.join(os.homedir(), '.local', 'bin'),
+    path.join(os.homedir(), '.nvm', 'current', 'bin'),
+  ]) {
+    const p = path.join(dir, name);
+    if (fsExists(p)) return p;
+  }
+
+  return null;
+}
+
+function fsExists(p) {
+  try { fs.accessSync(p); return true; } catch { return false; }
+}

package/lib/json-file.mjs

@@ -0,0 +1 @@
+export { readJsonSafe, writeJsonSafe } from './shared/json-file.mjs';

package/lib/locks.mjs

@@ -0,0 +1,10 @@
+export {
+  WHOLE_LOCK_SCOPE,
+  lockArgv,
+  lockBaseResource,
+  lockLabel,
+  lockScope,
+  locksConflict,
+  normalizeLockScope,
+  scopedLockResource
+} from './core/coordination/locks.mjs';

package/lib/messages.mjs

@@ -0,0 +1,3 @@
+export {
+  createMessageStore
+} from './core/coordination/messages.mjs';

package/lib/package-meta.mjs

@@ -1,24 +1,6 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-export function packageRoot(fromUrl = import.meta.url) {
-  return path.resolve(fileURLToPath(fromUrl), '..', '..');
-}
-
-export function readJson(file) {
-  return JSON.parse(fs.readFileSync(file, 'utf8'));
-}
-
-export function readPackageJson(root) {
-  return readJson(path.join(root, 'package.json'));
-}
-
-export function readPackageMeta(root) {
-  const pkg = readPackageJson(root);
-  return {
-    name: pkg.name,
-    version: pkg.version,
-    packageJson: pkg
-  };
-}
+export {
+  packageRoot,
+  readJson,
+  readPackageJson,
+  readPackageMeta
+} from './release/package-meta.mjs';

package/lib/peer-bindings.mjs

@@ -0,0 +1,14 @@
+export {
+  bindingFromDetected,
+  bindingHasProviderSession,
+  bindingHasRuntime,
+  bindingProviderSessionValue,
+  comparePeerBindings,
+  mergePeerBinding,
+  mergeRuntimeBinding,
+  peerBindingRuntimeRank
+} from './core/peers/bindings.mjs';
+
+export {
+  createPeerBindingStore
+} from './db/stores/peers.mjs';

package/lib/peer-format.mjs

@@ -0,0 +1,4 @@
+export {
+  sanitizePeerPart,
+  shortHash
+} from './core/peers/format.mjs';

package/lib/peer-identity.mjs

@@ -0,0 +1,15 @@
+export {
+  autoPeerBasis,
+  autoPeerId,
+  autoPeerKind,
+  autoPeerProviderSession,
+  autoPeerResumeId,
+  autoPeerSessionId,
+  currentPeer,
+  currentTtyName,
+  readAncestorCliInfo,
+  resolveCurrentPeer,
+  resumeIdFromArgs,
+  sanitizePeerPart,
+  shortHash
+} from './integrations/peers/identity.mjs';

package/lib/project-context.mjs

@@ -0,0 +1,6 @@
+export {
+  detectBranch,
+  detectRoot,
+  hasHccRootSync,
+  runGit
+} from './runtime/project-context.mjs';

package/lib/project-registry.mjs

@@ -0,0 +1,7 @@
+export {
+  projectRecord,
+  readProjectRegistry,
+  registerProject,
+  registerProjectActivity,
+  writeProjectRegistry
+} from './runtime/projects.mjs';

package/lib/provider-commands.mjs

@@ -0,0 +1,13 @@
+export {
+  bindingFromRun,
+  buildClaudeCommand,
+  buildCodexCommand,
+  buildPeerCommand,
+  defaultSessionCommand,
+  hasResumeOpts,
+  inferPeerKind,
+  parseClaudeCommandArgs,
+  parseCodexCommandArgs,
+  providerSessionParts,
+  providerSessionPeerId
+} from './integrations/providers.mjs';

package/lib/release/package-meta.mjs

@@ -0,0 +1,31 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export function packageRoot(fromUrl = import.meta.url) {
+  let dir = path.dirname(fileURLToPath(fromUrl));
+  for (;;) {
+    if (fs.existsSync(path.join(dir, 'package.json'))) return dir;
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return path.resolve(path.dirname(fileURLToPath(fromUrl)), '..', '..');
+}
+
+export function readJson(file) {
+  return JSON.parse(fs.readFileSync(file, 'utf8'));
+}
+
+export function readPackageJson(root) {
+  return readJson(path.join(root, 'package.json'));
+}
+
+export function readPackageMeta(root) {
+  const pkg = readPackageJson(root);
+  return {
+    name: pkg.name,
+    version: pkg.version,
+    packageJson: pkg
+  };
+}

package/lib/release/release-notes.mjs

@@ -0,0 +1,40 @@
+export function normalizeVersion(version) {
+  return String(version || '').replace(/^v/, '');
+}
+
+export function releaseSection(markdown, version) {
+  const lines = markdown.split(/\r?\n/);
+  const heading = `## ${version}`;
+  const start = lines.findIndex((line) => line.trim() === heading);
+  if (start < 0) return null;
+
+  let end = lines.length;
+  for (let i = start + 1; i < lines.length; i += 1) {
+    if (/^##\s+/.test(lines[i])) {
+      end = i;
+      break;
+    }
+  }
+  return lines.slice(start, end).join('\n').trimEnd();
+}
+
+export function validateReleaseSection(section, version) {
+  const problems = [];
+  if (!section) {
+    problems.push(`CHANGELOG.md is missing section ## ${version}`);
+    return problems;
+  }
+  if (!section.includes('### Summary')) problems.push(`## ${version} is missing ### Summary`);
+  if (!section.includes('### Highlights')) problems.push(`## ${version} is missing ### Highlights`);
+  if (section.includes('TODO') || section.includes('TBD')) problems.push(`## ${version} still contains TODO/TBD text`);
+  const bulletCount = (section.match(/^- /gm) || []).length;
+  if (bulletCount < 2) problems.push(`## ${version} should include at least two release-note bullets`);
+  return problems;
+}
+
+export function repoFromPackage(pkg) {
+  const repo = typeof pkg.repository === 'string' ? pkg.repository : pkg.repository?.url;
+  if (!repo) return null;
+  const match = repo.match(/github\.com[:/](.+?\/.+?)(?:\.git)?$/);
+  return match ? match[1] : null;
+}

package/lib/release-notes.mjs

@@ -1,40 +1,6 @@
-export function normalizeVersion(version) {
-  return String(version || '').replace(/^v/, '');
-}
-
-export function releaseSection(markdown, version) {
-  const lines = markdown.split(/\r?\n/);
-  const heading = `## ${version}`;
-  const start = lines.findIndex((line) => line.trim() === heading);
-  if (start < 0) return null;
-
-  let end = lines.length;
-  for (let i = start + 1; i < lines.length; i += 1) {
-    if (/^##\s+/.test(lines[i])) {
-      end = i;
-      break;
-    }
-  }
-  return lines.slice(start, end).join('\n').trimEnd();
-}
-
-export function validateReleaseSection(section, version) {
-  const problems = [];
-  if (!section) {
-    problems.push(`CHANGELOG.md is missing section ## ${version}`);
-    return problems;
-  }
-  if (!section.includes('### Summary')) problems.push(`## ${version} is missing ### Summary`);
-  if (!section.includes('### Highlights')) problems.push(`## ${version} is missing ### Highlights`);
-  if (section.includes('TODO') || section.includes('TBD')) problems.push(`## ${version} still contains TODO/TBD text`);
-  const bulletCount = (section.match(/^- /gm) || []).length;
-  if (bulletCount < 2) problems.push(`## ${version} should include at least two release-note bullets`);
-  return problems;
-}
-
-export function repoFromPackage(pkg) {
-  const repo = typeof pkg.repository === 'string' ? pkg.repository : pkg.repository?.url;
-  if (!repo) return null;
-  const match = repo.match(/github\.com[:/](.+?\/.+?)(?:\.git)?$/);
-  return match ? match[1] : null;
-}
+export {
+  normalizeVersion,
+  releaseSection,
+  repoFromPackage,
+  validateReleaseSection
+} from './release/release-notes.mjs';

package/lib/runtime/client.mjs

@@ -0,0 +1,42 @@
+import { CliError } from '../shared/errors.mjs';
+import { readRuntime } from './state.mjs';
+import { runtimeApiUrl } from '../web/runtime.mjs';
+
+const DEFAULT_CLI_NAME = 'hcc';
+
+export async function runtimeRequest(ctx, method, route, body = null, runtime = null, opts = {}) {
+  const cliName = opts.cliName || DEFAULT_CLI_NAME;
+  const rt = runtime || readRuntime(ctx, { cliName });
+  const url = runtimeApiUrl(rt, route);
+  const headers = { 'Content-Type': 'application/json' };
+  headers['X-HCC-Root'] = ctx.root;
+  headers['X-HCC-DB'] = ctx.dbPath;
+  if (rt.token) headers.Authorization = `Bearer ${rt.token}`;
+  let res;
+  try {
+    res = await fetch(url, {
+      method,
+      headers,
+      body: body === null ? undefined : JSON.stringify(body)
+    });
+  } 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
+    });
+  }
+  let json = null;
+  const text = await res.text();
+  if (text.trim()) {
+    try {
+      json = JSON.parse(text);
+    } catch {
+      throw new CliError('RUNTIME_BAD_RESPONSE', `Runtime returned non-JSON response from ${url.pathname}`);
+    }
+  }
+  if (!res.ok) {
+    const error = json && json.error ? json.error : { code: 'RUNTIME_ERROR', message: `Runtime request failed: ${res.status}` };
+    throw new CliError(error.code || 'RUNTIME_ERROR', error.message || `Runtime request failed: ${res.status}`, error);
+  }
+  return json || {};
+}

package/lib/runtime/paths.mjs

@@ -0,0 +1,45 @@
+import os from 'node:os';
+import path from 'node:path';
+
+export function projectStateDir(root) {
+  return path.join(root, '.hello-cc');
+}
+
+export function projectDbPath(root) {
+  return path.join(projectStateDir(root), 'mesh.db');
+}
+
+export function runtimePath(ctx) {
+  return path.join(projectStateDir(ctx.root), 'runtime.json');
+}
+
+export function webLogPath(ctx) {
+  return path.join(projectStateDir(ctx.root), 'web.log');
+}
+
+export function globalStateDir() {
+  return path.join(os.homedir(), '.hello-cc');
+}
+
+export function globalRuntimePath() {
+  return path.join(globalStateDir(), 'runtime.json');
+}
+
+export function globalWebTokenPath() {
+  return path.join(globalStateDir(), 'web-token');
+}
+
+export function projectRegistryPath() {
+  return path.join(globalStateDir(), 'projects.json');
+}
+
+export function contextForProject(root, dbPath = null, base = {}) {
+  const resolvedRoot = path.resolve(root);
+  return {
+    cwd: base.cwd || resolvedRoot,
+    root: resolvedRoot,
+    dbPath: path.resolve(dbPath || projectDbPath(resolvedRoot)),
+    json: Boolean(base.json),
+    explicitRoot: true
+  };
+}

package/lib/runtime/project-context.mjs

@@ -0,0 +1,32 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+import { spawnSync } from 'node:child_process';
+
+export function runGit(args, cwd) {
+  const result = spawnSync('git', args, {
+    cwd,
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'ignore']
+  });
+  if (result.status !== 0) return null;
+  return result.stdout.trim();
+}
+
+export function hasHccRootSync(cwd) {
+  if (!cwd) return null;
+  const dir = path.resolve(cwd);
+  const hccDir = path.join(dir, '.hello-cc');
+  return fs.existsSync(path.join(hccDir, 'mesh.db')) ||
+    fs.existsSync(path.join(hccDir, 'config.json'));
+}
+
+export function detectRoot(cwd, explicitRoot) {
+  if (explicitRoot) return path.resolve(explicitRoot);
+  if (process.env.HCC_ROOT) return path.resolve(process.env.HCC_ROOT);
+  return path.resolve(cwd);
+}
+
+export function detectBranch(cwd) {
+  return runGit(['rev-parse', '--abbrev-ref', 'HEAD'], cwd) || '';
+}

package/lib/runtime/projects.mjs

@@ -0,0 +1,76 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { projectDbPath, projectRegistryPath } from './paths.mjs';
+
+function registryTimestamp(nowFn = () => Math.floor(Date.now() / 1000)) {
+  return nowFn();
+}
+
+function normalizeProjectEntry(project) {
+  if (!project?.root) return null;
+  const root = path.resolve(project.root);
+  return {
+    root,
+    db: path.resolve(project.db || projectDbPath(root)),
+    name: String(project.name || path.basename(root) || root),
+    last_seen_at: Number.parseInt(project.last_seen_at || '0', 10) || 0
+  };
+}
+
+function projectRootExists(project) {
+  if (!project?.root) return false;
+  try {
+    return fs.existsSync(project.root) && fs.statSync(project.root).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+export function projectRecord(ctx, nowFn) {
+  return {
+    root: ctx.root,
+    db: ctx.dbPath,
+    name: path.basename(ctx.root) || ctx.root,
+    last_seen_at: registryTimestamp(nowFn)
+  };
+}
+
+export function readProjectRegistry() {
+  const file = projectRegistryPath();
+  if (!fs.existsSync(file)) return [];
+  try {
+    const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+    const rows = Array.isArray(parsed?.projects) ? parsed.projects : [];
+    return rows
+      .filter((p) => p && typeof p.root === 'string')
+      .map(normalizeProjectEntry)
+      .filter(projectRootExists);
+  } catch {
+    return [];
+  }
+}
+
+export function writeProjectRegistry(projects) {
+  const file = projectRegistryPath();
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const unique = new Map();
+  for (const project of projects) {
+    const row = normalizeProjectEntry(project);
+    if (!row) continue;
+    unique.set(row.root, row);
+  }
+  const rows = [...unique.values()].sort((a, b) => (b.last_seen_at || 0) - (a.last_seen_at || 0));
+  fs.writeFileSync(file, JSON.stringify({ projects: rows }, null, 2), { mode: 0o600 });
+  fs.chmodSync(file, 0o600);
+  return rows;
+}
+
+export function registerProject(ctx) {
+  const rows = readProjectRegistry().filter((p) => path.resolve(p.root) !== ctx.root);
+  rows.unshift(projectRecord(ctx));
+  return writeProjectRegistry(rows);
+}
+
+export function registerProjectActivity(ctx) {
+  try { registerProject(ctx); } catch {}
+}

package/lib/runtime/state.mjs

@@ -0,0 +1,128 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+import { CliError } from '../shared/errors.mjs';
+import {
+  globalRuntimePath,
+  runtimePath
+} from './paths.mjs';
+import { runtimeApiUrl } from '../web/runtime.mjs';
+
+const DEFAULT_PRODUCT_NAME = 'hello-cc';
+const DEFAULT_CLI_NAME = 'hcc';
+
+export function readGlobalRuntimeFile() {
+  const file = globalRuntimePath();
+  if (!fs.existsSync(file)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    try { fs.rmSync(file, { force: true }); } catch {}
+    return null;
+  }
+}
+
+export function writeGlobalRuntime(runtime) {
+  const file = globalRuntimePath();
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, JSON.stringify(runtime, null, 2), { mode: 0o600 });
+  fs.chmodSync(file, 0o600);
+  return file;
+}
+
+export function writeRuntime(ctx, runtime) {
+  const file = runtimePath(ctx);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, JSON.stringify(runtime, null, 2), { mode: 0o600 });
+  fs.chmodSync(file, 0o600);
+  return file;
+}
+
+export function readRuntime(ctx, opts = {}) {
+  if (process.env.HCC_RUNTIME_URL) {
+    return {
+      base_url: process.env.HCC_RUNTIME_URL,
+      token: process.env.HCC_RUNTIME_TOKEN || '',
+      source: 'env'
+    };
+  }
+  const file = runtimePath(ctx);
+  if (fs.existsSync(file)) {
+    try {
+      const runtime = JSON.parse(fs.readFileSync(file, 'utf8'));
+      if (!runtime.base_url) throw new Error('missing base_url');
+      return { ...runtime, source: file };
+    } catch {
+      try { fs.rmSync(file, { force: true }); } catch {}
+    }
+  }
+  const global = readGlobalRuntimeFile();
+  if (global?.base_url) {
+    return { ...global, source: globalRuntimePath(), global: true };
+  }
+  const productName = opts.productName || DEFAULT_PRODUCT_NAME;
+  const cliName = opts.cliName || DEFAULT_CLI_NAME;
+  throw new CliError('RUNTIME_NOT_RUNNING',
+    `No running ${productName} web runtime found. Start it with:\n  ${cliName} web`);
+}
+
+export function readRuntimeFile(ctx) {
+  const file = runtimePath(ctx);
+  if (!fs.existsSync(file)) return null;
+  return JSON.parse(fs.readFileSync(file, 'utf8'));
+}
+
+export async function probeRuntime(runtime) {
+  if (!runtime?.base_url) return false;
+  const url = runtimeApiUrl(runtime, '/api/runtime');
+  const headers = {};
+  if (runtime.token) headers.Authorization = `Bearer ${runtime.token}`;
+  try {
+    const response = await fetch(url, { headers });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+
+export async function readHealthyRuntime(ctx) {
+  try {
+    const runtime = readRuntimeFile(ctx);
+    if (runtime && await probeRuntime(runtime)) return runtime;
+    const global = readGlobalRuntimeFile();
+    if (global && await probeRuntime(global)) return global;
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+export async function readHealthyGlobalRuntime() {
+  try {
+    const runtime = readGlobalRuntimeFile();
+    if (!runtime) return null;
+    return await probeRuntime(runtime) ? runtime : null;
+  } catch {
+    return null;
+  }
+}
+
+export function clearRuntime(ctx, pid = process.pid) {
+  const file = runtimePath(ctx);
+  if (fs.existsSync(file)) {
+    try {
+      const runtime = JSON.parse(fs.readFileSync(file, 'utf8'));
+      if (!runtime.pid || runtime.pid === pid) fs.rmSync(file, { force: true });
+    } catch {
+      fs.rmSync(file, { force: true });
+    }
+  }
+  const globalFile = globalRuntimePath();
+  if (!fs.existsSync(globalFile)) return;
+  try {
+    const runtime = JSON.parse(fs.readFileSync(globalFile, 'utf8'));
+    if (!runtime.pid || runtime.pid === pid) fs.rmSync(globalFile, { force: true });
+  } catch {
+    fs.rmSync(globalFile, { force: true });
+  }
+}

package/lib/runtime-client.mjs

@@ -0,0 +1,3 @@
+export {
+  runtimeRequest
+} from './runtime/client.mjs';