create-windy 0.1.0

package/template/apps/server/src/http-app.test.ts

@@ -0,0 +1,77 @@
+import { describe, expect, test } from "bun:test";
+import { createPlatformHttpApp } from "./http-app.js";
+import { createPlatformObservability } from "./observability/bootstrap.js";
+import { createServerRuntime } from "./runtime.js";
+
+describe("platform HTTP app observability", () => {
+  test("校验并回传 request id，日志与指标不包含 URL 和查询值", async () => {
+    const records: Record<string, unknown>[] = [];
+    const runtime = createServerRuntime({ NODE_ENV: "test" });
+    const observability = createPlatformObservability({
+      databaseRequired: false,
+      auditStatus: () => runtime.auditSink.status(),
+      logger: {
+        info(fields) {
+          records.push(fields);
+        },
+      },
+    });
+    const app = createPlatformHttpApp(runtime, observability).get(
+      "/probe",
+      () => ({ ok: true }),
+    );
+    const response = await app.handle(
+      new Request("http://localhost/api/probe?q=secret-query", {
+        headers: { "x-request-id": "invalid request id" },
+      }),
+    );
+
+    expect(response.status).toBe(200);
+    expect(response.headers.get("x-request-id")).toMatch(
+      /^[A-Za-z0-9._-]{1,128}$/,
+    );
+    expect(JSON.stringify(records)).not.toContain("secret-query");
+    expect(observability.metrics.render()).not.toContain("secret-query");
+  });
+
+  // @windy-module system.license begin
+  test("License 限制模式在全局 Elysia 边界允许治理导出取消", async () => {
+    const runtime = createServerRuntime(
+      { NODE_ENV: "test" },
+      {
+        licenseResolver: {
+          resolve: () => ({
+            entitlements: [],
+            status: "expired",
+            restricted: true,
+          }),
+        },
+      },
+    );
+    const observability = createPlatformObservability({
+      databaseRequired: false,
+      auditStatus: () => runtime.auditSink.status(),
+      logger: { info() {} },
+    });
+    const app = createPlatformHttpApp(runtime, observability)
+      .post("/system/users/exports/:id/cancel", ({ params }) => ({
+        cancelled: params.id,
+      }))
+      .get("/system/users", () => ({ reachable: true }));
+
+    const allowed = await app.handle(
+      new Request("http://localhost/api/system/users/exports/export-1/cancel", {
+        method: "POST",
+      }),
+    );
+    expect(allowed.status).toBe(200);
+    expect(await allowed.json()).toEqual({ cancelled: "export-1" });
+
+    const denied = await app.handle(
+      new Request("http://localhost/api/system/users"),
+    );
+    expect(denied.status).toBe(403);
+    expect(await denied.json()).toMatchObject({ error: "LICENSE_RESTRICTED" });
+  });
+  // @windy-module system.license end
+});

package/template/apps/server/src/http-app.ts

@@ -0,0 +1,51 @@
+import { swagger } from "@elysiajs/swagger";
+import { Elysia } from "elysia";
+import type { createPlatformObservability } from "./observability/bootstrap.js";
+// @windy-module system.license begin
+import { restrictedRequestResponse } from "./request-restriction.js";
+// @windy-module system.license end
+import type { createServerRuntime } from "./runtime.js";
+
+type ServerRuntime = ReturnType<typeof createServerRuntime>;
+type PlatformObservability = ReturnType<typeof createPlatformObservability>;
+
+export function createPlatformHttpApp(
+  runtime: ServerRuntime,
+  observability: PlatformObservability,
+) {
+  return (
+    new Elysia({ prefix: "/api" })
+      .derive(async ({ request, server }) => ({
+        guardContext: await runtime.createGuardContext(request, {
+          clientIp: server?.requestIP(request)?.address,
+        }),
+        requestObservation: observability.http.begin(request.method),
+      }))
+      // @windy-module system.license begin
+      .onBeforeHandle(({ request, guardContext }) =>
+        restrictedRequestResponse(runtime, guardContext, request),
+      )
+      // @windy-module system.license end
+      .onAfterHandle(({ guardContext, set }) => {
+        set.headers["x-request-id"] = guardContext.requestId;
+      })
+      .onAfterResponse(
+        ({ request, guardContext, requestObservation, responseValue, set }) => {
+          observability.http.complete({
+            request,
+            guardContext,
+            observation: requestObservation,
+            responseValue,
+            status: set.status,
+          });
+        },
+      )
+      .use(
+        swagger({
+          documentation: {
+            info: { title: "Windy Platform API", version: "0.1.0" },
+          },
+        }),
+      )
+  );
+}

