@truefoundry/trueforge 0.2.0-rc.3 → 0.2.0-rc.5

package/dist/controller-main.js

@@ -16,6 +16,7 @@ var DEFAULT_POSTGRES_DB = "trueforge";
 var DEFAULT_POSTGRES_HOST = "localhost";
 var DEFAULT_POSTGRES_PORT = 5432;
 var DEFAULT_REDIS_URL = "redis://localhost:6379";
+var STANDALONE_TRUEFORGE_API_KEY = "trueforge-standalone";
 var DEFAULT_OIDC_USER_REFERENCE_CLAIM = "sub";
 var DEFAULT_OIDC_USER_DISPLAY_NAME_CLAIM = "name";
 var DEFAULT_OIDC_USER_ROLE_CLAIM = "groups";
@@ -330,6 +331,7 @@ var shared = {
   }),
   PUBLIC_BASE_URL: parsePublicBaseUrl(getEnv("PUBLIC_BASE_URL", { defaultValue: "" })),
   SERVER_URL: getEnv("SERVER_URL", { defaultValue: `http://localhost:${String(port)}` }) ?? `http://localhost:${String(port)}`,
+  TRUEFORGE_API_KEY: standalone ? getEnv("TRUEFORGE_API_KEY", { defaultValue: STANDALONE_TRUEFORGE_API_KEY }) ?? STANDALONE_TRUEFORGE_API_KEY : getEnv("TRUEFORGE_API_KEY", { required: true }) ?? "",
   TRUEFORGE_MTLS_ENABLED: parseBoolean({
     envKey: "TRUEFORGE_MTLS_ENABLED",
     raw: getEnv("TRUEFORGE_MTLS_ENABLED"),
@@ -437,11 +439,11 @@ if (isTrueFoundryModeEnabled(configuration)) {
     }
   }
 }
+if (!configuration.STANDALONE && configuration.TRUEFORGE_API_KEY.trim() === "") {
+  throw new Error("TRUEFORGE_API_KEY must not be empty when STANDALONE=false.");
+}
 var config_default = configuration;
 
-// src/controller.ts
-import { TrueForge } from "@truefoundry/trueforge-sdk";
-
 // src/controller/Controller.ts
 var CONTROLLER_STOPPED = "controller-stopped";
 var Controller = class {
@@ -536,6 +538,9 @@ var Controller = class {
   }
 };
 
+// src/controller/scheduleDispatch.ts
+import { TrueForge } from "@truefoundry/trueforge-sdk";
+
 // src/db/scheduleStore.ts
 import { randomUUID } from "crypto";
 
@@ -626,6 +631,9 @@ var CreateScheduleRunRequestSchema = z2.object({
   schedule_id: z2.string().min(1).max(64).describe("Immutable schedule identifier.")
 }).strict().describe("Trigger an immediate run for the given schedule. The task is taken from the schedule manifest.").openapi("CreateScheduleRunRequest");
 var CreateScheduleRunResponseSchema = z2.object({ data: ScheduleRunSchema }).openapi("CreateScheduleRunResponse");
