@treeseed/agent 0.8.5

package/dist/services/common.js

@@ -0,0 +1,212 @@
+import crypto from "node:crypto";
+import { AgentSdk } from "@treeseed/sdk";
+import { CloudflareQueuePullClient } from "@treeseed/sdk/remote";
+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 resolveServiceRepoRoot() {
+  return process.env.TREESEED_AGENT_REPO_ROOT?.trim() || process.cwd();
+}
+function createServiceSdk() {
+  return AgentSdk.createLocal({
+    repoRoot: resolveServiceRepoRoot(),
+    databaseName: process.env.TREESEED_AGENT_D1_DATABASE ?? "karyon-docs-site-data",
+    persistTo: process.env.TREESEED_AGENT_D1_PERSIST_TO ?? void 0
+  });
+}
+function createQueueClientConfig(token) {
+  const accountId = process.env.CLOUDFLARE_ACCOUNT_ID?.trim();
+  const queueId = process.env.TREESEED_QUEUE_ID?.trim();
+  if (!accountId || !queueId || !token) {
+    return null;
+  }
+  return {
+    accountId,
+    queueId,
+    token,
+    apiBaseUrl: process.env.TREESEED_QUEUE_API_BASE_URL?.trim() || void 0
+  };
+}
+function createQueueClient() {
+  const config = createQueueClientConfig(process.env.TREESEED_QUEUE_PULL_TOKEN?.trim() || "");
+  if (!config) {
+    return null;
+  }
+  return new CloudflareQueuePullClient(config);
+}
+function createQueuePushClient() {
+  const config = createQueueClientConfig(
+    process.env.TREESEED_QUEUE_PUSH_TOKEN?.trim() || process.env.CLOUDFLARE_API_TOKEN?.trim() || ""
+  );
+  if (!config) {
+    return null;
+  }
+  const apiBaseUrl = config.apiBaseUrl ?? "https://api.cloudflare.com/client/v4/accounts";
+  const baseUrl = `${apiBaseUrl.replace(/\/$/u, "")}/${config.accountId}/queues/${config.queueId}`;
+  return {
+    async enqueue(request) {
+      const response = await fetch(`${baseUrl}/messages`, {
+        method: "POST",
+        headers: {
+          accept: "application/json",
+          authorization: `Bearer ${config.token}`,
+          "content-type": "application/json"
+        },
+        body: JSON.stringify({
+          body: request.message,
+          content_type: "json",
+          delay_seconds: request.delaySeconds ?? 0
+        })
+      });
+      const payload = await response.json().catch(() => ({}));
+      if (!response.ok || payload.success === false) {
+        throw new Error(payload.errors?.[0]?.message ?? `Queue request failed with ${response.status}.`);
+      }
+    }
+  };
+}
+function queueEnvelopeForTask(task) {
+  return {
+    messageId: crypto.randomUUID(),
+    taskId: String(task.id ?? ""),
+    workDayId: String(task.workDayId ?? task.work_day_id ?? ""),
+    agentId: String(task.agentId ?? task.agent_id ?? ""),
+    taskType: String(task.type ?? ""),
+    idempotencyKey: String(task.idempotencyKey ?? task.idempotency_key ?? ""),
+    attempt: Number(task.attemptCount ?? task.attempt_count ?? 0) + 1,
+    payloadRef: `d1:tasks/${String(task.id ?? "")}`,
+    graphVersion: task.graphVersion !== void 0 && task.graphVersion !== null ? String(task.graphVersion) : task.graph_version !== void 0 && task.graph_version !== null ? String(task.graph_version) : null,
+    budgetHint: 1
+  };
+}
+async function enqueueTaskFromSdk(sdk, request) {
+  const queue = createQueuePushClient();
+  if (!queue) {
+    throw new Error("Queue push client not configured.");
+  }
+  const task = await sdk.get({ model: "task", id: request.taskId });
+  if (!task.payload) {
+    throw new Error("Unknown task.");
+  }
+  await queue.enqueue({
+    message: queueEnvelopeForTask(task.payload),
+    delaySeconds: request.deliveryDelaySeconds ?? 0
+  });
+  await sdk.recordTaskProgress({
+    id: request.taskId,
+    state: "queued",
+    appendEvent: { kind: "queued", data: { queueName: request.queueName ?? null } },
+    actor: request.actor
+  });
+  return { ok: true, taskId: request.taskId, queued: true };
+}
+async function buildTaskContext(sdk, taskId) {
+  const context = await sdk.getManagerContext(taskId);
+  const task = context.payload.task;
+  const agent = task ? (await sdk.get({ model: "agent", slug: String(task.agentId) })).payload : null;
+  return {
+    ...context.payload,
+    agent
+  };
+}
+async function seedRootTasks(sdk, workDayId) {
+  const specs = await sdk.listAgentSpecs({ enabled: true });
+  const created = [];
+  for (const spec of specs) {
+    const hasStartTrigger = spec.triggers.some((trigger) => trigger.type === "startup" || trigger.type === "schedule");
+    if (!hasStartTrigger) continue;
+    created.push(await sdk.createTask({
+      workDayId,
+      agentId: spec.slug,
+      type: "agent_root",
+      priority: 100,
+      idempotencyKey: `${workDayId}:${spec.slug}:root`,
+      payload: {
+        agentSlug: spec.slug,
+        handler: spec.handler,
+        triggerKinds: spec.triggers.map((entry) => entry.type)
+      },
+      graphVersion: null,
+      actor: "manager"
+    }));
+  }
+  return created;
+}
+async function seedGraphRefreshTask(sdk, request) {
+  const task = await sdk.createTask({
+    workDayId: request.workDayId,
+    agentId: "system",
+    type: "refresh_project_graph",
+    priority: 1e3,
+    idempotencyKey: `${request.workDayId}:refresh_project_graph`,
+    payload: {
+      projectId: request.projectId,
+      repositoryId: request.repositoryId ?? request.projectId
+    },
+    graphVersion: null,
+    actor: request.actor ?? "manager"
+  });
+  return task.payload;
+}
+async function startAndSeedWorkday(sdk, request) {
+  const workDay = await sdk.startWorkDay({
+    id: request.id,
+    projectId: request.projectId,
+    capacityBudget: request.capacityBudget,
+    graphVersion: null,
+    summary: { graphRefresh: { state: "queued" } },
+    actor: request.actor ?? "manager"
+  });
+  const graphTask = workDay.payload ? await seedGraphRefreshTask(sdk, {
+    workDayId: String(workDay.payload.id),
+    projectId: request.projectId,
+    actor: request.actor ?? "manager"
+  }) : null;
+  const tasks = workDay.payload ? await seedRootTasks(sdk, String(workDay.payload.id)) : [];
+  return {
+    ok: true,
+    workDay: workDay.payload,
+    seededTasks: [graphTask, ...tasks.map((entry) => entry.payload).filter(Boolean)].filter(Boolean)
+  };
+}
+function resolveManagerConfig() {
+  return {
+    host: process.env.HOST?.trim() || "0.0.0.0",
+    port: integerFromEnv("PORT", 3100),
+    projectId: process.env.TREESEED_PROJECT_ID?.trim() || "treeseed-market",
+    defaultCapacityBudget: integerFromEnv("TREESEED_WORKDAY_CAPACITY_BUDGET", 100)
+  };
+}
+function resolveWorkerConfig() {
+  return {
+    workerId: process.env.TREESEED_WORKER_ID?.trim() || `worker-${process.pid}`,
+    batchSize: integerFromEnv("TREESEED_QUEUE_BATCH_SIZE", integerFromEnv("TREESEED_RUNNER_MAX_LOCAL_WORKERS", 4)),
+    maxLocalWorkers: integerFromEnv("TREESEED_RUNNER_MAX_LOCAL_WORKERS", 4),
+    runnerServiceName: process.env.TREESEED_RUNNER_SERVICE_NAME?.trim() || process.env.RAILWAY_SERVICE_NAME?.trim() || `worker-runner-${process.pid}`,
+    volumeRoot: process.env.TREESEED_RUNNER_VOLUME_ROOT?.trim() || process.env.RAILWAY_VOLUME_MOUNT_PATH?.trim() || ".treeseed-runner",
+    volumeIdentity: process.env.TREESEED_RUNNER_VOLUME_ID?.trim() || process.env.RAILWAY_VOLUME_ID?.trim() || process.env.RAILWAY_VOLUME_NAME?.trim() || "local-runner-volume",
+    projectId: process.env.TREESEED_PROJECT_ID?.trim() || "treeseed-market",
+    environment: process.env.TREESEED_DEPLOY_ENVIRONMENT?.trim() || (process.env.NODE_ENV === "production" ? "prod" : "local"),
+    visibilityTimeoutMs: integerFromEnv("TREESEED_QUEUE_VISIBILITY_TIMEOUT_MS", 12e4),
+    pollIntervalMs: integerFromEnv("TREESEED_WORKER_POLL_INTERVAL_MS", 5e3),
+    idleExitMs: integerFromEnv("TREESEED_WORKER_IDLE_EXIT_MS", 0),
+    leaseSeconds: integerFromEnv("TREESEED_TASK_LEASE_SECONDS", 120)
+  };
+}
+export {
+  buildTaskContext,
+  createQueueClient,
+  createQueuePushClient,
+  createServiceSdk,
+  enqueueTaskFromSdk,
+  queueEnvelopeForTask,
+  resolveManagerConfig,
+  resolveServiceRepoRoot,
+  resolveWorkerConfig,
+  seedGraphRefreshTask,
+  seedRootTasks,
+  startAndSeedWorkday
+};

