create-windy 0.6.9 → 0.6.10

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

@@ -2,6 +2,7 @@ import type { RequestGuardContext } from "../guards.js";
 import type { RouteApp } from "../system/routes.js";
 import type { PlatformLicenseRuntime } from "./runtime-service.js";
 import type { StaticRouteAuthorizer } from "../module-host/static-route-authorization.js";
+import { registerLicensePairingRoutes } from "./pairing-routes.js";
 import {
   boundedJsonBodyErrorResponse,
   decodeOfflineActivationCode,
@@ -15,8 +16,12 @@ interface LicenseRouteContext {
   request: Request;
 }
 
+type PlatformLicenseRouteApp = Pick<RouteApp, "get" | "post"> & {
+  options(path: string, handler: (context: unknown) => unknown): unknown;
+};
+
 export function registerPlatformLicenseRoutes(
-  app: Pick<RouteApp, "get" | "post">,
+  app: PlatformLicenseRouteApp,
   licenseRuntime: PlatformLicenseRuntime,
   authorizer: StaticRouteAuthorizer,
 ) {
@@ -95,6 +100,8 @@ export function registerPlatformLicenseRoutes(
     { parse: "none" },
   );
 
+  registerLicensePairingRoutes(app, licenseRuntime, authorizer);
+
   return app;
 }
 

package/template/apps/server/src/license/runtime-service.ts

@@ -6,10 +6,12 @@ import {
   LicenseInstaller,
   MemoryLicenseStorage,
   parseSignedLicense,
+  validateLicenseDocument,
   WindyLicenseClient,
   type AtomicLicenseStore,
   type LicenseInstallResult,
   type LicensePublicKeyMap,
+  type LicenseRuntimeValidationResult,
   type LicenseStorage,
 } from "@southwind-ai/license";
 import type {
@@ -161,6 +163,24 @@ export class PlatformLicenseRuntime implements LicenseEntitlementResolver {
     return operation;
   }
 
+  async validateCandidate(
+    rawLicense: string,
+  ): Promise<LicenseRuntimeValidationResult> {
+    return validateLicenseDocument(rawLicense, {
+      productCode: this.options.productCode,
+      machineCode: this.options.machineCode,
+      publicKeys: this.options.publicKeys,
+      now: this.now(),
+    });
+  }
+
+  pairingTarget(): { productCode: string; machineCode: string } {
+    return {
+      productCode: this.options.productCode,
+      machineCode: this.options.machineCode,
+    };
+  }
+
   private async performInstall(
     rawLicense: string,
     context: LicenseInstallActorContext,

package/template/apps/web/package.json

@@ -14,16 +14,17 @@
   "dependencies": {
     "@antv/g2": "^5.4.8",
     "@lucide/vue": "^1.23.0",
+    "@southwind-ai/example-work-order": "workspace:*",
+    "@southwind-ai/license": "workspace:*",
+    "@southwind-ai/shared": "workspace:*",
     "@tailwindcss/vite": "^4.3.2",
     "@tanstack/vue-form": "^1.33.0",
     "@tanstack/vue-table": "^8.21.3",
     "@vueuse/core": "^14.3.0",
-    "@southwind-ai/example-work-order": "workspace:*",
-    "@southwind-ai/license": "workspace:*",
-    "@southwind-ai/shared": "workspace:*",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "pinia": "^3.0.4",
+    "qrcode": "^1.5.4",
     "reka-ui": "^2.10.1",
     "tailwind-merge": "^3.6.0",
     "tailwindcss": "^4.3.2",
@@ -33,9 +34,10 @@
     "vue-sonner": "^2.0.9"
   },
   "devDependencies": {
+    "@southwind-ai/modules": "workspace:*",
+    "@types/qrcode": "^1.5.6",
     "@vitejs/plugin-vue": "^6.0.7",
     "@vue/test-utils": "^2.4.11",
-    "@southwind-ai/modules": "workspace:*",
     "happy-dom": "^20.10.6",
     "tw-animate-css": "^1.4.0",
     "vite": "^8.1.4",

package/template/apps/web/src/components/license/LicensePairingCard.vue

@@ -0,0 +1,177 @@
+<script setup lang="ts">
+import { computed } from "vue";
+import {
+  KeyRoundIcon,
+  LoaderCircleIcon,
+  QrCodeIcon,
+  RefreshCwIcon,
+  SmartphoneIcon,
+} from "@lucide/vue";
+import { Button } from "@/components/ui/button";
+import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
+import { useLicensePairing } from "@/composables/useLicensePairing";
+import { useLicenseRuntime } from "@/composables/useLicenseRuntime";
+import { formatLicenseDateTime } from "./license-display";
+
+const emit = defineEmits<{
+  installed: [];
+}>();
+
+const runtime = useLicenseRuntime();
+const model = useLicensePairing({
+  confirm: runtime.confirmPairing,
+});
+const statusText = computed(() => {
+  const status = model.snapshot.value?.status;
+  if (status === "delivered")
+    return "手机已回传签名 License，请输入手机上的 8 位配对码。";
+  if (status === "expired") return "本次激活会话已过期，请重新生成二维码。";
+  if (status === "locked") return "配对码错误次数过多，本次会话已锁定。";
+  if (status === "consumed") return "配对激活完成，新 License 已生效。";
+  return model.session.value
+    ? "等待手机扫描并完成签发…"
+    : "客户端无需连接互联网；手机扫码签发后会自动回传。";
+});
+
+async function confirm(): Promise<void> {
+  if (await model.confirm()) emit("installed");
+}
+</script>
+
+<template>
+  <Card>
+    <CardHeader>
+      <CardTitle class="flex items-center gap-2 text-base">
+        <SmartphoneIcon class="size-4" />手机扫码快速激活
+      </CardTitle>
+    </CardHeader>
+    <CardContent class="space-y-4">
+      <p class="text-sm text-muted-foreground">{{ statusText }}</p>
+
+      <Button
+        v-if="!model.session.value"
+        :disabled="model.creating.value"
+        data-testid="create-license-pairing"
+        @click="model.create"
+      >
+        <LoaderCircleIcon
+          v-if="model.creating.value"
+          class="animate-spin"
+          data-icon="inline-start"
+        />
+        <QrCodeIcon v-else data-icon="inline-start" />
+        {{ model.creating.value ? "正在生成" : "生成激活二维码" }}
+      </Button>
+
+      <div
+        v-else
+        class="grid items-start gap-5 md:grid-cols-[minmax(0,20rem)_1fr]"
+      >
+        <div class="rounded-xl border bg-white p-3">
+          <img
+            v-if="model.qrDataUrl.value"
+            :src="model.qrDataUrl.value"
+            class="aspect-square w-full"
+            alt="License 手机配对激活二维码"
+            data-testid="license-pairing-qr"
+          />
+        </div>
+        <div class="space-y-4">
+          <div class="rounded-lg border bg-muted/40 p-3 text-sm">
+            <p class="text-muted-foreground">会话剩余时间</p>
+            <p class="font-mono text-lg" data-testid="pairing-countdown">
+              {{ model.secondsRemaining.value }} 秒
+            </p>
+          </div>
+
+          <dl
+            v-if="model.snapshot.value?.license"
+            class="grid gap-2 rounded-lg border p-3 text-sm"
+            data-testid="pairing-license-summary"
+          >
+            <div class="flex items-center justify-between gap-3">
+              <dt class="text-muted-foreground">License 版本</dt>
+              <dd class="font-medium">
+                {{ model.snapshot.value.license.licenseVersion.name }}
+              </dd>
+            </div>
+            <div class="flex items-center justify-between gap-3">
+              <dt class="text-muted-foreground">有效期至</dt>
+              <dd class="font-medium">
+                {{
+                  formatLicenseDateTime(model.snapshot.value.license.expiresAt)
+                }}
+              </dd>
+            </div>
+          </dl>
+
+          <form
+            v-if="model.ready.value"
+            class="space-y-3"
+            data-testid="license-pairing-form"
+            @submit.prevent="confirm"
+          >
+            <label class="block space-y-2 text-sm font-medium">
+              <span>手机配对码</span>
+              <input
+                :value="model.pairingCode.value"
+                inputmode="text"
+                autocomplete="one-time-code"
+                autocapitalize="characters"
+                spellcheck="false"
+                maxlength="8"
+                class="h-12 w-full rounded-md border border-input bg-background px-3 text-center font-mono text-xl tracking-[0.35em] uppercase outline-none focus-visible:border-ring focus-visible:ring-[3px] focus-visible:ring-ring/50"
+                placeholder="8 位数字或字母"
+                data-testid="license-pairing-code"
+                @input="
+                  model.updateCode(($event.target as HTMLInputElement).value)
+                "
+              />
+            </label>
+            <Button
+              type="submit"
+              :disabled="
+                model.confirming.value || model.pairingCode.value.length !== 8
+              "
+              data-testid="confirm-license-pairing"
+            >
+              <LoaderCircleIcon
+                v-if="model.confirming.value"
+                class="animate-spin"
+                data-icon="inline-start"
+              />
+              <KeyRoundIcon v-else data-icon="inline-start" />
+              {{ model.confirming.value ? "正在校验并安装" : "确认配对并安装" }}
+            </Button>
+          </form>
+
+          <Button
+            v-if="
+              model.snapshot.value?.status === 'expired' ||
+              model.snapshot.value?.status === 'locked'
+            "
+            variant="outline"
+            :disabled="model.creating.value"
+            @click="model.create"
+          >
+            <LoaderCircleIcon
+              v-if="model.creating.value"
+              class="animate-spin"
+              data-icon="inline-start"
+            />
+            <RefreshCwIcon v-else data-icon="inline-start" />重新生成
+          </Button>
+        </div>
+      </div>
+
+      <p
+        v-if="model.error.value"
+        class="text-sm text-destructive"
+        role="alert"
+        data-testid="license-pairing-error"
+      >
+        {{ model.error.value }}
+      </p>
+    </CardContent>
+  </Card>
+</template>

package/template/apps/web/src/components/license/LicensePairingCard.webtest.ts

@@ -0,0 +1,113 @@
+import { flushPromises, mount } from "@vue/test-utils";
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+import { resetLicenseRuntime } from "@/composables/useLicenseRuntime";
+import LicensePairingCard from "./LicensePairingCard.vue";
+
+const api = vi.hoisted(() => ({
+  create: vi.fn(),
+  load: vi.fn(),
+  confirm: vi.fn(),
+}));
+
+vi.mock("qrcode", () => ({
+  default: { toDataURL: vi.fn().mockResolvedValue("data:image/png;base64,qr") },
+}));
+
+vi.mock("@/services/license-api", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("@/services/license-api")>()),
+  createPlatformLicensePairingSession: api.create,
+  loadPlatformLicensePairingSession: api.load,
+  confirmPlatformLicensePairing: api.confirm,
+}));
+
+describe("License 手机配对卡片", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    resetLicenseRuntime();
+    api.create.mockReset().mockResolvedValue({
+      id: "session_1234567890",
+      token: "token_12345678901234567890",
+      nonce: "nonce_12345678901234567890",
+      productCode: "windy-platform",
+      machineCode: "machine_1",
+      expiresAt: "2030-08-21T00:05:00.000Z",
+      qrPayload: '{"type":"windy-license-pairing"}',
+      status: "waiting",
+    });
+    api.load.mockReset().mockResolvedValue({
+      id: "session_1234567890",
+      status: "delivered",
+      expiresAt: "2030-08-21T00:05:00.000Z",
+      license: {
+        licenseVersion: { key: "advanced", name: "高级付费版" },
+        expiresAt: "2031-08-21T00:00:00.000Z",
+      },
+    });
+    api.confirm.mockReset().mockResolvedValue({
+      installStatus: "installed",
+      snapshot: {
+        status: "valid",
+        restricted: false,
+        reminder: { level: "none" },
+        canViewDetails: false,
+      },
+    });
+    vi.setSystemTime(new Date("2030-08-21T00:00:00.000Z"));
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  test("扫码回传后只需输入 8 位配对码完成安装", async () => {
+    const wrapper = mount(LicensePairingCard);
+    await wrapper
+      .get('[data-testid="create-license-pairing"]')
+      .trigger("click");
+    await flushPromises();
+
+    expect(
+      wrapper.get('[data-testid="license-pairing-qr"]').attributes("src"),
+    ).toBe("data:image/png;base64,qr");
+    expect(api.create).toHaveBeenCalledWith(window.location.origin);
+    await vi.advanceTimersByTimeAsync(2_000);
+    await flushPromises();
+
+    expect(
+      wrapper.get('[data-testid="pairing-license-summary"]').text(),
+    ).toContain("高级付费版");
+
+    await wrapper
+      .get('[data-testid="license-pairing-code"]')
+      .setValue("abcd1234");
+    await wrapper.get('[data-testid="license-pairing-form"]').trigger("submit");
+    await flushPromises();
+
+    expect(api.confirm).toHaveBeenCalledWith(
+      "session_1234567890",
+      expect.stringMatching(/^[0-9A-Z]{8}$/),
+    );
+    expect(wrapper.emitted("installed")).toHaveLength(1);
+  });
+
+  test("手机已回传但未及时确认时仍按会话期限失效", async () => {
+    const wrapper = mount(LicensePairingCard);
+    await wrapper
+      .get('[data-testid="create-license-pairing"]')
+      .trigger("click");
+    await flushPromises();
+    await vi.advanceTimersByTimeAsync(2_000);
+    await flushPromises();
+    expect(wrapper.find('[data-testid="license-pairing-form"]').exists()).toBe(
+      true,
+    );
+
+    await vi.advanceTimersByTimeAsync(5 * 60_000);
+    await flushPromises();
+
+    expect(wrapper.find('[data-testid="license-pairing-form"]').exists()).toBe(
+      false,
+    );
+    expect(wrapper.text()).toContain("本次激活会话已过期");
+  });
+});

