@treeseed/sdk 0.9.0 → 0.10.6

package/dist/capacity-provider.js

@@ -0,0 +1,535 @@
+import {
+  TREESEED_REMOTE_CONTRACT_HEADER,
+  TREESEED_REMOTE_CONTRACT_VERSION
+} from "./remote.js";
+import {
+  collectTreeseedConfigSeedValues,
+  collectTreeseedEnvironmentContext,
+  resolveTreeseedMachineEnvironmentValues,
+  setTreeseedMachineEnvironmentValue
+} from "./operations/services/config-runtime.js";
+const CAPACITY_PROVIDER_ENDPOINTS = {
+  register: "/v1/provider/register",
+  heartbeat: "/v1/provider/heartbeat",
+  portfolio: "/v1/provider/portfolio",
+  workdays: "/v1/provider/workdays",
+  claimTask: "/v1/provider/tasks/claim",
+  taskEvents: (taskId) => `/v1/provider/tasks/${encodeURIComponent(taskId)}/events`,
+  completeTask: (taskId) => `/v1/provider/tasks/${encodeURIComponent(taskId)}/complete`,
+  failTask: (taskId) => `/v1/provider/tasks/${encodeURIComponent(taskId)}/fail`,
+  usage: "/v1/provider/usage",
+  reports: "/v1/provider/reports"
+};
+const CAPACITY_PROVIDER_SCOPES = [
+  "provider:register",
+  "provider:heartbeat",
+  "provider:portfolio:read",
+  "provider:tasks:claim",
+  "provider:tasks:update",
+  "provider:usage:report",
+  "provider:reports:write",
+  "provider:capabilities:write"
+];
+const CAPACITY_PROVIDER_ENV_KEYS = [
+  "TREESEED_MARKET_URL",
+  "TREESEED_MARKET_ID",
+  "TREESEED_CAPACITY_PROVIDER_API_KEY",
+  "TREESEED_PROVIDER_HOST_DATA_DIR",
+  "TREESEED_PROVIDER_DATA_DIR",
+  "TREESEED_PROVIDER_API_PORT",
+  "TREESEED_PROVIDER_HOST_API_PORT",
+  "TREESEED_PROVIDER_ENVIRONMENT",
+  "TREESEED_PROVIDER_CAPABILITIES_FILE",
+  "TREESEED_PROVIDER_BUDGET_FILE",
+  "TREESEED_PROVIDER_MAX_CONCURRENT_WORKDAYS",
+  "TREESEED_PROVIDER_MAX_CONCURRENT_RUNNERS",
+  "TREESEED_PROVIDER_DAILY_CREDIT_BUDGET",
+  "TREESEED_PROVIDER_MONTHLY_CREDIT_BUDGET",
+  "TREESEED_PROVIDER_STARTUP_MODE",
+  "TREESEED_CODEX_AUTH_FILE",
+  "TREESEED_CODEX_AUTH_JSON_B64",
+  "TREESEED_CODEX_AUTH_OVERWRITE"
+];
+const CAPACITY_PROVIDER_DEPLOYMENT_SERVICE_ROLES = ["api", "manager", "runner"];
+class CapacityProviderApiError extends Error {
+  constructor(message, status, payload) {
+    super(message);
+    this.status = status;
+    this.payload = payload;
+    this.name = "CapacityProviderApiError";
+  }
+  status;
+  payload;
+}
+function normalizeBaseUrl(value) {
+  const trimmed = value.trim().replace(/\/+$/u, "");
+  if (!trimmed) throw new Error("Capacity provider Market URL is required.");
+  return trimmed;
+}
+function stringValue(value, fallback) {
+  if (typeof value === "string" && value.length > 0) return value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  return fallback ?? "";
+}
+function objectStringValues(value = {}) {
+  return Object.fromEntries(
+    Object.entries(value).filter(([, entryValue]) => entryValue !== void 0 && entryValue !== null && String(entryValue).length > 0).map(([key, entryValue]) => [key, String(entryValue)])
+  );
+}
+function filterCapacityProviderEnv(value) {
+  const allowed = new Set(CAPACITY_PROVIDER_ENV_KEYS);
+  return Object.fromEntries(
+    Object.entries(value).filter(([key, entryValue]) => allowed.has(key) && typeof entryValue === "string" && entryValue.length > 0)
+  );
+}
+function capacityProviderConfigEntry(id) {
+  return {
+    id,
+    label: id,
+    group: "capacity-provider",
+    description: "Capacity provider launch value.",
+    howToGet: "Created by local seed or stored through trsd config.",
+    sensitivity: id === "TREESEED_CAPACITY_PROVIDER_API_KEY" ? "secret" : "plain",
+    targets: ["local-runtime"],
+    scopes: ["local", "staging", "prod"],
+    storage: "scoped",
+    requirement: "optional",
+    purposes: ["dev", "deploy", "config"]
+  };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function requireString(record, key, label) {
+  const value = record[key];
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`${label} is missing required string field "${key}".`);
+  }
+  return value;
+}
+function requireNumber(record, key, label) {
+  const value = record[key];
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new Error(`${label} is missing required numeric field "${key}".`);
+  }
+  return value;
+}
+function buildCapacityProviderAuthHeaders(apiKey) {
+  const trimmed = apiKey.trim();
+  if (!trimmed) throw new Error("Capacity provider API key is required.");
+  return {
+    authorization: `Bearer ${trimmed}`
+  };
+}
+function assertCapacityProviderOkEnvelope(value, label = "Capacity provider response") {
+  if (!isRecord(value) || value.ok !== true) {
+    throw new Error(`${label} must be an ok response envelope.`);
+  }
+}
+function assertCapacityProviderRegistrationResponse(value) {
+  assertCapacityProviderOkEnvelope(value, "Capacity provider registration response");
+  const record = value;
+  if (!isRecord(record.provider)) {
+    throw new Error("Capacity provider registration response is missing provider.");
+  }
+  requireString(record.provider, "id", "Capacity provider registration provider");
+  requireString(record.provider, "teamId", "Capacity provider registration provider");
+  requireString(record.provider, "name", "Capacity provider registration provider");
+  requireString(record.provider, "status", "Capacity provider registration provider");
+  requireString(record, "portfolioManifestUrl", "Capacity provider registration response");
+  requireNumber(record, "heartbeatIntervalSeconds", "Capacity provider registration response");
+}
+function assertCapacityProviderPortfolioManifest(value) {
+  if (!isRecord(value)) {
+    throw new Error("Capacity provider portfolio manifest must be an object.");
+  }
+  if (!isRecord(value.team)) {
+    throw new Error("Capacity provider portfolio manifest is missing team.");
+  }
+  requireString(value.team, "id", "Capacity provider portfolio team");
+  requireString(value.team, "slug", "Capacity provider portfolio team");
+  requireString(value.team, "name", "Capacity provider portfolio team");
+  if (!Array.isArray(value.projects)) {
+    throw new Error("Capacity provider portfolio manifest is missing projects.");
+  }
+  for (const [index, project] of value.projects.entries()) {
+    if (!isRecord(project)) throw new Error(`Capacity provider portfolio project ${index} must be an object.`);
+    requireString(project, "id", `Capacity provider portfolio project ${index}`);
+    requireString(project, "slug", `Capacity provider portfolio project ${index}`);
+    requireString(project, "name", `Capacity provider portfolio project ${index}`);
+    if (!isRecord(project.repository)) throw new Error(`Capacity provider portfolio project ${index} is missing repository.`);
+    if (!isRecord(project.agentSpecs)) throw new Error(`Capacity provider portfolio project ${index} is missing agentSpecs.`);
+    if (!isRecord(project.workPolicy)) throw new Error(`Capacity provider portfolio project ${index} is missing workPolicy.`);
+  }
+}
+function resolveCapacityProviderEnvironment(input) {
+  const env = {
+    TREESEED_MARKET_URL: normalizeBaseUrl(input.marketUrl),
+    TREESEED_MARKET_ID: input.marketId.trim(),
+    TREESEED_CAPACITY_PROVIDER_API_KEY: input.apiKey.trim(),
+    TREESEED_PROVIDER_DATA_DIR: input.providerDataDir ?? "/data",
+    TREESEED_PROVIDER_API_PORT: stringValue(input.providerApiPort, "3100"),
+    TREESEED_PROVIDER_ENVIRONMENT: input.providerEnvironment ?? "local"
+  };
+  if (!env.TREESEED_MARKET_ID) throw new Error("Capacity provider Market ID is required.");
+  if (!env.TREESEED_CAPACITY_PROVIDER_API_KEY) throw new Error("Capacity provider API key is required.");
+  if (input.providerHostDataDir) env.TREESEED_PROVIDER_HOST_DATA_DIR = input.providerHostDataDir;
+  if (input.capabilitiesFile) env.TREESEED_PROVIDER_CAPABILITIES_FILE = input.capabilitiesFile;
+  if (input.budgetFile) env.TREESEED_PROVIDER_BUDGET_FILE = input.budgetFile;
+  if (input.maxConcurrentWorkdays !== void 0) env.TREESEED_PROVIDER_MAX_CONCURRENT_WORKDAYS = stringValue(input.maxConcurrentWorkdays);
+  if (input.maxConcurrentRunners !== void 0) env.TREESEED_PROVIDER_MAX_CONCURRENT_RUNNERS = stringValue(input.maxConcurrentRunners);
+  if (input.dailyCreditBudget !== void 0) env.TREESEED_PROVIDER_DAILY_CREDIT_BUDGET = stringValue(input.dailyCreditBudget);
+  if (input.monthlyCreditBudget !== void 0) env.TREESEED_PROVIDER_MONTHLY_CREDIT_BUDGET = stringValue(input.monthlyCreditBudget);
+  if (input.codexAuthFile) env.TREESEED_CODEX_AUTH_FILE = input.codexAuthFile;
+  if (input.codexAuthJsonB64) env.TREESEED_CODEX_AUTH_JSON_B64 = input.codexAuthJsonB64;
+  if (input.codexAuthOverwrite !== void 0) env.TREESEED_CODEX_AUTH_OVERWRITE = stringValue(input.codexAuthOverwrite);
+  return env;
+}
+function resolveCapacityProviderLaunchEnvironment(input = {}) {
+  const scope = input.scope === "staging" || input.scope === "prod" ? input.scope : "local";
+  const env = input.env ?? process.env;
+  const overrides = objectStringValues(input.overrides);
+  let configValues = {};
+  let machineValues = {};
+  let source = "process-env";
+  if (input.tenantRoot) {
+    try {
+      configValues = collectTreeseedConfigSeedValues(input.tenantRoot, scope, env);
+      source = "treeseed-config";
+    } catch {
+      configValues = {};
+    }
+    try {
+      machineValues = resolveTreeseedMachineEnvironmentValues(input.tenantRoot, scope, CAPACITY_PROVIDER_ENV_KEYS);
+      source = "treeseed-config";
+    } catch {
+      machineValues = {};
+    }
+  }
+  const values = {
+    ...filterCapacityProviderEnv(configValues),
+    ...filterCapacityProviderEnv(machineValues),
+    ...filterCapacityProviderEnv(env),
+    ...filterCapacityProviderEnv(overrides)
+  };
+  const diagnostic = input.diagnostic === true || values.TREESEED_PROVIDER_STARTUP_MODE === "diagnostic";
+  const resolved = {
+    TREESEED_PROVIDER_DATA_DIR: "/data",
+    TREESEED_PROVIDER_API_PORT: "3100",
+    TREESEED_PROVIDER_ENVIRONMENT: scope,
+    ...values
+  };
+  if (!resolved.TREESEED_PROVIDER_HOST_API_PORT) {
+    resolved.TREESEED_PROVIDER_HOST_API_PORT = resolved.TREESEED_PROVIDER_API_PORT;
+  }
+  if (!resolved.TREESEED_PROVIDER_HOST_DATA_DIR) {
+    resolved.TREESEED_PROVIDER_HOST_DATA_DIR = ".treeseed/local-capacity-provider/data";
+  }
+  if (diagnostic) {
+    resolved.TREESEED_PROVIDER_STARTUP_MODE = "diagnostic";
+  }
+  const required = [
+    "TREESEED_MARKET_URL",
+    "TREESEED_MARKET_ID",
+    ...diagnostic ? [] : ["TREESEED_CAPACITY_PROVIDER_API_KEY"],
+    "TREESEED_PROVIDER_HOST_DATA_DIR"
+  ];
+  const missing = required.filter((key) => !resolved[key]);
+  if (input.requireConnection !== false && missing.length > 0) {
+    throw new Error(`Capacity provider launch environment is missing: ${missing.join(", ")}.`);
+  }
+  return {
+    env: resolved,
+    redactedEnv: redactCapacityProviderEnv(resolved),
+    missing,
+    diagnostic,
+    source
+  };
+}
+function persistCapacityProviderConnectionToTreeseedConfig(input) {
+  const scope = input.scope === "staging" || input.scope === "prod" ? input.scope : "local";
+  const env = resolveCapacityProviderEnvironment({
+    ...input,
+    providerEnvironment: input.providerEnvironment ?? "local",
+    providerHostDataDir: input.providerHostDataDir ?? ".treeseed/local-capacity-provider/data"
+  });
+  let registryEntries = [];
+  try {
+    registryEntries = collectTreeseedEnvironmentContext(input.tenantRoot).entries;
+  } catch {
+    registryEntries = [];
+  }
+  const entryById = new Map(registryEntries.map((entry) => [entry.id, entry]));
+  const keys = [
+    "TREESEED_MARKET_URL",
+    "TREESEED_MARKET_ID",
+    "TREESEED_CAPACITY_PROVIDER_API_KEY",
+    "TREESEED_PROVIDER_HOST_DATA_DIR",
+    "TREESEED_PROVIDER_ENVIRONMENT"
+  ];
+  for (const key of keys) {
+    const entry = entryById.get(key) ?? capacityProviderConfigEntry(key);
+    setTreeseedMachineEnvironmentValue(input.tenantRoot, scope, entry, env[key] ?? "");
+  }
+  return {
+    env,
+    redactedEnv: redactCapacityProviderEnv(env),
+    scope,
+    writtenKeys: keys
+  };
+}
+function redactCapacityProviderSecret(value) {
+  if (value.length <= 8) return "<redacted>";
+  return `${value.slice(0, 4)}...<redacted>`;
+}
+function isCapacityProviderSecretEnvKey(key) {
+  return /(?:API_KEY|AUTH|TOKEN|SECRET|PASSWORD|CREDENTIAL)/u.test(key);
+}
+function redactCapacityProviderEnv(env) {
+  const redacted = {};
+  for (const [key, value] of Object.entries(env)) {
+    redacted[key] = isCapacityProviderSecretEnvKey(key) ? redactCapacityProviderSecret(value) : value;
+  }
+  return redacted;
+}
+function renderCapacityProviderSelfHostInstructions(input) {
+  const env = resolveCapacityProviderEnvironment(input);
+  return {
+    composeFile: "packages/agent/compose.capacity-provider.yml",
+    commands: [
+      "npm -w packages/agent run capacity-provider:build",
+      "docker compose -f packages/agent/compose.capacity-provider.yml up"
+    ],
+    env,
+    redactedEnv: redactCapacityProviderEnv(env),
+    summary: "Unlock TreeSeed sensitive config, inject these values into the docker compose process environment, and start the package-owned capacity provider runtime."
+  };
+}
+function providerDeploymentServiceName(prefix, role) {
+  return `${prefix}-${role}`.replace(/[^a-zA-Z0-9_.-]+/gu, "-").replace(/^-+|-+$/gu, "").toLowerCase();
+}
+function providerDeploymentStartCommand(role) {
+  return `node ./dist/provider/entrypoint.js ${role}`;
+}
+function defaultProviderDeploymentAdapter(hostKind) {
+  return {
+    async provisionService(spec) {
+      return {
+        role: spec.role,
+        serviceName: spec.serviceName,
+        serviceId: `${hostKind}:${spec.serviceName}`,
+        url: spec.role === "api" ? `https://${spec.serviceName}.example.invalid` : null,
+        status: "deployed",
+        envRefs: Object.fromEntries(
+          Object.keys(spec.env).map((key) => [key, isCapacityProviderSecretEnvKey(key) ? `${spec.serviceName}:${key}` : spec.redactedEnv[key] ?? spec.env[key]])
+        )
+      };
+    }
+  };
+}
+async function deployCapacityProviderWithAdapter(input, launchMode, hostKind) {
+  const imageRef = input.imageRef ?? input.intent.imageRef ?? "ghcr.io/treeseed-ai/agent:capacity-provider";
+  const serviceNamePrefix = input.serviceNamePrefix ?? `${input.intent.capacityProviderId || "capacity-provider"}`.replace(/^cp[_-]?/u, "capacity-provider-").replace(/[^a-zA-Z0-9_.-]+/gu, "-");
+  const env = { ...input.env };
+  const redactedEnv = input.redactedEnv ?? redactCapacityProviderEnv(env);
+  const adapter = input.adapter ?? defaultProviderDeploymentAdapter(hostKind);
+  const services = {};
+  const diagnostics = [];
+  try {
+    for (const role of CAPACITY_PROVIDER_DEPLOYMENT_SERVICE_ROLES) {
+      const result = await adapter.provisionService({
+        role,
+        serviceName: providerDeploymentServiceName(serviceNamePrefix, role),
+        imageRef,
+        startCommand: providerDeploymentStartCommand(role),
+        env,
+        redactedEnv
+      });
+      services[role] = {
+        role,
+        serviceName: result.serviceName,
+        serviceId: result.serviceId ?? null,
+        url: result.url ?? null,
+        status: result.status ?? "deployed",
+        envRefs: result.envRefs ?? {},
+        metadata: result.metadata ?? {}
+      };
+    }
+    return {
+      ok: true,
+      launchMode,
+      hostKind,
+      imageRef,
+      status: "deployed",
+      serviceRefs: services,
+      envRefs: Object.fromEntries(Object.keys(env).map((key) => [key, isCapacityProviderSecretEnvKey(key) ? "<host-secret>" : redactedEnv[key] ?? env[key]])),
+      diagnostics,
+      deployedAt: (input.now ?? /* @__PURE__ */ new Date()).toISOString()
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      ok: false,
+      launchMode,
+      hostKind,
+      imageRef,
+      status: "failed",
+      serviceRefs: services,
+      envRefs: Object.fromEntries(Object.keys(env).map((key) => [key, isCapacityProviderSecretEnvKey(key) ? "<host-secret>" : redactedEnv[key] ?? env[key]])),
+      diagnostics: [message],
+      deployedAt: null,
+      error: { message }
+    };
+  }
+}
+function deployCapacityProviderToRailway(input) {
+  return deployCapacityProviderWithAdapter(input, "connected_host", "railway");
+}
+function deployCapacityProviderToManagedMarketHost(input) {
+  return deployCapacityProviderWithAdapter(input, "managed_market_host", "managed_market_host");
+}
+class MarketProviderClient {
+  marketUrl;
+  marketId;
+  apiKey;
+  fetchImpl;
+  userAgent;
+  constructor(options) {
+    this.marketUrl = normalizeBaseUrl(options.marketUrl);
+    this.marketId = options.marketId.trim();
+    this.apiKey = options.apiKey.trim();
+    if (!this.marketId) throw new Error("Capacity provider Market ID is required.");
+    if (!this.apiKey) throw new Error("Capacity provider API key is required.");
+    this.fetchImpl = options.fetchImpl ?? fetch;
+    this.userAgent = options.userAgent;
+  }
+  async requestJson(path, options = {}) {
+    const headers = {
+      accept: "application/json",
+      [TREESEED_REMOTE_CONTRACT_HEADER]: String(TREESEED_REMOTE_CONTRACT_VERSION),
+      ...buildCapacityProviderAuthHeaders(this.apiKey)
+    };
+    if (this.userAgent) headers["user-agent"] = this.userAgent;
+    if (options.body !== void 0) headers["content-type"] = "application/json";
+    const response = await this.fetchImpl(`${this.marketUrl}${path}`, {
+      method: options.method ?? "GET",
+      headers,
+      body: options.body === void 0 ? void 0 : JSON.stringify(options.body)
+    });
+    const payload = await response.json().catch(() => ({}));
+    if (!response.ok) {
+      const message = isRecord(payload) && typeof payload.error === "string" ? payload.error : `Capacity provider request failed with ${response.status}.`;
+      throw new CapacityProviderApiError(message, response.status, payload);
+    }
+    return payload;
+  }
+  register(request) {
+    return this.requestJson(CAPACITY_PROVIDER_ENDPOINTS.register, {
+      method: "POST",
+      body: { ...request, marketId: request.marketId ?? this.marketId }
+    }).then((response) => {
+      assertCapacityProviderRegistrationResponse(response);
+      return response;
+    });
+  }
+  heartbeat(request = {}) {
+    return this.requestJson(CAPACITY_PROVIDER_ENDPOINTS.heartbeat, {
+      method: "POST",
+      body: { ...request, marketId: request.marketId ?? this.marketId }
+    }).then((response) => {
+      assertCapacityProviderOkEnvelope(response, "Capacity provider heartbeat response");
+      return response;
+    });
+  }
+  portfolio() {
+    return this.requestJson(CAPACITY_PROVIDER_ENDPOINTS.portfolio).then((response) => {
+      assertCapacityProviderPortfolioManifest(response);
+      return response;
+    });
+  }
+  createWorkday(request) {
+    return this.requestJson(CAPACITY_PROVIDER_ENDPOINTS.workdays, {
+      method: "POST",
+      body: request
+    }).then((response) => {
+      assertCapacityProviderOkEnvelope(response, "Capacity provider workday response");
+      return response;
+    });
+  }
+  claimTask(request = {}) {
+    return this.requestJson(CAPACITY_PROVIDER_ENDPOINTS.claimTask, {
+      method: "POST",
+      body: request
+    }).then((response) => {
+      assertCapacityProviderOkEnvelope(response, "Capacity provider task claim response");
+      if (!Array.isArray(response.tasks)) throw new Error("Capacity provider task claim response is missing tasks.");
+      return response;
+    });
+  }
+  appendTaskEvent(taskId, request) {
+    return this.requestJson(CAPACITY_PROVIDER_ENDPOINTS.taskEvents(taskId), {
+      method: "POST",
+      body: request
+    }).then((response) => {
+      assertCapacityProviderOkEnvelope(response, "Capacity provider task event response");
+      return response;
+    });
+  }
+  completeTask(taskId, request = {}) {
+    return this.requestJson(CAPACITY_PROVIDER_ENDPOINTS.completeTask(taskId), {
+      method: "POST",
+      body: request
+    }).then((response) => {
+      assertCapacityProviderOkEnvelope(response, "Capacity provider task completion response");
+      return response;
+    });
+  }
+  failTask(taskId, request) {
+    return this.requestJson(CAPACITY_PROVIDER_ENDPOINTS.failTask(taskId), {
+      method: "POST",
+      body: request
+    }).then((response) => {
+      assertCapacityProviderOkEnvelope(response, "Capacity provider task failure response");
+      return response;
+    });
+  }
+  reportUsage(request) {
+    return this.requestJson(CAPACITY_PROVIDER_ENDPOINTS.usage, {
+      method: "POST",
+      body: request
+    }).then((response) => {
+      assertCapacityProviderOkEnvelope(response, "Capacity provider usage response");
+      return response;
+    });
+  }
+  writeReport(request) {
+    return this.requestJson(CAPACITY_PROVIDER_ENDPOINTS.reports, {
+      method: "POST",
+      body: request
+    }).then((response) => {
+      assertCapacityProviderOkEnvelope(response, "Capacity provider report response");
+      return response;
+    });
+  }
+}
+export {
+  CAPACITY_PROVIDER_DEPLOYMENT_SERVICE_ROLES,
+  CAPACITY_PROVIDER_ENDPOINTS,
+  CAPACITY_PROVIDER_ENV_KEYS,
+  CAPACITY_PROVIDER_SCOPES,
+  CapacityProviderApiError,
+  MarketProviderClient,
+  assertCapacityProviderOkEnvelope,
+  assertCapacityProviderPortfolioManifest,
+  assertCapacityProviderRegistrationResponse,
+  buildCapacityProviderAuthHeaders,
+  deployCapacityProviderToManagedMarketHost,
+  deployCapacityProviderToRailway,
+  isCapacityProviderSecretEnvKey,
+  persistCapacityProviderConnectionToTreeseedConfig,
+  redactCapacityProviderEnv,
+  redactCapacityProviderSecret,
+  renderCapacityProviderSelfHostInstructions,
+  resolveCapacityProviderEnvironment,
+  resolveCapacityProviderLaunchEnvironment
+};

