ai-world-sdk 1.2.1 → 1.2.3

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/__tests__/resource.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * ResourceClient 集成测试
+ * 使用真实 SDK 调用后端 /api/resources 接口
+ * 需要后端运行 + MinIO 服务 + 数据库可用
+ *
+ * 运行: npx jest --testPathPattern=resource.test.ts
+ */
+export {};

package/dist/__tests__/resource.test.js

@@ -0,0 +1,208 @@
+"use strict";
+/**
+ * ResourceClient 集成测试
+ * 使用真实 SDK 调用后端 /api/resources 接口
+ * 需要后端运行 + MinIO 服务 + 数据库可用
+ *
+ * 运行: npx jest --testPathPattern=resource.test.ts
+ */
+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 dotenv = __importStar(require("dotenv"));
+const index_1 = require("../index");
+dotenv.config();
+index_1.sdkConfig.setBaseUrl("http://localhost:8000");
+index_1.sdkConfig.setToken(process.env.AUTH_TOKEN || process.env.TOKEN || "");
+index_1.sdkConfig.setDebug(true);
+const PLUGIN_ID = "test-plugin";
+describe("ResourceClient 测试", () => {
+    let client;
+    let uploadedResourceId;
+    beforeAll(() => {
+        index_1.sdkConfig.setPluginId(PLUGIN_ID);
+        client = new index_1.ResourceClient();
+    });
+    // ==================== 上传 ====================
+    test("上传资源 - 默认 private", async () => {
+        const content = "Resource test content: " + Date.now();
+        const blob = new Blob([content], { type: "text/plain" });
+        const file = new File([blob], "resource-test.txt", { type: "text/plain" });
+        const result = await client.upload("test/resource-test.txt", file);
+        expect(result).toBeDefined();
+        expect(result.id).toBeDefined();
+        expect(result.path).toBe("test/resource-test.txt");
+        expect(result.access_level).toBe("private");
+        expect(result.owner_id).toBeDefined();
+        expect(result.plugin_id).toBe(PLUGIN_ID);
+        expect(result.size).toBeGreaterThan(0);
+        uploadedResourceId = result.id;
+        console.log("上传成功:", result);
+    }, 30000);
+    test("上传资源 - public 带描述", async () => {
+        const blob = new Blob(["public content"], { type: "text/plain" });
+        const file = new File([blob], "public-file.txt", { type: "text/plain" });
+        const result = await client.upload("test/public-file.txt", file, {
+            accessLevel: "public",
+            description: "公开测试文件",
+        });
+        expect(result).toBeDefined();
+        expect(result.access_level).toBe("public");
+        expect(result.description).toBe("公开测试文件");
+        console.log("公开资源上传成功:", result);
+    }, 30000);
+    // ==================== 列表 ====================
+    test("列出我的资源", async () => {
+        const resources = await client.listMy();
+        expect(resources).toBeDefined();
+        expect(Array.isArray(resources)).toBe(true);
+        expect(resources.length).toBeGreaterThan(0);
+        const testFile = resources.find((r) => r.path === "test/resource-test.txt");
+        expect(testFile).toBeDefined();
+        console.log(`我的资源 (${resources.length} 个):`, resources.map((r) => r.path));
+    }, 30000);
+    test("列出公开资源", async () => {
+        const resources = await client.listPublic();
+        expect(resources).toBeDefined();
+        expect(Array.isArray(resources)).toBe(true);
+        const publicFile = resources.find((r) => r.path === "test/public-file.txt");
+        expect(publicFile).toBeDefined();
+        console.log(`公开资源 (${resources.length} 个):`, resources.map((r) => r.path));
+    }, 30000);
+    // ==================== 获取详情 ====================
+    test("获取资源详情", async () => {
+        expect(uploadedResourceId).toBeDefined();
+        const info = await client.getInfo(uploadedResourceId);
+        expect(info).toBeDefined();
+        expect(info.id).toBe(uploadedResourceId);
+        expect(info.path).toBe("test/resource-test.txt");
+        expect(info.filename).toBe("resource-test.txt");
+        console.log("资源详情:", info);
+    }, 30000);
+    // ==================== 修改权限 ====================
+    test("修改访问级别为 public", async () => {
+        expect(uploadedResourceId).toBeDefined();
+        const updated = await client.updateAccess(uploadedResourceId, "public");
+        expect(updated).toBeDefined();
+        expect(updated.access_level).toBe("public");
+        console.log("访问级别已更新:", updated.access_level);
+    }, 30000);
+    test("修改访问级别为 specific_users", async () => {
+        expect(uploadedResourceId).toBeDefined();
+        const updated = await client.updateAccess(uploadedResourceId, "specific_users");
+        expect(updated).toBeDefined();
+        expect(updated.access_level).toBe("specific_users");
+        console.log("访问级别已更新:", updated.access_level);
+    }, 30000);
+    // ==================== 批量分享 ====================
+    test("批量添加分享 - 单个用户", async () => {
+        expect(uploadedResourceId).toBeDefined();
+        const result = await client.addShare(uploadedResourceId, 99);
+        expect(result).toBeDefined();
+        expect(result.resource_id).toBe(uploadedResourceId);
+        expect(result.total_requested).toBe(1);
+        console.log("批量添加分享（单个）:", result);
+    }, 30000);
+    test("批量添加分享 - 多个用户", async () => {
+        expect(uploadedResourceId).toBeDefined();
+        const result = await client.addShare(uploadedResourceId, [100, 101]);
+        expect(result).toBeDefined();
+        expect(result.total_requested).toBe(2);
+        console.log("批量添加分享（多个）:", result);
+    }, 30000);
+    test("批量移除分享 - 多个用户", async () => {
+        expect(uploadedResourceId).toBeDefined();
+        const result = await client.removeShare(uploadedResourceId, [99, 100, 101]);
+        expect(result).toBeDefined();
+        expect(result.total_requested).toBe(3);
+        console.log("批量移除分享:", result);
+    }, 30000);
+    // ==================== 下载 ====================
+    test("通过资源 ID 下载", async () => {
+        expect(uploadedResourceId).toBeDefined();
+        // 先改回 private 验证 owner 仍可下载
+        await client.updateAccess(uploadedResourceId, "private");
+        const blob = await client.download(uploadedResourceId);
+        expect(blob).toBeDefined();
+        expect(blob.size).toBeGreaterThan(0);
+        console.log("下载成功, 大小:", blob.size);
+    }, 30000);
+    // ==================== 列出被分享的 ====================
+    test("列出被分享给我的资源", async () => {
+        const resources = await client.listSharedWithMe();
+        expect(resources).toBeDefined();
+        expect(Array.isArray(resources)).toBe(true);
+        console.log(`被分享资源 (${resources.length} 个)`);
+    }, 30000);
+    // ==================== 跨插件 ====================
+    test("列出我的资源 - 跨插件", async () => {
+        const resources = await client.listMy({ crossPlugin: true });
+        expect(resources).toBeDefined();
+        expect(Array.isArray(resources)).toBe(true);
+        console.log(`跨插件资源 (${resources.length} 个)`);
+    }, 30000);
+    // ==================== 删除 ====================
+    test("删除资源", async () => {
+        expect(uploadedResourceId).toBeDefined();
+        await client.delete(uploadedResourceId);
+        console.log("资源已删除:", uploadedResourceId);
+        // 验证已删除
+        try {
+            await client.getInfo(uploadedResourceId);
+            fail("应该抛出错误");
+        }
+        catch (e) {
+            expect(e.message).toContain("404");
+        }
+    }, 30000);
+    // 清理 public-file
+    test("清理测试资源", async () => {
+        const resources = await client.listMy();
+        const publicFile = resources.find((r) => r.path === "test/public-file.txt");
+        if (publicFile) {
+            await client.delete(publicFile.id);
+            console.log("清理 public-file:", publicFile.id);
+        }
+    }, 30000);
+    // ==================== 插件 ID 验证 ====================
+    test("缺少 pluginId 时抛出错误", () => {
+        const originalPluginId = index_1.sdkConfig.getPluginId();
+        index_1.sdkConfig.setPluginId("");
+        const badClient = new index_1.ResourceClient();
+        expect(() => {
+            badClient.ensurePluginId();
+        }).toThrow("X-Plugin-Id is required");
+        index_1.sdkConfig.setPluginId(originalPluginId || PLUGIN_ID);
+    });
+});

