dsh-plugin-image-workbench 0.0.0-stage → 1.1.6

package/vendor/chatgpt2api/source/web/src/lib/auth-session.ts

@@ -0,0 +1,26 @@
+"use client";
+
+import { login } from "@/lib/api";
+import { clearStoredAuthSession, getStoredAuthSession, setStoredAuthSession, type StoredAuthSession } from "@/store/auth";
+
+export async function getValidatedAuthSession(): Promise<StoredAuthSession | null> {
+  const storedSession = await getStoredAuthSession();
+  if (!storedSession) {
+    return null;
+  }
+
+  try {
+    const data = await login(storedSession.key);
+    const nextSession: StoredAuthSession = {
+      key: storedSession.key,
+      role: data.role,
+      subjectId: data.subject_id,
+      name: data.name,
+    };
+    await setStoredAuthSession(nextSession);
+    return nextSession;
+  } catch {
+    await clearStoredAuthSession();
+    return null;
+  }
+}

package/vendor/chatgpt2api/source/web/src/lib/release.ts

@@ -0,0 +1,25 @@
+export type ReleaseInfo = {
+  version: string;
+  date: string;
+  items: { type: string; content: string }[];
+};
+
+export function parseChangelog(content: string): ReleaseInfo[] {
+  return content
+    .split(/^## /m)
+    .slice(1)
+    .map((block) => {
+      const [title = "", ...lines] = block.trim().split("\n");
+      const [, version = title.trim(), date = ""] =
+        title.match(/^(.+?)(?:\s+-\s+(.+))?$/) || [];
+      return {
+        version: version.trim(),
+        date: date.trim(),
+        items: lines
+          .map((line) => line.trim().match(/^\+\s+\[(.+?)\]\s+(.+)$/))
+          .filter((match): match is RegExpMatchArray => Boolean(match))
+          .map((match) => ({ type: match[1], content: match[2] })),
+      };
+    })
+    .filter((release) => release.items.length);
+}

package/vendor/chatgpt2api/source/web/src/lib/request.ts

@@ -0,0 +1,93 @@
+import axios, {AxiosError, type AxiosRequestConfig} from "axios";
+
+import webConfig from "@/constants/common-env";
+import {clearStoredAuthSession, getStoredAuthKey} from "@/store/auth";
+
+type RequestConfig = AxiosRequestConfig & {
+    redirectOnUnauthorized?: boolean;
+};
+
+type ErrorPayload = {
+    detail?: string | { error?: string | { message?: string } };
+    error?: string | { message?: string };
+    message?: string;
+};
+
+function errorMessageFromValue(value: unknown): string {
+    if (typeof value === "string") {
+        return value;
+    }
+    if (!value || typeof value !== "object") {
+        return "";
+    }
+
+    const item = value as { error?: unknown; message?: unknown };
+    if (typeof item.message === "string") {
+        return item.message;
+    }
+    return errorMessageFromValue(item.error);
+}
+
+export const request = axios.create({
+    baseURL: webConfig.apiUrl.replace(/\/$/, ""),
+});
+
+request.interceptors.request.use(async (config) => {
+    const nextConfig = {...config};
+    const authKey = await getStoredAuthKey();
+    const headers = {...(nextConfig.headers || {})} as Record<string, string>;
+    if (authKey && !headers.Authorization) {
+        headers.Authorization = `Bearer ${authKey}`;
+    }
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-expect-error
+    nextConfig.headers = headers;
+    return nextConfig;
+});
+
+request.interceptors.response.use(
+    (response) => response,
+    async (error: AxiosError<ErrorPayload>) => {
+        const status = error.response?.status;
+        const shouldRedirect = (error.config as RequestConfig | undefined)?.redirectOnUnauthorized !== false;
+        if (status === 401 && shouldRedirect && typeof window !== "undefined") {
+            // Avoid redirect loop — only redirect if not already on /login
+            if (!window.location.pathname.startsWith("/login")) {
+                await clearStoredAuthSession();
+                window.location.replace("/login");
+                // Return a never-resolving promise to prevent further error handling
+                // while the browser navigates away
+                return new Promise(() => {});
+            }
+        }
+
+        const payload = error.response?.data;
+        const message =
+            errorMessageFromValue(payload?.detail) ||
+            errorMessageFromValue(payload?.error) ||
+            payload?.message ||
+            error.message ||
+            `请求失败 (${status || 500})`;
+        return Promise.reject(new Error(message));
+    },
+);
+
+type RequestOptions = {
+    method?: string;
+    body?: unknown;
+    headers?: Record<string, string>;
+    redirectOnUnauthorized?: boolean;
+};
+
+export async function httpRequest<T>(path: string, options: RequestOptions = {}) {
+    const {method = "GET", body, headers, redirectOnUnauthorized = true} = options;
+    const config: RequestConfig = {
+        url: path,
+        method,
+        data: body,
+        headers,
+        redirectOnUnauthorized,
+    };
+    const response = await request.request<T>(config);
+    return response.data;
+}

package/vendor/chatgpt2api/source/web/src/lib/use-auth-guard.ts

@@ -0,0 +1,89 @@
+"use client";
+
+import { useEffect, useState } from "react";
+import { useRouter } from "next/navigation";
+
+import { getValidatedAuthSession } from "@/lib/auth-session";
+import {
+  getDefaultRouteForRole,
+  type AuthRole,
+  type StoredAuthSession,
+} from "@/store/auth";
+
+type UseAuthGuardResult = {
+  isCheckingAuth: boolean;
+  session: StoredAuthSession | null;
+};
+
+export function useAuthGuard(allowedRoles?: AuthRole[]): UseAuthGuardResult {
+  const router = useRouter();
+  const [session, setSession] = useState<StoredAuthSession | null>(null);
+  const [isCheckingAuth, setIsCheckingAuth] = useState(true);
+  const allowedRolesKey = (allowedRoles || []).join(",");
+
+  useEffect(() => {
+    let active = true;
+
+    const load = async () => {
+      const roleList = allowedRolesKey ? (allowedRolesKey.split(",") as AuthRole[]) : [];
+      const storedSession = await getValidatedAuthSession();
+      if (!active) {
+        return;
+      }
+
+      if (!storedSession) {
+        setSession(null);
+        setIsCheckingAuth(false);
+        router.replace("/login");
+        return;
+      }
+
+      if (roleList.length > 0 && !roleList.includes(storedSession.role)) {
+        setSession(storedSession);
+        setIsCheckingAuth(false);
+        router.replace(getDefaultRouteForRole(storedSession.role));
+        return;
+      }
+
+      setSession(storedSession);
+      setIsCheckingAuth(false);
+    };
+
+    void load();
+    return () => {
+      active = false;
+    };
+  }, [allowedRolesKey, router]);
+
+  return { isCheckingAuth, session };
+}
+
+export function useRedirectIfAuthenticated() {
+  const router = useRouter();
+  const [isCheckingAuth, setIsCheckingAuth] = useState(true);
+
+  useEffect(() => {
+    let active = true;
+
+    const load = async () => {
+      const storedSession = await getValidatedAuthSession();
+      if (!active) {
+        return;
+      }
+
+      if (storedSession) {
+        router.replace(getDefaultRouteForRole(storedSession.role));
+        return;
+      }
+
+      setIsCheckingAuth(false);
+    };
+
+    void load();
+    return () => {
+      active = false;
+    };
+  }, [router]);
+
+  return { isCheckingAuth };
+}

package/vendor/chatgpt2api/source/web/src/lib/utils.ts

@@ -0,0 +1,6 @@
+import { clsx, type ClassValue } from "clsx";
+import { twMerge } from "tailwind-merge";
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs));
+}

