create-windy 0.2.6 → 0.2.8

package/template/packages/license-sdk/src/offline-code.test.ts

@@ -1,172 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { zlibSync } from "fflate";
-import type { SignedLicenseV1 } from "@windy/shared";
-import { canonicalizeJson } from "./canonical-json.js";
-import { LicenseInstaller } from "./installation.js";
-import {
-  decodeOfflineActivationCode,
-  encodeOfflineActivationCode,
-  OfflineActivationCodeError,
-  offlineActivationCodeErrorMessage,
-  splitOfflineActivationCode,
-} from "./offline-code.js";
-import { MemoryAtomicLicenseStore } from "./storage.js";
-import { createSignedLicenseV1 } from "./test-fixtures.js";
-import { LICENSE_V1_TEST_VECTOR } from "./v1-test-vector.js";
-import { encodeBase32, segmentChecksum } from "./offline-code-base32.js";
-
-const FIXED_CODE =
-  "W1-00002BKRVA5NDJP99H7CTATEHPY-MQMPK9ES4QRMBSKAK952APFSHGP-5TKN1DS14JRJEB5Z50A2H4JWBAJ-9FS77MR1ABGDAG0HCXEG60RGAYR-AKV7XXXBMVPPTC4H6QXPYWZNVFB-DZ8B73QD830858QW5JG4517A08A-0PTMQHFVKW7SXHVJ7GZJY958JD1-4CKJHW8DT8R34CSJG9MG9S6WRR6-KJ8SK5XA1D8G55C0N0RXED9M17V-0RK1C024CYG60W352R99C811TGT-MW955JRJYE9N0M43SYBTGSSXV1N-JTZXJFF38PB9VKXVQC025A99CV9-PMKKY85Q4MZK9A07C58NCZKEF8M-TF6WTKT9SQ8081JC5G0PD6PX9AM-6BBD667KDYH64M0ZSMDW5Y47BTT-6GBJVKXKQDYRHDM9WNJS4R68Y4E-5VFNY9XMXJQAYGYQ2D5FJ86XVBK-7ZBW4RY5QPAVYVNCEJE5RE4AKEW-80AHEBNCBG5X";
-
-describe("W1 分组离线激活码", () => {
-  test("固定 V1 向量确定性编码并还原同一 SignedLicenseV1", () => {
-    const license = fixedLicense();
-    expect(encodeOfflineActivationCode(license)).toBe(FIXED_CODE);
-    const decoded = decodeOfflineActivationCode(FIXED_CODE);
-    expect(decoded.license).toEqual(license);
-    expect(decoded.canonicalLicense).toBe(canonicalizeJson(license));
-    expect(splitOfflineActivationCode(FIXED_CODE)).toHaveLength(20);
-  });
-
-  test("忽略大小写、空白、换行和连字符并安全归一化易混字符", () => {
-    const handwritten = FIXED_CODE.toLowerCase()
-      .replace(/^w1-/, "wI\n")
-      .replace(/0/g, "o")
-      .replace(/-/g, " \n");
-    expect(decodeOfflineActivationCode(handwritten).license).toEqual(
-      fixedLicense(),
-    );
-  });
-
-  test("单字符错误定位到具体分组，不自动修复", () => {
-    const damaged = replaceCharacter(FIXED_CODE, 3, "1");
-    expectCodeError(damaged, "group-checksum", 1);
-    try {
-      decodeOfflineActivationCode(damaged);
-    } catch (error) {
-      expect(offlineActivationCodeErrorMessage(error)).toContain("第 1 段");
-    }
-  });
-
-  test("拒绝校验字符错误、截断和未知版本", () => {
-    expectCodeError(replaceCharacter(FIXED_CODE, 27, "1"), "group-checksum", 1);
-    expect(() => decodeOfflineActivationCode(FIXED_CODE.slice(0, -1))).toThrow(
-      OfflineActivationCodeError,
-    );
-    expectCodeError(FIXED_CODE.replace(/^W1/, "W2"), "unsupported-version");
-  });
-
-  test("在规范化和 Base32 解码前拒绝超长打印码", () => {
-    expectCodeError(`W1-${"A".repeat(32 * 1024)}`, "input-too-long");
-  });
-
-  test("增量解压在压缩炸弹超过声明长度时立即拒绝", () => {
-    const compressed = zlibSync(new Uint8Array(2 * 1024 * 1024));
-    const bomb = codeFromCompressedPayload(compressed, 1024);
-    expectCodeError(bomb, "decompression-limit");
-  });
-
-  test("Base32 解码后拒绝超过压缩数据上限的信封", () => {
-    const oversizedCompressed = new Uint8Array(16 * 1024 + 1);
-    const code = codeFromCompressedPayload(oversizedCompressed, 1024);
-    expectCodeError(code, "decompression-limit");
-  });
-
-  test("编码层不认可篡改，验签失败和错误设备码都不覆盖 current", async () => {
-    const current = createSignedLicenseV1({
-      ...LICENSE_V1_TEST_VECTOR.claims,
-      licenseId: "current",
-      machineCode: "machine_1",
-      issuedAt: "2026-07-01T00:00:00.000Z",
-    });
-    const candidate = createSignedLicenseV1({
-      ...LICENSE_V1_TEST_VECTOR.claims,
-      licenseId: "candidate",
-      machineCode: "machine_2",
-      issuedAt: "2026-07-20T00:00:00.000Z",
-    });
-    const original = canonicalizeJson(current.license);
-    const store = new MemoryAtomicLicenseStore(original);
-    const decoded = decodeOfflineActivationCode(
-      encodeOfflineActivationCode(candidate.license),
-    );
-    const result = await new LicenseInstaller({
-      store,
-      productCode: "windy-platform",
-      machineCode: "machine_1",
-      publicKeys: { key_v1: candidate.publicKeyPem },
-      now: new Date("2026-08-01T00:00:00.000Z"),
-    }).install(decoded.canonicalLicense);
-
-    expect(result.status).toBe("rejected");
-    expect(result.failures).toContain("machine-mismatch");
-    expect(await store.readCurrent()).toBe(original);
-
-    const tampered = {
-      ...candidate.license,
-      claims: {
-        ...candidate.license.claims,
-        customer: { ...candidate.license.claims.customer, name: "篡改客户" },
-      },
-    };
-    const decodedTampered = decodeOfflineActivationCode(
-      encodeOfflineActivationCode(tampered),
-    );
-    const tamperedResult = await new LicenseInstaller({
-      store,
-      productCode: "windy-platform",
-      machineCode: "machine_2",
-      publicKeys: { key_v1: candidate.publicKeyPem },
-      now: new Date("2026-08-01T00:00:00.000Z"),
-    }).install(decodedTampered.canonicalLicense);
-    expect(tamperedResult.failures).toContain("invalid-signature");
-    expect(await store.readCurrent()).toBe(original);
-  });
-});
-
-function fixedLicense(): SignedLicenseV1 {
-  return {
-    formatVersion: 1,
-    algorithm: "ED25519",
-    publicKeyId: LICENSE_V1_TEST_VECTOR.keyId,
-    claims: LICENSE_V1_TEST_VECTOR.claims,
-    signature: LICENSE_V1_TEST_VECTOR.signature,
-  };
-}
-
-function replaceCharacter(value: string, index: number, next: string): string {
-  const compact = value.replaceAll("-", "");
-  const replaced = compact.slice(0, index) + next + compact.slice(index + 1);
-  return replaced;
-}
-
-function expectCodeError(
-  value: string,
-  code: OfflineActivationCodeError["code"],
-  groupIndex?: number,
-): void {
-  try {
-    decodeOfflineActivationCode(value);
-    throw new Error("预期离线激活码被拒绝");
-  } catch (error) {
-    expect(error).toBeInstanceOf(OfflineActivationCodeError);
-    expect((error as OfflineActivationCodeError).code).toBe(code);
-    expect((error as OfflineActivationCodeError).groupIndex).toBe(groupIndex);
-  }
-}
-
-function codeFromCompressedPayload(
-  compressed: Uint8Array,
-  expectedLength: number,
-): string {
-  const envelope = new Uint8Array(4 + compressed.length + 64 + 4);
-  new DataView(envelope.buffer).setUint32(0, expectedLength);
-  envelope.set(compressed, 4);
-  const encoded = encodeBase32(envelope);
-  const groups: string[] = [];
-  for (let offset = 0; offset < encoded.length; offset += 25) {
-    const data = encoded.slice(offset, offset + 25);
-    groups.push(data + segmentChecksum(data, groups.length));
-  }
-  return `W1-${groups.join("-")}`;
-}

