stageflow 0.27.0 → 0.30.0

package/dist/server/bootstrap.d.ts

@@ -45,6 +45,12 @@ export type StageflowHostBootstrap = {
     /** Periodic retention GC handle when enabled; already `.unref()`'d. */
     gcInterval?: NodeJS.Timeout;
     stopGcInterval: () => void;
+    /** Stops the schedule-trigger tick loop started at boot. */
+    stopScheduleSource: () => void;
+    /** Stops the GitHub poll-trigger loop started at boot. */
+    stopGithubPollSource: () => void;
+    /** Stops the email-trigger IMAP/IDLE listeners started at boot. */
+    stopEmailSource: () => void;
     /** Filesystem classification for `$STAGEFLOW_HOME` (Slot 8). */
     storeFilesystem?: StoreFilesystemClassification;
     /**

package/dist/server/bootstrap.js

@@ -12,6 +12,10 @@ import { assertStoreFilesystemSupported } from "../runstore/storeFilesystem.js";
 import { assertStoreQuickCheck, isSqliteCorruptError, maybeCheckpointResidualWal, rethrowAsStoreIntegrityFailed, } from "../runstore/sqlite/applyStorePragmas.js";
 import { RunManager } from "../runtime/runManager.js";
 import { PI_CODING_AGENT_DIR_ENV } from "../runtime/stageRoots.js";
+import { ScheduleSource, triggerTickIntervalMsFromEnv, } from "../runtime/scheduleSource.js";
+import { GithubPollSource, githubPollIntervalMsFromEnv, } from "../runtime/githubPollSource.js";
+import { EmailSource } from "../runtime/emailSource.js";
+import { fireTrigger } from "../runtime/triggerRunner.js";
 import { createRunChangeBus, getRunChangeBusFromWrappedStore, isRunStoreWrapped, wrapRunStoreWithChangeBus, } from "../runtime/runChangeBus.js";
 import { createMcpHttpHandler, resolveMcpStateless, } from "../mcp/server.js";
 import { loadHostConfig, } from "../config/hostConfig.js";
@@ -149,6 +153,9 @@ export async function bootstrapStageflowHost(options) {
                 close: async () => { },
             },
             stopGcInterval: () => { },
+            stopScheduleSource: () => { },
+            stopGithubPollSource: () => { },
+            stopEmailSource: () => { },
             storeFilesystem,
             serveBlocked,
             ...(hostConfig !== undefined ? { hostConfig } : {}),
@@ -231,6 +238,7 @@ export async function bootstrapStageflowHost(options) {
     });
     await manager.attachWaitingStages();
     await manager.reconcileOrphanedStages();
+    await manager.sweepBrowserSessions().catch(() => undefined);
     await manager.autoResumeInterruptedStages();
     await manager.resumeStalledSchedules();
     await manager.reenqueuePersistedQueuedRuns();
@@ -240,6 +248,58 @@ export async function bootstrapStageflowHost(options) {
         if (gcInterval !== undefined)
             clearInterval(gcInterval);
     };
+    const scheduleSource = new ScheduleSource({
+        store,
+        cwd,
+        intervalMs: triggerTickIntervalMsFromEnv(env),
+        logError: (message) => bootLog.error("trigger.schedule_source_failed", message),
+    });
+    const onTriggerFire = async (event) => {
+        try {
+            const result = await fireTrigger(event.triggerId, store, manager, {
+                cwd,
+                task: event.task,
+            });
+            if (!result.ok) {
+                bootLog.error("trigger.fire_failed", `trigger "${event.triggerId}" fire failed: ${result.reason}`);
+            }
+        }
+        catch (err) {
+            bootLog.error("trigger.fire_failed", `trigger "${event.triggerId}" fire threw: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    };
+    try {
+        // Boot-time catch-up: fire once for any schedule trigger whose next_run_at
+        // already passed while the Host was down, then reschedule from now —
+        // before starting the periodic ticker so this pass never races it.
+        await scheduleSource.tick(onTriggerFire);
+    }
+    catch (err) {
+        bootLog.error("trigger.schedule_catchup_failed", `boot catch-up tick failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    await scheduleSource.start(onTriggerFire);
+    const stopScheduleSource = () => {
+        void scheduleSource.stop();
+    };
+    const githubPollSource = new GithubPollSource({
+        store,
+        cwd,
+        intervalMs: githubPollIntervalMsFromEnv(env),
+        logError: (message) => bootLog.error("trigger.github_poll_source_failed", message),
+    });
+    await githubPollSource.start(onTriggerFire);
+    const stopGithubPollSource = () => {
+        void githubPollSource.stop();
+    };
+    const emailSource = new EmailSource({
+        store,
+        cwd,
+        logError: (message) => bootLog.error("trigger.email_source_failed", message),
+    });
+    await emailSource.start(onTriggerFire);
+    const stopEmailSource = () => {
+        void emailSource.stop();
+    };
     const mcpStateless = resolveMcpStateless({
         mcpStateless: options.mcpStateless,
     });
@@ -251,6 +311,7 @@ export async function bootstrapStageflowHost(options) {
         runChangeBus,
         providerAuthContext: options.providerAuthContext,
         projectRoot: rootDir,
+        ...(providerBoot !== undefined ? { providerBoot } : {}),
     }, { mcpStateless });
     return {
         a2a: await createA2aHost({
@@ -274,6 +335,9 @@ export async function bootstrapStageflowHost(options) {
         ...(providerBoot !== undefined ? { providerBoot } : {}),
         ...(gcInterval !== undefined ? { gcInterval } : {}),
         stopGcInterval,
+        stopScheduleSource,
+        stopGithubPollSource,
+        stopEmailSource,
         storeFilesystem,
     };
 }

package/dist/server/controlToken.js

@@ -158,11 +158,24 @@ export class BindRefusedError extends Error {
         this.name = "BindRefusedError";
     }
 }
+/**
+ * `POST /api/triggers/:id/webhook` is exempt from bearer auth: an external
+ * webhook sender can't present Stageflow's own control token, and the route
+ * authenticates the request itself via per-trigger HMAC signature
+ * verification instead. It still goes through `assertAllowedHttpAccess`
+ * (loopback/allowed-hosts gating) the same as every other `/api/*` route —
+ * only the bearer-token requirement is carved out here.
+ */
+function isTriggerWebhookRoute(method, pathname) {
+    return method === "POST" && /^\/api\/triggers\/[^/]+\/webhook$/.test(pathname);
+}
 export function requiredScopeFor(method, pathname) {
     if (pathname === "/mcp")
         return "drive";
     if (!pathname.startsWith("/api/"))
         return null;
+    if (isTriggerWebhookRoute(method, pathname))
+        return null;
     if (pathname === "/api/backup" || pathname.startsWith("/api/backup/")) {
         return "drive";
     }

package/dist/server/createHttpHost.js

@@ -135,6 +135,9 @@ export async function createHttpHost(options) {
     server.maxConnections = maxConnections;
     server.on("close", () => {
         boot.stopGcInterval();
+        boot.stopScheduleSource();
+        boot.stopGithubPollSource();
+        boot.stopEmailSource();
         void boot.mcpHandler.close();
     });
     await new Promise((resolve, reject) => {

package/dist/server/healthSurfaces.js

@@ -1,3 +1,4 @@
+import { getAuthStatus, } from "../agent/providerAuth.js";
 import { PACKAGE_VERSION, BUILD_SHA } from "../package-meta.js";
 import { globalStageflowHome } from "../project/globalHome.js";
 import { redactHostConfig } from "../config/hostConfig.js";
@@ -6,6 +7,31 @@ import { json } from "./createHttpHost.js";
 import { livezBody, probeGitVersion, readSchemaHealth, runReadyzChecks, } from "../diagnostics/checks.js";
 import { buildEgressHealth } from "../net/proxy.js";
 import { toolchainHealthMap } from "../preflight/toolchain.js";
+function bootProvidersSnapshot(providerBoot) {
+    return providerBoot
+        ? {
+            configured: providerBoot.configured,
+            failures: providerBoot.failures,
+        }
+        : { configured: [], failures: [] };
+}
+async function providersLiveSummary(cwd, authCtx) {
+    const note = "Live auth inspect — prefer list_providers / sf providers status. boot_providers is Host boot env only and may be empty when CLI credentials are configured.";
+    if (authCtx === undefined) {
+        return { configured: [], note };
+    }
+    try {
+        const status = await getAuthStatus(cwd, undefined, authCtx);
+        const rows = Array.isArray(status) ? status : [status];
+        return {
+            configured: rows.filter((r) => r.configured).map((r) => r.providerId),
+            note,
+        };
+    }
+    catch {
+        return { configured: [], note };
+    }
+}
 export function handleLivez(_req, res) {
     json(res, 200, livezBody());
 }
@@ -54,6 +80,8 @@ export async function buildRichHealthPayload(boot) {
         store: boot.store,
         bootCwd: boot.cwd,
     });
+    const boot_providers = bootProvidersSnapshot(boot.providerBoot);
+    const providers_live = await providersLiveSummary(boot.cwd, boot.providerAuthContext);
     const payload = {
         ...capacity,
         capacity: {
@@ -78,12 +106,9 @@ export async function buildRichHealthPayload(boot) {
             kind: r.kind,
             read_only: r.read_only,
         })),
-        providers: boot.providerBoot
-            ? {
-                configured: boot.providerBoot.configured,
-                failures: boot.providerBoot.failures,
-            }
-            : { configured: [], failures: [] },
+        boot_providers,
+        providers_live,
+        providers: boot_providers,
     };
     if (boot.hostConfig) {
         payload.config = redactHostConfig(boot.hostConfig);

package/dist/server/http.d.ts

@@ -1,5 +1,7 @@
 import type { AgentPort } from "../agent/port.js";
 import { type ProviderAuthContext } from "../agent/providerAuth.js";
+import { WorkshopChatSessionRegistry } from "../workshop/chatTurn.js";
+import { type OperatorAgentHost } from "../operatorAgent/index.js";
 import type { RunStoreKind } from "../runstore/createStore.js";
 import type { RunStore } from "../runstore/port.js";
 import type { RunManager } from "../runtime/runManager.js";
@@ -24,6 +26,8 @@ export type UiServerOptions = {
     runChangeBus?: RunChangeBus;
     allowedHosts?: AllowedHosts;
     controlTokens?: ControlTokens;
+    /** Optional Workshop Operator Agent Host (fake in tests). */
+    workshopOperatorHost?: OperatorAgentHost;
 };
 export declare function defaultUiDistDir(): string;
 export type OperatorRouteDeps = {
@@ -39,6 +43,17 @@ export type OperatorRouteDeps = {
     controlTokens?: ControlTokens;
     /** Live shutdown controller; set after listen so restore can beginDrain. */
     getShutdown?: () => import("./shutdown.js").ShutdownController | undefined;
+    /**
+     * Optional Operator Agent Host for Workshop chat (tests inject the fake host).
+     * Distinct from stage-execution AgentPort. Defaults to live Pi Workshop Author
+     * (fake remains available via createWorkshopOperatorHost / test injection).
+     */
+    workshopOperatorHost?: OperatorAgentHost;
+    /**
+     * Optional durable Workshop chat registry (host sessions keyed by session id).
+     * Defaults to a registry owned by this route surface.
+     */
+    workshopChatRegistry?: WorkshopChatSessionRegistry;
 };
 /**
  * The full operator-console route surface: REST API (runs, stages,