package/dist/capacity.d.ts

@@ -1,38 +1,5 @@
-import type { AttentionEstimate, AttentionPolicy, CapacityEstimateConfidence, CapacityGrant, CapacityPlan, CapacityProvider, CapacityProviderLane, CapacityReservation, CreateCapacityReservationRequest, CreateCapacityRoutingDecisionRequest, ExecutionProfile, HybridExecutionPlan, PlannedTaskNode, PlanningAdmissionResult, PlanningPolicy, PredictiveReservePolicy, RecordCapacityUsageRequest, ReservePrediction, TaskAdmissionDecision, TaskAdmissionPolicy, TaskClassification, TaskEstimateProfile, TaskPlanProposal, TaskMutationScope, TaskUsageActual, UtilityEstimate, UtilityPolicy, WorkdayBudgetEnvelope } from './sdk-types.ts';
+import type { AttentionEstimate, AttentionPolicy, CapacityEstimateConfidence, CapacityGrant, CapacityPlan, CapacityProvider, CapacityProviderLane, CapacityReservation, CreateCapacityReservationRequest, CreateCapacityRoutingDecisionRequest, ExecutionProfile, HybridExecutionPlan, PlannedTaskNode, PlanningAdmissionResult, PlanningPolicy, PredictiveReservePolicy, ProjectEnvironmentName, RecordCapacityUsageRequest, ReservePrediction, TaskAdmissionDecision, TaskAdmissionPolicy, TaskClassification, TaskEstimateProfile, TaskPlanProposal, TaskMutationScope, TaskUsageActual, UtilityEstimate, UtilityPolicy, WorkdayBudgetEnvelope } from './sdk-types.ts';
 import type { AgentProviderProfile } from './types/agents.ts';
