@treeseed/agent 0.8.5

package/dist/services/worker-capacity.js

@@ -0,0 +1,208 @@
+import { createWorkerPoolScaler } from "./worker-pool-scaler.js";
+function integerFromEnv(name, fallback) {
+  const value = process.env[name];
+  if (!value) return fallback;
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+function envValue(name) {
+  const value = process.env[name]?.trim();
+  return value ? value : "";
+}
+function parseJson(value, fallback) {
+  if (typeof value !== "string" || !value.trim()) {
+    return fallback;
+  }
+  try {
+    return JSON.parse(value);
+  } catch {
+    return fallback;
+  }
+}
+function readNumber(record, ...keys) {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "number" && Number.isFinite(value)) {
+      return value;
+    }
+    if (typeof value === "string" && value.trim()) {
+      const parsed = Number.parseFloat(value);
+      if (Number.isFinite(parsed)) {
+        return parsed;
+      }
+    }
+  }
+  return null;
+}
+function asRecords(value) {
+  return Array.isArray(value) ? value : [];
+}
+function resolveAutoscalePolicyFromEnv() {
+  return {
+    minWorkers: integerFromEnv("TREESEED_AGENT_POOL_MIN_WORKERS", 0),
+    maxWorkers: integerFromEnv("TREESEED_AGENT_POOL_MAX_WORKERS", 1),
+    targetQueueDepth: Math.max(1, integerFromEnv("TREESEED_AGENT_POOL_TARGET_QUEUE_DEPTH", 1)),
+    cooldownSeconds: Math.max(0, integerFromEnv("TREESEED_AGENT_POOL_COOLDOWN_SECONDS", 60))
+  };
+}
+function resolveWorkerPoolIdentityFromEnv(projectId) {
+  const environment = envValue("TREESEED_DEPLOY_ENVIRONMENT") || (process.env.NODE_ENV === "production" ? "prod" : "local");
+  const resolvedProjectId = projectId?.trim() || envValue("TREESEED_PROJECT_ID") || "treeseed-market";
+  return {
+    projectId: resolvedProjectId,
+    environment,
+    poolName: envValue("TREESEED_AGENT_POOL_NAME") || `${resolvedProjectId}-${environment}`
+  };
+}
+function computeDesiredWorkerCount(autoscale, metrics) {
+  const { minWorkers, maxWorkers, targetQueueDepth } = autoscale;
+  if (metrics.queuedCount <= 0 && metrics.activeLeases <= 0) {
+    return minWorkers;
+  }
+  const requiredByQueue = Math.ceil(metrics.queuedCount / Math.max(1, targetQueueDepth));
+  const minimumActive = metrics.activeLeases > 0 ? 1 : 0;
+  return Math.max(minWorkers, Math.min(maxWorkers, Math.max(requiredByQueue, minimumActive)));
+}
+function applyScaleCooldown(autoscale, latestDecision, nextDesired, now) {
+  if (!latestDecision) {
+    return nextDesired;
+  }
+  if (nextDesired >= latestDecision.desiredWorkers) {
+    return nextDesired;
+  }
+  const cooldownMs = Math.max(0, autoscale.cooldownSeconds) * 1e3;
+  if (cooldownMs === 0) {
+    return nextDesired;
+  }
+  const lastChangedAt = new Date(latestDecision.createdAt);
+  if (!Number.isFinite(lastChangedAt.valueOf())) {
+    return nextDesired;
+  }
+  return now.valueOf() - lastChangedAt.valueOf() < cooldownMs ? latestDecision.desiredWorkers : nextDesired;
+}
+function applyInteractiveWakeUpOverride(options) {
+  if (options.priorityClass !== "interactive") {
+    return options.desiredWorkers;
+  }
+  if (options.queuedCount <= 0 || options.currentWorkers > 0 || options.desiredWorkers > 0) {
+    return options.desiredWorkers;
+  }
+  return 1;
+}
+async function collectTaskMetrics(sdk, workDayId) {
+  const [queuedEnvelope, activeEnvelope] = await Promise.all([
+    sdk.searchTasks({
+      workDayId: workDayId ?? void 0,
+      limit: 500,
+      state: ["pending", "queued"]
+    }),
+    sdk.searchTasks({
+      workDayId: workDayId ?? void 0,
+      limit: 500,
+      state: ["claimed", "running"]
+    })
+  ]);
+  const queuedTasks = asRecords(queuedEnvelope.payload);
+  const activeTasks = asRecords(activeEnvelope.payload);
+  const queuedCredits = queuedTasks.reduce((total, task) => {
+    const payload = parseJson(String(task.payloadJson ?? "{}"), {});
+    const credits = readNumber(payload, "estimatedCredits") ?? 1;
+    return total + credits;
+  }, 0);
+  return {
+    queuedTasks,
+    activeTasks,
+    queuedCount: queuedTasks.length,
+    activeLeases: activeTasks.length,
+    queuedCredits
+  };
+}
+async function enqueueTaskAndEnsureCapacity(sdk, request) {
+  await request.enqueueTask(sdk, {
+    taskId: request.taskId,
+    queueName: request.queueName,
+    deliveryDelaySeconds: request.deliveryDelaySeconds,
+    actor: request.actor
+  });
+  const now = request.now ?? /* @__PURE__ */ new Date();
+  const identity = request.identity ?? resolveWorkerPoolIdentityFromEnv(request.projectId);
+  const autoscale = request.autoscale ?? resolveAutoscalePolicyFromEnv();
+  const scaler = request.scaler ?? createWorkerPoolScaler();
+  const metrics = await collectTaskMetrics(sdk);
+  const latestScaleDecision = await sdk.getLatestScaleDecision(identity.projectId, identity.environment, identity.poolName);
+  const currentWorkers = Math.max(0, Number(latestScaleDecision.payload?.desiredWorkers ?? 0));
+  const rawDesiredWorkers = computeDesiredWorkerCount(autoscale, metrics);
+  const desiredAfterCooldown = applyScaleCooldown(autoscale, latestScaleDecision.payload, rawDesiredWorkers, now);
+  const desiredWorkers = applyInteractiveWakeUpOverride({
+    priorityClass: request.priorityClass ?? "background",
+    queuedCount: metrics.queuedCount,
+    currentWorkers,
+    desiredWorkers: desiredAfterCooldown
+  });
+  const coldStartTriggered = (request.priorityClass ?? "background") === "interactive" && currentWorkers <= 0 && desiredWorkers > 0;
+  const scaleReason = desiredWorkers !== desiredAfterCooldown ? "interactive_cold_start" : coldStartTriggered ? "interactive_cold_start" : desiredWorkers !== rawDesiredWorkers ? "cooldown_hold" : request.priorityClass === "interactive" ? "interactive_enqueue" : "enqueue";
+  const recordedScaleDecision = await sdk.recordScaleDecision({
+    projectId: identity.projectId,
+    environment: identity.environment,
+    poolName: identity.poolName,
+    workDayId: null,
+    desiredWorkers,
+    observedQueueDepth: metrics.queuedCount,
+    observedActiveLeases: metrics.activeLeases,
+    reason: scaleReason,
+    metadata: {
+      priorityClass: request.priorityClass ?? "background",
+      taskId: request.taskId
+    }
+  });
+  const scaleDecision = recordedScaleDecision.payload ?? {
+    projectId: identity.projectId,
+    environment: identity.environment,
+    poolName: identity.poolName,
+    workDayId: null,
+    desiredWorkers,
+    observedQueueDepth: metrics.queuedCount,
+    observedActiveLeases: metrics.activeLeases,
+    reason: scaleReason,
+    metadata: {
+      priorityClass: request.priorityClass ?? "background",
+      taskId: request.taskId
+    },
+    createdAt: now.toISOString()
+  };
+  let scaleResult;
+  try {
+    scaleResult = await scaler.scale(scaleDecision);
+  } catch (error) {
+    scaleResult = {
+      applied: false,
+      provider: "error",
+      desiredWorkers,
+      metadata: {
+        reason: "scale_failed",
+        error: error instanceof Error ? error.message : String(error)
+      }
+    };
+  }
+  return {
+    ok: true,
+    taskId: request.taskId,
+    queued: true,
+    workerState: currentWorkers > 0 ? "warm" : desiredWorkers > 0 ? "cold_starting" : "warm",
+    desiredWorkers,
+    scaleApplied: scaleResult.applied,
+    scaleReason,
+    scaleDecision,
+    scaleResult,
+    metrics
+  };
+}
+export {
+  applyInteractiveWakeUpOverride,
+  applyScaleCooldown,
+  collectTaskMetrics,
+  computeDesiredWorkerCount,
+  enqueueTaskAndEnsureCapacity,
+  resolveAutoscalePolicyFromEnv,
+  resolveWorkerPoolIdentityFromEnv
+};

