opencode-wait-a-minute 0.0.0-stage → 1.1.0-rc.8

package/src/execution/strategy-identity.js

@@ -0,0 +1,162 @@
+// strategy-identity.js
+// Canonical hashing and identity for approvedStrategy objects.
+//
+// Exports:
+//   - createStrategyIdentity(rawStrategy): builds an identity { canonical, hash, ephemeral }
+//   - normalizeStrategy(rawStrategy): returns the canonical projection (volatile fields
+//     removed, keys sorted recursively, arrays normalized for stability)
+//   - hashStrategy(rawStrategy | identity): returns sha256 of canonical JSON
+//   - sameStrategy(a, b): strict-equality of canonical hashes
+//
+// Design goals:
+//   - Stable across property reordering (top-level + nested object keys sorted).
+//   - Stable across volatile/ephemeral fields (timestamps, IDs, attempt counters).
+//   - Pure: no I/O, no Date.now() side effects, no randomness.
+//   - Deterministic JSON via canonical projection.
+
+import { createHash } from "node:crypto";
+
+// Volatile keys do NOT affect strategy semantics and MUST be stripped before hashing.
+const VOLATILE_KEYS = new Set([
+  "createdAt",
+  "updatedAt",
+  "modifiedAt",
+  "instanceId",
+  "runId",
+  "correlationId",
+  "requestId",
+  "sessionId",
+  "traceId",
+  "attempt",
+  "durationMs",
+  "timestamp",
+  "ts",
+  "id",
+  "_id",
+]);
+
+// Keys whose value is an array of strategy rules (allowed/prohibited actions).
+// Arrays under these keys are sorted by their string representation to remain stable.
+const SORTED_ARRAY_KEYS = new Set([
+  "allowedActions",
+  "prohibitedActions",
+]);
+
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object") return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+
+function isVolatileKey(key) {
+  return VOLATILE_KEYS.has(key);
+}
+
+function stableKey(value) {
+  if (value === null) return " ";
+  if (typeof value === "string") return `s:${value}`;
+  if (typeof value === "number") return `n:${value}`;
+  if (typeof value === "boolean") return `b:${value}`;
+  if (Array.isArray(value)) return `a:${value.map(stableKey).join("|")}`;
+  if (typeof value === "object") {
+    const keys = Object.keys(value).sort();
+    return `o:${keys.map((k) => `${k}=${stableKey(value[k])}`).join("&")}`;
+  }
+  return `u:${String(value)}`;
+}
+
+function stableSortArray(arr) {
+  if (arr.length === 0) return arr;
+  const indexed = arr.map((v, i) => ({ i, k: stableKey(v) }));
+  indexed.sort((a, b) => {
+    if (a.k < b.k) return -1;
+    if (a.k > b.k) return 1;
+    return a.i - b.i;
+  });
+  return indexed.map((x) => arr[x.i]);
+}
+
+function canonicalizeValue(value) {
+  if (value === null || value === undefined) return null;
+  if (Array.isArray(value)) {
+    const arr = value.map((v) => canonicalizeValue(v));
+    return stableSortArray(arr);
+  }
+  if (typeof value === "object") {
+    if (!isPlainObject(value)) return value;
+    const sortedKeys = Object.keys(value).sort();
+    const out = {};
+    for (const key of sortedKeys) {
+      if (isVolatileKey(key)) continue;
+      out[key] = canonicalizeValue(value[key]);
+    }
+    return out;
+  }
+  return value;
+}
+
+function normalizeStrategy(rawStrategy) {
+  if (rawStrategy === null || rawStrategy === undefined) return null;
+  if (typeof rawStrategy !== "object") return null;
+  return canonicalizeValue(rawStrategy);
+}
+
+function hashStrategy(input) {
+  const normalized =
+    input && typeof input === "object" && input.__normalized === true
+      ? input.canonical
+      : normalizeStrategy(input);
+  if (normalized === null) return null;
+  const json = JSON.stringify(normalized);
+  return createHash("sha256").update(json).digest("hex");
+}
+
+function collectEphemeralKeys(value, prefix = "") {
+  const found = [];
+  if (value === null || value === undefined) return found;
+  if (typeof value !== "object" || Array.isArray(value)) return found;
+  if (!isPlainObject(value)) return found;
+  for (const key of Object.keys(value)) {
+    const path = prefix ? `${prefix}.${key}` : key;
+    if (isVolatileKey(key)) {
+      found.push(path);
+    } else {
+      const child = value[key];
+      if (child && typeof child === "object" && !Array.isArray(child) && isPlainObject(child)) {
+        found.push(...collectEphemeralKeys(child, path));
+      }
+    }
+  }
+  return found;
+}
+
+function createStrategyIdentity(rawStrategy) {
+  const canonical = normalizeStrategy(rawStrategy);
+  const hash = canonical === null ? null : hashStrategy({ __normalized: true, canonical });
+  const ephemeral = collectEphemeralKeys(rawStrategy);
+  return {
+    canonical,
+    hash,
+    ephemeral,
+    __normalized: true,
+  };
+}
+
+function sameStrategy(a, b) {
+  const ha = hashStrategy(a);
+  const hb = hashStrategy(b);
+  if (ha === null && hb === null) return true;
+  if (ha === null || hb === null) return false;
+  return ha === hb;
+}
+
+export {
+  createStrategyIdentity,
+  normalizeStrategy,
+  hashStrategy,
+  sameStrategy,
+  // exported for tests / advanced use:
+  canonicalizeValue as _canonicalizeValue,
+  VOLATILE_KEYS as _VOLATILE_KEYS,
+  SORTED_ARRAY_KEYS as _SORTED_ARRAY_KEYS,
+};

