create-windy 0.5.2 → 0.6.1

package/template/packages/storage/src/upload-validation.ts

@@ -0,0 +1,127 @@
+import { randomUUID } from "node:crypto";
+import {
+  UploadError,
+  type UploadAuthorizationBinding,
+  type UploadPart,
+  type UploadPartInput,
+  type UploadPolicy,
+  type UploadSession,
+} from "./upload-types.js";
+
+export function canonicalizeUploadIdentity(
+  input: { readonly filename: string; readonly mimeType: string },
+  allowedTypes: Readonly<Record<string, readonly string[]>>,
+) {
+  const filename = validFilename(input.filename);
+  const extension = extensionOf(filename);
+  const mimeType = normalizeMime(input.mimeType);
+  validateAllowedType(allowedTypes, mimeType, extension);
+  return { filename, extension, mimeType };
+}
+
+export function validateAuthorizationBinding(
+  binding: UploadAuthorizationBinding | undefined,
+): void {
+  if (
+    binding &&
+    (!/^[a-z0-9][a-z0-9._-]{0,79}$/.test(binding.moduleName) ||
+      !/^[0-9a-f]{64}$/.test(binding.scopeHash))
+  ) {
+    throw new UploadError("INVALID_UPLOAD", "上传授权绑定无效");
+  }
+}
+
+export function randomOpaqueId(prefix: "upload" | "file") {
+  return `${prefix}_${randomUUID().replaceAll("-", "")}`;
+}
+
+export function validFilename(value: string) {
+  const filename = value.trim();
+  if (
+    !filename ||
+    filename.length > 240 ||
+    filename.includes("/") ||
+    filename.includes("\\") ||
+    filename.includes(String.fromCharCode(0))
+  ) {
+    throw new UploadError("INVALID_UPLOAD", "文件名无效");
+  }
+  return filename;
+}
+
+export function extensionOf(filename: string) {
+  const dot = filename.lastIndexOf(".");
+  if (dot < 1 || dot === filename.length - 1) {
+    throw new UploadError("UNSUPPORTED_FILE_TYPE", "文件扩展名无效");
+  }
+  return filename.slice(dot + 1).toLowerCase();
+}
+
+export function normalizeMime(value: string) {
+  return value.split(";", 1)[0]!.trim().toLowerCase();
+}
+
+export function validateType(
+  policy: UploadPolicy,
+  mime: string,
+  extension: string,
+) {
+  validateAllowedType(policy.allowedTypes, mime, extension);
+}
+
+function validateAllowedType(
+  allowedTypes: Readonly<Record<string, readonly string[]>>,
+  mime: string,
+  extension: string,
+) {
+  if (!allowedTypes[mime]?.includes(extension)) {
+    throw new UploadError(
+      "UNSUPPORTED_FILE_TYPE",
+      "MIME 类型与文件扩展名不匹配或不受支持",
+    );
+  }
+}
+
+export function validatePartSize(
+  size: number,
+  policy: UploadPolicy,
+  session: UploadSession,
+) {
+  if (!Number.isSafeInteger(size) || size <= 0) {
+    throw new UploadError("INVALID_UPLOAD", "分片大小无效");
+  }
+  if (size > policy.maxPartByteSize) {
+    throw new UploadError("PART_TOO_LARGE", "分片超过允许大小");
+  }
+  if (session.receivedByteSize + size > session.expectedByteSize) {
+    throw new UploadError("UPLOAD_TOO_LARGE", "分片超过文件声明大小");
+  }
+}
+
+export function samePart(
+  part: UploadPart,
+  input: UploadPartInput,
+  hash: string,
+) {
+  return (
+    part.byteOffset === input.byteOffset &&
+    part.byteSize === input.byteSize &&
+    part.contentHash.value === hash
+  );
+}
+
+export function ensureContiguous(
+  parts: readonly UploadPart[],
+  session: UploadSession,
+) {
+  let offset = 0;
+  for (const [index, part] of parts.entries()) {
+    if (part.partNumber !== index || part.byteOffset !== offset) {
+      throw new UploadError("UPLOAD_INCOMPLETE", "上传分片不连续");
+    }
+    offset += part.byteSize;
+  }
+  if (offset !== session.expectedByteSize) {
+    throw new UploadError("UPLOAD_INCOMPLETE", "上传分片大小不完整");
+  }
+}

package/template/scripts/provision-speech-readiness.ts

