mixdog 0.9.62 → 0.9.64

package/scripts/webhook-smoke.mjs

@@ -1,201 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import * as crypto from 'node:crypto';
-import { mkdtempSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { readMarkdownDocument } from '../src/runtime/shared/markdown-frontmatter.mjs';
-
-// DATA_DIR resolves from MIXDOG_DATA_DIR at module import time (via
-// ./config.mjs -> resolvePluginData), so the env var MUST be set before
-// the first dynamic import of webhook.mjs. Endpoint defs + delivery dedup now
-// live in PG; this smoke suite deliberately exercises ONLY the pure,
-// PG-free surface (signature verify + header helpers) so it needs no live DB.
-const dataDir = mkdtempSync(join(tmpdir(), 'mixdog-webhook-test-'));
-process.env.MIXDOG_DATA_DIR = dataDir;
-
-const {
-  extractSignature,
-  verifySignature,
-  STRIPE_TOLERANCE_MS,
-} = await import('../src/runtime/channels/lib/webhook.mjs');
-const { extractDeliveryId, buildHeadersSummary } = await import(
-  '../src/runtime/channels/lib/webhook/deliveries.mjs'
-);
-
-function hmacHex(secret, payload) {
-  return crypto.createHmac('sha256', secret).update(payload).digest('hex');
-}
-
-// ── verifySignature: github/generic hex HMAC ──────────────────────────
-
-test('verifySignature: github parser accepts a valid sha256 hex signature', () => {
-  const secret = 'shh';
-  const body = '{"hello":"world"}';
-  const sig = hmacHex(secret, body);
-  assert.equal(verifySignature(secret, body, sig, 'github'), true);
-});
-
-test('verifySignature: generic parser accepts a valid sha256 hex signature', () => {
-  const secret = 'shh';
-  const body = '{"hello":"world"}';
-  const sig = hmacHex(secret, body);
-  assert.equal(verifySignature(secret, body, sig, 'generic'), true);
-});
-
-test('verifySignature: github/generic reject a wrong signature', () => {
-  const secret = 'shh';
-  const body = '{"hello":"world"}';
-  const wrong = hmacHex('other-secret', body);
-  assert.equal(verifySignature(secret, body, wrong, 'github'), false);
-});
-
-test('verifySignature: length-mismatch hex signature returns false without throwing', () => {
-  const secret = 'shh';
-  const body = 'payload';
-  // Valid hex, wrong byte length vs the 32-byte sha256 digest.
-  assert.doesNotThrow(() => {
-    assert.equal(verifySignature(secret, body, 'ab', 'github'), false);
-  });
-});
-
-test('verifySignature: malformed (non-hex) signature returns false without throwing', () => {
-  const secret = 'shh';
-  const body = 'payload';
-  assert.doesNotThrow(() => {
-    assert.equal(verifySignature(secret, body, 'not-hex-zzzz', 'github'), false);
-  });
-});
-
-// ── verifySignature: stripe t= / v1= scheme ───────────────────────────
-
-test('verifySignature: stripe accepts a valid t+v1 pair', () => {
-  const secret = 'stripe-secret';
-  const body = '{"id":"evt_1"}';
-  const t = Math.floor(Date.now() / 1000);
-  const v1 = hmacHex(secret, `${t}.${body}`);
-  assert.equal(verifySignature(secret, body, `t=${t},v1=${v1}`, 'stripe'), true);
-});
-
-test('verifySignature: stripe rejects a header missing t=', () => {
-  const secret = 'stripe-secret';
-  const body = '{"id":"evt_1"}';
-  const t = Math.floor(Date.now() / 1000);
-  const v1 = hmacHex(secret, `${t}.${body}`);
-  assert.equal(verifySignature(secret, body, `v1=${v1}`, 'stripe'), false);
-});
-
-test('verifySignature: stripe rejects a header missing v1=', () => {
-  const secret = 'stripe-secret';
-  const body = '{"id":"evt_1"}';
-  const t = Math.floor(Date.now() / 1000);
-  assert.equal(verifySignature(secret, body, `t=${t}`, 'stripe'), false);
-});
-
-test('verifySignature: stripe rejects a stale timestamp beyond the tolerance window (replay)', () => {
-  const secret = 'stripe-secret';
-  const body = '{"id":"evt_1"}';
-  const staleT = Math.floor((Date.now() - STRIPE_TOLERANCE_MS - 60_000) / 1000);
-  const v1 = hmacHex(secret, `${staleT}.${body}`);
-  assert.equal(verifySignature(secret, body, `t=${staleT},v1=${v1}`, 'stripe'), false);
-});
-
-test('verifySignature: stripe rejects a tampered v1 (HMAC mismatch) with a fresh t', () => {
-  const secret = 'stripe-secret';
-  const body = '{"id":"evt_1"}';
-  const t = Math.floor(Date.now() / 1000);
-  const tamperedV1 = hmacHex('wrong-secret', `${t}.${body}`);
-  assert.equal(verifySignature(secret, body, `t=${t},v1=${tamperedV1}`, 'stripe'), false);
-});
-
-// ── extractSignature: parser mapping + fallback scan ──────────────────
-
-test('extractSignature: github parser strips the sha256= prefix from x-hub-signature-256', () => {
-  const headers = { 'x-hub-signature-256': 'sha256=deadbeef' };
-  assert.equal(extractSignature(headers, 'github'), 'deadbeef');
-});
-
-test('extractSignature: generic parser strips the sha256= prefix from x-signature-256', () => {
-  const headers = { 'x-signature-256': 'sha256=cafebabe' };
-  assert.equal(extractSignature(headers, 'generic'), 'cafebabe');
-});
-
-test('extractSignature: stripe parser returns the raw stripe-signature value (no prefix)', () => {
-  const headers = { 'stripe-signature': 't=1,v1=abc123' };
-  assert.equal(extractSignature(headers, 'stripe'), 't=1,v1=abc123');
-});
-
-test('extractSignature: sentry parser returns the raw sentry-hook-signature value', () => {
-  const headers = { 'sentry-hook-signature': 'raw-sig-value' };
-  assert.equal(extractSignature(headers, 'sentry'), 'raw-sig-value');
-});
-
-test('extractSignature: unknown parser name falls back to scanning all known headers', () => {
-  const headers = { 'x-signature-256': 'sha256=fallback-hit' };
-  assert.equal(extractSignature(headers, 'no-such-parser'), 'fallback-hit');
-});
-
-test('extractSignature: no parser given scans known headers in declaration order', () => {
-  const headers = { 'x-hub-signature-256': 'sha256=github-hit' };
-  assert.equal(extractSignature(headers, undefined), 'github-hit');
-});
-
-test('extractSignature: returns null when no known signature header is present', () => {
-  const headers = { 'x-some-other-header': 'value' };
-  assert.equal(extractSignature(headers, 'github'), null);
-});
-
-// ── delivery-id extraction: header precedence + null fallback ─────────
-
-test('extractDeliveryId: prefers x-github-delivery over other id headers', () => {
-  const headers = { 'x-github-delivery': 'gh-1', 'x-delivery-id': 'dl-1', 'x-request-id': 'rq-1' };
-  assert.equal(extractDeliveryId(headers), 'gh-1');
-});
-
-test('extractDeliveryId: falls back to x-delivery-id then x-request-id', () => {
-  assert.equal(extractDeliveryId({ 'x-delivery-id': 'dl-1', 'x-request-id': 'rq-1' }), 'dl-1');
-  assert.equal(extractDeliveryId({ 'x-request-id': 'rq-1' }), 'rq-1');
-});
-
-test('extractDeliveryId: returns null when no id header is present', () => {
-  assert.equal(extractDeliveryId({ 'content-type': 'application/json' }), null);
-});
-
-// ── headers summary: event/delivery/content-type + signature presence ─
-
-test('buildHeadersSummary: captures event, delivery, content-type and signature presence', () => {
-  const summary = buildHeadersSummary({
-    'x-github-event': 'issues',
-    'x-github-delivery': 'gh-1',
-    'x-hub-signature-256': 'sha256=abc',
-    'content-type': 'application/json',
-  });
-  assert.equal(summary.event_type, 'issues');
-  assert.equal(summary.delivery_id, 'gh-1');
-  assert.equal(summary.signature_present, true);
-  assert.equal(summary.content_type, 'application/json');
-});
-
-test('buildHeadersSummary: signature_present is false when no signature header is present', () => {
-  const summary = buildHeadersSummary({ 'x-github-event': 'push' });
-  assert.equal(summary.signature_present, false);
-  assert.equal(summary.event_type, 'push');
-});
-
-// The webhook body/instructions still round-trip through the shared markdown
-// parser (frontmatter + body split); confirm that pure surface directly.
-test('readMarkdownDocument: WEBHOOK.md-shaped input yields frontmatter + body', () => {
-  const raw = [
-    '---',
-    'channel: main',
-    'parser: github',
-    '---',
-    '',
-    'Handle this webhook by summarizing the payload.',
-    '',
-  ].join('\n');
-  const { frontmatter, body } = readMarkdownDocument(raw);
-  assert.equal(frontmatter.channel, 'main');
-  assert.equal(frontmatter.parser, 'github');
-  assert.equal(body, 'Handle this webhook by summarizing the payload.');
-});

package/scripts/windows-hide-spawn-options-test.mjs

@@ -1,19 +0,0 @@
-import assert from 'node:assert/strict';
-import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import test from 'node:test';
-
-const root = fileURLToPath(new URL('..', import.meta.url));
-
-function source(relativePath) {
-  return readFileSync(join(root, relativePath), 'utf8');
-}
-
-test('Windows-sensitive Node re-execs keep their windows hidden', () => {
-  const cli = source('src/cli.mjs');
-  const jitRebuild = source('src/tui/dev/jit-rebuild.mjs');
-
-  assert.match(cli, /spawnSync\(process\.execPath, \[fileURLToPath\(import\.meta\.url\), \.\.\.argv\], \{\r?\n\s*stdio: 'inherit',\r?\n\s*env: \{ \.\.\.process\.env, MIXDOG_SWAP_REEXEC: '1' \},\r?\n\s*windowsHide: true,\r?\n\s*\}\)/);
-  assert.match(jitRebuild, /spawnSync\(process\.execPath, \[script\], \{\r?\n\s*stdio: process\.env\.MIXDOG_TUI_DEV_VERBOSE \? 'inherit' : 'ignore',\r?\n\s*windowsHide: true,\r?\n\s*\}\)/);
-});

package/scripts/worker-notify-rejection-test.mjs

@@ -1,51 +0,0 @@
-// The owner/worker notifyFn wrapper must not mask a Promise-returning upstream
-// notifyFn as a settled sync success. When the upstream promise REJECTS, the
-// owner-session enqueue fallback must still fire so the completion is delivered
-// rather than silently swallowed. A truthy resolve never enqueues (exact-once).
-import test from 'node:test';
-import assert from 'node:assert/strict';
-
-import { createNotify } from '../src/standalone/agent-tool/notify.mjs';
-
-const tick = () => new Promise((r) => setImmediate(r));
-const meta = { type: 'agent_task_result', execution_id: 'task_1', status: 'completed' };
-// A terminal completion text with a Result body — required for the model-visible
-// completion to persist through the owner-session enqueue.
-const doneText = 'Async agent task task_1 completed finished.\n\nResult:\n> ok';
-
-function makeMgr() {
-  const enqueued = [];
-  return {
-    enqueued,
-    enqueuePendingMessage(target, entry) { enqueued.push({ target, entry }); return 1; },
-  };
-}
-
-test('async upstream notifyFn rejection falls back to owner enqueue', async () => {
-  const mgr = makeMgr();
-  const { workerNotifyFn } = createNotify(mgr);
-  const notify = workerNotifyFn('sess_owner', {
-    callerSessionId: 'sess_owner',
-    notifyFn: () => Promise.reject(new Error('boom')),
-  });
-  const result = notify(doneText, meta);
-  assert.equal(result, true, 'optimistically reported delivered while in flight');
-  assert.equal(mgr.enqueued.length, 0, 'no sync fallback before settlement');
-  await tick();
-  await tick();
-  assert.equal(mgr.enqueued.length, 1, 'rejection rescued via owner enqueue fallback');
-  assert.equal(mgr.enqueued[0].target, 'sess_owner');
-});
-
-test('async upstream notifyFn truthy resolve never enqueues (exact-once)', async () => {
-  const mgr = makeMgr();
-  const { workerNotifyFn } = createNotify(mgr);
-  const notify = workerNotifyFn('sess_owner', {
-    callerSessionId: 'sess_owner',
-    notifyFn: () => Promise.resolve(true),
-  });
-  notify(doneText, meta);
-  await tick();
-  await tick();
-  assert.equal(mgr.enqueued.length, 0, 'successful async delivery does not double-enqueue');
-});

package/scripts/write-backpressure-test.mjs

@@ -1,147 +0,0 @@
-import assert from 'node:assert/strict'
-import { spawnSync } from 'node:child_process'
-import { mkdtempSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { dirname, join, resolve } from 'node:path'
-import test from 'node:test'
-import { fileURLToPath, pathToFileURL } from 'node:url'
-
-import {
-  TRACE_QUEUE_MAX_PENDING_EVENTS,
-  enqueueTraceEvents,
-  getTraceQueueStats,
-} from '../src/runtime/memory/lib/trace-store.mjs'
-
-const root = resolve(dirname(fileURLToPath(import.meta.url)), '..')
-const appenderModuleUrl = pathToFileURL(join(root, 'src/runtime/shared/buffered-appender.mjs')).href
-
-test('buffered appender caps stalled writes by dropping oldest bytes', () => {
-  const dir = mkdtempSync(join(tmpdir(), 'mixdog-buffered-appender-cap-'))
-  const loaderPath = join(dir, 'loader.mjs')
-  const delayedFsPath = join(dir, 'delayed-fs-promises.mjs')
-  const outputPath = join(dir, 'output.log')
-  try {
-    writeFileSync(delayedFsPath, `
-      import { appendFile as realAppendFile } from 'node:fs/promises'
-      export async function appendFile(...args) {
-        await new Promise(resolve => setTimeout(resolve, 200))
-        return realAppendFile(...args)
-      }
-    `)
-    writeFileSync(loaderPath, `
-      export async function resolve(specifier, context, nextResolve) {
-        if (specifier === 'node:fs/promises' && context.parentURL === ${JSON.stringify(appenderModuleUrl)}) {
-          return { url: new URL('./delayed-fs-promises.mjs', import.meta.url).href, shortCircuit: true }
-        }
-        return nextResolve(specifier, context)
-      }
-    `)
-    const child = spawnSync(process.execPath, [
-      '--experimental-loader', pathToFileURL(loaderPath).href,
-      '--input-type=module', '-e',
-      `
-        import assert from 'node:assert/strict'
-        import { readFileSync } from 'node:fs'
-        import {
-          BUFFERED_APPEND_MAX_BYTES, appendBuffered, drainPathSync, getBufferedAppenderStats,
-        } from ${JSON.stringify(appenderModuleUrl)}
-        const initial = 'I'.repeat(32 * 1024)
-        const old = 'O'.repeat(BUFFERED_APPEND_MAX_BYTES)
-        const newest = 'N'.repeat(64 * 1024)
-        appendBuffered(process.env.OUTPUT_PATH, initial)
-        appendBuffered(process.env.OUTPUT_PATH, old)
-        appendBuffered(process.env.OUTPUT_PATH, newest)
-        const stats = getBufferedAppenderStats(process.env.OUTPUT_PATH)
-        assert.equal(stats.bufferedBytes, BUFFERED_APPEND_MAX_BYTES)
-        assert.equal(stats.droppedBytes, newest.length)
-        drainPathSync(process.env.OUTPUT_PATH)
-        await new Promise(resolve => setTimeout(resolve, 250))
-        const written = readFileSync(process.env.OUTPUT_PATH, 'utf8')
-        const retainedOld = old.slice(newest.length)
-        assert.equal(written, initial + retainedOld + newest + initial)
-
-        const unicodePath = process.env.UNICODE_OUTPUT_PATH
-        const emoji = '😀'
-        const unicodeOld = emoji.repeat(BUFFERED_APPEND_MAX_BYTES / Buffer.byteLength(emoji, 'utf8'))
-        appendBuffered(unicodePath, initial)
-        appendBuffered(unicodePath, unicodeOld)
-        appendBuffered(unicodePath, 'x')
-        const unicodeStats = getBufferedAppenderStats(unicodePath)
-        assert.equal(unicodeStats.bufferedBytes, BUFFERED_APPEND_MAX_BYTES - 3)
-        assert.equal(unicodeStats.droppedBytes, 4)
-        drainPathSync(unicodePath)
-        await new Promise(resolve => setTimeout(resolve, 250))
-        assert.equal(readFileSync(unicodePath, 'utf8'), initial + unicodeOld.slice(2) + 'x' + initial)
-        assert.equal(getBufferedAppenderStats(unicodePath).droppedBytes, 4)
-
-        const oversizedPath = process.env.OVERSIZED_OUTPUT_PATH
-        const oversized = 'Z'.repeat(BUFFERED_APPEND_MAX_BYTES * 2)
-        appendBuffered(oversizedPath, initial)
-        appendBuffered(oversizedPath, oversized)
-        const oversizedStats = getBufferedAppenderStats(oversizedPath)
-        assert.equal(oversizedStats.bufferedBytes, BUFFERED_APPEND_MAX_BYTES)
-        assert.equal(oversizedStats.droppedBytes, BUFFERED_APPEND_MAX_BYTES)
-        drainPathSync(oversizedPath)
-        await new Promise(resolve => setTimeout(resolve, 250))
-        assert.equal(readFileSync(oversizedPath, 'utf8'), initial + oversized.slice(-BUFFERED_APPEND_MAX_BYTES) + initial)
-
-        const oversizedUnicodePath = process.env.OVERSIZED_UNICODE_OUTPUT_PATH
-        const oversizedUnicode = emoji.repeat(BUFFERED_APPEND_MAX_BYTES / 2 + 1)
-        const oversizedUnicodeBytes = Buffer.byteLength(oversizedUnicode, 'utf8')
-        appendBuffered(oversizedUnicodePath, initial)
-        appendBuffered(oversizedUnicodePath, oversizedUnicode)
-        const oversizedUnicodeStats = getBufferedAppenderStats(oversizedUnicodePath)
-        assert.equal(oversizedUnicodeStats.bufferedBytes, BUFFERED_APPEND_MAX_BYTES)
-        assert.equal(oversizedUnicodeStats.droppedBytes, oversizedUnicodeBytes - BUFFERED_APPEND_MAX_BYTES)
-        drainPathSync(oversizedUnicodePath)
-        await new Promise(resolve => setTimeout(resolve, 250))
-        assert.equal(readFileSync(oversizedUnicodePath, 'utf8'), initial + oversizedUnicode.slice(-BUFFERED_APPEND_MAX_BYTES / 2) + initial)
-      `,
-    ], {
-      cwd: root,
-      encoding: 'utf8',
-      env: {
-        ...process.env,
-        OUTPUT_PATH: outputPath,
-        UNICODE_OUTPUT_PATH: join(dir, 'unicode-output.log'),
-        OVERSIZED_OUTPUT_PATH: join(dir, 'oversized-output.log'),
-        OVERSIZED_UNICODE_OUTPUT_PATH: join(dir, 'oversized-unicode-output.log'),
-      },
-      timeout: 5_000,
-    })
-    assert.equal(child.status, 0, child.stderr || child.stdout)
-  } finally {
-    rmSync(dir, { recursive: true, force: true })
-  }
-})
-
-test('trace queue caps pending events by dropping oldest entries', async () => {
-  let releaseFirstFlush
-  const firstFlush = new Promise(resolve => { releaseFirstFlush = resolve })
-  const calls = []
-  const db = {
-    query(sql, params) {
-      calls.push({ sql, params })
-      return calls.length === 1 ? firstFlush : Promise.resolve()
-    },
-  }
-  const firstBatch = Array.from({ length: 500 }, (_, i) => ({ kind: `first-${i}` }))
-  const burst = Array.from(
-    { length: TRACE_QUEUE_MAX_PENDING_EVENTS + 64 },
-    (_, i) => ({ kind: `burst-${i}` }),
-  )
-
-  enqueueTraceEvents(db, firstBatch)
-  enqueueTraceEvents(db, burst)
-  const stats = getTraceQueueStats(db)
-  assert.equal(stats.pendingEvents, TRACE_QUEUE_MAX_PENDING_EVENTS)
-  assert.equal(stats.droppedEvents, 64)
-
-  releaseFirstFlush()
-  await new Promise(resolve => setTimeout(resolve, 250))
-  const chunkCalls = calls.slice(1)
-  assert.equal(chunkCalls.length, Math.ceil(TRACE_QUEUE_MAX_PENDING_EVENTS / Math.floor(65_535 / 17)))
-  assert.ok(chunkCalls.every(call => call.params.length <= 65_535))
-  const retainedKinds = chunkCalls.flatMap(call => call.params.filter((_, i) => i % 17 === 3))
-  assert.deepEqual(retainedKinds, burst.slice(64).map(event => event.kind))
-})