@treeseed/sdk 0.13.0-rc.6 → 0.13.0-rc.8

package/dist/reconcile/runtime/live-acceptance-runtime.js

@@ -1,324 +0,0 @@
-import { performance } from "node:perf_hooks";
-import { createCanonicalReconcileReport } from "../support/state/platform.js";
-const PROVIDER_CAPABILITIES = {
-  railway: ["project", "environment", "service", "image-service", "postgres", "volume", "domain", "variables", "deployment-health", "capacity-provider-runtime-assignment-proof"],
-  cloudflare: ["pages", "worker", "d1", "r2", "kv", "queue", "dns", "tunnel", "turnstile", "secrets", "cache-rules"],
-  github: ["repository-adoption", "bootstrap", "branch", "branch-rules", "actions-settings", "environment", "secret", "variable", "workflow-presence", "workflow-observation", "central-token"],
-  local: ["process", "port", "local-db", "local-runner", "docker-compose-capacity-provider", "capacity-provider-assignment-proof"]
-};
-function shortRunId(now = /* @__PURE__ */ new Date()) {
-  return now.toISOString().replace(/[^0-9]/gu, "").slice(0, 14);
-}
-function providerPrefix(environment, provider, runId) {
-  if (provider === "railway") return `trsd-rail-${runId}`.toLowerCase();
-  return `trsd-live-${environment}-${provider}-${runId}`.toLowerCase();
-}
-function providerPrefixRoot(environment, provider) {
-  if (provider === "railway") return "trsd-rail-";
-  return `trsd-live-${environment}-${provider}-`.toLowerCase();
-}
-function emitProgress(onProgress, event) {
-  if (!onProgress) return;
-  onProgress({
-    ...event,
-    message: event.message ?? [
-      event.provider,
-      event.capability,
-      event.phase
-    ].filter(Boolean).join(":")
-  });
-}
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function waitForLiveObservation(description, observe, isReady, options = {}) {
-  const attempts = Math.max(1, options.attempts ?? 8);
-  const intervalMs = Math.max(0, options.intervalMs ?? 750);
-  let lastValue;
-  let lastError;
-  for (let attempt = 1; attempt <= attempts; attempt += 1) {
-    try {
-      lastValue = await observe();
-      if (isReady(lastValue)) return lastValue;
-    } catch (error) {
-      lastError = error;
-    }
-    if (attempt < attempts) await sleep(intervalMs);
-  }
-  if (lastError) {
-    throw new Error(`${description} was not observed live: ${lastError instanceof Error ? lastError.message : String(lastError)}`);
-  }
-  throw new Error(`${description} was not observed live after ${attempts} attempt(s).`);
-}
-function scenario({
-  provider,
-  mode,
-  prefix,
-  capability,
-  ok,
-  phase,
-  action,
-  reason,
-  locators = {},
-  createdResources = [],
-  updatedResources = [],
-  replacedResources = [],
-  destroyedResources = [],
-  retainedResources = [],
-  issues = [],
-  startedAt,
-  completedAt,
-  durationMs
-}) {
-  const completed = completedAt ?? (/* @__PURE__ */ new Date()).toISOString();
-  const started = startedAt ?? completed;
-  return {
-    id: `live-test:${provider}:${capability}`,
-    provider,
-    capability,
-    mode,
-    ok,
-    phase,
-    action,
-    reason,
-    startedAt: started,
-    completedAt: completed,
-    durationMs: typeof durationMs === "number" ? Math.max(1, Math.ceil(durationMs)) : Math.max(1, Date.parse(completed) - Date.parse(started)),
-    locators,
-    createdResources,
-    updatedResources,
-    replacedResources,
-    destroyedResources,
-    retainedResources,
-    issues
-  };
-}
-function node(provider, environment, type, id, state = {}) {
-  return {
-    id,
-    provider,
-    type,
-    owner: "reconcile-live-test",
-    environment,
-    state
-  };
-}
-function redactProviderState(value) {
-  if (Array.isArray(value)) return value.map((entry) => redactProviderState(entry));
-  if (value && typeof value === "object") {
-    const redacted = {};
-    for (const [key, entry] of Object.entries(value)) {
-      redacted[key] = /secret|token|password|private|key/iu.test(key) ? "[redacted]" : redactProviderState(entry);
-    }
-    return redacted;
-  }
-  return value;
-}
-function providerNode(provider, environment, type, id, state = {}) {
-  return node(provider, environment, type, id, redactProviderState(state));
-}
-function blocking(provider, type, reason) {
-  return {
-    id: `live-test:${provider}:${type}:blocked`,
-    resourceId: `live-test:${provider}:${type}`,
-    severity: "blocking",
-    reason,
-    provider,
-    type
-  };
-}
-function describeLiveAcceptanceError(error) {
-  if (!(error instanceof Error)) return String(error);
-  if (!(error instanceof AggregateError) || error.errors.length === 0) return error.message;
-  return `${error.message} [${error.errors.map(describeLiveAcceptanceError).join("; ")}]`;
-}
-async function measuredScenario(input, fn) {
-  const started = /* @__PURE__ */ new Date();
-  const startedMs = performance.now();
-  emitProgress(input.onProgress, {
-    provider: input.provider,
-    mode: input.mode,
-    environment: input.environment,
-    runId: input.runId,
-    resourcePrefix: input.prefix,
-    capability: input.capability,
-    phase: input.phase === "verify" ? "verify" : input.phase === "cleanup" ? "cleanup" : input.phase === "destroy" ? "destroy" : "create",
-    message: input.startMessage ?? `${input.provider}:${input.capability}: ${input.phase} started`
-  });
-  try {
-    const value = await fn();
-    const completed = /* @__PURE__ */ new Date();
-    const durationMs = Math.max(1, Math.ceil(performance.now() - startedMs));
-    const resourcesFor = (resources) => typeof resources === "function" ? resources(value) : resources ?? [];
-    emitProgress(input.onProgress, {
-      provider: input.provider,
-      mode: input.mode,
-      environment: input.environment,
-      runId: input.runId,
-      resourcePrefix: input.prefix,
-      capability: input.capability,
-      phase: "complete",
-      elapsedMs: durationMs,
-      message: `${input.provider}:${input.capability}: ok in ${durationMs}ms`
-    });
-    return scenario({
-      provider: input.provider,
-      mode: input.mode,
-      prefix: input.prefix,
-      capability: input.capability,
-      ok: true,
-      phase: input.phase,
-      action: input.action,
-      reason: typeof input.successReason === "function" ? input.successReason(value) : input.successReason,
-      locators: input.locators,
-      createdResources: resourcesFor(input.createdResources),
-      updatedResources: resourcesFor(input.updatedResources),
-      replacedResources: resourcesFor(input.replacedResources),
-      destroyedResources: resourcesFor(input.destroyedResources),
-      retainedResources: resourcesFor(input.retainedResources),
-      startedAt: started.toISOString(),
-      completedAt: completed.toISOString(),
-      durationMs
-    });
-  } catch (error) {
-    const completed = /* @__PURE__ */ new Date();
-    const durationMs = Math.max(1, Math.ceil(performance.now() - startedMs));
-    const reason = describeLiveAcceptanceError(error);
-    emitProgress(input.onProgress, {
-      provider: input.provider,
-      mode: input.mode,
-      environment: input.environment,
-      runId: input.runId,
-      resourcePrefix: input.prefix,
-      capability: input.capability,
-      phase: "blocked",
-      elapsedMs: durationMs,
-      message: `${input.provider}:${input.capability}: blocked after ${durationMs}ms - ${reason}`
-    });
-    return scenario({
-      provider: input.provider,
-      mode: input.mode,
-      prefix: input.prefix,
-      capability: input.capability,
-      ok: false,
-      phase: "blocked",
-      action: "blocked",
-      reason,
-      locators: input.locators,
-      startedAt: started.toISOString(),
-      completedAt: completed.toISOString(),
-      durationMs
-    });
-  }
-}
-function reportForProvider({
-  provider,
-  mode,
-  runId,
-  prefix,
-  environment,
-  results,
-  cleanupDrift = []
-}) {
-  const capabilities = PROVIDER_CAPABILITIES[provider];
-  const desiredGraph = capabilities.map((capability) => ({
-    id: `live-test:${provider}:${capability}`,
-    provider,
-    type: capability,
-    owner: "reconcile-live-test",
-    environment,
-    spec: { prefix, isolated: true, mode }
-  }));
-  const resultByCapability = new Map(results.map((result) => [result.capability, result]));
-  const blockedDrift = [
-    ...desiredGraph.filter((entry) => !resultByCapability.get(String(entry.type))?.ok).map((entry) => blocking(provider, String(entry.type), resultByCapability.get(String(entry.type))?.reason ?? "Live scenario did not run.")),
-    ...cleanupDrift
-  ];
-  const actions = desiredGraph.map((entry) => {
-    const result = resultByCapability.get(String(entry.type));
-    return {
-      id: `${entry.id}:${result?.action ?? "blocked"}`,
-      kind: result?.ok ? result.action : "blocked",
-      resourceId: entry.id,
-      reason: result?.reason ?? "Live scenario did not run.",
-      provider,
-      type: entry.type
-    };
-  });
-  const postconditions = desiredGraph.map((entry) => {
-    const result = resultByCapability.get(String(entry.type));
-    return {
-      id: `${entry.id}:postcondition`,
-      resourceId: entry.id,
-      description: `${mode} live reconciliation postconditions pass for ${provider}:${entry.type}.`,
-      source: provider === "local" ? "local" : "api",
-      required: true,
-      ok: Boolean(result?.ok),
-      issues: result?.ok ? [] : [result?.reason ?? "Live scenario did not run."],
-      observed: result?.locators ?? {}
-    };
-  });
-  const createdResources = results.flatMap((result) => result.createdResources);
-  const updatedResources = results.flatMap((result) => result.updatedResources);
-  const replacedResources = results.flatMap((result) => result.replacedResources);
-  const destroyedResources = results.flatMap((result) => result.destroyedResources);
-  const retainedResources = results.flatMap((result) => result.retainedResources);
-  const report = createCanonicalReconcileReport({
-    desiredGraph,
-    observedGraph: desiredGraph.filter((entry) => resultByCapability.has(String(entry.type))).map((entry) => ({
-      ...entry,
-      state: {
-        verified: Boolean(resultByCapability.get(String(entry.type))?.ok),
-        locators: resultByCapability.get(String(entry.type))?.locators ?? {}
-      }
-    })),
-    diff: blockedDrift,
-    actions,
-    postconditions,
-    blockedDrift,
-    retainedResources,
-    destroyedResources,
-    liveVerification: {
-      ok: blockedDrift.length === 0,
-      source: `reconcile-live-test:${mode}`,
-      checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      issues: blockedDrift.map((entry) => entry.reason)
-    }
-  });
-  return {
-    provider,
-    mode,
-    runId,
-    resourcePrefix: prefix,
-    scenarioResults: results,
-    coverage: {
-      total: capabilities.length,
-      passed: results.filter((result) => result.ok).length,
-      failed: capabilities.length - results.filter((result) => result.ok).length,
-      capabilities
-    },
-    createdResources,
-    updatedResources,
-    replacedResources,
-    destroyedResources,
-    retainedResources,
-    cleanupDrift,
-    report,
-    ok: report.ok
-  };
-}
-export {
-  PROVIDER_CAPABILITIES,
-  blocking,
-  describeLiveAcceptanceError,
-  emitProgress,
-  measuredScenario,
-  node,
-  providerNode,
-  providerPrefix,
-  providerPrefixRoot,
-  reportForProvider,
-  scenario,
-  shortRunId,
-  waitForLiveObservation
-};

