create-windy 0.5.2 → 0.6.0

package/template/apps/server/src/storage/drizzle-upload-repository.ts

@@ -12,17 +12,41 @@ import {
   type UploadRepository,
   type UploadSession,
 } from "@southwind-ai/storage";
-import { and, asc, eq, lte, ne, sql } from "drizzle-orm";
+import { and, asc, eq, isNull, lte, ne, notExists, or, sql } from "drizzle-orm";
 import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import {
+  beginDrizzleCompletedUploadPurge,
+  deleteDrizzlePurgedUpload,
+} from "./drizzle-upload-purge.js";
+import { listDrizzleUploadArtifactRefs } from "./drizzle-upload-references.js";
 
 export class DrizzleUploadRepository implements UploadRepository {
   constructor(private readonly db: NodePgDatabase) {}
 
+  beginPurgeCompletedSession = (
+    id: string,
+    ownerId: string,
+    fileId: string,
+    updatedAt: string,
+  ) =>
+    beginDrizzleCompletedUploadPurge(this.db, id, ownerId, fileId, updatedAt);
+
+  deletePurgedSession = (id: string, ownerId: string, fileId: string) =>
+    deleteDrizzlePurgedUpload(this.db, id, ownerId, fileId);
+
   async createSession(input: NewUploadSession) {
     const [row] = await this.db
       .insert(fileUploadSessions)
       .values({
-        ...input,
+        id: input.id,
+        ownerId: input.ownerId,
+        purpose: input.purpose,
+        moduleName: input.authorizationBinding?.moduleName,
+        authorizationScopeHash: input.authorizationBinding?.scopeHash,
+        filename: input.filename,
+        extension: input.extension,
+        mimeType: input.mimeType,
+        expectedByteSize: input.expectedByteSize,
         expectedSha256: input.expectedContentHash?.value,
         expiresAt: new Date(input.expiresAt),
         fileExpiresAt: input.fileExpiresAt
@@ -131,6 +155,21 @@ export class DrizzleUploadRepository implements UploadRepository {
     });
   }
 
+  async beginAbortSession(id: string, ownerId: string, updatedAt: string) {
+    const rows = await this.db
+      .update(fileUploadSessions)
+      .set({ status: "aborting", updatedAt: new Date(updatedAt) })
+      .where(
+        and(
+          eq(fileUploadSessions.id, id),
+          eq(fileUploadSessions.ownerId, ownerId),
+          eq(fileUploadSessions.status, "uploading"),
+        ),
+      )
+      .returning({ id: fileUploadSessions.id });
+    return rows.length === 1;
+  }
+
   async abortSession(id: string, ownerId: string, updatedAt: string) {
     const rows = await this.db
       .update(fileUploadSessions)
@@ -146,6 +185,28 @@ export class DrizzleUploadRepository implements UploadRepository {
     return rows.length === 1;
   }
 
+  async finalizeAbortSession(id: string, ownerId: string, updatedAt: string) {
+    const rows = await this.db
+      .update(fileUploadSessions)
+      .set({ status: "aborted", updatedAt: new Date(updatedAt) })
+      .where(
+        and(
+          eq(fileUploadSessions.id, id),
+          eq(fileUploadSessions.ownerId, ownerId),
+          eq(fileUploadSessions.status, "aborting"),
+          isNull(fileUploadSessions.fileId),
+          notExists(
+            this.db
+              .select({ sessionId: fileUploadParts.sessionId })
+              .from(fileUploadParts)
+              .where(eq(fileUploadParts.sessionId, id)),
+          ),
+        ),
+      )
+      .returning({ id: fileUploadSessions.id });
+    return rows.length === 1;
+  }
+
   async getFile(id: string) {
     const [row] = await this.db
       .select()
@@ -162,6 +223,10 @@ export class DrizzleUploadRepository implements UploadRepository {
       .where(
         and(
           ne(fileUploadSessions.status, "completed"),
+          or(
+            ne(fileUploadSessions.status, "aborting"),
+            isNull(fileUploadSessions.fileId),
+          ),
           lte(fileUploadSessions.expiresAt, new Date(now)),
         ),
       )
@@ -180,18 +245,40 @@ export class DrizzleUploadRepository implements UploadRepository {
     return rows.map(mapFile);
   }
 
+  async claimExpiredSession(id: string, now: string) {
+    const rows = await this.db
+      .update(fileUploadSessions)
+      .set({ status: "expired", updatedAt: new Date(now) })
+      .where(
+        and(
+          eq(fileUploadSessions.id, id),
+          ne(fileUploadSessions.status, "completed"),
+          or(
+            ne(fileUploadSessions.status, "aborting"),
+            isNull(fileUploadSessions.fileId),
+          ),
+          lte(fileUploadSessions.expiresAt, new Date(now)),
+        ),
+      )
+      .returning({ id: fileUploadSessions.id });
+    return rows.length === 1;
+  }
+
+  async deleteClaimedSession(id: string) {
+    const rows = await this.db
+      .delete(fileUploadSessions)
+      .where(
+        and(
+          eq(fileUploadSessions.id, id),
+          eq(fileUploadSessions.status, "expired"),
+        ),
+      )
+      .returning({ id: fileUploadSessions.id });
+    return rows.length === 1;
+  }
+
   async listArtifactRefs() {
-    const [partRows, fileRows] = await Promise.all([
-      this.db
-        .select({ artifactRef: fileUploadParts.artifactRef })
-        .from(fileUploadParts),
-      this.db
-        .select({ artifactRef: fileMetadata.artifactRef })
-        .from(fileMetadata),
-    ]);
-    return [...partRows, ...fileRows].map((row) =>
-      artifactRef(row.artifactRef),
-    );
+    return listDrizzleUploadArtifactRefs(this.db);
   }
 
   async deleteParts(sessionId: string) {
@@ -214,9 +301,17 @@ export class DrizzleUploadRepository implements UploadRepository {
 function mapSession(
   row: typeof fileUploadSessions.$inferSelect,
 ): UploadSession {
+  const { moduleName, authorizationScopeHash, ...session } = row;
+  if (Boolean(moduleName) !== Boolean(authorizationScopeHash)) {
+    throw new Error("上传授权绑定持久化不完整");
+  }
   return {
-    ...row,
+    ...session,
     status: row.status as UploadSession["status"],
+    authorizationBinding:
+      moduleName && authorizationScopeHash
+        ? { moduleName, scopeHash: authorizationScopeHash }
+        : undefined,
     expectedContentHash: row.expectedSha256
       ? sha256ContentHash(row.expectedSha256)
       : undefined,

package/template/apps/server/src/storage/host-runtime.ts

@@ -0,0 +1,15 @@
+import type { UploadPolicy } from "@southwind-ai/storage";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import { createReportStagingRuntime } from "../report-staging/runtime.js";
+import { createStorageRuntime } from "./runtime.js";
+
+export function createStorageHostRuntime(
+  env: Record<string, string | undefined>,
+  db: NodePgDatabase | undefined,
+  policies: readonly UploadPolicy[],
+) {
+  return {
+    storageRuntime: createStorageRuntime(env, db, policies),
+    reportStagingRuntime: createReportStagingRuntime(env, db),
+  };
+}

package/template/apps/server/src/storage/routes-stream-cancellation.test.ts

@@ -0,0 +1,154 @@
+import { describe, expect, test } from "bun:test";
+import {
+  FileService,
+  InMemoryUploadRepository,
+  MemoryBlobStore,
+  UploadService,
+} from "@southwind-ai/storage";
+import { createFoundationSnapshot } from "../foundation.js";
+import type { RequestActor } from "../guards.js";
+import { createServerRuntime } from "../runtime.js";
+import { FakeRouteApp } from "../system/route-test-app.js";
+import { platformUploadPolicies } from "./runtime.js";
+import { registerStorageRoutes } from "./routes.js";
+
+describe("legacy Storage 分片路由取消未读请求体", () => {
+  test("Guard、参数校验和存储拒绝均 best-effort cancel 且保留原响应", async () => {
+    const fixture = setup();
+
+    const guardDenied = cancellableRequest();
+    const denied = await fixture.invoke(
+      actor([]),
+      "upload_11111111111111111111111111111111",
+      guardDenied.request,
+    );
+    expect(denied.status).toBe(403);
+    expect(guardDenied.cancelled()).toBe(true);
+
+    const session = await fixture.uploads.create({
+      ownerId: "uploader",
+      purpose: "bulk-data",
+      filename: "source.ndjson",
+      mimeType: "application/x-ndjson",
+      expectedByteSize: 3,
+    });
+    const invalid = cancellableRequest({ omitContentLength: true });
+    const invalidResponse = await fixture.invoke(
+      actor(["system.storage.create"]),
+      session.id,
+      invalid.request,
+    );
+    expect(invalidResponse.status).toBe(400);
+    await expect(invalidResponse.json()).resolves.toMatchObject({
+      error: "INVALID_UPLOAD",
+    });
+    expect(invalid.cancelled()).toBe(true);
+
+    const missing = cancellableRequest();
+    const missingResponse = await fixture.invoke(
+      actor(["system.storage.create"]),
+      "upload_22222222222222222222222222222222",
+      missing.request,
+    );
+    expect(missingResponse.status).toBe(404);
+    await expect(missingResponse.json()).resolves.toMatchObject({
+      error: "UPLOAD_NOT_FOUND",
+    });
+    expect(missing.cancelled()).toBe(true);
+  });
+
+  test("Guard 求值异常也取消未读请求体并保留原异常", async () => {
+    const fixture = setup(true);
+    const request = cancellableRequest();
+    await expect(
+      fixture.invoke(
+        actor(["system.storage.create"]),
+        "upload_33333333333333333333333333333333",
+        request.request,
+      ),
+    ).rejects.toThrow("injected guard failure");
+    expect(request.cancelled()).toBe(true);
+  });
+});
+
+function setup(guardFailure = false) {
+  const repository = new InMemoryUploadRepository();
+  const blobs = new MemoryBlobStore();
+  const uploads = new UploadService({
+    repository,
+    blobStore: blobs,
+    policies: platformUploadPolicies,
+  });
+  const runtime = createServerRuntime(
+    { NODE_ENV: "test" },
+    { featureCatalog: createFoundationSnapshot().features },
+  );
+  if (guardFailure) {
+    runtime.resolveFeature = async () => {
+      throw new Error("injected guard failure");
+    };
+  }
+  const app = new FakeRouteApp();
+  registerStorageRoutes(
+    app,
+    { uploads, files: new FileService(repository, blobs) },
+    runtime,
+    createFoundationSnapshot().features,
+  );
+  return {
+    uploads,
+    async invoke(
+      currentActor: RequestActor,
+      sessionId: string,
+      request: Request,
+    ) {
+      const guardContext = await runtime.createGuardContextForActor(
+        request,
+        currentActor,
+      );
+      return (await app.invoke(
+        "PUT",
+        "/system/storage/uploads/:id/parts/:partNumber",
+        {
+          guardContext,
+          request,
+          params: { id: sessionId, partNumber: "0" },
+          query: {},
+        },
+      )) as Response;
+    },
+  };
+}
+
+function cancellableRequest(options: { omitContentLength?: boolean } = {}) {
+  let wasCancelled = false;
+  const body = new ReadableStream<Uint8Array>({
+    cancel() {
+      wasCancelled = true;
+      throw new Error("injected cancel failure");
+    },
+  });
+  const headers: Record<string, string> = {
+    "x-upload-offset": "0",
+    "x-content-sha256": "0".repeat(64),
+  };
+  if (!options.omitContentLength) headers["content-length"] = "3";
+  return {
+    request: new Request("http://localhost/api/system/storage/upload", {
+      method: "PUT",
+      headers,
+      body,
+    }),
+    cancelled: () => wasCancelled,
+  };
+}
+
+function actor(permissionKeys: string[]): RequestActor {
+  return {
+    id: "uploader",
+    type: "user",
+    name: "上传者",
+    roleCodes: [],
+    permissionKeys,
+  };
+}

package/template/apps/server/src/storage/routes.test.ts

@@ -97,7 +97,12 @@ describe("文件存储路由", () => {
     expect(await downloaded.text()).toBe('{"id":1}\n');
     expect(
       fixture.runtime.auditSink.list().map(({ action }) => action),
-    ).toEqual(["file.upload.create", "file.upload.complete", "file.download"]);
+    ).toEqual([
+      "file.upload.create",
+      "file.upload.part.write",
+      "file.upload.complete",
+      "file.download",
+    ]);
   });
 
   test("只读权限不绕过 Owner；manage 权限可执行受审计的跨 Owner 下载", async () => {
@@ -261,7 +266,13 @@ function context(
   body?: unknown,
   params: Record<string, string> = {},
 ) {
-  return { guardContext, body, params, query: {} };
+  return {
+    guardContext,
+    body,
+    params,
+    query: {},
+    request: new Request("http://localhost/api/system/storage"),
+  };
 }
 
 function actor(id: string, permissionKeys: string[]): RequestActor {

package/template/apps/server/src/storage/routes.ts

@@ -117,23 +117,42 @@ export function registerStorageRoutes(
               ),
               sha256: context.request.headers.get("x-content-sha256") || "",
               body: context.request.body,
+              signal: context.request.signal,
             });
+            record(
+              runtime,
+              context.guardContext,
+              "file.upload.part.write",
+              part.sessionId,
+              {
+                partNumber: part.partNumber,
+                byteOffset: part.byteOffset,
+                byteSize: part.byteSize,
+                sha256: part.contentHash.value,
+              },
+            );
             return Response.json({
               partNumber: part.partNumber,
               receivedByteSize: part.byteOffset + part.byteSize,
               sha256: part.contentHash.value,
             });
           } catch (error) {
+            await cancelUnreadBody(
+              context.request.body,
+              "storage-upload-rejected",
+            );
             return uploadError(error);
           }
         },
+        false,
+        context.request.body,
       );
     },
     { parse: "none" },
   );
 
   app.post("/system/storage/uploads/:id/complete", async (rawContext) => {
-    const { guardContext, params } = routeContext(rawContext);
+    const { guardContext, params, request } = routeContext(rawContext);
     return guarded(
       runtime,
       guardContext,
@@ -145,6 +164,7 @@ export function registerStorageRoutes(
           const file = await services.uploads.complete(
             string(params.id),
             guardContext.actor.id,
+            request.signal,
           );
           record(runtime, guardContext, "file.upload.complete", file.id, {
             purpose: file.purpose,
@@ -160,7 +180,7 @@ export function registerStorageRoutes(
   });
 
   app.delete("/system/storage/uploads/:id", async (rawContext) => {
-    const { guardContext, params } = routeContext(rawContext);
+    const { guardContext, params, request } = routeContext(rawContext);
     return guarded(
       runtime,
       guardContext,
@@ -170,7 +190,11 @@ export function registerStorageRoutes(
       async () => {
         try {
           const id = string(params.id);
-          await services.uploads.abort(id, guardContext.actor.id);
+          await services.uploads.abort(
+            id,
+            guardContext.actor.id,
+            request.signal,
+          );
           record(runtime, guardContext, "file.upload.abort", id, {});
           return new Response(null, { status: 204 });
         } catch (error) {
@@ -258,22 +282,36 @@ async function guarded<T>(
   permissionKey: string,
   handler: () => T | Promise<T>,
   anonymous = false,
+  unreadBody?: ReadableStream<Uint8Array> | null,
 ) {
-  const result = await evaluateRouteGuards(runtime, context, {
-    permission: {
-      method,
-      path: "/api/system/storage",
-      permissionKey,
-      anonymous,
-    },
-    feature,
-  });
-  return result.allowed
-    ? handler()
-    : Response.json(
-        { error: "FORBIDDEN", reason: result.reason },
-        { status: 403 },
-      );
+  let result: Awaited<ReturnType<typeof evaluateRouteGuards>>;
+  try {
+    result = await evaluateRouteGuards(runtime, context, {
+      permission: {
+        method,
+        path: "/api/system/storage",
+        permissionKey,
+        anonymous,
+      },
+      feature,
+    });
+  } catch (error) {
+    await cancelUnreadBody(unreadBody, "storage-upload-guard-failed");
+    throw error;
+  }
+  if (result.allowed) return handler();
+  await cancelUnreadBody(unreadBody, "storage-upload-guard-denied");
+  return Response.json(
+    { error: "FORBIDDEN", reason: result.reason },
+    { status: 403 },
+  );
+}
+
+async function cancelUnreadBody(
+  body: ReadableStream<Uint8Array> | null | undefined,
+  reason: string,
+): Promise<void> {
+  await body?.cancel(reason).catch(() => undefined);
 }
 
 function record(
@@ -281,6 +319,7 @@ function record(
   context: ReturnType<typeof routeContext>["guardContext"],
   action:
     | "file.upload.create"
+    | "file.upload.part.write"
     | "file.upload.complete"
     | "file.upload.abort"
     | "file.download",

package/template/apps/server/src/storage/runtime.ts

@@ -23,6 +23,14 @@ export interface StorageRuntime {
 }
 
 export const platformUploadPolicies: UploadPolicy[] = [
+  {
+    purpose: "agent-screenshot",
+    maxByteSize: 8 * 1024 * 1024,
+    maxPartByteSize: 8 * 1024 * 1024,
+    sessionTtlMs: 60_000,
+    allowedTypes: { "image/png": ["png"] },
+    signature: "image",
+  },
   {
     purpose: "bulk-data",
     maxByteSize: 512 * 1024 * 1024,
@@ -56,7 +64,9 @@ export function createPlatformUploadPolicies(
     maxByteSize:
       policy.purpose === "bulk-data"
         ? config.storage.bulkDataMaxByteSize
-        : config.storage.brandingLogoMaxByteSize,
+        : policy.purpose === "branding-logo"
+          ? config.storage.brandingLogoMaxByteSize
+          : policy.maxByteSize,
   }));
 }
 
@@ -64,11 +74,12 @@ export function createStorageRuntime(
   env: Record<string, string | undefined>,
   db?: NodePgDatabase,
   policies: readonly UploadPolicy[] = platformUploadPolicies,
+  now?: () => Date,
 ): StorageRuntime {
   if (!db) {
     const repository = new InMemoryUploadRepository();
     const blobStore = new MemoryBlobStore();
-    return createRuntime(repository, blobStore, policies);
+    return createRuntime(repository, blobStore, policies, undefined, now);
   }
   const driver = env.WINDY_BLOB_DRIVER || "local";
   if (driver !== "local") {
@@ -78,7 +89,7 @@ export function createStorageRuntime(
   const repository = new DrizzleUploadRepository(db);
   const blobStore = new LocalFileBlobStore({ root });
   const maintenance = new LocalFileBlobMaintenance(root);
-  return createRuntime(repository, blobStore, policies, maintenance);
+  return createRuntime(repository, blobStore, policies, maintenance, now);
 }
 
 function createRuntime(
@@ -86,6 +97,7 @@ function createRuntime(
   blobStore: BlobStore,
   policies: readonly UploadPolicy[],
   maintenance?: BlobStoreMaintenance,
+  now?: () => Date,
 ): StorageRuntime {
   return {
     repository,
@@ -95,7 +107,8 @@ function createRuntime(
       blobStore,
       maintenance,
       policies,
+      now,
     }),
-    files: new FileService(repository, blobStore),
+    files: new FileService(repository, blobStore, now),
   };
 }

package/template/apps/server/src/system/route-types.ts

@@ -25,7 +25,11 @@ export interface RouteApp {
     handler: (context: unknown) => unknown,
     options?: { parse?: "none" },
   ): unknown;
-  delete(path: string, handler: (context: unknown) => unknown): unknown;
+  delete(
+    path: string,
+    handler: (context: unknown) => unknown,
+    options?: { parse?: "none" },
+  ): unknown;
 }
 
 export interface ResourceRouteConfig<T extends ManagedEntity> {

package/template/apps/server/src/system/system-resource-monitoring.test.ts

@@ -2,6 +2,7 @@ import { describe, expect, test } from "bun:test";
 import {
   calculateCpuMonitor,
   createGpuMonitorProbe,
+  terminateTimedOutProcess,
   type CpuSample,
 } from "./system-resource-monitoring.js";
 
@@ -79,4 +80,50 @@ describe("系统 CPU 与 GPU 监控", () => {
       devices: [],
     });
   });
+
+  test("设备查询抛错时降级而不拖垮运维快照", async () => {
+    const probe = createGpuMonitorProbe(async () => {
+      throw new Error("spawn EPERM");
+    });
+
+    await expect(probe()).resolves.toMatchObject({
+      status: "unavailable",
+      provider: "NVIDIA",
+      devices: [],
+      message: "nvidia-smi 查询失败，无法读取 GPU 指标。",
+    });
+  });
+
+  test("进程查询抛错时保留已取得的设备指标", async () => {
+    const probe = createGpuMonitorProbe(async (args) => {
+      if (args[0]?.startsWith("--query-gpu=")) {
+        return {
+          exitCode: 0,
+          stdout: "0, GPU-abc, NVIDIA RTX 5000, 75, 8192, 32768, 62\n",
+        };
+      }
+      throw new Error("process query failed");
+    });
+
+    await expect(probe()).resolves.toMatchObject({
+      status: "available",
+      devices: [{ uuid: "GPU-abc", processes: [] }],
+      message: "GPU 设备指标可用，但计算进程明细暂不可用。",
+    });
+  });
+
+  test("超时进程在宽限期后强制终止且不会无限等待 exited", async () => {
+    const signals: Array<number | undefined> = [];
+    await terminateTimedOutProcess(
+      {
+        exitCode: null,
+        exited: new Promise<number>(() => undefined),
+        kill: (signal) => signals.push(signal),
+      },
+      async () => undefined,
+      1,
+    );
+
+    expect(signals).toEqual([undefined, 9]);
+  });
 });