package/vendor/chatgpt2api/source/web/src/store/auth.ts

@@ -0,0 +1,112 @@
+"use client";
+
+import localforage from "localforage";
+
+export type AuthRole = "admin" | "user";
+
+export type StoredAuthSession = {
+  key: string;
+  role: AuthRole;
+  subjectId: string;
+  name: string;
+};
+
+export const AUTH_KEY_STORAGE_KEY = "chatgpt2api_auth_key";
+export const AUTH_SESSION_STORAGE_KEY = "chatgpt2api_auth_session";
+
+const authStorage = localforage.createInstance({
+  name: "chatgpt2api",
+  storeName: "auth",
+});
+
+function normalizeSession(value: unknown, fallbackKey = ""): StoredAuthSession | null {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+
+  const candidate = value as Partial<StoredAuthSession>;
+  const key = String(candidate.key || fallbackKey || "").trim();
+  const role = candidate.role === "admin" || candidate.role === "user" ? candidate.role : null;
+  if (!key || !role) {
+    return null;
+  }
+
+  return {
+    key,
+    role,
+    subjectId: String(candidate.subjectId || "").trim(),
+    name: String(candidate.name || "").trim(),
+  };
+}
+
+export function getDefaultRouteForRole(role: AuthRole) {
+  return role === "admin" ? "/accounts" : "/image";
+}
+
+export async function getStoredAuthKey() {
+  if (typeof window === "undefined") {
+    return "";
+  }
+  const value = await authStorage.getItem<string>(AUTH_KEY_STORAGE_KEY);
+  return String(value || "").trim();
+}
+
+export async function getStoredAuthSession() {
+  if (typeof window === "undefined") {
+    return null;
+  }
+
+  const [storedKey, storedSession] = await Promise.all([
+    authStorage.getItem<string>(AUTH_KEY_STORAGE_KEY),
+    authStorage.getItem<StoredAuthSession>(AUTH_SESSION_STORAGE_KEY),
+  ]);
+
+  const normalizedSession = normalizeSession(storedSession, String(storedKey || ""));
+  if (normalizedSession) {
+    if (normalizedSession.key !== String(storedKey || "").trim()) {
+      await authStorage.setItem(AUTH_KEY_STORAGE_KEY, normalizedSession.key);
+    }
+    return normalizedSession;
+  }
+
+  if (String(storedKey || "").trim()) {
+    await clearStoredAuthSession();
+  }
+  return null;
+}
+
+export async function setStoredAuthSession(session: StoredAuthSession) {
+  const normalizedSession = normalizeSession(session);
+  if (!normalizedSession) {
+    await clearStoredAuthSession();
+    return;
+  }
+
+  await Promise.all([
+    authStorage.setItem(AUTH_KEY_STORAGE_KEY, normalizedSession.key),
+    authStorage.setItem(AUTH_SESSION_STORAGE_KEY, normalizedSession),
+  ]);
+}
+
+export async function setStoredAuthKey(authKey: string) {
+  const normalizedAuthKey = String(authKey || "").trim();
+  if (!normalizedAuthKey) {
+    await clearStoredAuthSession();
+    return;
+  }
+  await authStorage.setItem(AUTH_KEY_STORAGE_KEY, normalizedAuthKey);
+}
+
+export async function clearStoredAuthSession() {
+  if (typeof window === "undefined") {
+    return;
+  }
+  await Promise.all([
+    authStorage.removeItem(AUTH_KEY_STORAGE_KEY),
+    authStorage.removeItem(AUTH_SESSION_STORAGE_KEY),
+  ]);
+}
+
+export async function clearStoredAuthKey() {
+  await clearStoredAuthSession();
+}