package/src/execution/tool-interceptor.js

@@ -0,0 +1,7 @@
+export function createToolInterceptor() {
+  return {
+    intercept(tool, args, handler) {
+      return handler(tool, args);
+    },
+  };
+}

package/src/execution/tool-result-classifier.js

@@ -0,0 +1,63 @@
+export const EXECUTION_STATUS = Object.freeze({
+  SUCCEEDED: "SUCCEEDED",
+  FAILED: "FAILED",
+  UNKNOWN: "UNKNOWN",
+});
+
+export const OUTCOME_STATUS = Object.freeze({
+  SATISFIED: "SATISFIED",
+  NOT_SATISFIED: "NOT_SATISFIED",
+  UNKNOWN: "UNKNOWN",
+});
+
+const RUNTIME_ERROR_PATTERNS = [
+  /\bchromium\b.*\b(missing|not\s+found|not\s+installed|executable\s+missing)/i,
+  /BROWSER_(EXECUTABLE_MISSING|NOT_FOUND|MISSING)/,
+  /\b(failed|error|cannot|not\s+found|null|undefined)\b/i,
+  /\bENOENT\b/,
+  /\bexecutable\s+file\s+not\s+found/i,
+];
+
+function detectRuntimeError(actual, unexpected, output) {
+  if (actual?.status === "failure" || actual?.status === "error") return true;
+  const text = JSON.stringify({ actual, unexpected, output });
+  return RUNTIME_ERROR_PATTERNS.some((re) => re.test(text));
+}
+
+export function classifyToolResult({ result, actual, unexpected, output, expected } = {}) {
+  const hasOutput = result !== undefined && result !== null;
+  const outputError = String(output?.error || "").toLowerCase();
+  const executionFailed =
+    outputError.length > 0 ||
+    (result === undefined && !hasOutput);
+
+  const execution = executionFailed ? EXECUTION_STATUS.FAILED : EXECUTION_STATUS.SUCCEEDED;
+
+  const expectedIsSuccess = expected?.expected?.status === "success" && (expected?.expected?.exitCode === undefined || expected?.expected?.exitCode === 0);
+  const actualSignalsSuccess =
+    actual?.status === "success" ||
+    (typeof result === "string" && !unexpected?.error);
+  const actualSignalsFailure = detectRuntimeError(actual, unexpected, output);
+
+  let outcome;
+  if (!expectedIsSuccess) {
+    outcome = OUTCOME_STATUS.UNKNOWN;
+  } else if (actualSignalsFailure) {
+    outcome = OUTCOME_STATUS.NOT_SATISFIED;
+  } else if (actualSignalsSuccess) {
+    outcome = OUTCOME_STATUS.SATISFIED;
+  } else {
+    outcome = OUTCOME_STATUS.UNKNOWN;
+  }
+
+  return { execution, outcome };
+}
+
+export function isSatisfied(result) {
+  return result?.outcome === OUTCOME_STATUS.SATISFIED;
+}
+
+export function isRuntimeFailure(result) {
+  return result?.execution === EXECUTION_STATUS.FAILED &&
+    result?.outcome === OUTCOME_STATUS.NOT_SATISFIED;
+}

