create-windy 0.5.1 → 0.6.0

package/template/packages/server-sdk/src/ai-runtime-readiness-validation-values.ts

@@ -0,0 +1,147 @@
+import {
+  AI_READINESS_REASON_CODES_V1,
+  AI_RUNTIME_MAX_CAPABILITIES_PER_OFFER_V1,
+  AI_RUNTIME_MAX_OFFERS_V1,
+  AI_RUNTIME_MAX_UNAVAILABLE_REASONS_V1,
+  AI_RUNTIME_MODALITIES_V1,
+  AI_RUNTIME_PROBE_FAILURE_CODES_V1,
+  type AiReadinessReasonCodeV1,
+  type AiReadinessReasonV1,
+  type AiRuntimeModalityV1,
+  type AiRuntimeOfferV1,
+  type AiRuntimeProbeFailureCodeV1,
+} from "./ai-runtime-readiness.js";
+import { parseAiContractStableKeyV1 } from "./ai-runtime-readiness-keys.js";
+import { parseAiRuntimeOfferLimitsV1 } from "./ai-runtime-readiness-limits.js";
+import {
+  isAiRuntimeRecordV1,
+  parseAiRuntimeEnumValueV1,
+  parseAiRuntimeTextV1,
+} from "./ai-runtime-readiness-values.js";
+
+const modalities = new Set<AiRuntimeModalityV1>(AI_RUNTIME_MODALITIES_V1);
+const reasonCodes = new Set<AiReadinessReasonCodeV1>(
+  AI_READINESS_REASON_CODES_V1,
+);
+const probeFailureCodes = new Set<AiRuntimeProbeFailureCodeV1>(
+  AI_RUNTIME_PROBE_FAILURE_CODES_V1,
+);
+
+export function parseAiRuntimeOffersV1(
+  raw: unknown,
+): readonly [AiRuntimeOfferV1, ...AiRuntimeOfferV1[]] | null {
+  if (
+    !Array.isArray(raw) ||
+    raw.length === 0 ||
+    raw.length > AI_RUNTIME_MAX_OFFERS_V1
+  ) {
+    return null;
+  }
+  const parsed: AiRuntimeOfferV1[] = [];
+  const variants = new Set<string>();
+  for (const entry of raw) {
+    if (!isAiRuntimeRecordV1(entry)) return null;
+    const variant = parseAiContractStableKeyV1(entry.variant);
+    const capabilities = stableKeyList(entry.capabilities);
+    const inputModalities = modalityList(entry.inputModalities);
+    const outputModalities = modalityList(entry.outputModalities);
+    const limits = parseAiRuntimeOfferLimitsV1(entry.limits);
+    if (
+      !variant ||
+      variants.has(variant) ||
+      !capabilities?.length ||
+      !inputModalities?.length ||
+      !outputModalities?.length ||
+      !limits
+    ) {
+      return null;
+    }
+    variants.add(variant);
+    parsed.push({
+      variant,
+      capabilities,
+      inputModalities,
+      outputModalities,
+      limits,
+    });
+  }
+  return asNonEmpty(parsed);
+}
+
+export function parseAiReadinessReasonsV1(
+  raw: unknown,
+): readonly [AiReadinessReasonV1, ...AiReadinessReasonV1[]] | null {
+  if (
+    !Array.isArray(raw) ||
+    raw.length === 0 ||
+    raw.length > AI_RUNTIME_MAX_UNAVAILABLE_REASONS_V1
+  ) {
+    return null;
+  }
+  const parsed: AiReadinessReasonV1[] = [];
+  const identities = new Set<string>();
+  for (const entry of raw) {
+    if (!isAiRuntimeRecordV1(entry)) return null;
+    const code = parseAiRuntimeEnumValueV1(entry.code, reasonCodes);
+    if (!code || typeof entry.retryable !== "boolean") return null;
+    if (code !== "DOWNSTREAM_PROBE_FAILED") {
+      if (identities.has(code)) return null;
+      identities.add(code);
+      parsed.push({ code, retryable: entry.retryable });
+      continue;
+    }
+    const subject = parseAiRuntimeEnumValueV1(entry.subject, probeFailureCodes);
+    if (
+      !subject ||
+      entry.expected !== undefined ||
+      entry.actual !== undefined
+    ) {
+      return null;
+    }
+    const identity = `${code}:${subject}`;
+    if (identities.has(identity)) return null;
+    identities.add(identity);
+    parsed.push({ code, retryable: entry.retryable, subject });
+  }
+  return asNonEmpty(parsed);
+}
+
+function modalityList(raw: unknown): readonly AiRuntimeModalityV1[] | null {
+  if (
+    !Array.isArray(raw) ||
+    raw.length === 0 ||
+    raw.length > AI_RUNTIME_MODALITIES_V1.length
+  ) {
+    return null;
+  }
+  const values = stringList(raw);
+  return values?.every((value) => modalities.has(value as AiRuntimeModalityV1))
+    ? (values as AiRuntimeModalityV1[])
+    : null;
+}
+
+function stableKeyList(raw: unknown): readonly string[] | null {
+  if (
+    !Array.isArray(raw) ||
+    raw.length > AI_RUNTIME_MAX_CAPABILITIES_PER_OFFER_V1
+  ) {
+    return null;
+  }
+  const values = raw.map(parseAiContractStableKeyV1);
+  if (values.some((value) => !value)) return null;
+  const keys = values as string[];
+  return new Set(keys).size === keys.length ? keys : null;
+}
+
+function stringList(raw: unknown): readonly string[] | null {
+  if (!Array.isArray(raw)) return null;
+  const values = raw.map(parseAiRuntimeTextV1);
+  if (values.some((value) => !value)) return null;
+  const strings = values as string[];
+  return new Set(strings).size === strings.length ? strings : null;
+}
+
+function asNonEmpty<T>(values: T[]): readonly [T, ...T[]] | null {
+  const [first, ...rest] = values;
+  return first === undefined ? null : [first, ...rest];
+}