package/dist/services/worker-pool-scaler.d.ts

@@ -0,0 +1,27 @@
+import type { ScaleDecision, WorkerPoolScaleResult, WorkerPoolScaler } from '@treeseed/sdk';
+export type WorkerPoolScalerKind = 'noop' | 'railway';
+export interface RailwayWorkerPoolScalerOptions {
+    apiToken?: string | null;
+    apiUrl?: string | null;
+    serviceId?: string | null;
+    environmentId?: string | null;
+    projectId?: string | null;
+    fetchImpl?: typeof fetch;
+}
+export declare class NoopWorkerPoolScaler implements WorkerPoolScaler {
+    scale(decision: ScaleDecision): Promise<WorkerPoolScaleResult>;
+}
+export declare class RailwayWorkerPoolScaler implements WorkerPoolScaler {
+    private readonly apiToken;
+    private readonly apiUrl;
+    private readonly serviceId;
+    private readonly environmentId;
+    private readonly projectId;
+    private readonly fetchImpl;
+    constructor(options?: RailwayWorkerPoolScalerOptions);
+    private railwayMutation;
+    private wakeRunner;
+    private sleepRunner;
+    scale(decision: ScaleDecision): Promise<WorkerPoolScaleResult>;
+}
+export declare function createWorkerPoolScaler(kind?: WorkerPoolScalerKind | null, options?: RailwayWorkerPoolScalerOptions): WorkerPoolScaler;

