@logicseek/hello-cc 1.0.5 → 1.1.0-rc.3

package/scripts/native-stability-checks.mjs

@@ -0,0 +1,40 @@
+import assert from 'node:assert/strict';
+
+// Explicit limits bound opt-in model consumption and idle observation time.
+export function stabilityOptions(args) {
+  const fields = [
+    ['--stability-cycles', 'cycles', 6, 1, 24],
+    ['--stability-burst', 'burst', 2, 1, 4],
+    ['--stability-idle-ms', 'idleMs', 30000, 0, 300000],
+    ['--stability-resume-every', 'resumeEvery', 2, 1, 24]
+  ];
+  const enabled = args.includes('--stability');
+  assert.ok(!args.includes('--stability-only') || enabled, '--stability-only requires --stability');
+  const config = {};
+  for (const [flag, key, fallback, min, max] of fields) {
+    const indices = args.flatMap((value, index) => value === flag ? [index] : []);
+    assert.ok(indices.length <= 1, `${flag} must not be repeated`);
+    assert.ok(enabled || !indices.length, `${flag} requires --stability`);
+    const raw = indices.length ? args[indices[0] + 1] : String(fallback);
+    assert.ok(typeof raw === 'string' && /^\d+$/.test(raw), `${flag} requires an integer`);
+    const value = Number(raw);
+    assert.ok(Number.isSafeInteger(value) && value >= min && value <= max, `${flag} must be ${min}..${max}`);
+    config[key] = value;
+  }
+  return enabled ? config : null;
+}
+
+export function stabilityPayload(text) {
+  assert.equal(typeof text, 'string');
+  const tuples = text.match(/\bHCC_STABILITY_(?:CODEX|CLAUDE|DSH)_[0-9a-f]{16}\|(?:SEED|T\d+_\d+_[0-9a-f]{8})(?:\|(?:SEED|T\d+_\d+_[0-9a-f]{8}))?/g) || [];
+  assert.equal(tuples.length, 1, 'reply must contain one unambiguous stability tuple');
+  return tuples[0];
+}
+
+export function assertStabilityEvidence(evidence) {
+  assert.equal(evidence.state, 'completed', 'stability work must complete');
+  assert.equal(evidence.replyCount, 1, 'stability work must have exactly one reply');
+  assert.equal(evidence.ackCount, 1, 'stability work must have exactly one ACK');
+  assert.equal(evidence.replyThread, evidence.messageId, 'reply must retain its request thread');
+  assert.equal(stabilityPayload(evidence.actual), evidence.expected, 'original context and FIFO predecessor must match');
+}

package/scripts/regression-cookie-expiry.mjs

@@ -0,0 +1,70 @@
+import { performance } from 'node:perf_hooks';
+import { setTimeout as sleep } from 'node:timers/promises';
+
+const CLOSE_TIMEOUT_MS = 5_000;
+
+// Fixture-only deadlines: cookie validity remains the server's wall-clock
+// decision. Clock correction must not make a monotonic sleep prove expiry.
+export function createCookieExpiryWindow(ttlMs, {
+  monotonicNow = () => performance.now(), wait = sleep,
+  setTimer = setTimeout, clearTimer = clearTimeout
+} = {}) {
+  const startedAt = monotonicNow();
+  const deadline = startedAt + ttlMs + CLOSE_TIMEOUT_MS;
+  let lastStatus = null;
+
+  function timeout(phase) {
+    return Object.assign(new Error(`cookie expiry ${phase} exceeded the original deadline`), {
+      code: 'COOKIE_EXPIRY_TIMEOUT',
+      extra: { elapsedMs: Math.round(monotonicNow() - startedAt), status: lastStatus }
+    });
+  }
+
+  async function bounded(operation, until, phase) {
+    const remaining = until - monotonicNow();
+    if (remaining <= 0) throw timeout(phase);
+    const controller = new AbortController();
+    let timer;
+    const expired = new Promise((_, reject) => {
+      timer = setTimer(() => {
+        const error = timeout(phase);
+        reject(error);
+        controller.abort(error);
+      }, remaining);
+    });
+    try {
+      const value = await Promise.race([Promise.resolve().then(() => operation(controller.signal)), expired]);
+      if (monotonicNow() >= until) throw timeout(phase);
+      return value;
+    } finally { clearTimer(timer); }
+  }
+
+  return {
+    prepare(operation) { return bounded(operation, deadline, 'setup'); },
+    async waitForHttpExpiry(probe) {
+      // Retain the original quiet TTL wait, but count it against the same
+      // overall deadline. Only poll when wall-clock expiry lags behind it.
+      await bounded(() => wait(Math.max(0, startedAt + ttlMs - monotonicNow())), deadline, 'initial wait');
+      for (;;) {
+        const response = await bounded(async signal => {
+          const value = await probe(signal);
+          lastStatus = value.status;
+          if (![200, 401].includes(lastStatus)) {
+            throw Object.assign(new Error(`cookie expiry HTTP returned unexpected status ${lastStatus}`), {
+              code: 'COOKIE_EXPIRY_HTTP_STATUS', extra: { status: lastStatus }
+            });
+          }
+          await value.body?.cancel();
+          return value;
+        }, deadline, 'HTTP check');
+        if (lastStatus === 401) return response;
+        const remaining = deadline - monotonicNow();
+        if (remaining <= 0) throw timeout('HTTP check');
+        await wait(Math.min(100, remaining));
+      }
+    },
+    waitForClose(closed) {
+      return bounded(() => closed, Math.min(deadline, monotonicNow() + CLOSE_TIMEOUT_MS), 'WebSocket close');
+    }
+  };
+}

