@treeseed/core 0.6.38 → 0.6.40

package/dist/services/workday-manager.js

@@ -0,0 +1,163 @@
+#!/usr/bin/env node
+import { fileURLToPath } from "node:url";
+import { createServiceSdk } from "./common.js";
+import {
+  resolveManagerServiceConfig,
+  runManagerAction,
+  runManagerCycle
+} from "./manager.js";
+function readDate(value) {
+  if (typeof value !== "string") return null;
+  const parsed = new Date(value);
+  return Number.isFinite(parsed.valueOf()) ? parsed : null;
+}
+function workdayCloseDeadline(workDay, durationMinutes, now) {
+  const startedAt = readDate(workDay?.startedAt) ?? readDate(workDay?.started_at) ?? now;
+  return new Date(startedAt.valueOf() + durationMinutes * 60 * 1e3);
+}
+async function sleep(ms) {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function acquireLease(sdk, config, workDayId) {
+  if (typeof sdk.claimWorkdayManagerLease !== "function") {
+    return { payload: { id: `local:${config.managerId}`, managerId: config.managerId } };
+  }
+  return sdk.claimWorkdayManagerLease({
+    projectId: config.projectId,
+    environment: config.environment,
+    workDayId,
+    managerId: config.managerId,
+    ttlSeconds: Math.max(60, Math.ceil(config.pollIntervalMs / 1e3) * 4),
+    staleAfterSeconds: Math.max(120, Math.ceil(config.pollIntervalMs / 1e3) * 8),
+    metadata: {
+      service: "workdayManager"
+    }
+  });
+}
+async function heartbeatLease(sdk, config, leaseId, workDayId) {
+  if (typeof sdk.claimWorkdayManagerLease !== "function") return;
+  await sdk.claimWorkdayManagerLease({
+    id: leaseId,
+    projectId: config.projectId,
+    environment: config.environment,
+    workDayId,
+    managerId: config.managerId,
+    ttlSeconds: Math.max(60, Math.ceil(config.pollIntervalMs / 1e3) * 4),
+    metadata: {
+      service: "workdayManager",
+      heartbeat: true
+    }
+  });
+}
+async function releaseLease(sdk, managerId, leaseId) {
+  if (!leaseId || typeof sdk.releaseWorkdayManagerLease !== "function") return;
+  await sdk.releaseWorkdayManagerLease({ id: leaseId, managerId }).catch(() => null);
+}
+async function recordRunnerCloseDecision(sdk, config, workDayId, action, reason) {
+  if (typeof sdk.recordRunnerScaleDecision !== "function") return;
+  const runners = typeof sdk.listWorkerRunners === "function" ? (await sdk.listWorkerRunners(config.projectId, config.environment).catch(() => ({ payload: [] }))).payload ?? [] : [];
+  if (runners.length === 0) {
+    await sdk.recordRunnerScaleDecision({
+      projectId: config.projectId,
+      environment: config.environment,
+      workDayId,
+      action: "noop",
+      reason: `${reason}:no_runners`,
+      metadata: { service: "workdayManager" }
+    }).catch(() => null);
+    return;
+  }
+  for (const runner of runners) {
+    await sdk.recordRunnerScaleDecision({
+      projectId: config.projectId,
+      environment: config.environment,
+      workDayId,
+      runnerId: typeof runner.runnerId === "string" ? runner.runnerId : null,
+      runnerServiceName: typeof runner.runnerServiceName === "string" ? runner.runnerServiceName : null,
+      action,
+      reason,
+      metadata: { service: "workdayManager" }
+    }).catch(() => null);
+  }
+}
+async function runScheduledWorkdayManager(options = {}) {
+  const sdk = options.sdk ?? createServiceSdk();
+  const config = options.config ?? {
+    ...resolveManagerServiceConfig(),
+    mode: "reconcile"
+  };
+  let now = options.now ?? /* @__PURE__ */ new Date();
+  const policyEnvelope = await sdk.getWorkPolicy(config.projectId, config.environment);
+  const policy = policyEnvelope.payload ?? await sdk.upsertWorkPolicy({
+    projectId: config.projectId,
+    environment: config.environment,
+    schedule: config.defaultSchedule,
+    enabled: true,
+    startCron: process.env.TREESEED_WORKDAY_START_CRON?.trim() || "0 9 * * 1-5",
+    durationMinutes: Number(process.env.TREESEED_WORKDAY_DURATION_MINUTES ?? 480),
+    maxRunners: config.autoscale.maxWorkers,
+    maxWorkersPerRunner: Number(process.env.TREESEED_RUNNER_MAX_LOCAL_WORKERS ?? 4),
+    dailyCreditBudget: config.dailyTaskCreditBudget,
+    closeoutGraceMinutes: Number(process.env.TREESEED_WORKDAY_CLOSEOUT_GRACE_MINUTES ?? 15),
+    dailyTaskCreditBudget: config.dailyTaskCreditBudget,
+    maxQueuedTasks: config.maxQueuedTasks,
+    maxQueuedCredits: config.maxQueuedCredits,
+    autoscale: config.autoscale,
+    creditWeights: config.creditWeights,
+    metadata: { managedBy: "workdayManager" }
+  }).then((created) => created.payload);
+  if (!policy?.enabled) {
+    return { ok: true, skipped: true, reason: "workday_policy_disabled" };
+  }
+  const requests = typeof sdk.listWorkdayRequests === "function" ? (await sdk.listWorkdayRequests(config.projectId, config.environment, "pending").catch(() => ({ payload: [] }))).payload ?? [] : [];
+  const oneOffRunRequested = requests.some((entry) => entry.type === "one_off_run");
+  const initial = await runManagerCycle({ sdk, config, now });
+  const workDay = initial.workDay;
+  if (!workDay && !oneOffRunRequested) {
+    return { ok: true, skipped: true, reason: "no_workday_started", initial };
+  }
+  const lease = await acquireLease(sdk, config, workDay ? String(workDay.id ?? "") : null);
+  if (!lease.payload) {
+    return { ok: true, skipped: true, reason: "healthy_manager_lease_exists" };
+  }
+  const leaseId = String(lease.payload.id ?? "");
+  let latest = initial;
+  try {
+    let activeWorkDay = workDay;
+    let closeDeadline = workdayCloseDeadline(activeWorkDay, Number(policy.durationMinutes ?? 480), now);
+    while (Date.now() < closeDeadline.valueOf()) {
+      await heartbeatLease(sdk, config, leaseId, activeWorkDay ? String(activeWorkDay.id ?? "") : null);
+      await sleep(config.pollIntervalMs);
+      now = /* @__PURE__ */ new Date();
+      latest = await runManagerCycle({ sdk, config, now });
+      activeWorkDay = latest.workDay;
+      closeDeadline = workdayCloseDeadline(activeWorkDay, Number(policy.durationMinutes ?? 480), now);
+    }
+    const workDayId = activeWorkDay ? String(activeWorkDay.id ?? "") : null;
+    await recordRunnerCloseDecision(sdk, config, workDayId, "drain", "workday_closeout");
+    const graceMs = Number(policy.closeoutGraceMinutes ?? 15) * 60 * 1e3;
+    const graceEnd = Date.now() + graceMs;
+    while (Date.now() < graceEnd) {
+      const result = await runManagerCycle({ sdk, config, now: /* @__PURE__ */ new Date() });
+      latest = result;
+      if (Number(result.queuedCount ?? 0) === 0 && Number(result.activeLeases ?? 0) === 0) {
+        break;
+      }
+      await sleep(config.pollIntervalMs);
+    }
+    const closed = await runManagerAction({ sdk, config, mode: "close-workday" });
+    await recordRunnerCloseDecision(sdk, config, workDayId, "sleep", "workday_closed");
+    return { ok: true, initial, latest, closed };
+  } finally {
+    await releaseLease(sdk, config.managerId, leaseId);
+  }
+}
+const currentFile = fileURLToPath(import.meta.url);
+const entryFile = process.argv[1] ?? "";
+if (entryFile === currentFile) {
+  process.stdout.write(`${JSON.stringify(await runScheduledWorkdayManager(), null, 2)}
+`);
+}
+export {
+  runScheduledWorkdayManager
+};

package/dist/services/workday-report.d.ts

@@ -4,7 +4,7 @@ export declare function runWorkdayReport(): Promise<{
     mode: "reconcile";
     managerId: string;
     projectId: string;
-    environment: "local" | "staging" | "prod";
+    environment: "local" | "prod" | "staging";
     insideWorkWindow: boolean;
     workPolicy: import("@treeseed/sdk").WorkdayPolicy;
     workDay: Record<string, unknown>;
@@ -55,8 +55,18 @@ export declare function runWorkdayReport(): Promise<{
             reportVersion: string;
             title: string;
         };
+        capacity: {
+            providerSplit: any;
+            grantedDailyCredits: number;
+            reservedCredits: number;
+            consumedCredits: number;
+            remainingDailyCredits: number | null;
+            providerCount: number;
+            laneCount: number;
+            grantCount: number;
+        };
         projectId: string;
-        environment: "local" | "staging" | "prod";
+        environment: "local" | "prod" | "staging";
         workDayId: string;
         state: string;
         totalTasks: number;
@@ -122,8 +132,18 @@ export declare function runWorkdayReport(): Promise<{
             reportVersion: string;
             title: string;
         };
+        capacity: {
+            providerSplit: any;
+            grantedDailyCredits: number;
+            reservedCredits: number;
+            consumedCredits: number;
+            remainingDailyCredits: number | null;
+            providerCount: number;
+            laneCount: number;
+            grantCount: number;
+        };
         projectId: string;
-        environment: "local" | "staging" | "prod";
+        environment: "local" | "prod" | "staging";
         workDayId: string;
         state: string;
         totalTasks: number;

package/dist/services/workday-start.d.ts

@@ -4,7 +4,7 @@ export declare function runWorkdayStart(): Promise<{
     mode: "reconcile";
     managerId: string;
     projectId: string;
-    environment: "local" | "staging" | "prod";
+    environment: "local" | "prod" | "staging";
     insideWorkWindow: boolean;
     workPolicy: import("@treeseed/sdk").WorkdayPolicy;
     workDay: Record<string, unknown>;
@@ -55,8 +55,18 @@ export declare function runWorkdayStart(): Promise<{
             reportVersion: string;
             title: string;
         };
+        capacity: {
+            providerSplit: any;
+            grantedDailyCredits: number;
+            reservedCredits: number;
+            consumedCredits: number;
+            remainingDailyCredits: number | null;
+            providerCount: number;
+            laneCount: number;
+            grantCount: number;
+        };
         projectId: string;
-        environment: "local" | "staging" | "prod";
+        environment: "local" | "prod" | "staging";
         workDayId: string;
         state: string;
         totalTasks: number;
@@ -122,8 +132,18 @@ export declare function runWorkdayStart(): Promise<{
             reportVersion: string;
             title: string;
         };
+        capacity: {
+            providerSplit: any;
+            grantedDailyCredits: number;
+            reservedCredits: number;
+            consumedCredits: number;
+            remainingDailyCredits: number | null;
+            providerCount: number;
+            laneCount: number;
+            grantCount: number;
+        };
         projectId: string;
-        environment: "local" | "staging" | "prod";
+        environment: "local" | "prod" | "staging";
         workDayId: string;
         state: string;
         totalTasks: number;

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

@@ -7,7 +7,6 @@ export interface RailwayWorkerPoolScalerOptions {
     environmentId?: string | null;
     projectId?: string | null;
     fetchImpl?: typeof fetch;
-    mutation?: string | null;
 }
 export declare class NoopWorkerPoolScaler implements WorkerPoolScaler {
     scale(decision: ScaleDecision): Promise<WorkerPoolScaleResult>;
@@ -19,9 +18,10 @@ export declare class RailwayWorkerPoolScaler implements WorkerPoolScaler {
     private readonly environmentId;
     private readonly projectId;
     private readonly fetchImpl;
-    private readonly mutation;
     constructor(options?: RailwayWorkerPoolScalerOptions);
-    private configured;
+    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

@@ -2,18 +2,6 @@ function envValue(name) {
   const value = process.env[name]?.trim();
   return value ? value : "";
 }
-const DEFAULT_RAILWAY_API_URL = "https://backboard.railway.com/graphql/v2";
-const DEFAULT_SCALE_MUTATION = `
-mutation TreeseedScaleService($serviceId: String!, $environmentId: String!, $replicas: Int!) {
-	serviceInstanceUpdate(
-		serviceId: $serviceId
-		environmentId: $environmentId
-		input: { numReplicas: $replicas }
-	) {
-		id
-	}
-}
-`.trim();
 class NoopWorkerPoolScaler {
   async scale(decision) {
     return {
@@ -33,69 +21,99 @@ class RailwayWorkerPoolScaler {
   environmentId;
   projectId;
   fetchImpl;
-  mutation;
   constructor(options = {}) {
     this.apiToken = options.apiToken?.trim() || envValue("RAILWAY_API_TOKEN") || null;
-    this.apiUrl = options.apiUrl?.trim() || envValue("TREESEED_RAILWAY_API_URL") || DEFAULT_RAILWAY_API_URL;
+    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;
-    this.mutation = options.mutation?.trim() || envValue("TREESEED_RAILWAY_SCALE_MUTATION") || DEFAULT_SCALE_MUTATION;
   }
-  configured() {
-    return Boolean(this.apiToken && this.serviceId && this.environmentId);
+  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) {
-    if (!this.configured() || !this.apiToken || !this.serviceId || !this.environmentId) {
+    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: false,
+        applied: true,
         provider: "railway",
-        desiredWorkers: decision.desiredWorkers,
+        desiredWorkers,
         metadata: {
-          reason: "railway_scaler_unconfigured",
+          action,
           projectId: this.projectId,
           serviceId: this.serviceId,
-          environmentId: this.environmentId
+          environmentId: this.environmentId,
+          result
         }
       };
-    }
-    const response = await this.fetchImpl(this.apiUrl, {
-      method: "POST",
-      headers: {
-        authorization: `Bearer ${this.apiToken}`,
-        "content-type": "application/json"
-      },
-      body: JSON.stringify({
-        query: this.mutation,
-        variables: {
+    } catch (error) {
+      return {
+        applied: false,
+        provider: "railway",
+        desiredWorkers,
+        metadata: {
+          action,
+          reason: "named_runner_action_failed",
+          projectId: this.projectId,
           serviceId: this.serviceId,
           environmentId: this.environmentId,
-          replicas: decision.desiredWorkers
+          error: error instanceof Error ? error.message : String(error)
         }
-      })
-    });
-    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 worker scale request failed with ${response.status}.`
-      );
+      };
     }
-    return {
-      applied: true,
-      provider: "railway",
-      desiredWorkers: decision.desiredWorkers,
-      metadata: {
-        projectId: this.projectId,
-        serviceId: this.serviceId,
-        environmentId: this.environmentId
-      }
-    };
   }
 }
 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")) ? "railway" : "noop";
+  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);

package/dist/services/worker.d.ts

@@ -10,4 +10,10 @@ export declare function runWorkerCycle(): Promise<{
     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>;