package/template/apps/server/src/index.ts

@@ -0,0 +1,374 @@
+import { loadPlatformConfig } from "@windy/config";
+import pino from "pino";
+import { registerAdminBootstrapRoute } from "./admin/routes.js";
+import { registerSessionContextRoute } from "./session/routes.js";
+import {
+  createFoundationSnapshot,
+  loadFoundationModules,
+} from "./foundation.js";
+import { registerFoundationRoute } from "./foundation-route.js";
+// @windy-module system.scheduler begin
+import { createApplicationServices } from "./application-services.js";
+// @windy-module system.scheduler end
+// @windy-module system.bulk-data begin
+import { registerBulkDataRoutes } from "./bulk-data/routes.js";
+// @windy-module system.bulk-data end
+// @windy-module system.data-governance begin
+import { registerGovernedUserExportRoutes } from "./data-governance/export/routes.js";
+// @windy-module system.data-governance end
+import { createServerRuntime } from "./runtime.js";
+// @windy-module system.scheduler begin
+import { readPositiveInt } from "./runtime-config.js";
+// @windy-module system.scheduler end
+// @windy-module system.agent begin
+import {
+  createSystemToolHandlers,
+  registerAgentRoutes,
+} from "./agent/routes.js";
+// @windy-module system.agent end
+import { registerAuthRoutes, registerAuthSessionRoute } from "./auth/routes.js";
+import { createAuthRuntime } from "./auth/runtime.js";
+import { createPlatformHttpApp } from "./http-app.js";
+import { bootstrapAdminPassword } from "./auth/bootstrap-admin.js";
+import { createServerPersistence } from "./persistence.js";
+// @windy-module system.license begin
+import { registerPlatformLicenseRoutes } from "./license/routes.js";
+import {
+  createPlatformLicenseRuntimeOptions,
+  hasConfiguredLicenseKeys,
+  PlatformLicenseRuntime,
+} from "./license/runtime-service.js";
+// @windy-module system.license end
+// @windy-module system.operations begin
+import { registerSystemOperationRoutes } from "./system/operations.js";
+import { createPostgresMonitorProbe } from "./system/postgres-monitoring.js";
+// @windy-module system.operations end
+import { registerSystemRoutes } from "./system/routes.js";
+import {
+  createSystemRepositories,
+  synchronizeBuiltInRoles,
+} from "./system/seed.js";
+// @windy-module system.scheduler begin
+import { registerSchedulerRoutes } from "./scheduler/routes.js";
+import { SchedulerWorker } from "./scheduler/worker.js";
+// @windy-module system.scheduler end
+// @windy-module system.settings begin
+import { registerBrandingSettingsRoutes } from "./settings/routes.js";
+import { createBrandingSettingsRepository } from "./settings/runtime.js";
+// @windy-module system.settings end
+import { registerProfileRoutes } from "./profile/routes.js";
+// @windy-module system.notification begin
+import { registerNotificationRoutes } from "./notification/routes.js";
+// @windy-module system.notification end
+// @windy-module work-order begin
+import {
+  createExampleModuleRuntime,
+  registerExampleModuleRoutes,
+} from "./example-modules.js";
+// @windy-module work-order end
+// @windy-module system.configuration begin
+import { bootstrapModuleConfiguration } from "./configuration/bootstrap.js";
+// @windy-module system.configuration end
+// @windy-module system.storage begin
+import { createStorageRuntime } from "./storage/runtime.js";
+import { registerStorageRoutes } from "./storage/routes.js";
+// @windy-module system.storage end
+import { validateServerModuleComposition } from "./module-composition.js";
+// @windy-module system.search begin
+import { createSearchHost } from "./search/host.js";
+// @windy-module system.search end
+// @windy-module system.workflow begin
+import { registerWorkflowRoutes } from "./workflow/routes.js";
+// @windy-module system.workflow end
+import {
+  createPlatformObservability,
+  logPlatformStartup,
+} from "./observability/bootstrap.js";
+
+const logger = pino({ name: "windy-server" });
+const platformConfig = loadPlatformConfig();
+const persistence = createServerPersistence(
+  process.env,
+  (status) => {
+    logger.error({ audit: status }, "审计持久化进入降级状态");
+  },
+  platformConfig,
+);
+// @windy-module system.audit begin
+await persistence?.auditWriter.recover();
+// @windy-module system.audit end
+// @windy-module system.configuration begin
+const configurationRuntime = await bootstrapModuleConfiguration(
+  platformConfig,
+  persistence?.configVersionRepository,
+);
+// @windy-module system.configuration end
+const foundationSnapshot = createFoundationSnapshot(platformConfig);
+// @windy-module system.configuration begin
+configurationRuntime.bindFoundation(foundationSnapshot);
+// @windy-module system.configuration end
+const foundationModules = loadFoundationModules();
+const systemRepositories = createSystemRepositories(foundationSnapshot, {
+  db: persistence?.db,
+});
+const featureSync = await systemRepositories.features.syncManifest(
+  foundationSnapshot.features,
+);
+await systemRepositories.menuRegistry.synchronize({
+  id: "system_bootstrap",
+  type: "service",
+  name: "平台初始化",
+  roleCodes: ["system"],
+  permissionKeys: ["system.menu.manage"],
+});
+await synchronizeBuiltInRoles(systemRepositories, foundationSnapshot);
+// @windy-module system.license begin
+const platformLicenseOptions = createPlatformLicenseRuntimeOptions(process.env);
+const platformLicenseRuntime = new PlatformLicenseRuntime(
+  platformLicenseOptions,
+);
+const useInstalledLicense =
+  Boolean(platformLicenseOptions.enforceRestrictions) ||
+  hasConfiguredLicenseKeys(platformLicenseOptions);
+// @windy-module system.license end
+const runtime = createServerRuntime(process.env, {
+  actorResolver: persistence?.actorResolver,
+  // @windy-module system.license begin
+  licenseResolver: useInstalledLicense
+    ? platformLicenseRuntime
+    : persistence?.licenseResolver,
+  // @windy-module system.license end
+  featureResolver: persistence ? systemRepositories.features : undefined,
+  // @windy-module system.audit begin
+  auditReader: persistence?.auditReader,
+  auditWriter: persistence?.auditWriter,
+  // @windy-module system.audit end
+});
+const observability = createPlatformObservability({
+  databaseCheck: persistence
+    ? async () => void (await persistence.pool.query("select 1"))
+    : undefined,
+  databaseRequired: process.env.NODE_ENV === "production",
+  auditStatus: () => runtime.auditSink.status(),
+  logger,
+});
+// @windy-module system.license begin
+platformLicenseRuntime.setAuditSink(runtime.auditSink);
+// @windy-module system.license end
+const { authRepository, authService } = createAuthRuntime({
+  repository: persistence?.authRepository,
+  sessionTtlSeconds: platformConfig.security.sessionTtlSeconds,
+  auditWriter: (event) => runtime.auditSink.recordCriticalEvent(event),
+  // @windy-module system.audit begin
+  auditReader: persistence?.auditReader,
+  // @windy-module system.audit end
+});
+// @windy-module system.storage begin
+const storageRuntime = createStorageRuntime(process.env, persistence?.db);
+// @windy-module system.storage end
+// @windy-module system.settings begin
+const brandingSettingsRepository = createBrandingSettingsRepository(
+  persistence?.db,
+  { softwareName: platformConfig.name, logoUrl: platformConfig.logoUrl },
+);
+// @windy-module system.settings end
+// @windy-module work-order begin
+const exampleModuleRuntime = createExampleModuleRuntime({
+  features: foundationSnapshot.features,
+  departments: systemRepositories.departments,
+  db: persistence?.db,
+});
+// @windy-module work-order end
+// @windy-module system.search begin
+const businessSearchProviders = [
+  // @windy-module work-order begin
+  ...(exampleModuleRuntime?.providers || []),
+  // @windy-module work-order end
+];
+// @windy-module system.search end
+// @windy-module system.search begin
+const searchHost = createSearchHost(
+  foundationModules,
+  { providers: businessSearchProviders },
+  runtime,
+);
+// @windy-module system.search end
+// @windy-module system.scheduler begin
+const businessTaskDefinitions = [
+  // @windy-module work-order begin
+  ...(exampleModuleRuntime?.tasks || []),
+  // @windy-module work-order end
+];
+const {
+  bulkDataService,
+  scheduler,
+  taskDefinitions: scheduledTaskDefinitions,
+  notifications: notificationRepository,
+  workflow: workflowService,
+  governedExportService,
+} = await createApplicationServices({
+  persistence,
+  systemRepositories,
+  foundation: foundationSnapshot,
+  runtime,
+  storage: storageRuntime,
+  exampleTasks: businessTaskDefinitions,
+  bulkRetentionDays: readPositiveInt(process.env.BULK_DATA_RETENTION_DAYS, 7),
+});
+const schedulerWorker = new SchedulerWorker(
+  scheduler,
+  readPositiveInt(process.env.SCHEDULER_POLL_INTERVAL_MS, 1_000),
+  () => logger.error({ event: "scheduler.tick.failed" }, "定时任务 tick 失败"),
+  (result) => observability.metrics.observeSchedulerTick(result),
+);
+// @windy-module system.scheduler end
+
+await bootstrapAdminPassword({
+  authService,
+  authRepository: persistence?.authRepository,
+  repositories: systemRepositories,
+  password: process.env.WINDY_BOOTSTRAP_ADMIN_PASSWORD,
+});
+
+const app = createPlatformHttpApp(runtime, observability);
+observability.register(app);
+
+registerAuthSessionRoute(app);
+
+registerAuthRoutes(app, authService, {
+  sessionCookieName: platformConfig.security.sessionCookieName,
+  secureCookie: process.env.NODE_ENV === "production",
+});
+registerProfileRoutes(
+  app,
+  authRepository,
+  runtime,
+  foundationSnapshot.features,
+);
+
+// @windy-module system.license begin
+registerPlatformLicenseRoutes(app, platformLicenseRuntime);
+// @windy-module system.license end
+
+// @windy-module system.settings begin
+registerBrandingSettingsRoutes(
+  app,
+  brandingSettingsRepository,
+  runtime,
+  foundationSnapshot.features,
+);
+// @windy-module system.settings end
+// @windy-module system.notification begin
+registerNotificationRoutes(
+  app,
+  notificationRepository,
+  runtime,
+  foundationSnapshot.features,
+);
+// @windy-module system.notification end
+// @windy-module system.workflow begin
+registerWorkflowRoutes(app, workflowService, runtime);
+// @windy-module system.workflow end
+// @windy-module system.configuration begin
+configurationRuntime.register(app, runtime, foundationSnapshot.features);
+// @windy-module system.configuration end
+// @windy-module system.storage begin
+registerStorageRoutes(
+  app,
+  {
+    uploads: storageRuntime.uploads,
+    files: storageRuntime.files,
+    isPublicBrandingFile: async (fileId) =>
+      (await brandingSettingsRepository.get()).logoUrl ===
+      `/api/platform/files/${fileId}`,
+  },
+  runtime,
+  foundationSnapshot.features,
+);
+// @windy-module system.storage end
+// @windy-module system.search begin
+searchHost.register(app);
+// @windy-module system.search end
+
+registerAdminBootstrapRoute(app, runtime, {
+  modules: foundationModules,
+  snapshot: foundationSnapshot,
+  loadMenus: () => systemRepositories.menuRegistry.tree(),
+});
+registerSessionContextRoute(app, runtime, foundationSnapshot.features);
+
+registerFoundationRoute(app, runtime, foundationSnapshot, systemRepositories);
+
+// @windy-module system.data-governance begin
+registerGovernedUserExportRoutes(
+  app,
+  governedExportService,
+  runtime,
+  foundationSnapshot.features,
+);
+// @windy-module system.data-governance end
+registerSystemRoutes(
+  app,
+  systemRepositories,
+  runtime,
+  foundationSnapshot.features,
+  { authRepository: persistence?.authRepository },
+);
+// @windy-module system.operations begin
+registerSystemOperationRoutes(app, runtime, foundationSnapshot.features, {
+  redisHealthProbe: configurationRuntime.redisHealthProbe,
+  onlineUserProvider: () =>
+    persistence?.authRepository.listActiveSessions(
+      new Date(),
+      new Date(Date.now() - 15 * 60 * 1_000),
+    ) ?? Promise.resolve([]),
+  databaseMonitorProbe: createPostgresMonitorProbe(persistence?.pool),
+});
+// @windy-module system.operations end
+// @windy-module system.agent begin
+const toolHandlers = createSystemToolHandlers(systemRepositories, runtime);
+registerAgentRoutes(app, foundationModules, toolHandlers, runtime);
+// @windy-module system.agent end
+// @windy-module system.scheduler begin
+registerSchedulerRoutes(app, scheduler, runtime, foundationSnapshot.features);
+// @windy-module system.scheduler end
+// @windy-module system.bulk-data begin
+registerBulkDataRoutes(
+  app,
+  bulkDataService,
+  runtime,
+  foundationSnapshot.features,
+);
+// @windy-module system.bulk-data end
+// @windy-module work-order begin
+registerExampleModuleRoutes({
+  app,
+  runtime,
+  moduleRuntime: exampleModuleRuntime,
+});
+// @windy-module work-order end
+
+validateServerModuleComposition({
+  modules: foundationModules,
+  routes: app.routes,
+  // @windy-module system.scheduler begin
+  tasks: scheduledTaskDefinitions,
+  // @windy-module system.scheduler end
+  // @windy-module system.agent begin
+  tools: toolHandlers,
+  // @windy-module system.agent end
+  // @windy-module system.search begin
+  providers: searchHost.providerKeys,
+  // @windy-module system.search end
+});
+
+const port = process.env.PORT ? Number(process.env.PORT) : 3000;
+app.listen(port);
+// @windy-module system.scheduler begin
+schedulerWorker.start();
+// @windy-module system.scheduler end
+logPlatformStartup(logger, {
+  featureSync,
+  persistenceEnabled: Boolean(persistence),
+  port,
+});