package/template/packages/server-sdk/src/ai-runtime-readiness-validation.ts

@@ -0,0 +1,299 @@
+import {
+  AI_RUNTIME_KINDS_V1,
+  AI_RUNTIME_PROBE_FAILURE_CODES_V1,
+  AI_RUNTIME_READINESS_SCHEMA_VERSION,
+  type AiReadinessReasonCodeV1,
+  type AiReadinessReasonV1,
+  type AiRuntimeDeploymentV1,
+  type AiRuntimeDownstreamProbeV1,
+  type AiRuntimeKindV1,
+  type AiRuntimeProbeFailureCodeV1,
+  type AiRuntimeReadinessV1,
+} from "./ai-runtime-readiness.js";
+import {
+  parseAiReadinessReasonsV1,
+  parseAiRuntimeOffersV1,
+} from "./ai-runtime-readiness-validation-values.js";
+import { captureAiRuntimeInputV1 } from "./ai-runtime-readiness-capture.js";
+import { parseAiContractStableKeyV1 } from "./ai-runtime-readiness-keys.js";
+import { parseAiRuntimeDeploymentIdentityV1 } from "./ai-runtime-readiness-identity.js";
+import { parseCanonicalAiTimestampV1 } from "./ai-runtime-readiness-time.js";
+import {
+  isAiRuntimeRecordV1,
+  parseAiRuntimeDigestV1,
+  parseAiRuntimeEnumValueV1,
+  parseAiRuntimeNonNegativeIntegerV1,
+} from "./ai-runtime-readiness-values.js";
+
+export type AiRuntimeReadinessParseResult =
+  | { readonly ok: true; readonly value: AiRuntimeReadinessV1 }
+  | {
+      readonly ok: false;
+      readonly observedAt: string;
+      readonly reasons: readonly [
+        AiReadinessReasonV1,
+        ...AiReadinessReasonV1[],
+      ];
+    };
+
+const runtimeKinds = new Set<AiRuntimeKindV1>(AI_RUNTIME_KINDS_V1);
+const runtimeStatuses = new Set<AiRuntimeReadinessV1["status"]>([
+  "ready",
+  "unavailable",
+]);
+const probeFailures = new Set<AiRuntimeProbeFailureCodeV1>(
+  AI_RUNTIME_PROBE_FAILURE_CODES_V1,
+);
+type AiRuntimeNotRunReasonV1 = Extract<
+  AiRuntimeDownstreamProbeV1,
+  { readonly status: "not-run" }
+>["reason"];
+const notRunReasons = new Set<AiRuntimeNotRunReasonV1>([
+  "NOT_CONFIGURED",
+  "NOT_PROBED",
+]);
+
+export function parseAiRuntimeReadinessV1(
+  raw: unknown,
+  fallbackObservedAt: string,
+): AiRuntimeReadinessParseResult {
+  const safeFallback =
+    parseCanonicalAiTimestampV1(fallbackObservedAt) ?? new Date().toISOString();
+  try {
+    const captured = captureAiRuntimeInputV1(raw);
+    return captured.ok
+      ? parseCapturedAiRuntimeReadinessV1(captured.value, safeFallback)
+      : invalid(safeFallback);
+  } catch {
+    return invalid(safeFallback);
+  }
+}
+
+function parseCapturedAiRuntimeReadinessV1(
+  raw: unknown,
+  fallbackObservedAt: string,
+): AiRuntimeReadinessParseResult {
+  if (!isAiRuntimeRecordV1(raw)) return invalid(fallbackObservedAt);
+  if (raw.schemaVersion !== AI_RUNTIME_READINESS_SCHEMA_VERSION) {
+    return failure(fallbackObservedAt, "CONTRACT_UNSUPPORTED", false);
+  }
+  const observedAt = isoDate(raw.observedAt);
+  const runtimeKind = parseAiRuntimeEnumValueV1(raw.runtimeKind, runtimeKinds);
+  const status = parseAiRuntimeEnumValueV1(raw.status, runtimeStatuses);
+  if (
+    !observedAt ||
+    !runtimeKind ||
+    !status ||
+    typeof raw.configured !== "boolean"
+  ) {
+    return invalid(observedAt ?? fallbackObservedAt);
+  }
+  const probe = parseProbe(raw.downstreamProbe);
+  if (!probe) {
+    const missingReason = missingPassedProbeReason(raw.downstreamProbe);
+    return missingReason
+      ? failure(observedAt, missingReason, false)
+      : invalid(observedAt);
+  }
+  const deployment = parseDeployment(raw.deployment);
+  if (deployment.reason) {
+    return failure(observedAt, deployment.reason, false);
+  }
+
+  if (status === "unavailable") {
+    const reasons = parseAiReadinessReasonsV1(raw.unavailableReasons);
+    if (
+      !reasons ||
+      !Array.isArray(raw.offers) ||
+      raw.offers.length !== 0 ||
+      !validUnavailableState(raw.configured, probe, reasons)
+    ) {
+      return invalid(observedAt);
+    }
+    return {
+      ok: true,
+      value: {
+        schemaVersion: AI_RUNTIME_READINESS_SCHEMA_VERSION,
+        status: "unavailable",
+        configured: raw.configured,
+        runtimeKind,
+        observedAt,
+        downstreamProbe: probe,
+        deployment: deployment.value,
+        offers: [],
+        unavailableReasons: reasons,
+      },
+    };
+  }
+
+  if (
+    !raw.configured ||
+    probe.status !== "passed" ||
+    !deployment.value ||
+    !Array.isArray(raw.unavailableReasons) ||
+    raw.unavailableReasons.length !== 0
+  ) {
+    return invalid(observedAt);
+  }
+  const offers = parseAiRuntimeOffersV1(raw.offers);
+  if (!offers) return invalid(observedAt);
+  return {
+    ok: true,
+    value: {
+      schemaVersion: AI_RUNTIME_READINESS_SCHEMA_VERSION,
+      status: "ready",
+      configured: true,
+      runtimeKind,
+      observedAt,
+      downstreamProbe: probe,
+      deployment: deployment.value,
+      offers,
+      unavailableReasons: [],
+    },
+  };
+}
+
+function validUnavailableState(
+  configured: boolean,
+  probe: AiRuntimeDownstreamProbeV1,
+  reasons: readonly AiReadinessReasonV1[],
+): boolean {
+  if (!configured) {
+    return (
+      probe.status === "not-run" &&
+      probe.reason === "NOT_CONFIGURED" &&
+      reasons.some(({ code }) => code === "RUNTIME_NOT_CONFIGURED")
+    );
+  }
+  if (probe.status === "not-run") {
+    return (
+      probe.reason === "NOT_PROBED" &&
+      reasons.some(({ code }) => code === "DOWNSTREAM_NOT_PROBED")
+    );
+  }
+  if (probe.status === "failed") {
+    const failureReasons = reasons.filter(
+      ({ code }) => code === "DOWNSTREAM_PROBE_FAILED",
+    );
+    const [failureReason] = failureReasons;
+    return (
+      failureReasons.length === 1 &&
+      failureReason?.subject === probe.failureCode &&
+      failureReason.retryable === probe.retryable
+    );
+  }
+  return reasons.some(
+    ({ code }) =>
+      code === "PROBE_STALE" ||
+      code === "PROBE_NOT_YET_VALID" ||
+      code === "PROBE_TTL_EXCEEDED" ||
+      code === "RESOURCE_UNAVAILABLE" ||
+      code === "OFFERS_DIGEST_MISMATCH" ||
+      code === "PROBE_ATTESTATION_MISMATCH",
+  );
+}
+
+function parseProbe(raw: unknown): AiRuntimeDownstreamProbeV1 | null {
+  if (!isAiRuntimeRecordV1(raw)) return null;
+  if (raw.status === "not-run") {
+    const reason = parseAiRuntimeEnumValueV1(raw.reason, notRunReasons);
+    return reason ? { status: "not-run", reason } : null;
+  }
+  const checkedAt = isoDate(raw.checkedAt);
+  const latencyMs = parseAiRuntimeNonNegativeIntegerV1(raw.latencyMs);
+  if (!checkedAt || latencyMs === null) return null;
+  if (raw.status === "failed") {
+    const failureCode = parseAiRuntimeEnumValueV1(
+      raw.failureCode,
+      probeFailures,
+    );
+    return failureCode && typeof raw.retryable === "boolean"
+      ? {
+          status: "failed",
+          checkedAt,
+          latencyMs,
+          failureCode,
+          retryable: raw.retryable,
+        }
+      : null;
+  }
+  if (raw.status !== "passed") return null;
+  const validUntil = isoDate(raw.validUntil);
+  const deploymentIdentity = parseAiRuntimeDeploymentIdentityV1(
+    raw.deploymentIdentity,
+  );
+  const releaseDigest = parseAiRuntimeDigestV1(raw.releaseDigest);
+  const offersDigest = parseAiRuntimeDigestV1(raw.offersDigest);
+  return validUntil && deploymentIdentity && releaseDigest && offersDigest
+    ? {
+        status: "passed",
+        checkedAt,
+        validUntil,
+        latencyMs,
+        deploymentIdentity,
+        releaseDigest,
+        offersDigest,
+      }
+    : null;
+}
+
+function missingPassedProbeReason(
+  raw: unknown,
+): AiReadinessReasonCodeV1 | null {
+  if (!isAiRuntimeRecordV1(raw) || raw.status !== "passed") return null;
+  if (!parseAiRuntimeDeploymentIdentityV1(raw.deploymentIdentity)) {
+    return "DEPLOYMENT_IDENTITY_MISSING";
+  }
+  if (!parseAiRuntimeDigestV1(raw.releaseDigest)) {
+    return "RELEASE_DIGEST_MISSING";
+  }
+  return parseAiRuntimeDigestV1(raw.offersDigest)
+    ? null
+    : "OFFERS_DIGEST_MISSING";
+}
+
+function parseDeployment(raw: unknown): {
+  value: AiRuntimeDeploymentV1 | null;
+  reason?: AiReadinessReasonCodeV1;
+} {
+  if (raw === null) return { value: null };
+  if (!isAiRuntimeRecordV1(raw)) {
+    return { value: null, reason: "DEPLOYMENT_IDENTITY_MISSING" };
+  }
+  const key = parseAiContractStableKeyV1(raw.key);
+  const identity = parseAiRuntimeDeploymentIdentityV1(raw.identity);
+  if (!identity) {
+    return { value: null, reason: "DEPLOYMENT_IDENTITY_MISSING" };
+  }
+  const releaseDigest = parseAiRuntimeDigestV1(raw.releaseDigest);
+  if (!releaseDigest) {
+    return { value: null, reason: "RELEASE_DIGEST_MISSING" };
+  }
+  const offersDigest = parseAiRuntimeDigestV1(raw.offersDigest);
+  if (!offersDigest) {
+    return { value: null, reason: "OFFERS_DIGEST_MISSING" };
+  }
+  return key
+    ? { value: { key, identity, releaseDigest, offersDigest } }
+    : { value: null, reason: "CONTRACT_INVALID" };
+}
+
+function failure(
+  observedAt: string,
+  code: AiReadinessReasonCodeV1,
+  retryable: boolean,
+): AiRuntimeReadinessParseResult {
+  return {
+    ok: false,
+    observedAt,
+    reasons: [{ code, retryable }],
+  };
+}
+
+function invalid(observedAt: string): AiRuntimeReadinessParseResult {
+  return failure(observedAt, "CONTRACT_INVALID", false);
+}
+
+function isoDate(value: unknown): string | null {
+  return parseCanonicalAiTimestampV1(value);
+}

