@logicseek/hello-cc 1.0.0 → 1.0.2-dsh.3

package/lib/mcp/tools.mjs

@@ -0,0 +1,197 @@
+import { CliError } from '../shared/errors.mjs';
+import { redactSecrets } from '../shared/redact.mjs';
+import { parseOpts, intOpt, required, positiveSafeIntOpt, wantsHelp } from '../cli-args.mjs';
+import { positiveIntOpt } from '../task-cli.mjs';
+import { tx } from '../db/schema.mjs';
+import { createMsgCommands } from '../cli/commands/msg.mjs';
+import { createTaskCommands } from '../cli/commands/task.mjs';
+import { createLockCommands } from '../cli/commands/lock.mjs';
+import { createCoordinationCommands } from '../cli/commands/coordination.mjs';
+import { createCoordinationState } from '../coordination-state.mjs';
+import { createMessageStore } from '../core/coordination/messages.mjs';
+import { createTaskStore } from '../core/coordination/tasks.mjs';
+import { createEvidenceRuntime } from '../core/peers/evidence-runtime.mjs';
+import { annotateTasksWithLiveness } from '../core/peers/liveness.mjs';
+import { clockGraceSuppressed, readClockGraceUntil } from '../shared/clock-grace.mjs';
+import { clockSafetyUnavailable } from '../core/coordination/clock-safety.mjs';
+import { leaseDeadline } from '../core/coordination/lease-renewal.mjs';
+import { scopedLockResource, lockLabel, lockScope, locksConflict } from '../core/coordination/locks.mjs';
+import { captureLockAcquireSubject, sameLockAcquireSubject, observeLockOwnerEvidence } from '../core/coordination/lock-evidence.mjs';
+import { runOptimisticEvidenceMutation } from '../core/coordination/optimistic-evidence.mjs';
+import { normalizeListText } from '../handoff.mjs';
+import { listTaskResults, recordTaskResult } from '../core/coordination/results.mjs';
+
+const string = (maxLength = 4096) => ({ type: 'string', minLength: 1, maxLength });
+const integer = (maximum = Number.MAX_SAFE_INTEGER) => ({ type: 'integer', minimum: 1, maximum });
+const strings = { type: 'array', maxItems: 50, items: string() };
+const definitions = [
+  ['hcc_state', 'Read coordination state for this project and peer.', {}, [], true],
+  ['hcc_task_list', 'List tasks visible to this peer, with owner evidence.',
+    { limit: integer(100), all: { type: 'boolean' } }, [], true],
+  ['hcc_inbox', 'Read this peer inbox without acknowledging messages.',
+    { limit: integer(100), all: { type: 'boolean' } }, [], true],
+  ['hcc_message_send', 'Send a coordination message as this executor peer.',
+    { to: string(256), body: string(16000), task_id: integer(), kind: { type: 'string', enum: ['note', 'ask', 'progress'] } }, ['to', 'body'], false],
+  ['hcc_task_next', 'Return the current task or claim one pending task. Never completes a task.', {}, [], false],
+  ['hcc_handoff', 'Record work, tests and risks for an owned task without completing it.',
+    { task_id: integer(), summary: string(16000), to: string(256), changed_files: strings, tests: strings, risks: strings }, ['task_id', 'summary'], false],
+  ['hcc_lock_acquire', 'Acquire a scoped resource lock for this peer and its task.',
+    { resource: string(1024), task_id: integer(), scope: string(256), ttl: integer(86400), reason: string(4096) }, ['resource', 'task_id'], false],
+  ['hcc_lock_release', 'Release this peer own lock; cannot force another owner lock.',
+    { resource: string(1024), scope: string(256) }, ['resource'], false],
+  ['hcc_result_list', 'Read evidence records submitted by this peer.',
+    { task_id: integer(), limit: integer(200) }, [], true],
+  ['hcc_result_record', 'Record local evidence for an owned task. Does not record publication, business acceptance, or task completion.',
+    { task_id: integer(), kind: { type: 'string', enum: ['verification', 'command', 'diff'] },
+      title: string(300), details: string(64000), evidence: { ...strings, maxItems: 20, items: string(2000) },
+      status: { type: 'string', enum: ['passed', 'failed', 'pending'] }, result_key: string(300) },
+    ['task_id', 'title', 'status'], false]
+];
+
+// Pure catalogue shared by MCP and the Cordis tool registry.
+export function scopedMcpToolDefinitions() {
+  return definitions.map(([name, description, properties, required, readOnly]) => ({
+    name, description, inputSchema: structuredClone({ type: 'object', properties, required, additionalProperties: false }),
+    annotations: { readOnlyHint: readOnly, destructiveHint: !readOnly, openWorldHint: false }
+  }));
+}
+
+function validate(value, schema, label) {
+  if (schema.type === 'object') {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) throw new CliError('BAD_ARGS', `${label} must be an object`);
+    for (const key of Object.keys(value)) {
+      if (!Object.hasOwn(schema.properties, key)) throw new CliError('BAD_ARGS', `Unknown argument: ${key}`);
+      validate(value[key], schema.properties[key], key);
+    }
+    for (const key of schema.required || []) if (!Object.hasOwn(value, key)) throw new CliError('BAD_ARGS', `Missing argument: ${key}`);
+  } else if (schema.type === 'string') {
+    if (typeof value !== 'string' || !value.trim() || value.length < (schema.minLength || 0) ||
+        value.length > schema.maxLength || value.includes('\0') || (schema.enum && !schema.enum.includes(value))) {
+      throw new CliError('BAD_ARGS', `${label} must be a valid bounded string`);
+    }
+  } else if (schema.type === 'integer') {
+    if (!Number.isSafeInteger(value) || value < schema.minimum || value > schema.maximum) throw new CliError('BAD_ARGS', `${label} must be a positive bounded integer`);
+  } else if (schema.type === 'boolean') {
+    if (typeof value !== 'boolean') throw new CliError('BAD_ARGS', `${label} must be boolean`);
+  } else if (schema.type === 'array') {
+    if (!Array.isArray(value) || value.length > schema.maxItems) throw new CliError('BAD_ARGS', `${label} must be a bounded array`);
+    for (const item of value) validate(item, schema.items, label);
+  }
+}
+
+export function createScopedMcpTools({ ctx, authority, connect: baseConnect, touchPeer, now, addEvent }) {
+  const peer = authority.scope.peer, scopedCtx = { ...ctx, cwd: authority.scope.root,
+    root: authority.scope.root, dbPath: authority.scope.dbPath, json: true };
+  let captured, databases = [], active = false, taskGuard = null;
+  function assertWrite(db) {
+    authority.assertOwnership(db);
+    if (taskGuard !== null) {
+      const row = db.prepare('SELECT * FROM tasks WHERE id = ?').get(taskGuard);
+      if (!row || row.owner !== peer) throw new CliError('TASK_OWNED', 'Task ownership changed before recording work');
+    }
+  }
+  function connect() {
+    const db = baseConnect(scopedCtx, { create: false, migrateRegistered: false });
+    databases.push(db);
+    authority.assertOwnership(db);
+    // Existing business functions keep their transactions. Guard each write
+    // inside that transaction, including commands that normally autocommit.
+    return new Proxy(db, { get(target, key) {
+      if (key === 'prepare') return sql => {
+        const statement = target.prepare(sql);
+        return new Proxy(statement, { get(stmt, property) {
+          if (property === 'run') return (...params) => {
+            const run = () => { assertWrite(target); return stmt.run(...params); };
+            return target.isTransaction ? run() : tx(target, run);
+          };
+          const value = stmt[property]; return typeof value === 'function' ? value.bind(stmt) : value;
+        } });
+      };
+      const value = target[key]; return typeof value === 'function' ? value.bind(target) : value;
+    } });
+  }
+  const evidence = createEvidenceRuntime({ now });
+  const messages = createMessageStore({ now, addEvent });
+  const tasks = createTaskStore({ now, addEvent, sendMessage: messages.sendMessage,
+    activePeerTtl: 600, observeClockSafety: evidence.observeTaskTakeoverClockSafety });
+  const dependencies = { connect, now, tx, addEvent, CliError, parseOpts, intOpt, required,
+    positiveSafeIntOpt, positiveIntOpt, wantsHelp, ACTIVE_PEER_TTL: 600, DEFAULT_LOCK_TTL: 900,
+    printResult: (_ctx, result) => { captured = result; },
+    resolveCurrentPeer: () => ({ id: peer, auto: false }),
+    touchCurrentPeer: (db, _ctx, identity, status) => {
+      if (identity.id !== peer) throw new CliError('MCP_SCOPE_INVALID', 'Peer identity changed');
+      authority.assertOwnership(db); touchPeer(db, peer, status);
+    },
+    iso: timestamp => new Date(timestamp * 1000).toISOString(),
+    ...messages, ...tasks, ...evidence,
+    annotateTasksWithLiveness, clockGraceSuppressed, readClockGraceUntil,
+    leaseDeadline, scopedLockResource, lockLabel, lockScope, locksConflict,
+    clockSafetyUnavailable, captureLockAcquireSubject, sameLockAcquireSubject,
+    observeLockOwnerEvidence, runOptimisticEvidenceMutation, normalizeListText
+  };
+  const { cmdTask, notifyTaskOwnerConflict } = createTaskCommands(dependencies);
+  const { cmdLock } = createLockCommands({ ...dependencies, notifyTaskOwnerConflict });
+  const { cmdMsg } = createMsgCommands(dependencies);
+  const { cmdHandoff } = createCoordinationCommands(dependencies);
+  const { statusSnapshot } = createCoordinationState({ connect, now, ...messages, ...tasks,
+    observePeerEvidence: evidence.observePeerEvidence });
+  const tools = scopedMcpToolDefinitions();
+  const byName = new Map(tools.map(tool => [tool.name, tool]));
+  const option = (key, value) => `--${key}=${value}`;
+  function assertTask(taskId, action) {
+    const db = connect();
+    const row = db.prepare('SELECT * FROM tasks WHERE id = ?').get(taskId);
+    if (!row) throw new CliError('NOT_FOUND', 'Task does not exist');
+    tasks.assertTaskOwnerForMutation(db, peer, row, action);
+    if (row.owner !== peer) throw new CliError('TASK_OWNED', 'Claim this task before recording work or acquiring its locks');
+    taskGuard = taskId;
+  }
+  async function execute(name, args) {
+    if (name === 'hcc_state') return statusSnapshot(scopedCtx, peer);
+    if (name === 'hcc_inbox') return messages.queryInbox(connect(), peer, args.all === true, args.limit || 20);
+    if (name === 'hcc_task_list') return cmdTask(scopedCtx, ['list', option('peer', peer), option('limit', args.limit || 50), ...(args.all ? ['--all'] : [])]);
+    if (name === 'hcc_task_next') return cmdTask(scopedCtx, ['next', option('peer', peer), '--count=1']);
+    if (name === 'hcc_result_list') return listTaskResults(connect(), { peer, taskId: args.task_id || null, limit: args.limit || 100 });
+    if (name === 'hcc_result_record') {
+      assertTask(args.task_id, 'result-record');
+      if (args.status === 'passed' && !args.evidence?.length) throw new CliError('BAD_ARGS', 'A passed result needs an evidence reference');
+      return recordTaskResult(connect(), { peer, taskId: args.task_id,
+        executorId: authority.scope.executorId, kind: args.kind, title: args.title,
+        details: args.details, evidence: args.evidence, status: args.status,
+        resultKey: args.result_key, stage: 'local', source: 'executor' }, { now, addEvent });
+    }
+    if (name === 'hcc_message_send') return cmdMsg(scopedCtx, ['send', option('from', peer), option('to', args.to),
+      option('body', args.body), option('kind', args.kind || 'note'), ...(args.task_id ? [option('task', args.task_id)] : [])]);
+    if (name === 'hcc_handoff') {
+      assertTask(args.task_id, 'handoff');
+      return cmdHandoff(scopedCtx, ['create', option('from', peer), option('task', args.task_id), option('summary', args.summary),
+        option('changed-files', JSON.stringify(args.changed_files || [])), option('tests', JSON.stringify(args.tests || [])),
+        option('risks', JSON.stringify(args.risks || [])), ...(args.to ? [option('to', args.to)] : [])]);
+    }
+    if (name === 'hcc_lock_acquire') assertTask(args.task_id, 'lock-acquire');
+    return cmdLock(scopedCtx, [name === 'hcc_lock_acquire' ? 'acquire' : 'release', option('peer', peer), option('resource', args.resource),
+      ...(args.scope ? [option('scope', args.scope)] : []), ...(args.task_id ? [option('task', args.task_id)] : []),
+      ...(args.ttl ? [option('ttl', args.ttl)] : []), ...(args.reason ? [option('reason', args.reason)] : [])]);
+  }
+  return {
+    list: () => tools.map(tool => structuredClone(tool)), has: name => byName.has(name),
+    async call(name, args) {
+      if (active) return { isError: true, content: [{ type: 'text', text: 'A scoped tool call is already running' }] };
+      active = true; captured = undefined; databases = []; taskGuard = null;
+      try {
+        if (!byName.has(name)) throw new CliError('BAD_ARGS', 'Unknown scoped tool');
+        validate(args, byName.get(name).inputSchema, 'arguments');
+        authority.assertValid();
+        const direct = await execute(name, args);
+        const structuredContent = redactSecrets({ ok: true, peer, data: captured === undefined ? direct : captured });
+        return { content: [{ type: 'text', text: JSON.stringify(structuredContent) }], structuredContent, isError: false };
+      } catch (error) {
+        const structuredContent = redactSecrets({ ok: false, peer, error: {
+          code: error instanceof CliError ? error.code : 'MCP_TOOL_FAILED',
+          message: error instanceof CliError ? error.message : 'The scoped tool call failed'
+        } });
+        return { content: [{ type: 'text', text: JSON.stringify(structuredContent) }], structuredContent, isError: true };
+      } finally { for (const db of databases) { try { db.close(); } catch {} } active = false; }
+    }
+  };
+}