package/template/apps/server/src/jobs/artifact-service.test.ts

@@ -0,0 +1,78 @@
+import { describe, expect, test } from "bun:test";
+import { MemoryBlobStore } from "@windy/storage";
+import { DurableArtifactService } from "./artifact-service.js";
+import { InMemoryDurableJobRepository } from "./repository.js";
+import { DurableJobService } from "./service.js";
+
+describe("DurableArtifactService", () => {
+  test("只有 Owner 或 manage 权限可读取且过期后统一拒绝", async () => {
+    let now = new Date("2026-07-16T00:00:00.000Z");
+    const repository = new InMemoryDurableJobRepository();
+    const jobs = new DurableJobService(repository, () => now);
+    const submitted = await jobs.submit({
+      handlerKey: "test.artifact",
+      idempotencyKey: "artifact-access-001",
+      payload: {},
+      requestedBy: "owner-1",
+    });
+    const snapshot = await jobs.get(submitted.job.id);
+    const stage = snapshot?.stages[0];
+    if (!stage) throw new Error("应创建默认阶段");
+    const blobStore = new MemoryBlobStore();
+    const bytes = new TextEncoder().encode("durable artifact");
+    const blob = await blobStore.put({
+      body: new ReadableStream({
+        start(controller) {
+          controller.enqueue(bytes);
+          controller.close();
+        },
+      }),
+    });
+    await repository.putArtifact({
+      id: Bun.randomUUIDv7(),
+      jobId: submitted.job.id,
+      stageId: stage.id,
+      kind: "result",
+      artifactRef: blob.ref,
+      filename: "result.txt",
+      contentType: "text/plain",
+      byteSize: blob.byteSize,
+      sha256: blob.contentHash.value,
+      ownerId: "owner-1",
+      expiresAt: "2026-07-17T00:00:00.000Z",
+      createdAt: now.toISOString(),
+    });
+    const service = new DurableArtifactService(
+      repository,
+      blobStore,
+      () => now,
+    );
+
+    expect(
+      await readText(
+        (await service.open(submitted.job.id, "result", "owner-1")).body,
+      ),
+    ).toBe("durable artifact");
+    await expect(
+      service.open(submitted.job.id, "result", "other-user"),
+    ).rejects.toMatchObject({
+      code: "ARTIFACT_FORBIDDEN",
+    });
+    expect(
+      await readText(
+        (await service.open(submitted.job.id, "result", "admin", true)).body,
+      ),
+    ).toBe("durable artifact");
+
+    now = new Date("2026-07-17T00:00:00.000Z");
+    await expect(
+      service.open(submitted.job.id, "result", "owner-1"),
+    ).rejects.toMatchObject({
+      code: "ARTIFACT_EXPIRED",
+    });
+  });
+});
+
+async function readText(body: ReadableStream<Uint8Array>) {
+  return new Response(body).text();
+}