package/scripts/regression-http-transport.mjs

@@ -0,0 +1,9 @@
+// Fixture traffic alternates HTTP requests with synchronous CLI work. Close
+// each response's connection so later requests cannot inherit its idle socket.
+// Use this from the fixture's first request: it cannot isolate a socket pool
+// already populated by other fetch callers. Never replay uncertain mutations.
+export function fixtureFetch(input, options = {}) {
+  const headers = new Headers(options.headers);
+  headers.set('Connection', 'close');
+  return globalThis.fetch(input, { ...options, headers });
+}

package/scripts/regression-terminal-marker.mjs

@@ -0,0 +1,95 @@
+// Terminal data frames are arbitrary stream chunks. Projections can be checked
+// independently, but must never supply a prefix to the raw stream matcher.
+const failures = new WeakMap();
+
+// Only errors created here carry publishable diagnostics. Never publish a
+// socket error's message, terminal contents, token, or caller-supplied fields.
+export function terminalMarkerFailureDiagnostic(error) {
+  return failures.get(error);
+}
+
+export function createTerminalMarkerMatcher(marker) {
+  if (typeof marker !== 'string' || !marker) throw new TypeError('A nonempty terminal marker is required');
+  const limit = marker.length - 1;
+  let suffix = '';
+  return {
+    get retainedLength() { return suffix.length; },
+    observe(type, value) {
+      if (!['snapshot', 'replace', 'data'].includes(type)) return false;
+      const data = String(value || '');
+      if (type !== 'data') return data.includes(marker);
+      const matched = data.includes(marker) || (suffix + data.slice(0, limit)).includes(marker);
+      suffix = limit === 0 ? '' : data.length >= limit
+        ? data.slice(-limit) : (suffix + data).slice(-limit);
+      return matched;
+    }
+  };
+}
+
+export function waitForTerminalMarker(ws, marker, { claim, release, timeoutMs = 15_000 }) {
+  const matcher = createTerminalMarkerMatcher(marker);
+  return new Promise((resolve, reject) => {
+    const controller = new AbortController();
+    let settled = false, sawMarker = false, inputStarted = false, inputSent = false;
+    let phase = 'snapshot';
+    const timer = setTimeout(() => finish('TERMINAL_MARKER_TIMEOUT'), timeoutMs);
+    const removeSocketListeners = () => {
+      ws.off('error', onError);
+      ws.off('close', onClose);
+    };
+    function finish(code = null) {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      ws.off('message', onMessage);
+      controller.abort();
+      // Keep the error listener until close: terminate() while connecting can
+      // emit an asynchronous error before its close event.
+      if (ws.readyState === 3) removeSocketListeners();
+      try {
+        if (code) ws.terminate();
+        else { try { release(); } catch {} ws.close(); }
+      } catch { try { ws.terminate(); } catch {} }
+      if (code) {
+        const error = Object.assign(new Error(`${code} (${phase})`), { code, phase });
+        failures.set(error, Object.freeze({ code, phase }));
+        reject(error);
+      } else resolve();
+    }
+    function onError() { finish('TERMINAL_MARKER_SOCKET_ERROR'); }
+    function onClose() {
+      if (!settled) finish('TERMINAL_MARKER_CLOSED');
+      removeSocketListeners();
+    }
+    function onMessage(raw) {
+      let message;
+      try { message = JSON.parse(String(raw)); }
+      catch { finish('TERMINAL_MARKER_MESSAGE_INVALID'); return; }
+      if (!message || typeof message !== 'object' || Array.isArray(message)) { finish('TERMINAL_MARKER_MESSAGE_INVALID'); return; }
+      if (message.type === 'error') { finish('TERMINAL_MARKER_SERVER_ERROR'); return; }
+      // Initial history is not evidence that this connection's input worked.
+      // A snapshot received again must never submit the command again.
+      if (inputSent) sawMarker ||= matcher.observe(message.type, message.data);
+      if (sawMarker) { finish(); return; }
+      if (message.type !== 'snapshot' || inputStarted) return;
+      inputStarted = true;
+      phase = 'control';
+      Promise.resolve().then(() => {
+        if (settled) return;
+        return claim(controller.signal);
+      }).then(() => {
+        if (settled) return;
+        phase = 'input';
+        try {
+          inputSent = true;
+          ws.send(JSON.stringify({ type: 'input', data: `echo ${marker}\r`,
+            action_token: ws.hccActionToken, epoch: ws.hccControl?.epoch }));
+          if (!settled) phase = 'marker';
+        } catch { finish('TERMINAL_MARKER_INPUT_FAILED'); }
+      }).catch(() => finish('TERMINAL_MARKER_CONTROL_FAILED'));
+    }
+    ws.on('message', onMessage);
+    ws.on('error', onError);
+    ws.on('close', onClose);
+  });
+}