package/vendor/chatgpt2api/source/web/src/store/editable-file-history.ts

@@ -0,0 +1,33 @@
+"use client";
+
+import localforage from "localforage";
+
+export type EditableFileDraft = {
+  prompt?: string;
+  images?: string[];
+  title?: string;
+};
+
+const editableFileStorage = localforage.createInstance({
+  name: "chatgpt2api",
+  storeName: "editable_file_history",
+});
+
+const draftsKey = (kind: string) => `drafts:${kind}`;
+const deletedKey = (kind: string) => `deleted:${kind}`;
+
+export async function listEditableFileDrafts(kind: string): Promise<Record<string, EditableFileDraft>> {
+  return (await editableFileStorage.getItem<Record<string, EditableFileDraft>>(draftsKey(kind))) || {};
+}
+
+export async function saveEditableFileDrafts(kind: string, drafts: Record<string, EditableFileDraft>): Promise<void> {
+  await editableFileStorage.setItem(draftsKey(kind), drafts);
+}
+
+export async function listDeletedEditableFileIds(kind: string): Promise<Set<string>> {
+  return new Set((await editableFileStorage.getItem<string[]>(deletedKey(kind))) || []);
+}
+
+export async function saveDeletedEditableFileIds(kind: string, ids: Set<string>): Promise<void> {
+  await editableFileStorage.setItem(deletedKey(kind), [...ids]);
+}