ai-world-sdk 1.2.2 → 1.2.5

package/dist/__tests__/login.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/login.test.js

@@ -0,0 +1,170 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const http = __importStar(require("http"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const login_1 = require("../login");
+const TEST_DIR = path.join(__dirname, "__login_test_tmp__");
+beforeEach(() => {
+    if (!fs.existsSync(TEST_DIR)) {
+        fs.mkdirSync(TEST_DIR, { recursive: true });
+    }
+});
+afterEach(() => {
+    if (fs.existsSync(TEST_DIR)) {
+        fs.rmSync(TEST_DIR, { recursive: true, force: true });
+    }
+});
+describe("readEnvLocal", () => {
+    it("returns empty object when file does not exist", () => {
+        const result = (0, login_1.readEnvLocal)(TEST_DIR);
+        expect(result).toEqual({});
+    });
+    it("parses key=value pairs from .env.local", () => {
+        const envPath = path.join(TEST_DIR, ".env.local");
+        fs.writeFileSync(envPath, "DEBUG=true\nDEBUG_TOKEN=abc123\n# comment\nPLUGIN_ID=test\n");
+        const result = (0, login_1.readEnvLocal)(TEST_DIR);
+        expect(result).toEqual({
+            DEBUG: "true",
+            DEBUG_TOKEN: "abc123",
+            PLUGIN_ID: "test",
+        });
+    });
+    it("skips blank lines and comments", () => {
+        const envPath = path.join(TEST_DIR, ".env.local");
+        fs.writeFileSync(envPath, "\n# header\n\nKEY=value\n\n");
+        const result = (0, login_1.readEnvLocal)(TEST_DIR);
+        expect(result).toEqual({ KEY: "value" });
+    });
+});
+describe("writeEnvLocal", () => {
+    it("creates .env.local when it does not exist", () => {
+        (0, login_1.writeEnvLocal)(TEST_DIR, { DEBUG: "true", DEBUG_TOKEN: "token123" });
+        const envPath = path.join(TEST_DIR, ".env.local");
+        expect(fs.existsSync(envPath)).toBe(true);
+        const content = fs.readFileSync(envPath, "utf-8");
+        expect(content).toContain("DEBUG=true");
+        expect(content).toContain("DEBUG_TOKEN=token123");
+    });
+    it("updates existing keys and preserves others", () => {
+        const envPath = path.join(TEST_DIR, ".env.local");
+        fs.writeFileSync(envPath, "# comment\nDEBUG=false\nPLUGIN_ID=old\n");
+        (0, login_1.writeEnvLocal)(TEST_DIR, { DEBUG: "true", DEBUG_TOKEN: "newtoken" });
+        const content = fs.readFileSync(envPath, "utf-8");
+        expect(content).toContain("# comment");
+        expect(content).toContain("DEBUG=true");
+        expect(content).toContain("PLUGIN_ID=old");
+        expect(content).toContain("DEBUG_TOKEN=newtoken");
+        expect(content).not.toContain("DEBUG=false");
+    });
+    it("does not duplicate keys on repeated writes", () => {
+        (0, login_1.writeEnvLocal)(TEST_DIR, { DEBUG_TOKEN: "v1" });
+        (0, login_1.writeEnvLocal)(TEST_DIR, { DEBUG_TOKEN: "v2" });
+        const content = fs.readFileSync(path.join(TEST_DIR, ".env.local"), "utf-8");
+        const matches = content.match(/DEBUG_TOKEN/g);
+        expect(matches).toHaveLength(1);
+        expect(content).toContain("DEBUG_TOKEN=v2");
+    });
+});
+describe("resolvePluginId", () => {
+    it("returns plugin_id from plugin.json when it exists", () => {
+        const pluginJson = path.join(TEST_DIR, "plugin.json");
+        fs.writeFileSync(pluginJson, JSON.stringify({ plugin_id: "my-plugin", name: "My Plugin" }));
+        expect((0, login_1.resolvePluginId)(TEST_DIR)).toBe("my-plugin");
+    });
+    it("falls back to package.json name when plugin.json does not exist", () => {
+        fs.writeFileSync(path.join(TEST_DIR, "package.json"), JSON.stringify({ name: "my-pkg" }));
+        expect((0, login_1.resolvePluginId)(TEST_DIR)).toBe("my-pkg");
+    });
+    it("falls back to package.json name when plugin.json has no plugin_id", () => {
+        fs.writeFileSync(path.join(TEST_DIR, "plugin.json"), JSON.stringify({ name: "No ID" }));
+        fs.writeFileSync(path.join(TEST_DIR, "package.json"), JSON.stringify({ name: "fallback-pkg" }));
+        expect((0, login_1.resolvePluginId)(TEST_DIR)).toBe("fallback-pkg");
+    });
+    it("falls back to directory name when neither plugin.json nor package.json exist", () => {
+        expect((0, login_1.resolvePluginId)(TEST_DIR)).toBe(path.basename(TEST_DIR));
+    });
+});
+describe("validateToken", () => {
+    let server = null;
+    let port;
+    afterEach((done) => {
+        if (server && server.listening) {
+            server.close(() => {
+                server = null;
+                done();
+            });
+        }
+        else {
+            server = null;
+            done();
+        }
+    });
+    it("returns true for valid token", async () => {
+        server = http.createServer((req, res) => {
+            if (req.headers.authorization === "Bearer valid-token") {
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ id: 1, email: "test@test.com" }));
+            }
+            else {
+                res.writeHead(401);
+                res.end();
+            }
+        });
+        await new Promise((resolve) => {
+            server.listen(0, () => resolve());
+        });
+        port = server.address().port;
+        const result = await (0, login_1.validateToken)(`http://localhost:${port}`, "valid-token");
+        expect(result).toBe(true);
+    });
+    it("returns false for invalid token", async () => {
+        server = http.createServer((_req, res) => {
+            res.writeHead(401);
+            res.end();
+        });
+        await new Promise((resolve) => {
+            server.listen(0, () => resolve());
+        });
+        port = server.address().port;
+        const result = await (0, login_1.validateToken)(`http://localhost:${port}`, "bad-token");
+        expect(result).toBe(false);
+    });
+    it("returns false when server is unreachable", async () => {
+        const result = await (0, login_1.validateToken)("http://localhost:19999", "any-token");
+        expect(result).toBe(false);
+    });
+});