package/dist/services/index.d.ts

@@ -0,0 +1,6 @@
+export { runManagerAction, runManagerCycle, startManagerLoop } from './manager.ts';
+export { runWorkerCycle, startWorkerLoop } from './worker.ts';
+export { runScheduledWorkdayManager } from './workday-manager.ts';
+export { runWorkdayStart } from './workday-start.ts';
+export { runWorkdayReport } from './workday-report.ts';
+export { createWorkerPoolScaler, RailwayWorkerPoolScaler, NoopWorkerPoolScaler } from './worker-pool-scaler.ts';

package/dist/services/index.js

@@ -0,0 +1,19 @@
+import { runManagerAction, runManagerCycle, startManagerLoop } from "./manager.js";
+import { runWorkerCycle, startWorkerLoop } from "./worker.js";
+import { runScheduledWorkdayManager } from "./workday-manager.js";
+import { runWorkdayStart } from "./workday-start.js";
+import { runWorkdayReport } from "./workday-report.js";
+import { createWorkerPoolScaler, RailwayWorkerPoolScaler, NoopWorkerPoolScaler } from "./worker-pool-scaler.js";
+export {
+  NoopWorkerPoolScaler,
+  RailwayWorkerPoolScaler,
+  createWorkerPoolScaler,
+  runManagerAction,
+  runManagerCycle,
+  runScheduledWorkdayManager,
+  runWorkdayReport,
+  runWorkdayStart,
+  runWorkerCycle,
+  startManagerLoop,
+  startWorkerLoop
+};