package/template/packages/license-sdk/src/offline-code.ts

@@ -1,319 +0,0 @@
-import { strFromU8, strToU8, zlibSync } from "fflate";
-import type { SignedLicense } from "@windy/shared";
-import { canonicalizeJson } from "./canonical-json.js";
-import { parseSignedLicense } from "./license-parser.js";
-import {
-  decodeBase32,
-  encodeBase32,
-  isBase32Character,
-  segmentChecksum,
-} from "./offline-code-base32.js";
-import {
-  decodeEd25519Signature,
-  ED25519_SIGNATURE_BYTES,
-  encodeEd25519Signature,
-  fromCompactTuple,
-  toCompactTuple,
-} from "./offline-code-wire.js";
-import { OFFLINE_ACTIVATION_CODE_LIMITS } from "./offline-code-limits.js";
-import {
-  decompressOfflineCode,
-  OfflineCodeDecompressionLimitError,
-} from "./offline-code-decompression.js";
-
-const PREFIX = "W1";
-const DATA_CHARACTERS_PER_SEGMENT = 25;
-const CHECKSUM_CHARACTERS = 2;
-const MAX_CANONICAL_BYTES = OFFLINE_ACTIVATION_CODE_LIMITS.decompressedBytes;
-
-export type OfflineActivationCodeErrorCode =
-  | "empty"
-  | "invalid-prefix"
-  | "unsupported-version"
-  | "invalid-character"
-  | "invalid-length"
-  | "input-too-long"
-  | "decompression-limit"
-  | "group-checksum"
-  | "payload-checksum"
-  | "damaged-payload"
-  | "invalid-license";
-
-export class OfflineActivationCodeError extends Error {
-  constructor(
-    readonly code: OfflineActivationCodeErrorCode,
-    message: string,
-    readonly groupIndex?: number,
-  ) {
-    super(message);
-    this.name = "OfflineActivationCodeError";
-  }
-}
-
-export interface DecodedOfflineActivationCode {
-  license: SignedLicense;
-  canonicalLicense: string;
-}
-
-export function encodeOfflineActivationCode(license: SignedLicense): string {
-  const canonicalLicense = canonicalizeJson(license);
-  const validated = parseSignedLicense(canonicalLicense);
-  if (!validated) {
-    throw new OfflineActivationCodeError("invalid-license", "License 格式无效");
-  }
-  const raw = strToU8(JSON.stringify(toCompactTuple(validated)));
-  if (raw.byteLength > MAX_CANONICAL_BYTES) {
-    throw new OfflineActivationCodeError("invalid-license", "License 内容过长");
-  }
-  const compressed = zlibSync(raw, { level: 9 });
-  if (compressed.byteLength > OFFLINE_ACTIVATION_CODE_LIMITS.compressedBytes) {
-    throw new OfflineActivationCodeError(
-      "invalid-license",
-      "License 压缩内容过长",
-    );
-  }
-  let signature: Uint8Array;
-  try {
-    signature = decodeEd25519Signature(validated.signature);
-  } catch (error) {
-    throw new OfflineActivationCodeError(
-      "invalid-license",
-      error instanceof Error ? error.message : "License ED25519 签名无效",
-    );
-  }
-  const envelope = new Uint8Array(
-    4 + compressed.byteLength + ED25519_SIGNATURE_BYTES + 4,
-  );
-  writeUint32(envelope, 0, raw.byteLength);
-  envelope.set(compressed, 4);
-  envelope.set(signature, 4 + compressed.byteLength);
-  writeUint32(
-    envelope,
-    envelope.byteLength - 4,
-    crc32(strToU8(canonicalLicense)),
-  );
-  return formatGroups(encodeBase32(envelope));
-}
-
-export function decodeOfflineActivationCode(
-  input: string,
-): DecodedOfflineActivationCode {
-  const normalized = normalizeInput(input);
-  const encoded = verifyAndJoinGroups(normalized.slice(PREFIX.length));
-  let envelope: Uint8Array;
-  try {
-    envelope = decodeBase32(encoded);
-  } catch {
-    throw new OfflineActivationCodeError(
-      "damaged-payload",
-      "激活码末尾数据不完整或已损坏",
-    );
-  }
-  if (envelope.byteLength < 10) {
-    throw new OfflineActivationCodeError(
-      "invalid-length",
-      "激活码数据长度不足",
-    );
-  }
-  const expectedLength = readUint32(envelope, 0);
-  if (expectedLength === 0 || expectedLength > MAX_CANONICAL_BYTES) {
-    throw new OfflineActivationCodeError(
-      "damaged-payload",
-      "激活码声明的内容长度无效",
-    );
-  }
-  let raw: Uint8Array;
-  try {
-    raw = decompressOfflineCode(
-      envelope.subarray(4, -(ED25519_SIGNATURE_BYTES + 4)),
-      expectedLength,
-    );
-  } catch (error) {
-    if (error instanceof OfflineCodeDecompressionLimitError) {
-      throw new OfflineActivationCodeError(
-        "decompression-limit",
-        "离线激活码内容超过安全上限",
-      );
-    }
-    throw new OfflineActivationCodeError(
-      "damaged-payload",
-      "激活码压缩内容已损坏",
-    );
-  }
-  if (raw.byteLength !== expectedLength) {
-    throw new OfflineActivationCodeError(
-      "damaged-payload",
-      "激活码内容长度校验失败",
-    );
-  }
-  let compact: unknown;
-  try {
-    compact = JSON.parse(strFromU8(raw));
-  } catch {
-    throw new OfflineActivationCodeError(
-      "damaged-payload",
-      "激活码紧凑内容已损坏",
-    );
-  }
-  const signature = encodeEd25519Signature(
-    envelope.subarray(-(ED25519_SIGNATURE_BYTES + 4), -4),
-  );
-  let canonicalLicense: string;
-  try {
-    canonicalLicense = canonicalizeJson(fromCompactTuple(compact, signature));
-  } catch (error) {
-    throw new OfflineActivationCodeError(
-      "damaged-payload",
-      error instanceof Error ? error.message : "激活码紧凑字段无效",
-    );
-  }
-  if (
-    crc32(strToU8(canonicalLicense)) !==
-    readUint32(envelope, envelope.byteLength - 4)
-  ) {
-    throw new OfflineActivationCodeError(
-      "payload-checksum",
-      "激活码整体校验失败",
-    );
-  }
-  const license = parseSignedLicense(canonicalLicense);
-  if (!license || canonicalizeJson(license) !== canonicalLicense) {
-    throw new OfflineActivationCodeError(
-      "invalid-license",
-      "激活码不是规范的 License",
-    );
-  }
-  return { license, canonicalLicense };
-}
-
-export function splitOfflineActivationCode(code: string): string[] {
-  const normalized = normalizeInput(code);
-  const body = normalized.slice(PREFIX.length);
-  return [PREFIX, ...chunkGroups(body)];
-}
-
-export function offlineActivationCodeErrorMessage(error: unknown): string {
-  if (!(error instanceof OfflineActivationCodeError))
-    return "离线激活码无法识别";
-  if (error.code === "group-checksum" && error.groupIndex) {
-    return `第 ${error.groupIndex} 段输入有误，请对照签发页面重新输入`;
-  }
-  return error.message;
-}
-
-function normalizeInput(input: string): string {
-  if (input.length > OFFLINE_ACTIVATION_CODE_LIMITS.printedCharacters) {
-    throw new OfflineActivationCodeError("input-too-long", "离线激活码过长");
-  }
-  const compact = input.toUpperCase().replace(/[\s-]/g, "");
-  if (compact.length > OFFLINE_ACTIVATION_CODE_LIMITS.normalizedCharacters) {
-    throw new OfflineActivationCodeError("input-too-long", "离线激活码过长");
-  }
-  if (!compact)
-    throw new OfflineActivationCodeError("empty", "请输入离线激活码");
-  const normalized = compact.replace(/O/g, "0").replace(/[IL]/g, "1");
-  if (!normalized.startsWith("W")) {
-    throw new OfflineActivationCodeError(
-      "invalid-prefix",
-      "激活码必须以 W1 开头",
-    );
-  }
-  if (!normalized.startsWith(PREFIX)) {
-    throw new OfflineActivationCodeError(
-      "unsupported-version",
-      "不支持该激活码版本",
-    );
-  }
-  for (const character of normalized.slice(PREFIX.length)) {
-    if (!isBase32Character(character)) {
-      throw new OfflineActivationCodeError(
-        "invalid-character",
-        `激活码包含无法识别的字符：${character}`,
-      );
-    }
-  }
-  return normalized;
-}
-
-function formatGroups(encoded: string): string {
-  const segments: string[] = [];
-  for (
-    let offset = 0;
-    offset < encoded.length;
-    offset += DATA_CHARACTERS_PER_SEGMENT
-  ) {
-    const data = encoded.slice(offset, offset + DATA_CHARACTERS_PER_SEGMENT);
-    segments.push(data + segmentChecksum(data, segments.length));
-  }
-  return `${PREFIX}-${segments.join("-")}`;
-}
-
-function verifyAndJoinGroups(body: string): string {
-  if (body.length < 2) {
-    throw new OfflineActivationCodeError(
-      "invalid-length",
-      "激活码缺少数据分组",
-    );
-  }
-  const segments = chunkGroups(body);
-  return segments
-    .map((segment, index) => {
-      if (
-        segment.length <= CHECKSUM_CHARACTERS ||
-        segment.length > DATA_CHARACTERS_PER_SEGMENT + CHECKSUM_CHARACTERS
-      ) {
-        throw new OfflineActivationCodeError(
-          "invalid-length",
-          "激活码分段长度无效",
-          index + 1,
-        );
-      }
-      const data = segment.slice(0, -CHECKSUM_CHARACTERS);
-      if (
-        segment.slice(-CHECKSUM_CHARACTERS) !== segmentChecksum(data, index)
-      ) {
-        throw new OfflineActivationCodeError(
-          "group-checksum",
-          `第 ${index + 1} 段校验失败`,
-          index + 1,
-        );
-      }
-      return data;
-    })
-    .join("");
-}
-
-function chunkGroups(body: string): string[] {
-  const size = DATA_CHARACTERS_PER_SEGMENT + CHECKSUM_CHARACTERS;
-  const groups: string[] = [];
-  for (let offset = 0; offset < body.length; offset += size) {
-    groups.push(body.slice(offset, offset + size));
-  }
-  return groups;
-}
-
-function crc32(bytes: Uint8Array): number {
-  let crc = 0xffffffff;
-  for (const byte of bytes) {
-    crc ^= byte;
-    for (let bit = 0; bit < 8; bit += 1) {
-      crc = (crc >>> 1) ^ (crc & 1 ? 0xedb88320 : 0);
-    }
-  }
-  return (crc ^ 0xffffffff) >>> 0;
-}
-
-function readUint32(bytes: Uint8Array, offset: number): number {
-  return new DataView(
-    bytes.buffer,
-    bytes.byteOffset,
-    bytes.byteLength,
-  ).getUint32(offset);
-}
-
-function writeUint32(bytes: Uint8Array, offset: number, value: number): void {
-  new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength).setUint32(
-    offset,
-    value,
-  );
-}