package/template/apps/web/src/composables/useLicensePairing.ts

@@ -0,0 +1,168 @@
+import {
+  computed,
+  onBeforeUnmount,
+  readonly,
+  shallowReadonly,
+  shallowRef,
+} from "vue";
+import { normalizeLicensePairingCode } from "@southwind-ai/license/pairing";
+import {
+  createPlatformLicensePairingSession,
+  loadPlatformLicensePairingSession,
+  type LicensePairingSession,
+  type LicensePairingSessionSnapshot,
+} from "@/services/license-api";
+
+interface UseLicensePairingOptions {
+  confirm(sessionId: string, pairingCode: string): Promise<unknown>;
+}
+
+export function useLicensePairing(options: UseLicensePairingOptions) {
+  const session = shallowRef<LicensePairingSession>();
+  const snapshot = shallowRef<LicensePairingSessionSnapshot>();
+  const qrDataUrl = shallowRef("");
+  const pairingCode = shallowRef("");
+  const error = shallowRef("");
+  const creating = shallowRef(false);
+  const confirming = shallowRef(false);
+  const now = shallowRef(Date.now());
+  let pollTimer: ReturnType<typeof setInterval> | undefined;
+  let clockTimer: ReturnType<typeof setInterval> | undefined;
+
+  const secondsRemaining = computed(() => {
+    const expiresAt = session.value?.expiresAt;
+    return expiresAt
+      ? Math.max(0, Math.ceil((Date.parse(expiresAt) - now.value) / 1_000))
+      : 0;
+  });
+  const ready = computed(() => snapshot.value?.status === "delivered");
+
+  async function create(): Promise<void> {
+    creating.value = true;
+    error.value = "";
+    stopTimers();
+    try {
+      const created = await createPlatformLicensePairingSession(
+        window.location.origin,
+      );
+      session.value = created;
+      snapshot.value = {
+        id: created.id,
+        status: "waiting",
+        expiresAt: created.expiresAt,
+      };
+      const { default: QRCode } = await import("qrcode");
+      qrDataUrl.value = await QRCode.toDataURL(created.qrPayload, {
+        errorCorrectionLevel: "M",
+        margin: 2,
+        width: 320,
+      });
+      startTimers();
+    } catch (current) {
+      error.value = messageOf(current);
+      session.value = undefined;
+      snapshot.value = undefined;
+      qrDataUrl.value = "";
+    } finally {
+      creating.value = false;
+    }
+  }
+
+  async function refresh(): Promise<void> {
+    const current = session.value;
+    if (!current) return;
+    try {
+      snapshot.value = await loadPlatformLicensePairingSession(current.id);
+      if (snapshot.value.status !== "waiting") stopPolling();
+    } catch (currentError) {
+      error.value = messageOf(currentError);
+    }
+  }
+
+  async function confirm(): Promise<boolean> {
+    const current = session.value;
+    if (!current) return false;
+    error.value = "";
+    confirming.value = true;
+    try {
+      const normalized = normalizeLicensePairingCode(pairingCode.value);
+      pairingCode.value = normalized;
+      await options.confirm(current.id, normalized);
+      snapshot.value = {
+        id: current.id,
+        status: "consumed",
+        expiresAt: current.expiresAt,
+        license: snapshot.value?.license,
+      };
+      stopTimers();
+      return true;
+    } catch (currentError) {
+      error.value = messageOf(currentError);
+      await refresh();
+      return false;
+    } finally {
+      confirming.value = false;
+    }
+  }
+
+  function updateCode(value: string): void {
+    pairingCode.value = value
+      .toUpperCase()
+      .replace(/[^0-9A-Z]/g, "")
+      .slice(0, 8);
+  }
+
+  function startTimers(): void {
+    stopTimers();
+    now.value = Date.now();
+    pollTimer = setInterval(() => void refresh(), 2_000);
+    clockTimer = setInterval(() => {
+      now.value = Date.now();
+      if (secondsRemaining.value === 0) {
+        stopTimers();
+        if (
+          snapshot.value?.status === "waiting" ||
+          snapshot.value?.status === "delivered"
+        ) {
+          snapshot.value = {
+            id: snapshot.value.id,
+            status: "expired",
+            expiresAt: snapshot.value.expiresAt,
+          };
+        }
+      }
+    }, 1_000);
+  }
+
+  function stopPolling(): void {
+    if (pollTimer) clearInterval(pollTimer);
+    pollTimer = undefined;
+  }
+
+  function stopTimers(): void {
+    stopPolling();
+    if (clockTimer) clearInterval(clockTimer);
+    clockTimer = undefined;
+  }
+
+  onBeforeUnmount(stopTimers);
+  return {
+    session: shallowReadonly(session),
+    snapshot: shallowReadonly(snapshot),
+    qrDataUrl: readonly(qrDataUrl),
+    pairingCode: readonly(pairingCode),
+    error: readonly(error),
+    creating: readonly(creating),
+    confirming: readonly(confirming),
+    secondsRemaining,
+    ready,
+    create,
+    refresh,
+    confirm,
+    updateCode,
+  };
+}
+
+function messageOf(value: unknown): string {
+  return value instanceof Error ? value.message : String(value);
+}