package/dist/reconcile/runtime/live-acceptance-starter-runtime.d.ts

@@ -1,123 +0,0 @@
-import { type CapacityProviderPrivateJwk } from '../../capacity/providers/capacity-provider.js';
-import { MarketClient } from '../../entrypoints/clients/market-client.js';
-import type { CapacityGovernanceRuntimeConnection } from '../capacity/capacity-core/live-acceptance-capacity-governance.js';
-export interface LocalStarterCapacityConfig {
-    starter: 'engineering' | 'research';
-    repositoryName: string;
-    agentPaths: string[];
-    capabilities: string[];
-    allowedModes: Array<'planning' | 'acting'>;
-    agentSeconds: number;
-    durationSeconds?: number;
-    parameters: Record<string, unknown> | ((input: {
-        projectId: string;
-        projectSlug: string;
-        allocationSetId: string;
-        repositoryRef: string;
-    }) => Record<string, unknown>);
-    projectMetadata: Record<string, unknown>;
-}
-export declare function localStarterDurationSeconds(config: Pick<LocalStarterCapacityConfig, 'agentSeconds' | 'durationSeconds'>): number;
-export declare function localStarterProjectSlug(starter: LocalStarterCapacityConfig['starter'], runId: string): string;
-export declare function finalizeLocalStarterAcceptance(cleanup: (status: 'completed' | 'cancelled') => Promise<unknown>, executionError: unknown, label: string): Promise<void>;
-export declare function terminalizeStarterWorkdayRun(input: {
-    adminClient: MarketClient;
-    teamId: string;
-    workdayRunId: string;
-    status: 'completed' | 'cancelled';
-    summary: Record<string, unknown>;
-}): Promise<any>;
-export declare function provisionLocalStarterProject(input: {
-    adminClient: MarketClient;
-    runId: string;
-    runtime: CapacityGovernanceRuntimeConnection;
-    config: LocalStarterCapacityConfig;
-}): Promise<{
-    project: {
-        id: string;
-        slug: string;
-    };
-    binding: any;
-    synchronized: {
-        agentClasses: any[];
-        resolvedRef: string;
-        signalContracts: Record<string, import("../../index.js").AgentSignalContract>;
-        proposalTypeContracts: Record<string, import("../../index.js").ProposalTypeContract>;
-    };
-    cleanup: () => Promise<undefined>;
-}>;
-export declare function provisionLocalStarterCapacity(input: {
-    adminClient: MarketClient;
-    apiUrl: string;
-    runId: string;
-    runtime: CapacityGovernanceRuntimeConnection;
-    privateJwk: CapacityProviderPrivateJwk;
-    fetchImpl: typeof fetch;
-    config: LocalStarterCapacityConfig;
-}): Promise<{
-    key: string;
-    project: {
-        id: string;
-        slug: string;
-    };
-    binding: any;
-    grantId: string;
-    allocationId: string;
-    workdayRunId: string;
-    connection: {
-        providerAccessToken: string;
-        projectId: string;
-        providerSessionId: string;
-        providerSessionSequence: number;
-        teamId: string;
-        providerId: string;
-        membershipId: string;
-        credentialId: string;
-        membershipCredential: string;
-    };
-    cleanup: (runStatus?: "completed" | "cancelled") => Promise<void>;
-}>;
-export declare function provisionLocalStarterPortfolioCapacity(input: {
-    adminClient: MarketClient;
-    apiUrl: string;
-    runId: string;
-    runtime: CapacityGovernanceRuntimeConnection;
-    privateJwk: CapacityProviderPrivateJwk;
-    fetchImpl: typeof fetch;
-    configs: LocalStarterCapacityConfig[];
-}): Promise<{
-    projects: {
-        project: {
-            id: string;
-            slug: string;
-        };
-        binding: any;
-        synchronized: {
-            agentClasses: any[];
-            resolvedRef: string;
-            signalContracts: Record<string, import("../../index.js").AgentSignalContract>;
-            proposalTypeContracts: Record<string, import("../../index.js").ProposalTypeContract>;
-        };
-        cleanup: () => Promise<undefined>;
-    }[];
-    workdayRunIds: string[];
-    allocationId: string;
-    grants: {
-        grantId: string;
-        projectId: string;
-        teamId: string;
-        grantScope: "project";
-    }[];
-    capabilities: string[];
-    connection: {
-        providerAccessToken: string;
-        providerSessionId: string;
-        providerSessionSequence: number;
-        teamId: string;
-        providerId: string;
-        membershipId: string;
-        credentialId: string;
-        membershipCredential: string;
-    };
-    cleanup: (runStatus?: "completed" | "cancelled") => Promise<void>;
-}>;