-export type ProcessingEnvironment = 'local' | 'staging' | 'prod';
-export interface CapacityProviderRegistration {
-    id: string;
-    teamId: string;
-    providerKind: 'processing-host';
-    serviceBaseUrl: string;
-    environments: ProcessingEnvironment[];
-    capabilities: string[];
-    status: 'pending' | 'active' | 'degraded' | 'disabled';
-    heartbeatAt: string;
-    limits: {
-        maxWorkers: number;
-        dailyTaskCreditBudget: number;
-        maxQueuedTasks: number;
-    };
-}
-export interface CapacityProviderHeartbeat {
-    providerId: string;
-    status: CapacityProviderRegistration['status'];
-    heartbeatAt: string;
-    queueDepth?: number | null;
-    activeWorkers?: number | null;
-    draining?: boolean;
-}
-export interface CapacityProviderHealth {
-    ok: boolean;
-    status: CapacityProviderRegistration['status'];
-    capabilities: string[];
-    queueDepth: number;
-    activeWorkers: number;
-    draining: boolean;
-    checkedAt: string;
-}
 export interface CapacityEstimateInput {
     taskSignature?: string | null;
     taskKind?: string | null;
@@ -141,7 +108,7 @@ export interface TeamCapacitySummary {
 }
 export interface ProjectCapacitySummary extends TeamCapacitySummary {
     projectId: string;
-    environment: ProcessingEnvironment;
+    environment: ProjectEnvironmentName | 'local';
     readiness: 'ready' | 'waiting_for_budget' | 'waiting_for_provider' | 'paused_by_policy' | 'needs_approval';
     reasons: string[];
 }

package/dist/control-plane-client.d.ts

@@ -1,4 +1,4 @@
-import type { AgentPool, AgentPoolRegistration, AgentPoolScaleDecision, ApprovalRequest, CapacityGrant, CapacityPlan, CapacityProvider, CapacityProviderLane, CapacityReservation, CapacityRoutingDecision, CatalogArtifactVersion, CatalogItem, CatalogItemFilters, CreateCapacityReservationRequest, CreateCapacityRoutingDecisionRequest, CreateProjectDeploymentRequest, CreateTaskEstimateRequest, CreateTaskUsageActualRequest, PriorityOverride, PrioritySnapshot, ProjectConnection, ProjectDeployment, ProjectEnvironment, ProjectEnvironmentName, ProjectHosting, ProjectInfrastructureResource, ProjectWorkdaySummary, RecordAgentPoolRegistrationRequest, RecordCapacityUsageRequest, RepositoryClaim, RunnerScaleDecision, ScaleDecision, SdkAppendTaskEventRequest, SdkClaimTaskRequest, SdkClaimWorkdayManagerLeaseRequest, SdkCloseWorkDayRequest, SdkCompleteTaskRequest, SdkCreateTaskRequest, SdkFailTaskRequest, SdkManagerContextPayload, SdkRecordRepositoryClaimRequest, SdkRecordRunnerScaleDecisionRequest, SdkRecordWorkerRunnerRequest, SdkReleaseWorkdayManagerLeaseRequest, SdkStartWorkDayRequest, SdkTaskEntity, SdkTaskEventEntity, SdkTaskOutputEntity, SdkTaskProgressRequest, SdkTaskSearchRequest, SdkCreateWorkdayRequest, SdkWorkDayEntity, TeamStorageLocator, TeamWebHost, TaskEstimate, UpsertAgentPoolRequest, UpsertCapacityGrantRequest, UpsertCapacityProviderLaneRequest, UpsertCapacityProviderRequest, UpsertCatalogArtifactVersionRequest, UpsertCatalogItemRequest, UpsertProjectEnvironmentRequest, UpsertProjectHostingRequest, UpsertProjectInfrastructureResourceRequest, UpsertTeamStorageLocatorRequest, UpsertTeamWebHostRequest, WorkdayPolicy, WorkdayManagerLease, WorkdayRequest, WorkerRunner, SdkPriorityOverrideRequest, SdkUpsertWorkPolicyRequest } from './sdk-types.ts';
+import type { AgentPool, AgentPoolRegistration, AgentPoolScaleDecision, ApprovalRequest, CapacityGrant, CapacityPlan, CapacityProvider, CapacityProviderLane, CapacityProviderRotateKeyResponse, CapacityReservation, CapacityRoutingDecision, CatalogArtifactVersion, CatalogItem, CatalogItemFilters, CreateCapacityProviderRequest, CreateCapacityProviderResponse, CreateCapacityReservationRequest, CreateCapacityRoutingDecisionRequest, CreateProjectDeploymentRequest, CreateTaskEstimateRequest, CreateTaskUsageActualRequest, PriorityOverride, PrioritySnapshot, ProjectConnection, ProjectDeployment, ProjectEnvironment, ProjectEnvironmentName, ProjectHosting, ProjectInfrastructureResource, ProjectWorkdaySummary, RecordAgentPoolRegistrationRequest, RecordCapacityUsageRequest, RenameCapacityProviderRequest, RepositoryClaim, RunnerScaleDecision, ScaleDecision, SdkAppendTaskEventRequest, SdkClaimTaskRequest, SdkClaimWorkdayManagerLeaseRequest, SdkCloseWorkDayRequest, SdkCompleteTaskRequest, SdkCreateTaskRequest, SdkFailTaskRequest, SdkManagerContextPayload, SdkRecordRepositoryClaimRequest, SdkRecordRunnerScaleDecisionRequest, SdkRecordWorkerRunnerRequest, SdkReleaseWorkdayManagerLeaseRequest, SdkStartWorkDayRequest, SdkTaskEntity, SdkTaskEventEntity, SdkTaskOutputEntity, SdkTaskProgressRequest, SdkTaskSearchRequest, SdkCreateWorkdayRequest, SdkWorkDayEntity, TeamStorageLocator, TeamWebHost, TaskEstimate, UpsertAgentPoolRequest, UpsertCapacityGrantRequest, UpsertCapacityProviderLaneRequest, UpsertCapacityProviderRequest, UpsertCatalogArtifactVersionRequest, UpsertCatalogItemRequest, UpsertProjectEnvironmentRequest, UpsertProjectHostingRequest, UpsertProjectInfrastructureResourceRequest, UpsertTeamStorageLocatorRequest, UpsertTeamWebHostRequest, WorkdayPolicy, WorkdayManagerLease, WorkdayRequest, WorkerRunner, SdkPriorityOverrideRequest, SdkUpsertWorkPolicyRequest } from './sdk-types.ts';
 import type { AgentMessageRecord, AgentStatusRecord, DirectBoardItemSummary, InboxItem, LaunchProjectRequest, LaunchProjectResult, ProjectOverviewSummary, ReleaseDetail, ReleaseSummary, SharePackageStatus, TeamHomeSummary, TeamMemberSummary, WorkstreamDetail, WorkstreamSummary } from './project-workflow.ts';
 export interface ControlPlaneClientOptions {
     baseUrl: string;
@@ -128,8 +128,13 @@ export declare class ControlPlaneClient {
     listCapacityProviders(teamId: string): Promise<(CapacityProvider & {
         lanes?: CapacityProviderLane[];
     })[]>;
-    createCapacityProvider(teamId: string, input: UpsertCapacityProviderRequest): Promise<CapacityProvider>;
-    updateCapacityProvider(teamId: string, providerId: string, input: Partial<UpsertCapacityProviderRequest>): Promise<CapacityProvider>;
+    createCapacityProvider(teamId: string, input: UpsertCapacityProviderRequest): Promise<CreateCapacityProviderResponse>;
+    createCapacityProviderRegistration(teamId: string, input: CreateCapacityProviderRequest): Promise<CreateCapacityProviderResponse>;
+    updateCapacityProvider(teamId: string, providerId: string, input: Partial<UpsertCapacityProviderRequest> | RenameCapacityProviderRequest): Promise<{
+        ok: true;
+        provider: CapacityProvider;
+    }>;
+    rotateCapacityProviderApiKey(teamId: string, providerId: string): Promise<CapacityProviderRotateKeyResponse>;
     listCapacityProviderLanes(teamId: string, providerId: string): Promise<CapacityProviderLane[]>;
     createCapacityProviderLane(teamId: string, providerId: string, input: UpsertCapacityProviderLaneRequest): Promise<CapacityProviderLane>;
     listCapacityGrants(teamId: string, input?: {

package/dist/control-plane-client.js

@@ -41,7 +41,7 @@ class ControlPlaneClient {
     if (!payload.ok) {
       throw new Error(`Control-plane request returned a non-ok envelope for ${pathname}.`);
     }
-    return payload.payload;
+    return Object.prototype.hasOwnProperty.call(payload, "payload") ? payload.payload : payload;
   }
   listCatalogItems(filters = {}) {
     return this.requestJson("GET", "/v1/catalog", {
@@ -476,6 +476,11 @@ class ControlPlaneClient {
       body: input
     });
   }
+  createCapacityProviderRegistration(teamId, input) {
+    return this.requestJson("POST", `/v1/teams/${encodeURIComponent(teamId)}/capacity-providers`, {
+      body: input
+    });
+  }
   updateCapacityProvider(teamId, providerId, input) {
     return this.requestJson(
       "PATCH",
@@ -483,6 +488,12 @@ class ControlPlaneClient {
       { body: input }
     );
   }
+  rotateCapacityProviderApiKey(teamId, providerId) {
+    return this.requestJson(
+      "POST",
+      `/v1/teams/${encodeURIComponent(teamId)}/capacity-providers/${encodeURIComponent(providerId)}/keys/rotate`
+    );
+  }
   listCapacityProviderLanes(teamId, providerId) {
     return this.requestJson(
       "GET",

package/dist/dispatch.js

@@ -72,7 +72,6 @@ const LOCAL_ONLY_WORKFLOW_OPERATIONS = /* @__PURE__ */ new Set([
   "secrets:rotate-passphrase",
   "secrets:rotate-machine-key",
   "dev",
-  "dev:watch",
   "mailpit:up",
   "mailpit:down",
   "mailpit:logs",

package/dist/index.d.ts

@@ -4,6 +4,7 @@ export { projectConnectionModeFromHosting } from './sdk-types.ts';
 export { createControlPlaneReporter } from './control-plane.ts';
 export { ControlPlaneClient } from './control-plane-client.ts';
 export * from './seeds/index.ts';
+export { CAPACITY_PROVIDER_ENDPOINTS, CAPACITY_PROVIDER_DEPLOYMENT_SERVICE_ROLES, CAPACITY_PROVIDER_ENV_KEYS, CAPACITY_PROVIDER_SCOPES, CapacityProviderApiError, MarketProviderClient, assertCapacityProviderOkEnvelope, assertCapacityProviderPortfolioManifest, assertCapacityProviderRegistrationResponse, buildCapacityProviderAuthHeaders, deployCapacityProviderToManagedMarketHost, deployCapacityProviderToRailway, isCapacityProviderSecretEnvKey, redactCapacityProviderEnv, redactCapacityProviderSecret, renderCapacityProviderSelfHostInstructions, persistCapacityProviderConnectionToTreeseedConfig, resolveCapacityProviderEnvironment, resolveCapacityProviderLaunchEnvironment, } from './capacity-provider.ts';
 export { DEFAULT_EXECUTION_PROFILE_ID, DEFAULT_EXECUTION_PROFILES, DEFAULT_TASK_ADMISSION_POLICY, buildTaskEstimateProfileFromActuals, computeWorkdayBudgetEnvelope, decideTaskAdmission, estimateAttentionForTask, estimateConfidenceFromProfile, estimateLearningPercentile, estimateLearningVariance, estimateForClassification, estimateProfileConfidenceScore, estimateUtilityForTask, isInterruptedUsageActual, normalizeHybridExecutionPlan, mutationRequiresRepositoryClaim, normalizePlanningPolicy, normalizePredictiveReservePolicy, normalizeTaskPlanProposal, normalizeExecutionProfile, normalizeAttentionPolicy, normalizeTaskAdmissionPolicy, normalizeUtilityPolicy, predictReserveForCapacityPlan, progressivelyAdmitPlanProposal, rankPlannedTaskNodes, reservationHasCapacity, reserveCreditsForEstimate, routeAndReserveCapacity, scoreCapacityLane, selectBestCapacityLane, selectTaskEstimateProfile, settleCapacityActuals, shouldInterruptForCapacity, synthesizePlanEstimate, createReservationReleaseEntry, summarizeCapacityPlan, summarizeProjectCapacityPlan, summarizeTeamCapacityPlan, validateTaskPlanProposal, } from './capacity.ts';
 export { executeKnowledgeHubProviderLaunch, validateKnowledgeHubProviderLaunchPrerequisites, } from './operations/services/hub-provider-launch.ts';
 export { createKnowledgeHubRepositories, defaultHubContentResolutionPolicy, executeKnowledgeHubLaunch, normalizeKnowledgeHubLaunchIntent, planKnowledgeHubLaunch, planKnowledgeHubRepositories, validateRepositoryHost, type HubContentResolutionPolicy, type KnowledgeHubLaunchIntent, type KnowledgeHubLaunchPhase, type KnowledgeHubLaunchPlan, type KnowledgeHubLaunchResult, type KnowledgeHubRepositoryPlan, type RepositoryHost, } from './operations/services/hub-launch.ts';
@@ -39,6 +40,7 @@ export type { KnowledgeHubProviderLaunchPreflightReport, KnowledgeHubProviderLau
 export type * from './project-workflow.ts';
 export type { ControlPlaneAgentPoolHeartbeat, ControlPlaneDeploymentReport, ControlPlaneEnvironmentReport, ControlPlaneReporter, ControlPlaneReporterKind, ControlPlaneResourceReport, ControlPlaneScaleDecisionReport, ControlPlaneWorkdaySummaryReport, } from './control-plane.ts';
 export type { ControlPlaneClientOptions } from './control-plane-client.ts';
+export type { CapacityProviderBudgetCapacity, CapacityProviderCapability, CapacityProviderConnectionState, CapacityProviderDeploymentIntent, CapacityProviderDeploymentResult, CapacityProviderDeploymentStatus, CapacityProviderEnvironmentInput, CapacityProviderEnvironmentName, CapacityProviderHealthState, CapacityProviderHeartbeatRequest, CapacityProviderHeartbeatResponse, CapacityProviderLaunchMode, CapacityProviderLaunchEnvironment, CapacityProviderLaunchEnvironmentInput, CapacityProviderConnectionConfigInput, CapacityProviderConnectionConfigResult, CapacityProviderPortfolioManifest, CapacityProviderPortfolioProject, CapacityProviderRegistrationRequest, CapacityProviderRegistrationResponse, CapacityProviderRuntimeInfo, CapacityProviderScope, CapacityProviderSelfHostInstructions, CapacityProviderStatus, MarketProviderClientOptions, ProviderReportRequest, ProviderReportResponse, ProviderTaskClaimRequest, ProviderTaskClaimResponse, ProviderTaskCompleteRequest, ProviderTaskCompleteResponse, ProviderTaskEventRequest, ProviderTaskEventResponse, ProviderTaskFailRequest, ProviderTaskFailResponse, ProviderUsageReport, ProviderUsageReportResponse, ProviderWorkdayRequest, ProviderWorkdayResponse, } from './capacity-provider.ts';
 export type { AdmissionEstimateInput, CapacityInterruptionInput, CapacityEstimateInput, CapacityLaneCandidate, CapacityLaneScore, CapacityTaskEstimate, AttentionEstimate, AttentionPolicy, CapacityRoutePressure, RouteAndReserveCandidate, RouteAndReserveResult, TaskAdmissionInput, WorkdayBudgetEnvelopeInput, } from './capacity.ts';
 export type { TreeseedFieldAliasBinding, TreeseedFieldAliasRegistry, } from './field-aliases.ts';
 export type * from './operations-types.ts';