package/template/packages/license-sdk/src/payload.test.ts

@@ -1,72 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { licenseVersionKey, type LicenseV1Claims } from "@windy/shared";
-import {
-  createLicenseSigningPayload,
-  getLicensePayloadHandler,
-  LicensePayloadError,
-  parseLicenseSigningPayload,
-} from "./payload.js";
-
-const claims: LicenseV1Claims = {
-  licenseId: "license_1",
-  productCode: "windy-platform",
-  customer: { id: "customer_1", code: "C001", name: "示例客户" },
-  project: { id: "project_1", code: "P001", name: "生产项目" },
-  contract: { id: "contract_1", contractNumber: "HT-001", version: "1" },
-  machineCode: "machine_1",
-  issuedAt: "2026-07-10T00:00:00.000Z",
-  expiresAt: "2027-07-10T00:00:00.000Z",
-  licenseVersion: {
-    key: licenseVersionKey("standard"),
-    name: "普通付费版",
-  },
-};
-
-describe("License V1 payload handler", () => {
-  test("字段构造顺序不同仍产生相同 canonical payload", () => {
-    const reversed = Object.fromEntries(
-      Object.entries(claims).reverse(),
-    ) as unknown as LicenseV1Claims;
-    const base = signedPayload(claims);
-    const reordered = signedPayload(reversed);
-
-    expect(reordered).toBe(base);
-    expect(parseLicenseSigningPayload(1, base).claims).toEqual(claims);
-    expect(base.startsWith('{"algorithm":"ED25519","claims":')).toBe(true);
-  });
-
-  test("拒绝未知版本、legacy 缺省版本和非 canonical payload", () => {
-    expect(() => getLicensePayloadHandler(2)).toThrow(LicensePayloadError);
-    expect(() => getLicensePayloadHandler(undefined)).toThrow(
-      "不支持的 License 格式版本",
-    );
-    const pretty = JSON.stringify(
-      {
-        formatVersion: 1,
-        algorithm: "ED25519",
-        publicKeyId: "key_1",
-        claims,
-      },
-      null,
-      2,
-    );
-    expect(() => parseLicenseSigningPayload(1, pretty)).toThrow(
-      "必须使用 RFC 8785 canonical JSON",
-    );
-  });
-
-  test("V1 明确拒绝 legacy 容量字段", () => {
-    expect(() =>
-      signedPayload({ ...claims, maxUsers: 10 } as unknown as LicenseV1Claims),
-    ).toThrow("未知：maxUsers");
-  });
-});
-
-function signedPayload(value: LicenseV1Claims): string {
-  return createLicenseSigningPayload({
-    formatVersion: 1,
-    algorithm: "ED25519",
-    publicKeyId: "key_1",
-    claims: value,
-  });
-}