@@ -0,0 +1,147 @@
+import { randomUUID } from "node:crypto";
+import { chmod, readFile, rename, writeFile } from "node:fs/promises";
+
+const environmentPath = ".env";
+const temporaryPath = ".env.speech-pins.tmp";
+const source = await readFile(environmentPath, "utf8").catch(() => "");
+const values = parseEnvironment(source);
+const deploymentKey = values.SPEECH_DEPLOYMENT_KEY || "speech.primary";
+const deploymentIdentity =
+  values.SPEECH_DEPLOYMENT_IDENTITY || `windy-deployment-v1_${randomUUID()}`;
+
+const process = Bun.spawn(
+  [
+    "docker",
+    "compose",
+    "--profile",
+    "speech",
+    "run",
+    "--build",
+    "--rm",
+    "-e",
+    `SPEECH_DEPLOYMENT_KEY=${deploymentKey}`,
+    "-e",
+    `SPEECH_DEPLOYMENT_IDENTITY=${deploymentIdentity}`,
+    "speech-server",
+    "python",
+    "-m",
+    "southwind_speech_server.pin_cli",
+  ],
+  { stdout: "pipe", stderr: "pipe" },
+);
+const timeout = setTimeout(() => process.kill(), 120_000);
+const [stdout, stderr, exitCode] = await Promise.all([
+  readBounded(process.stdout, 1024 * 1024),
+  readBounded(process.stderr, 1024 * 1024),
+  process.exited,
+]);
+clearTimeout(timeout);
+if (exitCode !== 0) {
+  const detail = stderr.trim().split(/\r?\n/).at(-1) || "full probe failed";
+  throw new Error(`Speech readiness pins 生成失败：${detail.slice(0, 200)}`);
+}
+const pins = parsePins(stdout);
+if (
+  pins.deploymentKey !== deploymentKey ||
+  pins.deploymentIdentity !== deploymentIdentity
+) {
+  throw new Error("Speech readiness pins 身份不匹配");
+}
+const updated = updateEnvironment(source, {
+  SPEECH_DEPLOYMENT_KEY: pins.deploymentKey,
+  SPEECH_DEPLOYMENT_IDENTITY: pins.deploymentIdentity,
+  SPEECH_RELEASE_DIGEST: pins.releaseDigest,
+  SPEECH_OFFERS_DIGEST: pins.offersDigest,
+});
+await writeFile(temporaryPath, updated, { mode: 0o600 });
+await rename(temporaryPath, environmentPath);
+await chmod(environmentPath, 0o600);
+console.log("Speech readiness full probe 已通过并写入 .env（权限 0600）");
+
+interface SpeechPins {
+  deploymentKey: string;
+  deploymentIdentity: string;
+  releaseDigest: string;
+  offersDigest: string;
+}
+
+function parsePins(output: string): SpeechPins {
+  for (const line of output.trim().split(/\r?\n/).reverse()) {
+    try {
+      const value: unknown = JSON.parse(line);
+      if (validPins(value)) return value;
+    } catch {
+      // Docker may emit bounded progress lines before the single JSON result.
+    }
+  }
+  throw new Error("Speech readiness pins 输出无效");
+}
+
+function validPins(value: unknown): value is SpeechPins {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const item = value as Record<string, unknown>;
+  return (
+    typeof item.deploymentKey === "string" &&
+    /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,127}$/.test(item.deploymentKey) &&
+    typeof item.deploymentIdentity === "string" &&
+    /^windy-deployment-v1_[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}$/.test(
+      item.deploymentIdentity,
+    ) &&
+    typeof item.releaseDigest === "string" &&
+    /^sha256:[a-f0-9]{64}$/.test(item.releaseDigest) &&
+    typeof item.offersDigest === "string" &&
+    /^sha256:[a-f0-9]{64}$/.test(item.offersDigest)
+  );
+}
+
+function parseEnvironment(source: string) {
+  const result: Record<string, string> = {};
+  for (const line of source.split(/\r?\n/)) {
+    const match = /^([A-Z][A-Z0-9_]*)=(.*)$/.exec(line);
+    if (match) result[match[1]!] = match[2]!.trim();
+  }
+  return result;
+}
+
+function updateEnvironment(
+  source: string,
+  changes: Readonly<Record<string, string>>,
+) {
+  const remaining = new Map(Object.entries(changes));
+  const lines = source.split(/\r?\n/).map((line) => {
+    const match = /^([A-Z][A-Z0-9_]*)=/.exec(line);
+    const value = match ? remaining.get(match[1]!) : undefined;
+    if (value === undefined || !match) return line;
+    remaining.delete(match[1]!);
+    return `${match[1]}=${value}`;
+  });
+  if (lines.at(-1) === "") lines.pop();
+  for (const [key, value] of remaining) lines.push(`${key}=${value}`);
+  return `${lines.join("\n")}\n`;
+}
+
+async function readBounded(
+  stream: ReadableStream<Uint8Array>,
+  maximum: number,
+) {
+  const reader = stream.getReader();
+  const chunks: Uint8Array[] = [];
+  let size = 0;
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    size += value.byteLength;
+    if (size > maximum) {
+      process.kill();
+      throw new Error("Speech readiness pin 子进程输出超过上限");
+    }
+    chunks.push(value);
+  }
+  const bytes = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+}