+var ExecuteScheduleRunRequestSchema = z2.object({
+  schedule_run_id: z2.string().min(1).max(64).describe("Immutable schedule run identifier.")
+}).strict().openapi("ExecuteScheduleRunRequest");
 
 // src/db/scheduleStore.ts
 function cronRunName(scheduledFor) {
@@ -656,6 +664,71 @@ function shouldSyncPendingRun(previous, next) {
   return previous.status !== next.status || previous.manifest.cron !== next.manifest.cron || previous.manifest.timezone !== next.manifest.timezone;
 }
 
+// src/http/tls.ts
+import { readFileSync } from "fs";
+import { createServer as createHttpsServer } from "https";
+import { join } from "path";
+import { rootCertificates, TLSSocket } from "tls";
+import { Agent, fetch as undiciFetch } from "undici";
+var TLS_CERT_FILE = "tls.crt";
+var TLS_KEY_FILE = "tls.key";
+var TLS_CA_FILE = "ca.crt";
+function readTlsFile(input) {
+  const filePath = join(input.dir, input.fileName);
+  try {
+    return readFileSync(filePath, "utf8");
+  } catch (error) {
+    throw new Error(
+      `${input.enabledEnvKey} is true but ${filePath} could not be read. Check that the mTLS secret is mounted at the configured certs directory, or set ${input.enabledEnvKey}=false.`,
+      { cause: error }
+    );
+  }
+}
+function normalizeTlsUrl(input) {
+  if (!input.enabled) {
+    return input.url;
+  }
+  const parsed = new URL(input.url);
+  if (parsed.protocol === "http:") {
+    parsed.protocol = "https:";
+  }
+  return parsed.href;
+}
+function createTlsDispatcher(options) {
+  if (!options.enabled) {
+    return void 0;
+  }
+  const read = (fileName) => readTlsFile({ dir: options.dir, fileName, enabledEnvKey: options.enabledEnvKey });
+  return new Agent({
+    connect: {
+      // Appended to the default roots, not replacing them: passing `ca` alone would override Node's
+      // entire trust store for this dispatcher (breaks public HTTPS peers on the same agent).
+      ca: [...rootCertificates, read(TLS_CA_FILE)],
+      cert: read(TLS_CERT_FILE),
+      key: read(TLS_KEY_FILE)
+    }
+  });
+}
+function requestUrlFromFetchInput(input) {
+  if (typeof input === "string") {
+    return input;
+  }
+  if (input instanceof URL) {
+    return input.href;
+  }
+  return input.url;
+}
+function createTlsFetch(options) {
+  const dispatcher = createTlsDispatcher({
+    ...options,
+    enabledEnvKey: "TRUEFORGE_MTLS_ENABLED"
+  });
+  if (dispatcher === void 0) {
+    return void 0;
+  }
+  return (input, init) => undiciFetch(requestUrlFromFetchInput(input), { ...init, dispatcher });
+}
+
 // src/runtime/cron.ts
 import { CronExpressionParser } from "cron-parser";
 function nextTriggerAfter(input) {
@@ -678,22 +751,19 @@ function scheduleRunFailureReason(error) {
 }
 var SCHEDULE_DISPATCH_INTERVAL_MS = 6e4;
 var SCHEDULE_DISPATCH_LOOP_NAME = "schedule-dispatch";
-function executeScheduledRun(client) {
-  return async ({ run, schedule }) => {
-    const { data: session } = await client.internal.sessions.getOrCreateByExternalId({
-      externalId: run.id,
-      agent: { name: schedule.agent_name },
-      source: { type: "schedule", id: schedule.id, runId: run.id }
-    });
-    const turns = await client.sessions.listTurns(session.id, { limit: 1 });
-    if (turns.data.length > 0) {
-      return;
-    }
-    await client.sessions.createTurn(session.id, {
-      input: [{ type: "user.message", content: schedule.manifest.task }],
-      previousTurnId: "none"
-    });
+function createHttpScheduleRunExecutor() {
+  const tls = {
+    enabled: config_default.TRUEFORGE_MTLS_ENABLED,
+    dir: config_default.TRUEFORGE_MTLS_CERTS_DIR
   };
+  const tlsFetch = createTlsFetch(tls);
+  const client = new TrueForge({
+    baseUrl: normalizeTlsUrl({ url: config_default.SERVER_URL, enabled: tls.enabled }),
+    token: config_default.TRUEFORGE_API_KEY,
+    timeoutInSeconds: 60,
+    ...tlsFetch === void 0 ? {} : { fetch: tlsFetch }
+  });
+  return (scheduleRunId) => client.internal.schedules.executeRun({ scheduleRunId });
 }
 async function finishScheduledRun(params) {
   const { store, withTransaction, run, status, reason, now: now2 } = params;
@@ -792,14 +862,15 @@ async function dispatchScheduledRuns(params) {
   return { dispatched, failed };
 }
 function scheduleDispatchLoop(params) {
-  const { scheduleStore, client, withTransaction, logger } = params;
+  const { scheduleStore, withTransaction, logger } = params;
+  const executeRun = createHttpScheduleRunExecutor();
   return {
     name: SCHEDULE_DISPATCH_LOOP_NAME,
     intervalMs: SCHEDULE_DISPATCH_INTERVAL_MS,
     async tick(signal) {
       const result = await dispatchScheduledRuns({
         store: scheduleStore,
-        onTriggered: executeScheduledRun(client),
+        onTriggered: (item) => executeRun(item.run.id),
         logger,
         withTransaction,
         signal
@@ -811,94 +882,17 @@ function scheduleDispatchLoop(params) {
   };
 }
 
-// src/http/tls.ts
-import { readFileSync } from "fs";
-import { createServer as createHttpsServer } from "https";
-import { join } from "path";
-import { rootCertificates, TLSSocket } from "tls";
-import { Agent, fetch as undiciFetch } from "undici";
-var TLS_CERT_FILE = "tls.crt";
-var TLS_KEY_FILE = "tls.key";
-var TLS_CA_FILE = "ca.crt";
-function readTlsFile(input) {
-  const filePath = join(input.dir, input.fileName);
-  try {
-    return readFileSync(filePath, "utf8");
-  } catch (error) {
-    throw new Error(
-      `${input.enabledEnvKey} is true but ${filePath} could not be read. Check that the mTLS secret is mounted at the configured certs directory, or set ${input.enabledEnvKey}=false.`,
-      { cause: error }
-    );
-  }
-}
-function normalizeTlsUrl(input) {
-  if (!input.enabled) {
-    return input.url;
-  }
-  const parsed = new URL(input.url);
-  if (parsed.protocol === "http:") {
-    parsed.protocol = "https:";
-  }
-  return parsed.href;
-}
-function createTlsDispatcher(options) {
-  if (!options.enabled) {
-    return void 0;
-  }
-  const read = (fileName) => readTlsFile({ dir: options.dir, fileName, enabledEnvKey: options.enabledEnvKey });
-  return new Agent({
-    connect: {
-      // Appended to the default roots, not replacing them: passing `ca` alone would override Node's
-      // entire trust store for this dispatcher (breaks public HTTPS peers on the same agent).
-      ca: [...rootCertificates, read(TLS_CA_FILE)],
-      cert: read(TLS_CERT_FILE),
-      key: read(TLS_KEY_FILE)
-    }
-  });
-}
-function requestUrlFromFetchInput(input) {
-  if (typeof input === "string") {
-    return input;
-  }
-  if (input instanceof URL) {
-    return input.href;
-  }
-  return input.url;
-}
-function createTlsFetch(options) {
-  const dispatcher = createTlsDispatcher({
-    ...options,
-    enabledEnvKey: "TRUEFORGE_MTLS_ENABLED"
-  });
-  if (dispatcher === void 0) {
-    return void 0;
-  }
-  return (input, init) => undiciFetch(requestUrlFromFetchInput(input), { ...init, dispatcher });
-}
-
 // src/controller.ts
-function createScheduleApiClient(params) {
-  const baseUrl = normalizeTlsUrl({ url: params.baseUrl, enabled: params.tls.enabled });
-  const fetchImpl = createTlsFetch(params.tls);
-  return new TrueForge({
-    baseUrl,
-    auth: false,
-    ...fetchImpl !== void 0 ? { fetch: fetchImpl } : {}
-  });
-}
 function createController(params) {
-  const { scheduleStore, withTransaction, logger, baseUrl } = params;
-  const tls = params.tls ?? { enabled: false, dir: "" };
   return new Controller({
     loops: [
       scheduleDispatchLoop({
-        scheduleStore,
-        client: createScheduleApiClient({ baseUrl, tls }),
-        withTransaction,
-        logger
+        scheduleStore: params.scheduleStore,
+        withTransaction: params.withTransaction,
+        logger: params.logger
       })
     ],
-    logger
+    logger: params.logger
   });
 }
 function runController(params) {
@@ -1179,6 +1173,11 @@ var PostgresScheduleStore = class {
     const row = await db.selectFrom("schedule_run").selectAll().where("tenant_id", "=", input.tenant_id).where("id", "=", input.id).executeTakeFirst();
     return row === void 0 ? void 0 : toRunRecord(row);
   }
+  async getRunById(input, transaction) {
+    const db = transaction ?? this.#db;
+    const row = await db.selectFrom("schedule_run").selectAll().where("id", "=", input.id).executeTakeFirst();
+    return row === void 0 ? void 0 : toRunRecord(row);
+  }
   async getScheduledRunFor(input, transaction) {
     const db = transaction ?? this.#db;
     const row = await db.selectFrom("schedule_run").selectAll().where("tenant_id", "=", input.tenant_id).where("schedule_id", "=", input.schedule_id).where("status", "=", "scheduled").executeTakeFirst();
@@ -1333,20 +1332,14 @@ try {
     statementTimeoutMs: config_default.POSTGRES_STATEMENT_TIMEOUT_MS,
     idleInTransactionSessionTimeoutMs: config_default.POSTGRES_IDLE_IN_TRANSACTION_SESSION_TIMEOUT_MS
   });
-  const mtls = {
-    enabled: config_default.TRUEFORGE_MTLS_ENABLED,
-    dir: config_default.TRUEFORGE_MTLS_CERTS_DIR
-  };
   logger.info("Controller starting", {
     serverUrl: config_default.SERVER_URL,
-    mTlsEnabled: mtls.enabled
+    mTlsEnabled: config_default.TRUEFORGE_MTLS_ENABLED
   });
   runController({
     scheduleStore: new PostgresScheduleStore(db),
     withTransaction: (callback) => db.transaction().execute(callback),
     logger,
-    baseUrl: config_default.SERVER_URL,
-    tls: mtls,
     gracefulTimeoutSeconds: config_default.GRACEFUL_TIMEOUT_SECONDS,
     onStopped: () => db.destroy()
   });