package/dist/config.d.ts

@@ -9,13 +9,20 @@
  *
  * 注意: {VERSION} 占位符会在构建时被替换为实际版本号
  */
-export declare const SDK_SIGNATURE = "AI_WORLD_SDK_V:1.2.1";
+export declare const SDK_SIGNATURE = "AI_WORLD_SDK_V:1.2.3";
 /**
  * 版本兼容性错误
  */
 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.1";
-    readonly sdkVersion = "1.2.1";
+    private _authenticated;
+    private _authCheckPromise;
+    private _currentUser;
+    readonly sdkSignature = "AI_WORLD_SDK_V:1.2.3";
+    readonly sdkVersion = "1.2.3";
     constructor();
     /**
      * Set global base URL
@@ -77,6 +87,23 @@ declare class SDKConfig {
      * 获取插件 ID（从 window.__INITIAL_DATA__ 自动获取或手动设置）
      */
     getPluginId(): string | null;
+    /**
+     * 检查当前 token 是否有效，获取登录用户信息
+     */
+    checkAuthentication(): Promise<boolean>;
+    private _performAuthCheck;
+    /**
+     * 获取当前登录状态
+     */
+    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.1";
+const SDK_VERSION = "1.2.3";
 /**
  * SDK 特征码 - 用于在构建后的 JS 文件中识别 SDK 版本
  * 格式: AI_WORLD_SDK_V:版本号
@@ -15,7 +15,7 @@ const SDK_VERSION = "1.2.1";
  *
  * 注意: {VERSION} 占位符会在构建时被替换为实际版本号
  */
-exports.SDK_SIGNATURE = "AI_WORLD_SDK_V:1.2.1";
+exports.SDK_SIGNATURE = "AI_WORLD_SDK_V:1.2.3";
 /**
  * 版本兼容性错误
  */
@@ -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,81 @@ 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 response = await fetch(`${baseUrl}/api/auth/me`, {
+                method: 'GET',
+                headers: {
+                    'Authorization': `Bearer ${this._token}`,
+                    'Content-Type': 'application/json',
+                },
+            });
+            if (response.ok) {
+                const user = await response.json();
+                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;
+        }
+    }
+    /**
+     * 获取当前登录状态
+     */
+    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
      * 检查与后端的版本兼容性