package/template/apps/web/src/composables/useLicenseRuntime.ts

@@ -1,5 +1,6 @@
 import { readonly, shallowReadonly, shallowRef } from "vue";
 import {
+  confirmPlatformLicensePairing,
   installPlatformActivationCode,
   installPlatformLicense,
   loadPlatformLicense,
@@ -55,6 +56,15 @@ async function installActivationCode(
   return performInstall(() => installPlatformActivationCode(activationCode));
 }
 
+async function confirmPairing(
+  sessionId: string,
+  pairingCode: string,
+): Promise<PlatformLicenseSnapshot> {
+  return performInstall(() =>
+    confirmPlatformLicensePairing(sessionId, pairingCode),
+  );
+}
+
 async function performInstall(
   operation: () => ReturnType<typeof installPlatformLicense>,
 ): Promise<PlatformLicenseSnapshot> {
@@ -82,6 +92,7 @@ export function useLicenseRuntime() {
     refresh: () => load(true),
     install,
     installActivationCode,
+    confirmPairing,
   };
 }
 

package/template/apps/web/src/pages/license/LicensePage.vue

@@ -1,6 +1,7 @@
 <script setup lang="ts">
 import { onMounted } from "vue";
 import LicenseActivationCodeForm from "@/components/license/LicenseActivationCodeForm.vue";
+import LicensePairingCard from "@/components/license/LicensePairingCard.vue";
 import LicenseStatusCard from "@/components/license/LicenseStatusCard.vue";
 import LicenseUploadForm from "@/components/license/LicenseUploadForm.vue";
 import PageLoading from "@/components/common/PageLoading.vue";
@@ -33,6 +34,12 @@ async function activate(activationCode: string) {
     toast.error("激活码安装失败", { description: runtime.error.value });
   }
 }