package/template/packages/server-sdk/src/ai-runtime-readiness-values.ts

@@ -0,0 +1,42 @@
+import type { AiRuntimeReleaseDigestV1 } from "./ai-runtime-readiness.js";
+
+export function isAiRuntimeRecordV1(
+  value: unknown,
+): value is Record<string, unknown> {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+
+export function parseAiRuntimeTextV1(value: unknown): string | null {
+  return typeof value === "string" && value.trim() ? value : null;
+}
+
+export function parseAiRuntimeDigestV1(
+  value: unknown,
+): AiRuntimeReleaseDigestV1 | null {
+  return typeof value === "string" && /^sha256:[a-f0-9]{64}$/.test(value)
+    ? (value as AiRuntimeReleaseDigestV1)
+    : null;
+}
+
+export function parseAiRuntimePositiveIntegerV1(value: unknown): number | null {
+  return Number.isSafeInteger(value) && Number(value) > 0
+    ? Number(value)
+    : null;
+}
+
+export function parseAiRuntimeNonNegativeIntegerV1(
+  value: unknown,
+): number | null {
+  return Number.isSafeInteger(value) && Number(value) >= 0
+    ? Number(value)
+    : null;
+}
+
+export function parseAiRuntimeEnumValueV1<T extends string>(
+  value: unknown,
+  allowed: ReadonlySet<T>,
+): T | null {
+  return typeof value === "string" && allowed.has(value as T)
+    ? (value as T)
+    : null;
+}

package/template/packages/server-sdk/src/ai-runtime-readiness.adversarial-input.contract.test.ts

@@ -0,0 +1,146 @@
+import { describe, expect, test } from "bun:test";
+import {
+  parseAiRuntimeReadinessV1,
+  projectAiOperationReadinessV1,
+} from "../index.js";
+import {
+  cloneRecord,
+  readinessContractFixtures as fixtures,
+  type ReadinessContractFixture,
+} from "./ai-runtime-readiness.contract-support.js";
+
+const rawSecret =
+  "https://runtime.internal.invalid Authorization: Bearer raw-secret";
+
+for (const fixture of fixtures) {
+  describe(`${fixture.name} adversarial readiness input`, () => {
+    test("accessor 从不执行且原始错误不泄漏", () => {
+      for (const nested of [false, true]) {
+        let reads = 0;
+        const snapshot = cloneRecord(fixture.snapshot);
+        const target = nested
+          ? cloneRecord(snapshot.downstreamProbe)
+          : snapshot;
+        Object.defineProperty(target, nested ? "status" : "schemaVersion", {
+          enumerable: true,
+          get() {
+            reads += 1;
+            throw new Error(rawSecret);
+          },
+        });
+        if (nested) snapshot.downstreamProbe = target;
+
+        expectInvalidWithoutLeak(fixture, snapshot);
+        expect(reads).toBe(0);
+      }
+    });
+
+    test("Proxy 与 revoked Proxy 不执行 trap、不抛且不泄漏", () => {
+      let traps = 0;
+      const proxy = new Proxy(cloneRecord(fixture.snapshot), {
+        get() {
+          traps += 1;
+          throw new Error(rawSecret);
+        },
+        getOwnPropertyDescriptor() {
+          traps += 1;
+          throw new Error(rawSecret);
+        },
+        getPrototypeOf() {
+          traps += 1;
+          throw new Error(rawSecret);
+        },
+        ownKeys() {
+          traps += 1;
+          throw new Error(rawSecret);
+        },
+      });
+      expectInvalidWithoutLeak(fixture, proxy);
+      expect(traps).toBe(0);
+
+      const nested = cloneRecord(fixture.snapshot);
+      nested.downstreamProbe = proxy;
+      expectInvalidWithoutLeak(fixture, nested);
+      expect(traps).toBe(0);
+
+      const revocable = Proxy.revocable(cloneRecord(fixture.snapshot), {});
+      revocable.revoke();
+      expectInvalidWithoutLeak(fixture, revocable.proxy);
+    });
+
+    test("非 JSON 对象结构与原型污染输入失败关闭", () => {
+      const customPrototype = Object.assign(
+        Object.create({ inherited: true }) as Record<string, unknown>,
+        cloneRecord(fixture.snapshot),
+      );
+      const nullPrototype = Object.assign(
+        Object.create(null) as Record<string, unknown>,
+        cloneRecord(fixture.snapshot),
+      );
+      const withSymbol = cloneRecord(fixture.snapshot);
+      Object.defineProperty(withSymbol, Symbol("secret"), {
+        enumerable: true,
+        value: rawSecret,
+      });
+      const withNonEnumerable = cloneRecord(fixture.snapshot);
+      Object.defineProperty(withNonEnumerable, "secret", {
+        enumerable: false,
+        value: rawSecret,
+      });
+      const cyclic = cloneRecord(fixture.snapshot);
+      cyclic.self = cyclic;
+      const shared = cloneRecord(fixture.snapshot);
+      const deployment = cloneRecord(shared.deployment);
+      shared.deployment = deployment;
+      shared.alias = deployment;
+      const polluted = cloneRecord(fixture.snapshot);
+      Object.defineProperty(polluted, "__proto__", {
+        enumerable: true,
+        value: { readinessPolluted: true },
+      });
+
+      for (const snapshot of [
+        customPrototype,
+        nullPrototype,
+        withSymbol,
+        withNonEnumerable,
+        cyclic,
+        shared,
+        polluted,
+      ]) {
+        expectInvalidWithoutLeak(fixture, snapshot);
+      }
+      expect(
+        (Object.prototype as { readinessPolluted?: boolean }).readinessPolluted,
+      ).toBeUndefined();
+    });
+  });
+}
+
+function expectInvalidWithoutLeak(
+  fixture: ReadinessContractFixture,
+  snapshot: unknown,
+) {
+  const project = () =>
+    projectAiOperationReadinessV1(fixture.operation, snapshot, {
+      now: fixture.now,
+    });
+  const parse = () => parseAiRuntimeReadinessV1(snapshot, fixture.now);
+
+  expect(project).not.toThrow();
+  const projected = project();
+  expect(projected.status).toBe("unavailable");
+  expect(projected.unavailableReasons).toEqual([
+    { code: "CONTRACT_INVALID", retryable: false },
+  ]);
+  expect(JSON.stringify(projected)).not.toContain(rawSecret);
+
+  expect(parse).not.toThrow();
+  const parsed = parse();
+  expect(parsed.ok).toBe(false);
+  if (parsed.ok) return;
+  expect(parsed.reasons).toEqual([
+    { code: "CONTRACT_INVALID", retryable: false },
+  ]);
+  expect(JSON.stringify(parsed)).not.toContain(rawSecret);
+}