package/dist/services/manager.d.ts

@@ -0,0 +1,333 @@
+#!/usr/bin/env node
+import { type ControlPlaneReporter, type PrioritySnapshot, type PrioritySnapshotItem, type ProjectEnvironmentName, type ScaleDecision, type WorkdayPolicy, type WorkdaySchedule, type WorkerPoolScaleResult, type WorkerPoolScaler } from '@treeseed/sdk';
+import { createServiceSdk } from './common.ts';
+import { type WorkerPoolScalerKind } from './worker-pool-scaler.ts';
+type ManagerSdk = ReturnType<typeof createServiceSdk>;
+type ManagerMode = 'reconcile' | 'open-workday' | 'close-workday' | 'report-workday' | 'loop';
+type ManagerConfig = ReturnType<typeof resolveManagerServiceConfig>;
+type TaskRecord = Record<string, unknown>;
+export declare function resolveManagerServiceConfig(): {
+    mode: ManagerMode;
+    managerId: string;
+    marketBaseUrl: string;
+    runnerToken: string;
+    projectId: string;
+    teamId: string;
+    environment: ProjectEnvironmentName | "local";
+    poolName: string;
+    serviceBaseUrl: string | null;
+    pollIntervalMs: number;
+    dailyTaskCreditBudget: number;
+    maxQueuedTasks: number;
+    maxQueuedCredits: number;
+    priorityModels: string[];
+    priorityLimitPerModel: number;
+    graphInvalidated: boolean;
+    defaultSchedule: WorkdaySchedule;
+    scalerKind: WorkerPoolScalerKind | null;
+    creditWeights: import("@treeseed/sdk").TaskCreditWeight[];
+    autoscale: {
+        minWorkers: number;
+        maxWorkers: number;
+        targetQueueDepth: number;
+        cooldownSeconds: number;
+    };
+    host: string;
+    port: number;
+    defaultCapacityBudget: number;
+};
+export declare function runManagerAction(options?: {
+    mode?: ManagerMode;
+    sdk?: ManagerSdk;
+    config?: ManagerConfig;
+    reporter?: ControlPlaneReporter;
+    scaler?: WorkerPoolScaler;
+    now?: Date;
+}): Promise<{
+    ok: boolean;
+    mode: "reconcile";
+    managerId: string;
+    projectId: string;
+    environment: "local" | "staging" | "prod";
+    insideWorkWindow: boolean;
+    workPolicy: WorkdayPolicy;
+    workDay: null;
+    prioritySnapshot: null;
+    seededTasks: never[];
+    queuedCount: number;
+    activeLeases: number;
+    desiredWorkers: number;
+    scaleResult: {
+        applied: boolean;
+        provider: string;
+        desiredWorkers: number;
+        metadata: {
+            reason: string;
+        };
+    };
+    workdaySummary: null;
+} | {
+    ok: boolean;
+    mode: "reconcile";
+    managerId: string;
+    projectId: string;
+    environment: "local" | "staging" | "prod";
+    insideWorkWindow: boolean;
+    workPolicy: WorkdayPolicy;
+    workDay: Record<string, unknown>;
+    prioritySnapshot: PrioritySnapshot | null;
+    seededTasks: TaskRecord[];
+    queuedCount: number;
+    activeLeases: number;
+    desiredWorkers: number;
+    scaleResult: WorkerPoolScaleResult;
+    workdaySummary: Record<string, unknown> | null;
+} | {
+    ok: boolean;
+    created: boolean;
+    workDay: Record<string, unknown>;
+    skipped?: undefined;
+    reason?: undefined;
+    prioritySnapshot?: undefined;
+} | {
+    ok: boolean;
+    created: boolean;
+    skipped: boolean;
+    reason: string;
+    workDay?: undefined;
+    prioritySnapshot?: undefined;
+} | {
+    ok: boolean;
+    created: boolean;
+    workDay: import("@treeseed/sdk").SdkWorkDayEntity | null;
+    prioritySnapshot: PrioritySnapshot | null;
+    skipped?: undefined;
+    reason?: undefined;
+} | {
+    ok: boolean;
+    skipped: boolean;
+    reason: string;
+    workDay?: undefined;
+    summary?: undefined;
+    scale?: undefined;
+} | {
+    ok: boolean;
+    workDay: import("@treeseed/sdk").SdkWorkDayEntity | null;
+    summary: {
+        contentSnapshot: {
+            relativePath: string;
+            slug: string;
+            reportVersion: string;
+            title: string;
+        };
+        capacity: {
+            providerSplit: {
+                providerId: string;
+                laneId: string;
+                state: import("@treeseed/sdk/types").CapacityReservationState;
+                reservedCredits: number;
+                consumedCredits: number;
+                reservedProviderUnits: number | null;
+                consumedProviderUnits: number | null;
+                reservedUsd: number | null;
+                consumedUsd: number | null;
+            }[];
+            grantedDailyCredits: number;
+            reservedCredits: number;
+            consumedCredits: number;
+            remainingDailyCredits: number | null;
+            providerCount: number;
+            laneCount: number;
+            grantCount: number;
+        } | null;
+        projectId: string;
+        environment: "local" | "staging" | "prod";
+        workDayId: string;
+        state: string;
+        totalTasks: number;
+        completedTasks: number;
+        failedTasks: number;
+        queuedTasks: number;
+        activeTasks: number;
+        dailyTaskCreditBudget: number;
+        usedTaskCredits: number;
+        remainingTaskCredits: number;
+        creditLedgerEntries: number;
+        prioritySnapshotId: string | null;
+        priorityItemCount: number;
+        priorityItems: PrioritySnapshotItem[];
+        taskItems: {
+            id: string;
+            agentId: string | undefined;
+            type: string | undefined;
+            state: string | undefined;
+            priority: number | undefined;
+            idempotencyKey: string | undefined;
+            createdAt: string | null;
+            startedAt: string | null;
+            completedAt: string | null;
+            lastErrorCode: string | null;
+            lastErrorMessage: string | null;
+            lastEventKind: string | null;
+            outputCount: number;
+            changedFiles: string[];
+        }[];
+        changedFiles: string[];
+        releases: {
+            id: string | undefined;
+            deploymentKind: string;
+            status: string;
+            releaseTag: string | null;
+            commitSha: string | null;
+            sourceRef: string | null;
+            startedAt: string | null;
+            finishedAt: string | null;
+            createdAt: string | null;
+        }[];
+        scaleDecision: ScaleDecision;
+        scaleResult: WorkerPoolScaleResult;
+        generatedAt: string;
+    };
+    scale: WorkerPoolScaleResult;
+    skipped?: undefined;
+    reason?: undefined;
+} | {
+    ok: boolean;
+    skipped: boolean;
+    reason: string;
+    workDayId?: undefined;
+    summary?: undefined;
+} | {
+    ok: boolean;
+    workDayId: unknown;
+    summary: {
+        contentSnapshot: {
+            relativePath: string;
+            slug: string;
+            reportVersion: string;
+            title: string;
+        };
+        capacity: {
+            providerSplit: {
+                providerId: string;
+                laneId: string;
+                state: import("@treeseed/sdk/types").CapacityReservationState;
+                reservedCredits: number;
+                consumedCredits: number;
+                reservedProviderUnits: number | null;
+                consumedProviderUnits: number | null;
+                reservedUsd: number | null;
+                consumedUsd: number | null;
+            }[];
+            grantedDailyCredits: number;
+            reservedCredits: number;
+            consumedCredits: number;
+            remainingDailyCredits: number | null;
+            providerCount: number;
+            laneCount: number;
+            grantCount: number;
+        } | null;
+        projectId: string;
+        environment: "local" | "staging" | "prod";
+        workDayId: string;
+        state: string;
+        totalTasks: number;
+        completedTasks: number;
+        failedTasks: number;
+        queuedTasks: number;
+        activeTasks: number;
+        dailyTaskCreditBudget: number;
+        usedTaskCredits: number;
+        remainingTaskCredits: number;
+        creditLedgerEntries: number;
+        prioritySnapshotId: string | null;
+        priorityItemCount: number;
+        priorityItems: PrioritySnapshotItem[];
+        taskItems: {
+            id: string;
+            agentId: string | undefined;
+            type: string | undefined;
+            state: string | undefined;
+            priority: number | undefined;
+            idempotencyKey: string | undefined;
+            createdAt: string | null;
+            startedAt: string | null;
+            completedAt: string | null;
+            lastErrorCode: string | null;
+            lastErrorMessage: string | null;
+            lastEventKind: string | null;
+            outputCount: number;
+            changedFiles: string[];
+        }[];
+        changedFiles: string[];
+        releases: {
+            id: string | undefined;
+            deploymentKind: string;
+            status: string;
+            releaseTag: string | null;
+            commitSha: string | null;
+            sourceRef: string | null;
+            startedAt: string | null;
+            finishedAt: string | null;
+            createdAt: string | null;
+        }[];
+        scaleDecision: ScaleDecision;
+        scaleResult: WorkerPoolScaleResult;
+        generatedAt: string;
+    };
+    skipped?: undefined;
+    reason?: undefined;
+}>;
+export declare function runManagerCycle(options?: {
+    sdk?: ManagerSdk;
+    config?: ManagerConfig;
+    reporter?: ControlPlaneReporter;
+    scaler?: WorkerPoolScaler;
+    now?: Date;
+}): Promise<{
+    ok: boolean;
+    mode: "reconcile";
+    managerId: string;
+    projectId: string;
+    environment: "local" | "staging" | "prod";
+    insideWorkWindow: boolean;
+    workPolicy: WorkdayPolicy;
+    workDay: null;
+    prioritySnapshot: null;
+    seededTasks: never[];
+    queuedCount: number;
+    activeLeases: number;
+    desiredWorkers: number;
+    scaleResult: {
+        applied: boolean;
+        provider: string;
+        desiredWorkers: number;
+        metadata: {
+            reason: string;
+        };
+    };
+    workdaySummary: null;
+} | {
+    ok: boolean;
+    mode: "reconcile";
+    managerId: string;
+    projectId: string;
+    environment: "local" | "staging" | "prod";
+    insideWorkWindow: boolean;
+    workPolicy: WorkdayPolicy;
+    workDay: Record<string, unknown>;
+    prioritySnapshot: PrioritySnapshot | null;
+    seededTasks: TaskRecord[];
+    queuedCount: number;
+    activeLeases: number;
+    desiredWorkers: number;
+    scaleResult: WorkerPoolScaleResult;
+    workdaySummary: Record<string, unknown> | null;
+}>;
+export declare function startManagerLoop(options?: {
+    sdk?: ManagerSdk;
+    config?: ManagerConfig;
+    reporter?: ControlPlaneReporter;
+    scaler?: WorkerPoolScaler;
+}): Promise<void>;
+export {};