chainlesschain 0.66.0 → 0.81.0

package/src/lib/skill-marketplace.js

@@ -394,4 +394,329 @@ export function _resetState() {
   _services.clear();
   _invocations.clear();
   _seq = 0;
+  _maxConcurrentInvocationsPerService =
+    DEFAULT_MAX_CONCURRENT_INVOCATIONS_PER_SERVICE;
+}
+
+/* ═══════════════════════════════════════════════════════════════
+ * V2 (Phase 65) — Frozen enums + async invocation lifecycle +
+ * per-service concurrency cap + patch-merged setInvocationStatus +
+ * stats-v2. Strictly additive on top of the legacy surface above.
+ * ═══════════════════════════════════════════════════════════════ */
+
+export const SERVICE_STATUS_V2 = Object.freeze({
+  DRAFT: "draft",
+  PUBLISHED: "published",
+  DEPRECATED: "deprecated",
+  SUSPENDED: "suspended",
+});
+
+export const INVOCATION_STATUS_V2 = Object.freeze({
+  PENDING: "pending",
+  RUNNING: "running",
+  SUCCESS: "success",
+  FAILED: "failed",
+  TIMEOUT: "timeout",
+});
+
+export const PRICING_MODEL_V2 = Object.freeze({
+  FREE: "free",
+  PAY_PER_CALL: "pay_per_call",
+  SUBSCRIPTION: "subscription",
+  TIERED: "tiered",
+});
+
+const DEFAULT_MAX_CONCURRENT_INVOCATIONS_PER_SERVICE = 10;
+let _maxConcurrentInvocationsPerService =
+  DEFAULT_MAX_CONCURRENT_INVOCATIONS_PER_SERVICE;
+export const MARKETPLACE_DEFAULT_MAX_CONCURRENT_INVOCATIONS =
+  DEFAULT_MAX_CONCURRENT_INVOCATIONS_PER_SERVICE;
+
+export function setMaxConcurrentInvocations(n) {
+  if (typeof n !== "number" || !Number.isFinite(n) || n < 1) {
+    throw new Error("maxConcurrentInvocations must be a positive integer");
+  }
+  _maxConcurrentInvocationsPerService = Math.floor(n);
+  return _maxConcurrentInvocationsPerService;
+}
+
+export function getMaxConcurrentInvocations() {
+  return _maxConcurrentInvocationsPerService;
+}
+
+export function getActiveInvocationCount(serviceId) {
+  let count = 0;
+  for (const inv of _invocations.values()) {
+    if (
+      (serviceId == null || inv.serviceId === serviceId) &&
+      (inv.status === INVOCATION_STATUS_V2.PENDING ||
+        inv.status === INVOCATION_STATUS_V2.RUNNING)
+    ) {
+      count++;
+    }
+  }
+  return count;
+}
+
+// Invocation state machine:
+//   pending → { running, failed, timeout }
+//   running → { success, failed, timeout }
+//   success/failed/timeout are terminal.
+const _invocationTerminal = new Set([
+  INVOCATION_STATUS_V2.SUCCESS,
+  INVOCATION_STATUS_V2.FAILED,
+  INVOCATION_STATUS_V2.TIMEOUT,
+]);
+const _invocationAllowed = new Map([
+  [
+    INVOCATION_STATUS_V2.PENDING,
+    new Set([
+      INVOCATION_STATUS_V2.RUNNING,
+      INVOCATION_STATUS_V2.FAILED,
+      INVOCATION_STATUS_V2.TIMEOUT,
+    ]),
+  ],
+  [
+    INVOCATION_STATUS_V2.RUNNING,
+    new Set([
+      INVOCATION_STATUS_V2.SUCCESS,
+      INVOCATION_STATUS_V2.FAILED,
+      INVOCATION_STATUS_V2.TIMEOUT,
+    ]),
+  ],
+  [INVOCATION_STATUS_V2.SUCCESS, new Set([])],
+  [INVOCATION_STATUS_V2.FAILED, new Set([])],
+  [INVOCATION_STATUS_V2.TIMEOUT, new Set([])],
+]);
+
+/**
+ * beginInvocationV2 — creates a PENDING invocation row (no output/duration).
+ * Caller drives the transition via startInvocation (→ RUNNING),
+ * completeInvocation (→ SUCCESS), failInvocation / timeoutInvocation,
+ * or the generic setInvocationStatus.
+ */
+export function beginInvocationV2(db, config = {}) {
+  const serviceId = String(config.serviceId || "").trim();
+  if (!serviceId) throw new Error("serviceId is required");
+  const service = _mustGetService(serviceId);
+  if (service.status !== SERVICE_STATUS_V2.PUBLISHED) {
+    throw new Error(
+      `Cannot invoke non-published service (status=${service.status})`,
+    );
+  }
+
+  const activeCount = getActiveInvocationCount(serviceId);
+  if (activeCount >= _maxConcurrentInvocationsPerService) {
+    throw new Error(
+      `Max concurrent invocations reached: ${activeCount}/${_maxConcurrentInvocationsPerService}`,
+    );
+  }
+
+  const callerId = config.callerId ? String(config.callerId).trim() : null;
+  const input = config.input ?? null;
+  const now = Number(config.now ?? Date.now());
+  const id = config.id || crypto.randomUUID();
+
+  const invocation = {
+    id,
+    serviceId,
+    callerId,
+    input,
+    output: null,
+    status: INVOCATION_STATUS_V2.PENDING,
+    durationMs: null,
+    error: null,
+    startedAt: null,
+    completedAt: null,
+    createdAt: now,
+    _seq: ++_seq,
+  };
+  _invocations.set(id, invocation);
+
+  if (db) {
+    db.prepare(
+      `INSERT INTO skill_invocations (id, service_id, caller_id, input, output, status, duration_ms, error, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    ).run(
+      id,
+      serviceId,
+      callerId,
+      input == null ? null : JSON.stringify(input),
+      null,
+      INVOCATION_STATUS_V2.PENDING,
+      null,
+      null,
+      now,
+    );
+  }
+
+  return _strip(invocation);
+}
+
+function _mustGetInvocation(invocationId) {
+  const inv = _invocations.get(invocationId);
+  if (!inv) throw new Error(`Invocation not found: ${invocationId}`);
+  return inv;
+}
+
+function _persistInvocation(db, invocationId, fields) {
+  if (!db) return;
+  const setClauses = Object.keys(fields)
+    .map((k) => `${k} = ?`)
+    .join(", ");
+  const values = Object.values(fields).map((v) =>
+    v && typeof v === "object" ? JSON.stringify(v) : v,
+  );
+  db.prepare(`UPDATE skill_invocations SET ${setClauses} WHERE id = ?`).run(
+    ...values,
+    invocationId,
+  );
+}
+
+export function startInvocation(db, invocationId, opts = {}) {
+  return setInvocationStatus(db, invocationId, INVOCATION_STATUS_V2.RUNNING, {
+    startedAt: Number(opts.now ?? Date.now()),
+  });
+}
+
+export function completeInvocationV2(db, invocationId, opts = {}) {
+  return setInvocationStatus(db, invocationId, INVOCATION_STATUS_V2.SUCCESS, {
+    output: opts.output ?? null,
+    durationMs: opts.durationMs == null ? null : Number(opts.durationMs),
+  });
+}
+
+export function failInvocationV2(db, invocationId, errorMessage, opts = {}) {
+  return setInvocationStatus(db, invocationId, INVOCATION_STATUS_V2.FAILED, {
+    error: errorMessage ? String(errorMessage) : null,
+    durationMs: opts.durationMs == null ? null : Number(opts.durationMs),
+  });
+}
+
+export function timeoutInvocationV2(db, invocationId, opts = {}) {
+  return setInvocationStatus(db, invocationId, INVOCATION_STATUS_V2.TIMEOUT, {
+    error: opts.error ? String(opts.error) : "timeout",
+    durationMs: opts.durationMs == null ? null : Number(opts.durationMs),
+  });
+}
+
+export function setInvocationStatus(db, invocationId, newStatus, patch = {}) {
+  const inv = _mustGetInvocation(invocationId);
+
+  if (!Object.values(INVOCATION_STATUS_V2).includes(newStatus)) {
+    throw new Error(`Unknown invocation status: ${newStatus}`);
+  }
+
+  const allowed = _invocationAllowed.get(inv.status);
+  if (!allowed || !allowed.has(newStatus)) {
+    throw new Error(
+      `Invalid invocation status transition: ${inv.status} → ${newStatus}`,
+    );
+  }
+
+  const now = Date.now();
+  inv.status = newStatus;
+
+  const dbFields = { status: newStatus };
+
+  if (patch.output !== undefined) {
+    inv.output = patch.output;
+    dbFields.output =
+      patch.output == null ? null : JSON.stringify(patch.output);
+  }
+  if (patch.error !== undefined) {
+    inv.error = patch.error;
+    dbFields.error = patch.error;
+  }
+  if (patch.durationMs !== undefined) {
+    const d = patch.durationMs == null ? null : Number(patch.durationMs);
+    if (d != null && (Number.isNaN(d) || d < 0)) {
+      throw new Error(`Invalid durationMs: ${patch.durationMs}`);
+    }
+    inv.durationMs = d;
+    dbFields.duration_ms = d;
+  }
+  if (patch.startedAt !== undefined) {
+    inv.startedAt = patch.startedAt;
+  }
+
+  if (_invocationTerminal.has(newStatus) && inv.completedAt == null) {
+    inv.completedAt = now;
+    // Bump the service's invocation counter once on terminal.
+    const service = _services.get(inv.serviceId);
+    if (service) {
+      service.invocationCount = (service.invocationCount || 0) + 1;
+      service.updatedAt = now;
+      _persistService(db, inv.serviceId, {
+        invocation_count: service.invocationCount,
+        updated_at: now,
+      });
+    }
+  }
+
+  _persistInvocation(db, invocationId, dbFields);
+
+  return _strip(inv);
+}
+
+export function getMarketplaceStatsV2() {
+  const services = [..._services.values()];
+  const invocations = [..._invocations.values()];
+
+  const servicesByStatus = {};
+  for (const s of Object.values(SERVICE_STATUS_V2)) servicesByStatus[s] = 0;
+  for (const s of services)
+    servicesByStatus[s.status] = (servicesByStatus[s.status] || 0) + 1;
+
+  const invocationsByStatus = {};
+  for (const s of Object.values(INVOCATION_STATUS_V2))
+    invocationsByStatus[s] = 0;
+  for (const inv of invocations)
+    invocationsByStatus[inv.status] =
+      (invocationsByStatus[inv.status] || 0) + 1;
+
+  const servicesByPricing = {};
+  for (const p of Object.values(PRICING_MODEL_V2)) servicesByPricing[p] = 0;
+  for (const s of services) {
+    const model =
+      s.pricing && typeof s.pricing === "object" && s.pricing.model
+        ? String(s.pricing.model)
+        : PRICING_MODEL_V2.FREE;
+    if (servicesByPricing[model] == null) servicesByPricing[model] = 0;
+    servicesByPricing[model]++;
+  }
+
+  let totalDuration = 0;
+  let durationSamples = 0;
+  for (const inv of invocations) {
+    if (inv.durationMs != null && inv.status === INVOCATION_STATUS_V2.SUCCESS) {
+      totalDuration += inv.durationMs;
+      durationSamples++;
+    }
+  }
+  const avgDurationMs =
+    durationSamples > 0
+      ? Number((totalDuration / durationSamples).toFixed(1))
+      : 0;
+  const successRate =
+    invocations.length > 0
+      ? Number(
+          (
+            invocationsByStatus[INVOCATION_STATUS_V2.SUCCESS] /
+            invocations.length
+          ).toFixed(3),
+        )
+      : 0;
+
+  return {
+    totalServices: services.length,
+    totalInvocations: invocations.length,
+    activeInvocations: getActiveInvocationCount(),
+    maxConcurrentInvocations: _maxConcurrentInvocationsPerService,
+    servicesByStatus,
+    invocationsByStatus,
+    servicesByPricing,
+    avgDurationMs,
+    successRate,
+  };
 }

package/src/lib/sla-manager.js

@@ -481,4 +481,279 @@ export function _resetState() {
   _metrics.clear();
   _violations.clear();
   _seq = 0;
+  _maxActiveSlasPerOrg = DEFAULT_MAX_ACTIVE_SLAS_PER_ORG;
+}
+
+/* ═══════════════════════════════════════════════════════════════
+ * V2 (Phase 61) — Frozen enums + contract/violation state
+ * machines + active-per-org cap + auto-expire + stats-v2.
+ * Strictly additive on top of the legacy surface above.
+ * ═══════════════════════════════════════════════════════════════ */
+
+export const SLA_STATUS_V2 = Object.freeze({
+  ACTIVE: "active",
+  EXPIRED: "expired",
+  TERMINATED: "terminated",
+});
+
+export const SLA_TIER_V2 = Object.freeze({
+  GOLD: "gold",
+  SILVER: "silver",
+  BRONZE: "bronze",
+});
+
+export const SLA_TERM_V2 = Object.freeze({
+  AVAILABILITY: "availability",
+  RESPONSE_TIME: "response_time",
+  THROUGHPUT: "throughput",
+  ERROR_RATE: "error_rate",
+});
+
+export const VIOLATION_SEVERITY_V2 = Object.freeze({
+  MINOR: "minor",
+  MODERATE: "moderate",
+  MAJOR: "major",
+  CRITICAL: "critical",
+});
+
+export const VIOLATION_STATUS_V2 = Object.freeze({
+  OPEN: "open",
+  ACKNOWLEDGED: "acknowledged",
+  RESOLVED: "resolved",
+  WAIVED: "waived",
+});
+
+const DEFAULT_MAX_ACTIVE_SLAS_PER_ORG = 1;
+let _maxActiveSlasPerOrg = DEFAULT_MAX_ACTIVE_SLAS_PER_ORG;
+export const SLA_DEFAULT_MAX_ACTIVE_PER_ORG = DEFAULT_MAX_ACTIVE_SLAS_PER_ORG;
+
+export function setMaxActiveSlasPerOrg(n) {
+  if (typeof n !== "number" || !Number.isFinite(n) || n < 1) {
+    throw new Error("maxActiveSlasPerOrg must be a positive integer");
+  }
+  _maxActiveSlasPerOrg = Math.floor(n);
+  return _maxActiveSlasPerOrg;
+}
+
+export function getMaxActiveSlasPerOrg() {
+  return _maxActiveSlasPerOrg;
+}
+
+// Contract state machine: active → { expired, terminated }; both terminal.
+const _contractTerminal = new Set([
+  SLA_STATUS_V2.EXPIRED,
+  SLA_STATUS_V2.TERMINATED,
+]);
+const _contractAllowed = new Map([
+  [
+    SLA_STATUS_V2.ACTIVE,
+    new Set([SLA_STATUS_V2.EXPIRED, SLA_STATUS_V2.TERMINATED]),
+  ],
+  [SLA_STATUS_V2.EXPIRED, new Set([])],
+  [SLA_STATUS_V2.TERMINATED, new Set([])],
+]);
+
+// Violation state machine: open → { acknowledged, resolved, waived };
+// acknowledged → { resolved, waived }; resolved/waived terminal.
+const _violationTerminal = new Set([
+  VIOLATION_STATUS_V2.RESOLVED,
+  VIOLATION_STATUS_V2.WAIVED,
+]);
+const _violationAllowed = new Map([
+  [
+    VIOLATION_STATUS_V2.OPEN,
+    new Set([
+      VIOLATION_STATUS_V2.ACKNOWLEDGED,
+      VIOLATION_STATUS_V2.RESOLVED,
+      VIOLATION_STATUS_V2.WAIVED,
+    ]),
+  ],
+  [
+    VIOLATION_STATUS_V2.ACKNOWLEDGED,
+    new Set([VIOLATION_STATUS_V2.RESOLVED, VIOLATION_STATUS_V2.WAIVED]),
+  ],
+  [VIOLATION_STATUS_V2.RESOLVED, new Set([])],
+  [VIOLATION_STATUS_V2.WAIVED, new Set([])],
+]);
+
+export function getActiveSlaCountForOrg(orgId) {
+  let count = 0;
+  for (const c of _contracts.values()) {
+    if (c.orgId === orgId && c.status === SLA_STATUS_V2.ACTIVE) count++;
+  }
+  return count;
+}
+
+/**
+ * createSLAV2 — like createSLA but enforces per-org active-contract cap
+ * and rejects unknown tier/status at the boundary. Augments stored
+ * contract with in-memory V2 fields (violationStatus doesn't apply here;
+ * see recordViolation*).
+ */
+export function createSLAV2(db, config = {}) {
+  const orgId = config.orgId;
+  if (!orgId) throw new Error("orgId is required");
+
+  const activeCount = getActiveSlaCountForOrg(orgId);
+  if (activeCount >= _maxActiveSlasPerOrg) {
+    throw new Error(
+      `Max active SLAs per org reached: ${activeCount}/${_maxActiveSlasPerOrg}`,
+    );
+  }
+
+  return createSLA(db, config);
+}
+
+export function setSLAStatus(db, slaId, newStatus) {
+  const contract = _contracts.get(slaId);
+  if (!contract) throw new Error(`SLA not found: ${slaId}`);
+
+  if (!Object.values(SLA_STATUS_V2).includes(newStatus)) {
+    throw new Error(`Unknown SLA status: ${newStatus}`);
+  }
+
+  const allowed = _contractAllowed.get(contract.status);
+  if (!allowed || !allowed.has(newStatus)) {
+    throw new Error(
+      `Invalid SLA status transition: ${contract.status} → ${newStatus}`,
+    );
+  }
+
+  contract.status = newStatus;
+  contract.updatedAt = Date.now();
+  db.prepare(
+    `UPDATE sla_contracts SET status = ?, updated_at = ? WHERE sla_id = ?`,
+  ).run(contract.status, contract.updatedAt, slaId);
+
+  const { _seq: _omit, ...rest } = contract;
+  void _omit;
+  return rest;
+}
+
+export function expireSLA(db, slaId) {
+  return setSLAStatus(db, slaId, SLA_STATUS_V2.EXPIRED);
+}
+
+/**
+ * autoExpireSLAs — bulk-flip ACTIVE contracts whose endDate < now to
+ * EXPIRED. Returns the list of flipped contracts.
+ */
+export function autoExpireSLAs(db, nowMs = Date.now()) {
+  const flipped = [];
+  for (const contract of _contracts.values()) {
+    if (contract.status === SLA_STATUS_V2.ACTIVE && contract.endDate < nowMs) {
+      contract.status = SLA_STATUS_V2.EXPIRED;
+      contract.updatedAt = nowMs;
+      db.prepare(
+        `UPDATE sla_contracts SET status = ?, updated_at = ? WHERE sla_id = ?`,
+      ).run(contract.status, contract.updatedAt, contract.slaId);
+      const { _seq: _omit, ...rest } = contract;
+      void _omit;
+      flipped.push(rest);
+    }
+  }
+  return flipped;
+}
+
+export function setViolationStatus(db, violationId, newStatus, patch = {}) {
+  const violation = _violations.get(violationId);
+  if (!violation) throw new Error(`Violation not found: ${violationId}`);
+
+  if (!Object.values(VIOLATION_STATUS_V2).includes(newStatus)) {
+    throw new Error(`Unknown violation status: ${newStatus}`);
+  }
+
+  const current = violation.v2Status || VIOLATION_STATUS_V2.OPEN;
+  const allowed = _violationAllowed.get(current);
+  if (!allowed || !allowed.has(newStatus)) {
+    throw new Error(
+      `Invalid violation status transition: ${current} → ${newStatus}`,
+    );
+  }
+
+  violation.v2Status = newStatus;
+  if (typeof patch.note === "string") {
+    violation.note = patch.note;
+  }
+  if (_violationTerminal.has(newStatus)) {
+    violation.resolvedAt = Date.now();
+    db.prepare(
+      `UPDATE sla_violations SET resolved_at = ? WHERE violation_id = ?`,
+    ).run(violation.resolvedAt, violationId);
+  }
+
+  return { ...violation };
+}
+
+export function acknowledgeViolation(db, violationId, note) {
+  return setViolationStatus(db, violationId, VIOLATION_STATUS_V2.ACKNOWLEDGED, {
+    note,
+  });
+}
+
+export function resolveViolation(db, violationId, note) {
+  return setViolationStatus(db, violationId, VIOLATION_STATUS_V2.RESOLVED, {
+    note,
+  });
+}
+
+export function waiveViolation(db, violationId, note) {
+  return setViolationStatus(db, violationId, VIOLATION_STATUS_V2.WAIVED, {
+    note,
+  });
+}
+
+export function getSLAStatsV2() {
+  const contracts = [..._contracts.values()];
+  const violations = [..._violations.values()];
+
+  const byStatus = {};
+  for (const s of Object.values(SLA_STATUS_V2)) byStatus[s] = 0;
+  for (const c of contracts) byStatus[c.status] = (byStatus[c.status] || 0) + 1;
+
+  const byTier = {};
+  for (const t of Object.values(SLA_TIER_V2)) byTier[t] = 0;
+  for (const c of contracts) byTier[c.tier] = (byTier[c.tier] || 0) + 1;
+
+  const bySeverity = {};
+  for (const s of Object.values(VIOLATION_SEVERITY_V2)) bySeverity[s] = 0;
+  for (const v of violations)
+    bySeverity[v.severity] = (bySeverity[v.severity] || 0) + 1;
+
+  const byTerm = {};
+  for (const t of Object.values(SLA_TERM_V2)) byTerm[t] = 0;
+  for (const v of violations) byTerm[v.term] = (byTerm[v.term] || 0) + 1;
+
+  const byViolationStatus = {};
+  for (const s of Object.values(VIOLATION_STATUS_V2)) byViolationStatus[s] = 0;
+  for (const v of violations) {
+    const s = v.v2Status || VIOLATION_STATUS_V2.OPEN;
+    byViolationStatus[s] = (byViolationStatus[s] || 0) + 1;
+  }
+
+  let totalCompensation = 0;
+  for (const v of violations) {
+    if (v.compensationAmount) totalCompensation += v.compensationAmount;
+  }
+
+  const activeOrgs = new Set();
+  for (const c of contracts) {
+    if (c.status === SLA_STATUS_V2.ACTIVE) activeOrgs.add(c.orgId);
+  }
+
+  return {
+    totalContracts: contracts.length,
+    activeContracts: byStatus[SLA_STATUS_V2.ACTIVE] || 0,
+    activeOrgs: activeOrgs.size,
+    maxActiveSlasPerOrg: _maxActiveSlasPerOrg,
+    byStatus,
+    byTier,
+    violations: {
+      total: violations.length,
+      byTerm,
+      bySeverity,
+      byStatus: byViolationStatus,
+      totalCompensation: Number(totalCompensation.toFixed(4)),
+    },
+  };
 }