package/dist/config.d.ts

@@ -9,13 +9,20 @@
  *
  * 注意: {VERSION} 占位符会在构建时被替换为实际版本号
  */
-export declare const SDK_SIGNATURE = "AI_WORLD_SDK_V:1.2.2";
+export declare const SDK_SIGNATURE = "AI_WORLD_SDK_V:1.2.5";
 /**
  * 版本兼容性错误
  */
 export declare class VersionCompatibilityError extends Error {
     constructor(message: string);
 }
+export interface AuthenticatedUser {
+    id: number;
+    email?: string;
+    full_name?: string;
+    avatar_url?: string;
+    feishu_user_id?: string;
+}
 declare class SDKConfig {
     private _baseUrl;
     private _token;
@@ -24,8 +31,11 @@ declare class SDKConfig {
     private _pluginId;
     private _versionCompatible;
     private _versionCheckPromise;
-    readonly sdkSignature = "AI_WORLD_SDK_V:1.2.2";
-    readonly sdkVersion = "1.2.2";
+    private _authenticated;
+    private _authCheckPromise;
+    private _currentUser;
+    readonly sdkSignature = "AI_WORLD_SDK_V:1.2.5";
+    readonly sdkVersion = "1.2.5";
     constructor();
     /**
      * Set global base URL
@@ -77,6 +87,24 @@ declare class SDKConfig {
      * 获取插件 ID（从 window.__INITIAL_DATA__ 自动获取或手动设置）
      */
     getPluginId(): string | null;
+    /**
+     * 检查当前 token 是否有效，获取登录用户信息
+     */
+    checkAuthentication(): Promise<boolean>;
+    private _performAuthCheck;
+    private _nodeAuthCheck;
+    /**
+     * 获取当前登录状态
+     */
+    isAuthenticated(): boolean | null;
+    /**
+     * 获取当前登录用户信息（需先完成 checkAuthentication）
+     */
+    getCurrentUser(): AuthenticatedUser | null;
+    /**
+     * 等待登录检查完成并确保已登录，未登录则抛出错误
+     */
+    ensureAuthenticated(): Promise<AuthenticatedUser>;
     /**
      * Check version compatibility with backend
      * 检查与后端的版本兼容性

package/dist/config.js

@@ -7,7 +7,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.sdkConfig = exports.VersionCompatibilityError = exports.SDK_SIGNATURE = void 0;
 // SDK 版本号（构建时自动从 package.json 更新）
 // 此版本号会在运行 npm run build 时自动从 package.json 读取并更新
-const SDK_VERSION = "1.2.2";
+const SDK_VERSION = "1.2.5";
 /**
  * SDK 特征码 - 用于在构建后的 JS 文件中识别 SDK 版本
  * 格式: AI_WORLD_SDK_V:版本号
@@ -15,7 +15,7 @@ const SDK_VERSION = "1.2.2";
  *
  * 注意: {VERSION} 占位符会在构建时被替换为实际版本号
  */
-exports.SDK_SIGNATURE = "AI_WORLD_SDK_V:1.2.2";
+exports.SDK_SIGNATURE = "AI_WORLD_SDK_V:1.2.5";
 /**
  * 版本兼容性错误
  */
@@ -33,48 +33,100 @@ class SDKConfig {
         this._headers = {};
         this._debug = false;
         this._pluginId = null;
-        this._versionCompatible = null; // null 表示未检查，true/false 表示检查结果
-        this._versionCheckPromise = null; // 版本检查的 Promise，避免重复请求
-        // SDK 版本标识（用于后端扫描检测）
+        this._versionCompatible = null;
+        this._versionCheckPromise = null;
+        this._authenticated = null; // null = 未检查
+        this._authCheckPromise = null;
+        this._currentUser = null;
         this.sdkSignature = exports.SDK_SIGNATURE;
         this.sdkVersion = SDK_VERSION;
         // 在全局对象上注册 SDK 版本信息（用于后端扫描检测）
         if (typeof globalThis !== "undefined") {
             globalThis.__AI_WORLD_SDK_VERSION__ = SDK_VERSION;
         }
-        // 通过cookie获取token
-        try {
-            const cookieString = typeof document !== 'undefined' ? document.cookie : '';
-            const tokenRow = cookieString.split('; ').find(row => row.startsWith('auth_token='));
-            if (tokenRow) {
-                const tokenValue = tokenRow.split('=')[1];
-                // 处理 URL 编码的 token（如果有）
-                this._token = decodeURIComponent(tokenValue);
+        const isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined';
+        if (isBrowser) {
+            // 浏览器环境：从 cookie 获取 token
+            try {
+                const tokenRow = document.cookie.split('; ').find(row => row.startsWith('auth_token='));
+                if (tokenRow) {
+                    const tokenValue = tokenRow.split('=')[1];
+                    this._token = decodeURIComponent(tokenValue);
+                }
             }
-        }
-        catch (error) {
-            console.warn('Failed to read token from cookie:', error);
-        }
-        // 通过cookie获取baseUrl
-        const baseUrl = typeof window !== 'undefined' ? window.location.origin : '';
-        this._baseUrl = baseUrl;
-        // 从 window.__INITIAL_DATA__ 获取 plugin_id（SSR 插件环境）
-        try {
-            if (typeof window !== 'undefined' && window.__INITIAL_DATA__) {
-                const initialData = window.__INITIAL_DATA__;
-                if (initialData.plugin_id) {
-                    this._headers['X-Plugin-Id'] = this._pluginId = initialData.plugin_id;
+            catch (error) {
+                console.warn('Failed to read token from cookie:', error);
+            }
+            this._baseUrl = window.location.origin;
+            // 从 window.__INITIAL_DATA__ 获取 plugin_id（SSR 插件环境）
+            try {
+                if (window.__INITIAL_DATA__) {
+                    const initialData = window.__INITIAL_DATA__;
+                    if (initialData.plugin_id) {
+                        this._headers['X-Plugin-Id'] = this._pluginId = initialData.plugin_id;
+                    }
                 }
             }
+            catch (error) {
+                console.warn('Failed to read plugin_id from __INITIAL_DATA__:', error);
+            }
+            // Vite dev 模式：从 aiWorldPlugin 注入的 window.__AI_WORLD_CONFIG__ 读取
+            try {
+                const aiConfig = window.__AI_WORLD_CONFIG__;
+                if (aiConfig) {
+                    if (!this._token && aiConfig.token) {
+                        this._token = aiConfig.token;
+                    }
+                    if (aiConfig.debug) {
+                        this._debug = true;
+                    }
+                    if (!this._pluginId && aiConfig.pluginId) {
+                        this._pluginId = aiConfig.pluginId;
+                        this._headers['X-Plugin-Id'] = aiConfig.pluginId;
+                    }
+                    if (aiConfig.baseUrl) {
+                        this._baseUrl = aiConfig.baseUrl;
+                    }
+                }
+            }
+            catch {
+                // __AI_WORLD_CONFIG__ not available
+            }
         }
-        catch (error) {
-            console.warn('Failed to read plugin_id from __INITIAL_DATA__:', error);
+        else {
+            // 非浏览器环境（Node.js / Vite dev）：从 process.env 读取
+            try {
+                const debugToken = typeof process !== 'undefined' && process.env?.DEBUG_TOKEN;
+                if (debugToken) {
+                    this._token = debugToken;
+                }
+                const debugFlag = typeof process !== 'undefined' && process.env?.DEBUG;
+                if (debugFlag === 'true') {
+                    this._debug = true;
+                }
+                const pluginId = typeof process !== 'undefined' && process.env?.PLUGIN_ID;
+                if (pluginId) {
+                    this._pluginId = pluginId;
+                    this._headers['X-Plugin-Id'] = pluginId;
+                }
+                const baseUrl = typeof process !== 'undefined' && process.env?.AI_WORLD_BASE_URL;
+                if (baseUrl) {
+                    this._baseUrl = baseUrl.replace(/\/$/, "");
+                }
+            }
+            catch {
+                // process.env may not be available in some runtimes
+            }
         }
         this._headers['X-SDK-Version'] = SDK_VERSION;
         // 自动检查版本兼容性（异步，不阻塞初始化）
         this.checkVersionCompatibility().catch((error) => {
             console.warn('版本兼容性检查失败:', error);
         });
+        // 自动检查登录状态（异步，不阻塞初始化）
+        this.checkAuthentication().catch(() => {
+            // 静默处理，详细日志在 checkAuthentication 内部
+        });
     }
     /**
      * Set global base URL
@@ -146,6 +198,128 @@ class SDKConfig {
     getPluginId() {
         return this._pluginId;
     }
+    /**
+     * 检查当前 token 是否有效，获取登录用户信息
+     */
+    async checkAuthentication() {
+        if (this._authenticated !== null) {
+            return this._authenticated;
+        }
+        if (this._authCheckPromise) {
+            return this._authCheckPromise;
+        }
+        this._authCheckPromise = this._performAuthCheck();
+        const result = await this._authCheckPromise;
+        this._authCheckPromise = null;
+        return result;
+    }
+    async _performAuthCheck() {
+        if (!this._token) {
+            this._authenticated = false;
+            console.warn('[ai-world-sdk] 未检测到登录 token，请先登录。Vite 项目请在 vite.config 中添加 aiWorldPlugin()');
+            return false;
+        }
+        const baseUrl = this._baseUrl || (typeof window !== 'undefined' ? window.location.origin : '');
+        if (!baseUrl) {
+            this._authenticated = false;
+            return false;
+        }
+        try {
+            const isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined';
+            let ok = false;
+            let user = null;
+            if (isBrowser) {
+                const response = await fetch(`${baseUrl}/api/auth/me`, {
+                    method: 'GET',
+                    headers: {
+                        'Authorization': `Bearer ${this._token}`,
+                        'Content-Type': 'application/json',
+                    },
+                });
+                if (response.ok) {
+                    user = await response.json();
+                    ok = true;
+                }
+            }
+            else {
+                // Node.js 环境：使用 https/http 模块，支持自签名证书
+                const result = await this._nodeAuthCheck(baseUrl, this._token);
+                ok = result.ok;
+                user = result.user;
+            }
+            if (ok && user) {
+                this._authenticated = true;
+                this._currentUser = user;
+                if (this._debug) {
+                    console.log(`[ai-world-sdk] 已登录: ${user.full_name || user.email || user.id}`);
+                }
+                return true;
+            }
+            this._authenticated = false;
+            this._token = null;
+            console.warn('[ai-world-sdk] Token 已过期或无效，请重新登录');
+            return false;
+        }
+        catch {
+            this._authenticated = false;
+            return false;
+        }
+    }
+    _nodeAuthCheck(baseUrl, token) {
+        return new Promise((resolve) => {
+            try {
+                const url = new URL(`${baseUrl}/api/auth/me`);
+                // eslint-disable-next-line @typescript-eslint/no-var-requires
+                const mod = url.protocol === 'https:' ? require('https') : require('http');
+                const req = mod.get(url.href, {
+                    headers: { 'Authorization': `Bearer ${token}`, 'Content-Type': 'application/json' },
+                    rejectUnauthorized: false,
+                }, (res) => {
+                    let body = '';
+                    res.on('data', (chunk) => { body += chunk; });
+                    res.on('end', () => {
+                        if (res.statusCode >= 200 && res.statusCode < 300) {
+                            try {
+                                resolve({ ok: true, user: JSON.parse(body) });
+                            }
+                            catch {
+                                resolve({ ok: true, user: null });
+                            }
+                        }
+                        else {
+                            resolve({ ok: false, user: null });
+                        }
+                    });
+                });
+                req.on('error', () => resolve({ ok: false, user: null }));
+            }
+            catch {
+                resolve({ ok: false, user: null });
+            }
+        });
+    }
+    /**
+     * 获取当前登录状态
+     */
+    isAuthenticated() {
+        return this._authenticated;
+    }
+    /**
+     * 获取当前登录用户信息（需先完成 checkAuthentication）
+     */
+    getCurrentUser() {
+        return this._currentUser;
+    }
+    /**
+     * 等待登录检查完成并确保已登录，未登录则抛出错误
+     */
+    async ensureAuthenticated() {
+        const ok = await this.checkAuthentication();
+        if (!ok || !this._currentUser) {
+            throw new Error('未登录，请先完成登录。Vite 项目请在 vite.config 中添加 aiWorldPlugin()');
+        }
+        return this._currentUser;
+    }
     /**
      * Check version compatibility with backend
      * 检查与后端的版本兼容性

package/dist/index.d.ts

@@ -30,7 +30,7 @@ export { DownloadClient, type DownloadConfig, type DownloadOptions, type StreamD
 export { MinioStorageClient, type MinioStorageConfig, type UploadResponse, type ObjectInfo, type PresignedUrlResponse, type UploadOptions, type ListOptions, } from "./minio";
 export { ResourceClient, type ResourceClientConfig, type ResourceInfo, type AccessLevel, type UploadResourceOptions, type ListResourceOptions, } from "./resource";
 export { AuthClient, getCurrentUserInfo, type AuthConfig, type UserInfo, };
-export { sdkConfig, VersionCompatibilityError, SDK_SIGNATURE } from "./config";
+export { sdkConfig, VersionCompatibilityError, SDK_SIGNATURE, type AuthenticatedUser } from "./config";
 /**
  * Create a chat model instance based on model name
  */

package/dist/login.d.ts

@@ -0,0 +1,33 @@
+/**
+ * AI World SDK - Login utilities (Node.js only)
+ * 登录工具函数，仅在 Node.js 环境使用（Vite Plugin / CLI）
+ */
+/**
+ * 从项目根目录推断 pluginId：plugin.json plugin_id → package.json name → 目录名
+ */
+export declare function resolvePluginId(projectRoot: string): string;
+export interface LoginOptions {
+    baseUrl?: string;
+    timeout?: number;
+}
+export interface LoginResult {
+    token: string;
+    baseUrl: string;
+}
+/**
+ * 验证 token 是否有效
+ * 使用 https/http 模块替代 fetch，以支持自签名证书（rejectUnauthorized: false）
+ */
+export declare function validateToken(baseUrl: string, token: string): Promise<boolean>;
+/**
+ * 读取 .env.local 中的环境变量
+ */
+export declare function readEnvLocal(projectRoot: string): Record<string, string>;
+/**
+ * 写入/合并 .env.local，只更新指定的 key，保留其他内容
+ */
+export declare function writeEnvLocal(projectRoot: string, updates: Record<string, string>): void;
+/**
+ * 执行登录流程：启动本地 HTTP 服务器 → 打开浏览器 → 等待回调
+ */
+export declare function performLogin(options?: LoginOptions): Promise<LoginResult>;

package/dist/login.js

@@ -0,0 +1,272 @@
+"use strict";
+/**
+ * AI World SDK - Login utilities (Node.js only)
+ * 登录工具函数，仅在 Node.js 环境使用（Vite Plugin / CLI）
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvePluginId = resolvePluginId;
+exports.validateToken = validateToken;
+exports.readEnvLocal = readEnvLocal;
+exports.writeEnvLocal = writeEnvLocal;
+exports.performLogin = performLogin;
+const http = __importStar(require("http"));
+const https = __importStar(require("https"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+/**
+ * 从项目根目录推断 pluginId：plugin.json plugin_id → package.json name → 目录名
+ */
+function resolvePluginId(projectRoot) {
+    try {
+        const pluginJsonPath = path.join(projectRoot, "plugin.json");
+        if (fs.existsSync(pluginJsonPath)) {
+            const data = JSON.parse(fs.readFileSync(pluginJsonPath, "utf-8"));
+            if (data.plugin_id)
+                return data.plugin_id;
+        }
+    }
+    catch {
+        // ignore parse errors
+    }
+    try {
+        const pkgJsonPath = path.join(projectRoot, "package.json");
+        if (fs.existsSync(pkgJsonPath)) {
+            const data = JSON.parse(fs.readFileSync(pkgJsonPath, "utf-8"));
+            if (data.name)
+                return data.name;
+        }
+    }
+    catch {
+        // ignore parse errors
+    }
+    return path.basename(projectRoot);
+}
+const CALLBACK_PORT = 18000;
+const LOGIN_TIMEOUT_MS = 60000;
+const DEFAULT_BASE_URL = "https://aiworld.local:8000";
+/**
+ * 验证 token 是否有效
+ * 使用 https/http 模块替代 fetch，以支持自签名证书（rejectUnauthorized: false）
+ */
+function validateToken(baseUrl, token) {
+    return new Promise((resolve) => {
+        try {
+            const url = new URL(`${baseUrl}/api/auth/me`);
+            const mod = url.protocol === "https:" ? https : http;
+            const req = mod.get(url.href, {
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                    "Content-Type": "application/json",
+                },
+                rejectUnauthorized: false,
+            }, (res) => {
+                res.resume();
+                resolve(res.statusCode !== undefined && res.statusCode >= 200 && res.statusCode < 300);
+            });
+            req.on("error", () => resolve(false));
+        }
+        catch {
+            resolve(false);
+        }
+    });
+}
+/**
+ * 强制确保端口可用：如果被占用则 kill 占用进程
+ */
+function ensurePort(port) {
+    try {
+        const result = (0, child_process_1.execSync)(`lsof -ti:${port}`, { encoding: "utf-8" }).trim();
+        if (result) {
+            const pids = result.split("\n").filter(Boolean);
+            for (const pid of pids) {
+                try {
+                    (0, child_process_1.execSync)(`kill -9 ${pid}`, { stdio: "ignore" });
+                }
+                catch {
+                    // pid may have already exited
+                }
+            }
+            // Brief wait for OS to release the port
+            (0, child_process_1.execSync)("sleep 0.3");
+        }
+    }
+    catch {
+        // lsof returns non-zero when no process found — port is free
+    }
+}
+/**
+ * 打开浏览器
+ */
+function openBrowser(url) {
+    const platform = process.platform;
+    const cmd = platform === "darwin"
+        ? "open"
+        : platform === "win32"
+            ? "start"
+            : "xdg-open";
+    (0, child_process_1.exec)(`${cmd} "${url}"`, (err) => {
+        if (err) {
+            console.log(`[ai-world] 无法自动打开浏览器，请手动访问: ${url}`);
+        }
+    });
+}
+/**
+ * 读取 .env.local 中的环境变量
+ */
+function readEnvLocal(projectRoot) {
+    const envPath = path.join(projectRoot, ".env.local");
+    const vars = {};
+    if (!fs.existsSync(envPath))
+        return vars;
+    const content = fs.readFileSync(envPath, "utf-8");
+    for (const line of content.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#"))
+            continue;
+        const eqIdx = trimmed.indexOf("=");
+        if (eqIdx === -1)
+            continue;
+        const key = trimmed.slice(0, eqIdx).trim();
+        const value = trimmed.slice(eqIdx + 1).trim();
+        vars[key] = value;
+    }
+    return vars;
+}
+/**
+ * 写入/合并 .env.local，只更新指定的 key，保留其他内容
+ */
+function writeEnvLocal(projectRoot, updates) {
+    const envPath = path.join(projectRoot, ".env.local");
+    let lines = [];
+    if (fs.existsSync(envPath)) {
+        lines = fs.readFileSync(envPath, "utf-8").split("\n");
+    }
+    const updatedKeys = new Set();
+    for (let i = 0; i < lines.length; i++) {
+        const trimmed = lines[i].trim();
+        if (!trimmed || trimmed.startsWith("#"))
+            continue;
+        const eqIdx = trimmed.indexOf("=");
+        if (eqIdx === -1)
+            continue;
+        const key = trimmed.slice(0, eqIdx).trim();
+        if (key in updates) {
+            lines[i] = `${key}=${updates[key]}`;
+            updatedKeys.add(key);
+        }
+    }
+    for (const [key, value] of Object.entries(updates)) {
+        if (!updatedKeys.has(key)) {
+            lines.push(`${key}=${value}`);
+        }
+    }
+    // Remove trailing empty lines then add single newline at end
+    while (lines.length > 0 && lines[lines.length - 1].trim() === "") {
+        lines.pop();
+    }
+    lines.push("");
+    fs.writeFileSync(envPath, lines.join("\n"), "utf-8");
+}
+/**
+ * 执行登录流程：启动本地 HTTP 服务器 → 打开浏览器 → 等待回调
+ */
+function performLogin(options = {}) {
+    const baseUrl = options.baseUrl || DEFAULT_BASE_URL;
+    const timeout = options.timeout || LOGIN_TIMEOUT_MS;
+    return new Promise((resolve, reject) => {
+        ensurePort(CALLBACK_PORT);
+        let settled = false;
+        let timeoutId;
+        const server = http.createServer((req, res) => {
+            const url = new URL(req.url || "/", `http://localhost:${CALLBACK_PORT}`);
+            if (url.pathname === "/callback") {
+                const token = url.searchParams.get("token");
+                res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+                if (token) {
+                    res.end(`
+<!DOCTYPE html>
+<html><head><meta charset="utf-8"><title>AI World 登录成功</title></head>
+<body style="display:flex;justify-content:center;align-items:center;height:100vh;font-family:system-ui;background:#f5f5f5">
+<div style="text-align:center;padding:40px;background:white;border-radius:12px;box-shadow:0 2px 12px rgba(0,0,0,.1)">
+<h2 style="color:#52c41a">✓ 登录成功</h2>
+<p style="color:#666">Token 已保存，可以关闭此页面</p>
+</div></body></html>`);
+                    if (!settled) {
+                        settled = true;
+                        clearTimeout(timeoutId);
+                        server.close();
+                        resolve({ token, baseUrl });
+                    }
+                }
+                else {
+                    res.end(`
+<!DOCTYPE html>
+<html><head><meta charset="utf-8"><title>AI World 登录失败</title></head>
+<body style="display:flex;justify-content:center;align-items:center;height:100vh;font-family:system-ui;background:#f5f5f5">
+<div style="text-align:center;padding:40px;background:white;border-radius:12px;box-shadow:0 2px 12px rgba(0,0,0,.1)">
+<h2 style="color:#ff4d4f">✗ 登录失败</h2>
+<p style="color:#666">未收到 token，请重试</p>
+</div></body></html>`);
+                }
+                return;
+            }
+            res.writeHead(404);
+            res.end("Not Found");
+        });
+        server.on("error", (err) => {
+            if (!settled) {
+                settled = true;
+                reject(new Error(`无法启动本地回调服务器: ${err.message}`));
+            }
+        });
+        server.listen(CALLBACK_PORT, () => {
+            const callbackUrl = `http://localhost:${CALLBACK_PORT}/callback`;
+            const loginUrl = `${baseUrl}/api/auth/login?redirect=${encodeURIComponent(callbackUrl)}`;
+            console.log(`[ai-world] 正在打开浏览器登录...`);
+            console.log(`[ai-world] 如果浏览器未自动打开，请手动访问:`);
+            console.log(`[ai-world] ${loginUrl}`);
+            openBrowser(loginUrl);
+            timeoutId = setTimeout(() => {
+                if (!settled) {
+                    settled = true;
+                    server.close();
+                    reject(new Error(`登录超时（${timeout / 1000}s），请重新启动 dev server`));
+                }
+            }, timeout);
+        });
+    });
+}

package/dist/vite-plugin.d.ts

@@ -0,0 +1,14 @@
+/**
+ * AI World SDK - Vite Plugin
+ * 在 Vite dev server 启动时自动检测并完成登录
+ * 仅在 Node.js 环境运行（vite.config.ts），不会被打包到浏览器代码中
+ *
+ * 使用方式:
+ *   import { aiWorldPlugin } from 'ai-world-sdk/vite'
+ *   export default defineConfig({ plugins: [aiWorldPlugin()] })
+ */
+export interface AIWorldPluginOptions {
+    /** AI World 后端地址，默认 https://aiworld.local:8000 */
+    baseUrl?: string;
+}
+export declare function aiWorldPlugin(options?: AIWorldPluginOptions): any;

package/dist/vite-plugin.js

@@ -0,0 +1,83 @@
+"use strict";
+/**
+ * AI World SDK - Vite Plugin
+ * 在 Vite dev server 启动时自动检测并完成登录
+ * 仅在 Node.js 环境运行（vite.config.ts），不会被打包到浏览器代码中
+ *
+ * 使用方式:
+ *   import { aiWorldPlugin } from 'ai-world-sdk/vite'
+ *   export default defineConfig({ plugins: [aiWorldPlugin()] })
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aiWorldPlugin = aiWorldPlugin;
+const login_1 = require("./login");
+const DEFAULT_BASE_URL = "https://aiworld.local:8000";
+function aiWorldPlugin(options = {}) {
+    const baseUrl = options.baseUrl || DEFAULT_BASE_URL;
+    let hasLoggedIn = false;
+    let projectRoot = process.cwd();
+    return {
+        name: "ai-world-sdk",
+        apply: "serve",
+        // 将 .env.local 中的配置注入到浏览器页面的 window.__AI_WORLD_CONFIG__
+        // 使 SDK 在浏览器端能自动读取 token/pluginId/baseUrl
+        transformIndexHtml() {
+            const env = (0, login_1.readEnvLocal)(projectRoot);
+            const config = { baseUrl };
+            if (env["DEBUG_TOKEN"])
+                config.token = env["DEBUG_TOKEN"];
+            if (env["PLUGIN_ID"])
+                config.pluginId = env["PLUGIN_ID"];
+            if (env["DEBUG"] === "true")
+                config.debug = true;
+            return [{
+                    tag: "script",
+                    attrs: { type: "text/javascript" },
+                    children: `window.__AI_WORLD_CONFIG__=${JSON.stringify(config)};`,
+                    injectTo: "head-prepend",
+                }];
+        },
+        configureServer(server) {
+            projectRoot = server.config?.root || process.cwd();
+            server.httpServer?.once("listening", async () => {
+                if (hasLoggedIn)
+                    return;
+                const env = (0, login_1.readEnvLocal)(projectRoot);
+                const existingToken = env["DEBUG_TOKEN"] || process.env.DEBUG_TOKEN;
+                // 确保 PLUGIN_ID 存在，不存在则从 plugin.json 或目录名推断
+                if (!env["PLUGIN_ID"] && !process.env.PLUGIN_ID) {
+                    const pluginId = (0, login_1.resolvePluginId)(projectRoot);
+                    (0, login_1.writeEnvLocal)(projectRoot, { PLUGIN_ID: pluginId });
+                    console.log(`[ai-world] PLUGIN_ID 设置为 "${pluginId}"`);
+                }
+                if (existingToken) {
+                    const valid = await (0, login_1.validateToken)(baseUrl, existingToken);
+                    if (valid) {
+                        console.log("[ai-world] Token 有效，跳过登录");
+                        return;
+                    }
+                    console.log("[ai-world] Token 已过期或无效，需要重新登录");
+                }
+                else {
+                    console.log("[ai-world] 未检测到 DEBUG_TOKEN，需要登录");
+                }
+                try {
+                    const result = await (0, login_1.performLogin)({ baseUrl });
+                    hasLoggedIn = true;
+                    const pluginId = env["PLUGIN_ID"] || process.env.PLUGIN_ID || (0, login_1.resolvePluginId)(projectRoot);
+                    (0, login_1.writeEnvLocal)(projectRoot, {
+                        DEBUG: "true",
+                        DEBUG_TOKEN: result.token,
+                        PLUGIN_ID: pluginId,
+                    });
+                    console.log("[ai-world] 登录成功，Token 已写入 .env.local");
+                    console.log("[ai-world] 正在重启 dev server 以加载新的环境变量...");
+                    await server.restart();
+                }
+                catch (err) {
+                    console.error(`[ai-world] 登录失败: ${err.message}`);
+                }
+            });
+        },
+    };
+}

package/package.json

@@ -1,9 +1,19 @@
 {
   "name": "ai-world-sdk",
-  "version": "1.2.2",
+  "version": "1.2.5",
   "description": "TypeScript SDK for AI World Platform - Chat Models, Image Generation, and Video Generation",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./vite": {
+      "types": "./dist/vite-plugin.d.ts",
+      "default": "./dist/vite-plugin.js"
+    }
+  },
   "scripts": {
     "update-version": "node scripts/update-version.js",
     "build": "npm run update-version && rm -rf dist && tsc",