+
+function pairingInstalled() {
+  toast.success("手机配对激活完成", {
+    description: "配对码已确认，新授权立即生效。",
+  });
+}
 </script>
 
 <template>
@@ -57,6 +64,7 @@ async function activate(activationCode: string) {
       :snapshot="runtime.snapshot.value"
     />
     <LicenseUploadForm :loading="runtime.installing.value" @upload="upload" />
+    <LicensePairingCard @installed="pairingInstalled" />
     <LicenseActivationCodeForm
       :loading="runtime.installing.value"
       @activate="activate"

package/template/apps/web/src/services/license-api.ts

@@ -30,6 +30,34 @@ interface LicenseInstallResponse {
   snapshot: PlatformLicenseSnapshot;
 }
 
+export type LicensePairingSessionStatus =
+  | "waiting"
+  | "delivered"
+  | "expired"
+  | "locked"
+  | "consumed";
+
+export interface LicensePairingSession {
+  id: string;
+  token: string;
+  nonce: string;
+  productCode: string;
+  machineCode: string;
+  expiresAt: string;
+  qrPayload: string;
+  status: "waiting";
+}
+
+export interface LicensePairingSessionSnapshot {
+  id: string;
+  status: LicensePairingSessionStatus;
+  expiresAt: string;
+  license?: {
+    licenseVersion: { key: string; name: string };
+    expiresAt: string;
+  };
+}
+
 export function loadPlatformLicense(): Promise<PlatformLicenseSnapshot> {
   return apiRequest<PlatformLicenseSnapshot>("/license/runtime");
 }
@@ -51,3 +79,35 @@ export function installPlatformActivationCode(
     body: JSON.stringify({ activationCode }),
   });
 }
+
+export function createPlatformLicensePairingSession(
+  callbackOrigin: string,
+): Promise<LicensePairingSession> {
+  return apiRequest<LicensePairingSession>(
+    "/license/runtime/pairing/sessions",
+    { method: "POST", body: JSON.stringify({ callbackOrigin }) },
+  );
+}
+
+export function loadPlatformLicensePairingSession(
+  sessionId: string,
+): Promise<LicensePairingSessionSnapshot> {
+  return apiRequest<LicensePairingSessionSnapshot>(
+    `/license/runtime/pairing/sessions/${encodeURIComponent(sessionId)}`,
+    undefined,
+    { suppressFailureHandler: true },
+  );
+}
+
+export function confirmPlatformLicensePairing(
+  sessionId: string,
+  pairingCode: string,
+): Promise<LicenseInstallResponse> {
+  return apiRequest<LicenseInstallResponse>(
+    `/license/runtime/pairing/sessions/${encodeURIComponent(sessionId)}/confirm`,
+    {
+      method: "POST",
+      body: JSON.stringify({ pairingCode }),
+    },
+  );
+}