package/template/apps/server/src/jobs/artifact-service.ts

@@ -0,0 +1,94 @@
+import type { BlobStore, ReadableBlob } from "@windy/storage";
+import type { DurableJobRepository } from "./repository.js";
+import type { DurableJobArtifact } from "./types.js";
+
+export type DurableArtifactErrorCode =
+  | "ARTIFACT_NOT_FOUND"
+  | "ARTIFACT_FORBIDDEN"
+  | "ARTIFACT_EXPIRED"
+  | "ARTIFACT_CONTENT_MISSING";
+
+export class DurableArtifactError extends Error {
+  constructor(
+    readonly code: DurableArtifactErrorCode,
+    message: string,
+  ) {
+    super(message);
+    this.name = "DurableArtifactError";
+  }
+}
+
+export interface OpenedDurableArtifact {
+  artifact: DurableJobArtifact;
+  body: ReadableBlob["body"];
+}
+
+export class DurableArtifactService {
+  constructor(
+    private readonly repository: DurableJobRepository,
+    private readonly blobStore: BlobStore,
+    private readonly now: () => Date = () => new Date(),
+  ) {}
+
+  async open(
+    jobId: string,
+    kind: string,
+    actorId: string,
+    allowManage = false,
+  ): Promise<OpenedDurableArtifact> {
+    const artifact = await this.inspect(jobId, kind, actorId, allowManage);
+    return this.openInspected(artifact);
+  }
+
+  async inspect(
+    jobId: string,
+    kind: string,
+    actorId: string,
+    allowManage = false,
+  ): Promise<DurableJobArtifact> {
+    const snapshot = await this.repository.get(jobId);
+    const artifact = snapshot?.artifacts.find((item) => item.kind === kind);
+    if (!artifact) {
+      throw new DurableArtifactError("ARTIFACT_NOT_FOUND", "任务产物不存在");
+    }
+    if (artifact.ownerId !== actorId && !allowManage) {
+      throw new DurableArtifactError("ARTIFACT_FORBIDDEN", "无权访问任务产物");
+    }
+    if (artifact.expiresAt && artifact.expiresAt <= this.now().toISOString()) {
+      throw new DurableArtifactError("ARTIFACT_EXPIRED", "任务产物已过期");
+    }
+    const blob = await this.blobStore.inspect(artifact.artifactRef);
+    if (
+      !blob ||
+      blob.byteSize !== artifact.byteSize ||
+      blob.contentHash.value !== artifact.sha256
+    ) {
+      throw new DurableArtifactError(
+        "ARTIFACT_CONTENT_MISSING",
+        "任务产物内容不可用",
+      );
+    }
+    return artifact;
+  }
+
+  async openInspected(
+    artifact: DurableJobArtifact,
+  ): Promise<OpenedDurableArtifact> {
+    const blob = await this.blobStore.open(artifact.artifactRef);
+    if (
+      !blob ||
+      blob.byteSize !== artifact.byteSize ||
+      blob.contentHash.value !== artifact.sha256
+    ) {
+      throw new DurableArtifactError(
+        "ARTIFACT_CONTENT_MISSING",
+        "任务产物内容不可用",
+      );
+    }
+    return { artifact, body: blob.body };
+  }
+
+  async deleteInspected(artifact: DurableJobArtifact) {
+    await this.blobStore.delete(artifact.artifactRef);
+  }
+}