package/src/integration/canary-deploy.js

@@ -0,0 +1,143 @@
+/**
+ * Canary Deploy
+ *
+ * Staged rollout with health-check tracking and auto-abort on threshold
+ * breach. The canary evaluator is dependency-injected so production code
+ * uses real telemetry while tests can simulate any health trajectory.
+ *
+ * API:
+ *   canaryDeploy({
+ *     releaseId,
+ *     rolloutPercent,    // integer 0..100, size of canary cohort
+ *     durationMs,        // observation window
+ *     healthCheck,       // () => { ok, completionRate, errorRate }
+ *     thresholds,        // { minCompletionRate, maxErrorRate }
+ *     tickMs,            // polling interval (default 10ms)
+ *     now,               // injectable clock (default Date.now)
+ *   })
+ *     -> Promise<{
+ *        status: "advanced" | "aborted",
+ *        reason: string,
+ *        observations: Array<{ at, ok, completionRate, errorRate }>,
+ *      }>
+ */
+
+const DEFAULT_THRESHOLDS = {
+  minCompletionRate: 0.9, // drop > 10% relative triggers abort
+  maxErrorRate: 0.05,    // spike > 5% triggers abort
+};
+
+const DEFAULT_TICK_MS = 10;
+
+/**
+ * Run a canary rollout. Resolves once the canary either advances (healthy
+ * for the full window) or auto-aborts (breach detected). Never rejects:
+ * failures surface as `{ status: "aborted", reason }`.
+ */
+export async function canaryDeploy(opts) {
+  const {
+    releaseId,
+    rolloutPercent,
+    durationMs,
+    healthCheck,
+    thresholds = DEFAULT_THRESHOLDS,
+    tickMs = DEFAULT_TICK_MS,
+    now = () => Date.now(),
+  } = opts || {};
+
+  if (typeof releaseId !== "string" || !releaseId) {
+    return {
+      status: "aborted",
+      reason: "releaseId required",
+      observations: [],
+    };
+  }
+  if (!Number.isFinite(rolloutPercent) || rolloutPercent < 0 || rolloutPercent > 100) {
+    return {
+      status: "aborted",
+      reason: "rolloutPercent must be 0..100",
+      observations: [],
+    };
+  }
+  if (!Number.isFinite(durationMs) || durationMs <= 0) {
+    return {
+      status: "aborted",
+      reason: "durationMs must be > 0",
+      observations: [],
+    };
+  }
+  if (typeof healthCheck !== "function") {
+    return {
+      status: "aborted",
+      reason: "healthCheck function required",
+      observations: [],
+    };
+  }
+
+  const minCompletion = thresholds.minCompletionRate ?? DEFAULT_THRESHOLDS.minCompletionRate;
+  const maxError = thresholds.maxErrorRate ?? DEFAULT_THRESHOLDS.maxErrorRate;
+
+  // Real-time clock for pacing + deadline; injectable `now` is for `at` timestamps.
+  const realStart = Date.now();
+  const realDeadline = realStart + durationMs;
+  const observations = [];
+
+  while (true) {
+    let sample;
+    try {
+      sample = await healthCheck();
+    } catch (err) {
+      return {
+        status: "aborted",
+        reason: `health check threw: ${err && err.message ? err.message : String(err)}`,
+        observations,
+      };
+    }
+
+    const observation = {
+      at: now(),
+      ok: !!sample?.ok,
+      completionRate: typeof sample?.completionRate === "number" ? sample.completionRate : null,
+      errorRate: typeof sample?.errorRate === "number" ? sample.errorRate : null,
+    };
+    observations.push(observation);
+
+    if (!observation.ok) {
+      return {
+        status: "aborted",
+        reason: "health check reported unhealthy",
+        observations,
+      };
+    }
+    if (
+      observation.completionRate !== null &&
+      observation.completionRate < minCompletion
+    ) {
+      return {
+        status: "aborted",
+        reason: `completion rate ${observation.completionRate} < ${minCompletion}`,
+        observations,
+      };
+    }
+    if (observation.errorRate !== null && observation.errorRate > maxError) {
+      return {
+        status: "aborted",
+        reason: `error rate ${observation.errorRate} > ${maxError}`,
+        observations,
+      };
+    }
+
+    if (Date.now() >= realDeadline) {
+      return {
+        status: "advanced",
+        reason: "canary healthy for full window",
+        observations,
+      };
+    }
+    await sleep(tickMs);
+  }
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/src/integration/collector.js

@@ -0,0 +1,59 @@
+export function createMetricsCollector() {
+  const series = new Map();
+
+  function key(name, tags) {
+    const tagStr = tags ? Object.keys(tags).sort().map(k => `${k}=${tags[k]}`).join(',') : '';
+    return `${name}|${tagStr}`;
+  }
+
+  function record(name, value, tags) {
+    const k = key(name, tags);
+    if (!series.has(k)) {
+      series.set(k, { name, tags: tags || {}, values: [] });
+    }
+    series.get(k).values.push(value);
+  }
+
+  function snapshotFor(entry) {
+    const values = entry.values;
+    if (values.length === 0) {
+      return { count: 0, sum: 0, min: 0, max: 0, avg: 0, p50: 0, p95: 0, p99: 0 };
+    }
+    const sorted = [...values].sort((a, b) => a - b);
+    const sum = values.reduce((a, b) => a + b, 0);
+    const count = values.length;
+    const pct = (p) => {
+      if (sorted.length === 1) return sorted[0];
+      const idx = Math.min(sorted.length - 1, Math.max(0, Math.round(p * (sorted.length - 1))));
+      return sorted[idx];
+    };
+    return {
+      count,
+      sum,
+      min: sorted[0],
+      max: sorted[count - 1],
+      avg: sum / count,
+      p50: pct(0.5),
+      p95: pct(0.95),
+      p99: pct(0.99),
+    };
+  }
+
+  function getSnapshot() {
+    const out = [];
+    for (const entry of series.values()) {
+      out.push({
+        name: entry.name,
+        tags: entry.tags,
+        ...snapshotFor(entry),
+      });
+    }
+    return out;
+  }
+
+  function reset() {
+    series.clear();
+  }
+
+  return { record, getSnapshot, reset };
+}

package/src/integration/error-recovery.js

@@ -0,0 +1,6 @@
+export function recover(error, context) {
+  if (context && context.retry) return { recovered: true, action: 'retry' };
+  if (context && context.fallback) return { recovered: true, action: 'fallback' };
+  if (context && context.circuitOpen) return { recovered: false, action: 'circuit-open' };
+  return { recovered: false, error };
+}

package/src/integration/event-bus.js

@@ -0,0 +1,66 @@
+/**
+ * Event Bus — minimal pub/sub.
+ *
+ * Synchronous event delivery with off() to detach handlers. Designed for
+ * production hardening (M5-50) — inter-module decoupling.
+ */
+
+/**
+ * @typedef {Object} EventBus
+ * @property {(event: string, handler: Function) => () => void} on
+ * @property {(event: string, handler: Function) => void} off
+ * @property {(event: string, payload?: unknown) => void} emit
+ * @property {(event: string) => number} listenerCount
+ * @property {() => void} removeAllListeners
+ */
+
+/**
+ * Create a new event bus.
+ * @returns {EventBus}
+ */
+export function createEventBus() {
+  /** @type {Map<string, Set<Function>>} */
+  const map = new Map();
+
+  function on(event, handler) {
+    if (typeof handler !== "function") throw new TypeError("handler must be function");
+    let set = map.get(event);
+    if (!set) {
+      set = new Set();
+      map.set(event, set);
+    }
+    set.add(handler);
+    return () => off(event, handler);
+  }
+
+  function off(event, handler) {
+    const set = map.get(event);
+    if (!set) return;
+    set.delete(handler);
+    if (set.size === 0) map.delete(event);
+  }
+
+  function emit(event, payload) {
+    const set = map.get(event);
+    if (!set) return;
+    // copy to allow off() during iteration
+    for (const fn of [...set]) {
+      try {
+        fn(payload, { event });
+      } catch (_err) {
+        // swallow listener errors — pub/sub isolation
+      }
+    }
+  }
+
+  function listenerCount(event) {
+    const set = map.get(event);
+    return set ? set.size : 0;
+  }
+
+  function removeAllListeners() {
+    map.clear();
+  }
+
+  return { on, off, emit, listenerCount, removeAllListeners };
+}

package/src/integration/health-checker.js

@@ -0,0 +1,57 @@
+export function createHealthChecker() {
+  const checks = new Map();
+
+  function register(name, fn) {
+    if (typeof fn !== 'function') {
+      throw new TypeError(`Health check "${name}" must be a function`);
+    }
+    checks.set(name, fn);
+  }
+
+  function unregister(name) {
+    return checks.delete(name);
+  }
+
+  async function runOne(name) {
+    const fn = checks.get(name);
+    if (!fn) {
+      return { name, status: 'unknown', error: 'not registered' };
+    }
+    const started = Date.now();
+    try {
+      const result = await fn();
+      const latencyMs = Date.now() - started;
+      // Treat thrown exception as fail; explicit return shape otherwise.
+      if (result && typeof result === 'object' && 'status' in result) {
+        return { name, ...result, latencyMs };
+      }
+      return { name, status: 'ok', latencyMs, details: result };
+    } catch (err) {
+      return {
+        name,
+        status: 'fail',
+        latencyMs: Date.now() - started,
+        error: err && err.message ? err.message : String(err),
+      };
+    }
+  }
+
+  async function check(name) {
+    if (name) return runOne(name);
+    const results = await Promise.all(
+      Array.from(checks.keys()).map((n) => runOne(n))
+    );
+    const overall = results.every((r) => r.status === 'ok')
+      ? 'ok'
+      : results.some((r) => r.status === 'ok')
+      ? 'degraded'
+      : 'fail';
+    return { overall, checks: results, timestamp: Date.now() };
+  }
+
+  function list() {
+    return Array.from(checks.keys());
+  }
+
+  return { register, unregister, check, list };
+}

package/src/integration/logger.js

@@ -0,0 +1,39 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+const LOG_FILE = process.env.WAM_LOG_FILE || path.join(process.cwd(), '.wam', 'plugin.log');
+
+/**
+ * Simple diagnostic logger for wait-a-minute-plugin.
+ * Prefixes: [ISO-Timestamp] [LEVEL] [category] Message
+ */
+export const logger = {
+  _log(level, category, message) {
+    const timestamp = new Date().toISOString();
+    const formattedMessage = `[${timestamp}] [${level}] [${category}] ${message}\n`;
+    
+    try {
+      const logDir = path.dirname(LOG_FILE);
+      if (!fs.existsSync(logDir)) {
+        fs.mkdirSync(logDir, { recursive: true });
+      }
+      fs.appendFileSync(LOG_FILE, formattedMessage, 'utf8');
+    } catch (err) {
+      console.error(`[LOGGER-ERROR] Failed to write to log file: ${err.message}`);
+    }
+  },
+
+  info(category, message) {
+    this._log('INFO', category, message);
+  },
+
+  warn(category, message) {
+    this._log('WARN', category, message);
+  },
+
+  error(category, message) {
+    this._log('ERROR', category, message);
+  }
+};
+
+