@treeseed/agent 0.8.5

package/dist/services/remote-runner.d.ts

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+import { AgentSdk } from '@treeseed/sdk';
+export declare function resolveRemoteRunnerConfig(): {
+    marketBaseUrl: string;
+    projectId: string;
+    runnerToken: string;
+    runnerId: string;
+    batchSize: number;
+    pollIntervalMs: number;
+};
+export declare function runRemoteRunnerCycle(options?: {
+    sdk?: AgentSdk;
+    config?: ReturnType<typeof resolveRemoteRunnerConfig>;
+    fetchImpl?: typeof fetch;
+}): Promise<{
+    ok: boolean;
+    processed: number;
+    idle: boolean;
+    reason: string;
+} | {
+    ok: boolean;
+    processed: number;
+    idle?: undefined;
+    reason?: undefined;
+}>;
+export declare function startRemoteRunnerLoop(options?: {
+    sdk?: AgentSdk;
+    config?: ReturnType<typeof resolveRemoteRunnerConfig>;
+    fetchImpl?: typeof fetch;
+}): Promise<void>;

package/dist/services/remote-runner.js

@@ -0,0 +1,230 @@
+#!/usr/bin/env node
+import { fileURLToPath } from "node:url";
+import { RemoteTreeseedClient, RemoteTreeseedRunnerClient, TreeseedOperationsSdk } from "@treeseed/sdk";
+import { createServiceSdk } from "./common.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 resolveRemoteRunnerConfig() {
+  return {
+    marketBaseUrl: envValue("TREESEED_MARKET_API_BASE_URL") || envValue("TREESEED_API_BASE_URL"),
+    projectId: envValue("TREESEED_PROJECT_ID") || "treeseed-market",
+    runnerToken: envValue("TREESEED_PROJECT_RUNNER_TOKEN"),
+    runnerId: envValue("TREESEED_REMOTE_RUNNER_ID") || `remote-runner-${process.pid}`,
+    batchSize: integerFromEnv("TREESEED_REMOTE_RUNNER_BATCH_SIZE", 1),
+    pollIntervalMs: integerFromEnv("TREESEED_REMOTE_RUNNER_POLL_INTERVAL_MS", 5e3)
+  };
+}
+function createRunnerClient(config, fetchImpl) {
+  if (!config.marketBaseUrl || !config.runnerToken) {
+    if (process.env.TREESEED_LOCAL_DEV_MODE?.trim()) {
+      return null;
+    }
+    throw new Error(
+      "Remote runner requires TREESEED_MARKET_API_BASE_URL (or TREESEED_API_BASE_URL) and TREESEED_PROJECT_RUNNER_TOKEN."
+    );
+  }
+  return new RemoteTreeseedRunnerClient(new RemoteTreeseedClient({
+    hosts: [{ id: "market", baseUrl: config.marketBaseUrl }],
+    activeHostId: "market",
+    auth: {
+      accessToken: config.runnerToken
+    }
+  }, {
+    fetchImpl
+  }));
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function runnerWorkspacePaths(projectId) {
+  const volumeRoot = envValue("TREESEED_WORKER_VOLUME_ROOT") || "/data";
+  const workspaceRoot = `${volumeRoot}/workspaces/${projectId}`;
+  return {
+    root: workspaceRoot,
+    site: `${workspaceRoot}/site`,
+    content: `${workspaceRoot}/content`,
+    parent: `${workspaceRoot}/workspace-root`
+  };
+}
+function inputForRunnerJob(job) {
+  const input = asRecord(job.input);
+  if (job.namespace !== "content" || job.operation !== "publish") {
+    return input;
+  }
+  const paths = runnerWorkspacePaths(job.projectId);
+  return {
+    ...input,
+    tenantRoot: typeof input.tenantRoot === "string" ? input.tenantRoot : paths.site,
+    contentRepositoryRoot: typeof input.contentRepositoryRoot === "string" ? input.contentRepositoryRoot : paths.content,
+    workspaceRoot: typeof input.workspaceRoot === "string" ? input.workspaceRoot : paths.root
+  };
+}
+async function prepareLaunchIntentWithCredentialSessions(runner, jobId, launchJobInput, launchIntent) {
+  const sessions = asRecord(launchJobInput.credentialSessions);
+  const nextIntent = JSON.parse(JSON.stringify(launchIntent));
+  const execution = asRecord(nextIntent.execution);
+  const providerLaunchInput = asRecord(execution.providerLaunchInput);
+  const envOverlay = {};
+  const consume = async (key) => {
+    const sessionId = typeof sessions[key] === "string" ? sessions[key].trim() : "";
+    if (!sessionId || !runner) return null;
+    return (await runner.consumeCredentialSession(jobId, sessionId)).payload;
+  };
+  const repositorySession = await consume("repositoryHost");
+  if (repositorySession?.config) {
+    const token = repositorySession.config.GH_TOKEN ?? repositorySession.config.GITHUB_TOKEN;
+    if (token) {
+      envOverlay.GH_TOKEN = token;
+      envOverlay.GITHUB_TOKEN = repositorySession.config.GITHUB_TOKEN ?? token;
+    }
+    const owner = repositorySession.config.organizationOrOwner ?? repositorySession.config.owner;
+    if (owner) {
+      nextIntent.repository = {
+        ...asRecord(nextIntent.repository),
+        owner
+      };
+      providerLaunchInput.repoOwner = owner;
+    }
+  }
+  const webSession = await consume("webHost");
+  if (webSession?.config) {
+    providerLaunchInput.cloudflareHost = {
+      ...asRecord(providerLaunchInput.cloudflareHost),
+      config: webSession.config
+    };
+  }
+  const processingSession = await consume("processingHost");
+  if (processingSession?.config) {
+    providerLaunchInput.processingHost = {
+      ...asRecord(providerLaunchInput.processingHost),
+      config: processingSession.config
+    };
+  }
+  nextIntent.execution = {
+    ...execution,
+    providerLaunchInput
+  };
+  return { intent: nextIntent, envOverlay };
+}
+async function runRemoteRunnerCycle(options = {}) {
+  const config = options.config ?? resolveRemoteRunnerConfig();
+  const sdk = options.sdk ?? createServiceSdk();
+  const runner = createRunnerClient(config, options.fetchImpl);
+  if (!runner) {
+    return { ok: true, processed: 0, idle: true, reason: "registration_unconfigured" };
+  }
+  const pulled = await runner.pull(config.projectId, {
+    limit: config.batchSize,
+    runnerId: config.runnerId
+  });
+  if (pulled.payload.length === 0) {
+    return { ok: true, processed: 0 };
+  }
+  let processed = 0;
+  for (const job of pulled.payload) {
+    try {
+      await runner.progress(job.id, {
+        summary: `Running ${job.namespace}:${job.operation}`,
+        data: {
+          runnerId: config.runnerId,
+          status: "running"
+        }
+      });
+      const launchJobInput = job.input && typeof job.input === "object" ? job.input : {};
+      const launchIntent = launchJobInput.launchIntent && typeof launchJobInput.launchIntent === "object" ? launchJobInput.launchIntent : launchJobInput;
+      const isLaunchJob = job.namespace === "workflow" && job.operation === "launch_project";
+      if (isLaunchJob) {
+        await runner.progress(job.id, {
+          summary: "Validating launch plan and preparing repository topology.",
+          data: {
+            runnerId: config.runnerId,
+            phase: "preflight_running",
+            status: "running",
+            title: "Validating launch plan"
+          }
+        });
+      }
+      const preparedLaunch = isLaunchJob ? await prepareLaunchIntentWithCredentialSessions(runner, job.id, launchJobInput, launchIntent) : null;
+      const result = isLaunchJob ? await new TreeseedOperationsSdk().execute({
+        operationName: launchJobInput.resume === true ? "hub.resume_launch" : "hub.execute_launch",
+        input: preparedLaunch?.intent ?? launchIntent
+      }, {
+        cwd: process.env.TREESEED_MARKET_REPO_ROOT?.trim() || process.cwd(),
+        env: {
+          ...process.env,
+          ...preparedLaunch?.envOverlay ?? {}
+        },
+        transport: "sdk",
+        onProgress: async (event) => {
+          if (event.kind !== "hub_launch_phase") return;
+          await runner.progress(job.id, {
+            summary: typeof event.summary === "string" ? event.summary : null,
+            data: {
+              ...event,
+              runnerId: config.runnerId
+            }
+          });
+        }
+      }) : await sdk.dispatch({
+        namespace: job.namespace,
+        operation: job.operation,
+        input: inputForRunnerJob(job),
+        preferredMode: "prefer_local"
+      });
+      if (isLaunchJob) {
+        await runner.progress(job.id, {
+          summary: "Launch execution completed; applying control-plane projections.",
+          data: {
+            runnerId: config.runnerId,
+            phase: "projection_running",
+            status: "running",
+            title: "Recording launch result"
+          }
+        });
+      }
+      await runner.complete(job.id, {
+        output: result.mode === "inline" ? result.payload : result
+      });
+      processed += 1;
+    } catch (error) {
+      await runner.fail(job.id, {
+        code: "runner_execution_failed",
+        message: error instanceof Error ? error.message : String(error)
+      }).catch(() => null);
+    }
+  }
+  return { ok: true, processed };
+}
+async function startRemoteRunnerLoop(options = {}) {
+  const config = options.config ?? resolveRemoteRunnerConfig();
+  for (; ; ) {
+    try {
+      await runRemoteRunnerCycle({
+        ...options,
+        config
+      });
+    } catch (error) {
+      process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+    }
+    await new Promise((resolvePromise) => setTimeout(resolvePromise, config.pollIntervalMs));
+  }
+}
+const currentFile = fileURLToPath(import.meta.url);
+const entryFile = process.argv[1] ?? "";
+if (entryFile === currentFile) {
+  await startRemoteRunnerLoop();
+}
+export {
+  resolveRemoteRunnerConfig,
+  runRemoteRunnerCycle,
+  startRemoteRunnerLoop
+};

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

@@ -0,0 +1,53 @@
+import type { PrioritySnapshot, ScaleDecision, WorkerPoolScaleResult } from '@treeseed/sdk';
+type JsonRecord = Record<string, unknown>;
+export interface WorkdayContentTaskSummary {
+    id: string;
+    agentId?: string;
+    type?: string;
+    state?: string;
+    priority?: number;
+    idempotencyKey?: string;
+    createdAt?: string | null;
+    startedAt?: string | null;
+    completedAt?: string | null;
+    lastErrorCode?: string | null;
+    lastErrorMessage?: string | null;
+    lastEventKind?: string | null;
+    outputCount?: number;
+    changedFiles?: string[];
+}
+export interface WorkdayContentReleaseRecord {
+    id?: string;
+    deploymentKind: string;
+    status: string;
+    releaseTag?: string | null;
+    commitSha?: string | null;
+    sourceRef?: string | null;
+    startedAt?: string | null;
+    finishedAt?: string | null;
+    createdAt?: string | null;
+}
+export interface WorkdayContentSnapshotInput {
+    repoRoot: string;
+    projectId: string;
+    teamId: string;
+    environment: string;
+    workDay: JsonRecord;
+    summary: JsonRecord;
+    prioritySnapshot: PrioritySnapshot | null;
+    scaleDecision: ScaleDecision;
+    scaleResult: WorkerPoolScaleResult;
+    tasks: WorkdayContentTaskSummary[];
+    changedFiles: string[];
+    releases: WorkdayContentReleaseRecord[];
+    generatedAt: string;
+}
+export interface WorkdayContentSnapshotResult {
+    filePath: string;
+    relativePath: string;
+    slug: string;
+    reportVersion: string;
+    title: string;
+}
+export declare function writeWorkdayContentSnapshot(input: WorkdayContentSnapshotInput): WorkdayContentSnapshotResult;
+export {};

package/dist/services/workday-content.js

@@ -0,0 +1,190 @@
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { relative, resolve } from "node:path";
+import { stringify as stringifyYaml } from "yaml";
+function stableHash(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function sanitizeSegment(value, fallback) {
+  const normalized = value.trim().replaceAll(/[\\/]+/g, "-").replaceAll(/[^a-zA-Z0-9._-]+/g, "-").replaceAll(/-+/g, "-").replaceAll(/^-|-$/g, "");
+  return normalized || fallback;
+}
+function compactTimestamp(value) {
+  return value.replaceAll(/[-:]/g, "").replace(/\.\d{3}Z$/u, "Z");
+}
+function toIsoDate(value) {
+  if (typeof value !== "string" || !value.trim()) {
+    return null;
+  }
+  const parsed = new Date(value);
+  return Number.isFinite(parsed.valueOf()) ? parsed.toISOString() : null;
+}
+function bodySummary(summary) {
+  return typeof summary.summary === "string" && summary.summary.trim() ? summary.summary.trim() : `Completed ${Number(summary.completedTasks ?? 0)} tasks, with ${Number(summary.failedTasks ?? 0)} failures and ${Number(summary.remainingTaskCredits ?? 0)} remaining task credits.`;
+}
+function renderTasks(tasks) {
+  if (tasks.length === 0) {
+    return "- No tasks were recorded.\n";
+  }
+  return tasks.map((task) => {
+    const suffix = [
+      task.state ? `state: ${task.state}` : null,
+      task.agentId ? `agent: ${task.agentId}` : null,
+      Number.isFinite(task.priority) ? `priority: ${task.priority}` : null,
+      task.lastEventKind ? `last event: ${task.lastEventKind}` : null,
+      task.outputCount ? `outputs: ${task.outputCount}` : null
+    ].filter(Boolean).join(", ");
+    return `- \`${task.id}\` ${task.type ?? "task"}${suffix ? ` (${suffix})` : ""}`;
+  }).join("\n") + "\n";
+}
+function renderChangedFiles(changedFiles) {
+  if (changedFiles.length === 0) {
+    return "- No changed files were reported by task outputs.\n";
+  }
+  return changedFiles.map((filePath) => `- \`${filePath}\``).join("\n") + "\n";
+}
+function renderReleases(releases) {
+  if (releases.length === 0) {
+    return "- No releases or deployments were recorded during this workday.\n";
+  }
+  return releases.map((release) => {
+    const label = release.releaseTag || release.commitSha || release.id || release.deploymentKind;
+    const details = [release.deploymentKind, release.status, release.sourceRef].filter(Boolean).join(", ");
+    return `- \`${label}\`${details ? ` (${details})` : ""}`;
+  }).join("\n") + "\n";
+}
+function renderPriorityItems(snapshot) {
+  if (!snapshot?.items?.length) {
+    return "- No priority snapshot items were captured.\n";
+  }
+  return snapshot.items.map((item) => {
+    const details = [
+      item.model,
+      Number.isFinite(item.priority) ? `priority: ${item.priority}` : null,
+      Number.isFinite(item.estimatedCredits) ? `credits: ${item.estimatedCredits}` : null
+    ].filter(Boolean).join(", ");
+    return `- \`${item.id}\`${item.title ? ` ${item.title}` : ""}${details ? ` (${details})` : ""}`;
+  }).join("\n") + "\n";
+}
+function buildMarkdownBody(input) {
+  const summaryText = bodySummary(input.summary);
+  return [
+    summaryText,
+    "",
+    "## Budget",
+    "",
+    `- Daily task-credit budget: ${Number(input.summary.dailyTaskCreditBudget ?? 0)}`,
+    `- Used task credits: ${Number(input.summary.usedTaskCredits ?? 0)}`,
+    `- Remaining task credits: ${Number(input.summary.remainingTaskCredits ?? 0)}`,
+    `- Credit ledger entries: ${Number(input.summary.creditLedgerEntries ?? 0)}`,
+    "",
+    "## Priority Plan",
+    "",
+    renderPriorityItems(input.prioritySnapshot).trimEnd(),
+    "",
+    "## Tasks",
+    "",
+    renderTasks(input.tasks).trimEnd(),
+    "",
+    "## Changed Files",
+    "",
+    renderChangedFiles(input.changedFiles).trimEnd(),
+    "",
+    "## Releases",
+    "",
+    renderReleases(input.releases).trimEnd(),
+    "",
+    "## Final Status",
+    "",
+    `- Workday state: ${String(input.workDay.state ?? "completed")}`,
+    `- Desired workers: ${Number(input.scaleDecision.desiredWorkers ?? 0)}`,
+    `- Queue depth at report: ${Number(input.scaleDecision.observedQueueDepth ?? 0)}`,
+    `- Active leases at report: ${Number(input.scaleDecision.observedActiveLeases ?? 0)}`,
+    `- Scale provider: ${input.scaleResult.provider}`,
+    ""
+  ].join("\n");
+}
+function writeWorkdayContentSnapshot(input) {
+  const outputRoot = resolve(input.repoRoot, "src/content/workdays");
+  mkdirSync(outputRoot, { recursive: true });
+  const workDayId = String(input.workDay.id ?? "workday");
+  const startedAt = toIsoDate(input.workDay.startedAt ?? input.workDay.started_at) ?? input.generatedAt;
+  const endedAt = toIsoDate(input.workDay.endedAt ?? input.workDay.ended_at);
+  const generatedAt = toIsoDate(input.generatedAt) ?? (/* @__PURE__ */ new Date()).toISOString();
+  const datePart = (startedAt || generatedAt).slice(0, 10);
+  const slugBase = `${datePart}/${sanitizeSegment(workDayId, "workday")}`;
+  const identityHash = stableHash(JSON.stringify({
+    workDayId,
+    generatedAt,
+    summary: input.summary,
+    changedFiles: input.changedFiles,
+    releases: input.releases
+  })).slice(0, 8);
+  const reportVersion = `${compactTimestamp(generatedAt)}-${identityHash}`;
+  const title = `Workday ${workDayId} Report ${generatedAt.slice(0, 10)}`;
+  const slug = `workdays/${slugBase}/${reportVersion}`;
+  const frontmatter = {
+    title,
+    slug,
+    workDayId,
+    reportVersion,
+    reportKind: "workday_summary",
+    projectId: input.projectId,
+    teamId: input.teamId,
+    environment: input.environment,
+    status: "live",
+    visibility: "team",
+    workdayState: String(input.workDay.state ?? "completed"),
+    startedAt,
+    endedAt,
+    generatedAt,
+    createdAt: generatedAt,
+    summary: bodySummary(input.summary),
+    dailyTaskCreditBudget: Number(input.summary.dailyTaskCreditBudget ?? 0),
+    usedTaskCredits: Number(input.summary.usedTaskCredits ?? 0),
+    remainingTaskCredits: Number(input.summary.remainingTaskCredits ?? 0),
+    creditLedgerEntries: Number(input.summary.creditLedgerEntries ?? 0),
+    prioritySnapshotId: input.prioritySnapshot?.id ?? null,
+    priorityItemCount: input.prioritySnapshot?.items.length ?? 0,
+    priorityItems: input.prioritySnapshot?.items ?? [],
+    totalTasks: Number(input.summary.totalTasks ?? input.tasks.length),
+    completedTasks: Number(input.summary.completedTasks ?? 0),
+    failedTasks: Number(input.summary.failedTasks ?? 0),
+    queuedTasks: Number(input.summary.queuedTasks ?? 0),
+    activeTasks: Number(input.summary.activeTasks ?? 0),
+    taskItems: input.tasks,
+    changedFiles: input.changedFiles,
+    releases: input.releases,
+    scaleDecision: input.scaleDecision,
+    scaleResult: input.scaleResult,
+    metadata: {
+      source: "manager",
+      projectId: input.projectId
+    }
+  };
+  const markdownBody = buildMarkdownBody(input);
+  let fileName = `${datePart}-${sanitizeSegment(workDayId, "workday")}--${reportVersion}.mdx`;
+  let filePath = resolve(outputRoot, fileName);
+  let duplicateCounter = 1;
+  while (existsSync(filePath)) {
+    fileName = `${datePart}-${sanitizeSegment(workDayId, "workday")}--${reportVersion}-${duplicateCounter}.mdx`;
+    filePath = resolve(outputRoot, fileName);
+    duplicateCounter += 1;
+  }
+  const document = `---
+${stringifyYaml(frontmatter).trimEnd()}
+---
+
+${markdownBody}`;
+  writeFileSync(filePath, document, "utf8");
+  return {
+    filePath,
+    relativePath: relative(input.repoRoot, filePath).replaceAll("\\", "/"),
+    slug,
+    reportVersion,
+    title
+  };
+}
+export {
+  writeWorkdayContentSnapshot
+};