package/dist/services/worker-pool-scaler.js

@@ -0,0 +1,127 @@
+function envValue(name) {
+  const value = process.env[name]?.trim();
+  return value ? value : "";
+}
+class NoopWorkerPoolScaler {
+  async scale(decision) {
+    return {
+      applied: false,
+      provider: "noop",
+      desiredWorkers: decision.desiredWorkers,
+      metadata: {
+        reason: "scaler_unconfigured"
+      }
+    };
+  }
+}
+class RailwayWorkerPoolScaler {
+  apiToken;
+  apiUrl;
+  serviceId;
+  environmentId;
+  projectId;
+  fetchImpl;
+  constructor(options = {}) {
+    this.apiToken = options.apiToken?.trim() || envValue("RAILWAY_API_TOKEN") || null;
+    this.apiUrl = options.apiUrl?.trim() || envValue("TREESEED_RAILWAY_API_URL") || "https://backboard.railway.com/graphql/v2";
+    this.serviceId = options.serviceId?.trim() || envValue("TREESEED_RAILWAY_WORKER_SERVICE_ID") || envValue("TREESEED_WORKER_SERVICE_ID") || null;
+    this.environmentId = options.environmentId?.trim() || envValue("TREESEED_RAILWAY_ENVIRONMENT_ID") || null;
+    this.projectId = options.projectId?.trim() || envValue("TREESEED_RAILWAY_PROJECT_ID") || null;
+    this.fetchImpl = options.fetchImpl ?? fetch;
+  }
+  async railwayMutation(query, variables) {
+    if (!this.apiToken) {
+      throw new Error("Configure RAILWAY_API_TOKEN before waking Railway worker runners.");
+    }
+    const response = await this.fetchImpl(this.apiUrl, {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${this.apiToken}`,
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({ query, variables })
+    });
+    const payload = await response.json().catch(() => ({}));
+    if (!response.ok || Array.isArray(payload.errors) && payload.errors.length > 0) {
+      throw new Error(payload.errors?.[0]?.message ?? `Railway runner request failed with ${response.status}.`);
+    }
+    return payload.data;
+  }
+  async wakeRunner() {
+    if (!this.serviceId || !this.environmentId) {
+      throw new Error("Railway runner wake requires serviceId and environmentId.");
+    }
+    const mutation = envValue("TREESEED_RAILWAY_RUNNER_WAKE_MUTATION") || `
+mutation TreeseedRailwayRunnerWake($serviceId: String!, $environmentId: String!) {
+	serviceInstanceRedeploy(serviceId: $serviceId, environmentId: $environmentId)
+}
+`.trim();
+    return await this.railwayMutation(mutation, {
+      serviceId: this.serviceId,
+      environmentId: this.environmentId,
+      projectId: this.projectId
+    });
+  }
+  async sleepRunner() {
+    if (!this.serviceId || !this.environmentId) {
+      throw new Error("Railway runner sleep requires serviceId and environmentId.");
+    }
+    const mutation = envValue("TREESEED_RAILWAY_RUNNER_SLEEP_MUTATION") || `
+mutation TreeseedRailwayRunnerSleep($serviceId: String!, $environmentId: String!) {
+	deploymentRemove(serviceId: $serviceId, environmentId: $environmentId)
+}
+`.trim();
+    return await this.railwayMutation(mutation, {
+      serviceId: this.serviceId,
+      environmentId: this.environmentId,
+      projectId: this.projectId
+    });
+  }
+  async scale(decision) {
+    const desiredWorkers = Math.max(0, Number(decision.desiredWorkers ?? 0));
+    const action = desiredWorkers > 0 ? "wake" : "sleep";
+    try {
+      const result = action === "wake" ? await this.wakeRunner() : await this.sleepRunner();
+      return {
+        applied: true,
+        provider: "railway",
+        desiredWorkers,
+        metadata: {
+          action,
+          projectId: this.projectId,
+          serviceId: this.serviceId,
+          environmentId: this.environmentId,
+          result
+        }
+      };
+    } catch (error) {
+      return {
+        applied: false,
+        provider: "railway",
+        desiredWorkers,
+        metadata: {
+          action,
+          reason: "named_runner_action_failed",
+          projectId: this.projectId,
+          serviceId: this.serviceId,
+          environmentId: this.environmentId,
+          error: error instanceof Error ? error.message : String(error)
+        }
+      };
+    }
+  }
+}
+function createWorkerPoolScaler(kind, options = {}) {
+  const configuredKind = envValue("TREESEED_WORKER_POOL_SCALER") || null;
+  const inferredKind = envValue("RAILWAY_API_TOKEN") && (envValue("TREESEED_RAILWAY_WORKER_SERVICE_ID") || envValue("TREESEED_WORKER_SERVICE_ID")) && envValue("TREESEED_RAILWAY_ENVIRONMENT_ID") ? "railway" : "noop";
+  const resolvedKind = kind ?? configuredKind ?? inferredKind;
+  if (resolvedKind === "railway") {
+    return new RailwayWorkerPoolScaler(options);
+  }
+  return new NoopWorkerPoolScaler();
+}
+export {
+  NoopWorkerPoolScaler,
+  RailwayWorkerPoolScaler,
+  createWorkerPoolScaler
+};

package/dist/services/worker.d.ts

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+export declare function runWorkerCycle(): Promise<{
+    ok: boolean;
+    processed: number;
+    idle: boolean;
+    reason: string;
+} | {
+    ok: boolean;
+    processed: number;
+    idle?: undefined;
+    reason?: undefined;
+}>;
+export declare function shouldExitWorkerLoopAfterIdle(options: {
+    idleExitMs?: number | null;
+    idleSince: number | null;
+    now: number;
+    processed: number;
+}): boolean;
+export declare function startWorkerLoop(): Promise<void>;