package/lib/process/identity.mjs

@@ -98,7 +98,9 @@ function parseMacBootToken(text) {
 }
 
 function macIdentity(pid) {
-  const boot = run('sysctl', ['-n', 'kern.boottime']);
+  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;
   const bootToken = parseMacBootToken(boot.stdout);
   if (!bootToken) return null;
@@ -152,6 +154,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/release/release-notes.mjs

@@ -2,6 +2,15 @@ export function normalizeVersion(version) {
   return String(version || '').replace(/^v/, '');
 }
 
+export function isPrereleaseVersion(version) {
+  const numeric = '(?:0|[1-9][0-9]*)';
+  const identifier = `(?:${numeric}|[0-9]*[A-Za-z-][0-9A-Za-z-]*)`;
+  const semver = new RegExp(`^${numeric}\\.${numeric}\\.${numeric}(?:-(${identifier}(?:\\.${identifier})*))?(?:\\+[0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*)?$`);
+  const match = normalizeVersion(version).match(semver);
+  if (!match) throw new Error(`Invalid release version: ${version}`);
+  return match[1] !== undefined;
+}
+
 export function releaseSection(markdown, version) {
   const lines = markdown.split(/\r?\n/);
   const heading = `## ${version}`;

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/runtime/native/client.mjs

@@ -0,0 +1,38 @@
+import http from 'node:http';
+import { CliError } from '../../shared/errors.mjs';
+import { readNativePointer } from './store.mjs';
+
+export function nativeRequest(ctx, method, route, body = null, { timeoutMs = 35000 } = {}) {
+  const pointer = readNativePointer(ctx);
+  if (!pointer) return Promise.reject(new CliError('NATIVE_RUNTIME_OFFLINE', 'Native runtime is offline. Run hcc native up.'));
+  return new Promise((resolve, reject) => {
+    const payload = body === null ? null : JSON.stringify(body);
+    let timer;
+    const fail = (error) => { clearTimeout(timer); reject(error); };
+    const invalid = (message) => new CliError('NATIVE_RESPONSE_INVALID', message, { uncertain: method !== 'GET' });
+    const request = http.request({ host: '127.0.0.1', port: pointer.port, method, path: route,
+      headers: { authorization: `Bearer ${pointer.token}`, ...(payload ? { 'content-type': 'application/json', 'content-length': Buffer.byteLength(payload) } : {}) }
+    }, (response) => {
+      let data = '';
+      response.setEncoding('utf8');
+      response.on('data', (chunk) => {
+        data += chunk;
+        if (Buffer.byteLength(data) > 8 * 1024 * 1024) response.destroy(invalid('Native response is too large'));
+      });
+      response.on('error', (error) => fail(error instanceof CliError ? error : invalid('Native response was interrupted; inspect status before retrying.')));
+      response.on('end', () => {
+        clearTimeout(timer);
+        try {
+          const result = JSON.parse(data);
+          if (!result || typeof result !== 'object' || Array.isArray(result) || typeof result.ok !== 'boolean') throw invalid('Invalid native response; inspect status before retrying.');
+          if (!result.ok) fail(new CliError(result.error?.code || 'NATIVE_REQUEST_FAILED', result.error?.message || 'Native request failed', result.error?.extra || {}));
+          else if (response.statusCode < 200 || response.statusCode >= 300) fail(invalid('Native runtime returned an unsuccessful HTTP response'));
+          else resolve(result.data);
+        } catch (error) { fail(error instanceof CliError ? error : invalid('Invalid native JSON response; inspect status before retrying.')); }
+      });
+    });
+    timer = setTimeout(() => request.destroy(new CliError('NATIVE_CLIENT_TIMEOUT', 'Native runtime request timed out; inspect status before retrying.', { uncertain: method !== 'GET' })), timeoutMs);
+    request.on('error', (error) => fail(error instanceof CliError ? error : new CliError('NATIVE_RUNTIME_OFFLINE', 'Cannot reach the native runtime', { uncertain: method !== 'GET' })));
+    request.end(payload);
+  });
+}