@heyputer/puter.js 2.0.2 → 2.0.4

package/index.d.ts

@@ -1,479 +0,0 @@
-declare global {
-    interface Window {
-        puter: Puter;
-    }
-}
-
-declare namespace Puter {
-    // Main Puter interface
-    interface Puter {
-        // Properties
-        appID: string;
-        env: 'app' | 'web' | 'gui';
-
-        // Utility methods
-        print(text: string, options?: { code?: boolean }): void;
-        randName(separator?: string): string;
-        exit(statusCode?: number): void;
-
-        // Sub-modules
-        ai: AI;
-        apps: Apps;
-        auth: Auth;
-        drivers: Drivers;
-        fs: FileSystem;
-        hosting: Hosting;
-        kv: KV;
-        net: Networking;
-        perms: Permissions;
-        ui: UI;
-        workers: Workers;
-    }
-
-    // AI Module
-    interface AI {
-        chat(prompt: string, options?: ChatOptions): Promise<ChatResponse>;
-        chat(prompt: string, testMode?: boolean, options?: ChatOptions): Promise<ChatResponse>;
-        chat(prompt: string, imageURL?: string, testMode?: boolean, options?: ChatOptions): Promise<ChatResponse>;
-        chat(prompt: string, imageURLArray?: string[], testMode?: boolean, options?: ChatOptions): Promise<ChatResponse>;
-        chat(messages: ChatMessage[], testMode?: boolean, options?: ChatOptions): Promise<ChatResponse>;
-
-        img2txt(image: string | File | Blob, testMode?: boolean): Promise<string>;
-
-        txt2img(prompt: string, testMode?: boolean): Promise<HTMLImageElement>;
-        txt2img(prompt: string, options?: Txt2ImgOptions): Promise<HTMLImageElement>;
-
-        txt2speech(text: string): Promise<HTMLAudioElement>;
-        txt2speech(text: string, options?: Txt2SpeechOptions): Promise<HTMLAudioElement>;
-        txt2speech(text: string, language?: string): Promise<HTMLAudioElement>;
-        txt2speech(text: string, language?: string, voice?: string): Promise<HTMLAudioElement>;
-        txt2speech(text: string, language?: string, voice?: string, engine?: string): Promise<HTMLAudioElement>;
-    }
-
-    interface ChatOptions {
-        model?: string;
-        stream?: boolean;
-        max_tokens?: number;
-        temperature?: number;
-        tools?: ToolDefinition[];
-    }
-
-    interface ToolDefinition {
-        type: 'function';
-        function: {
-            name: string;
-            description: string;
-            parameters: object;
-            strict?: boolean;
-        };
-    }
-
-    interface ChatMessage {
-        role: 'system' | 'assistant' | 'user' | 'function' | 'tool';
-        content: string | ContentObject[];
-        tool_call_id?: string;
-    }
-
-    interface ContentObject {
-        type: 'text' | 'file';
-        text?: string;
-        puter_path?: string;
-    }
-
-    interface ChatResponse {
-        message: {
-            role: string;
-            content: string;
-            tool_calls?: ToolCall[];
-        };
-    }
-
-    interface ToolCall {
-        id: string;
-        function: {
-            name: string;
-            arguments: string;
-        };
-    }
-
-    interface Txt2ImgOptions {
-        model?: 'gpt-image-1' | 'gemini-2.5-flash-image-preview' | 'dall-e-3';
-        quality?: 'high' | 'medium' | 'low' | 'hd' | 'standard';
-        input_image?: string;
-        input_image_mime_type?: string;
-    }
-
-    interface Txt2SpeechOptions {
-        language?: string;
-        voice?: string;
-        engine?: 'standard' | 'neural' | 'generative';
-    }
-
-    // Apps Module
-    interface Apps {
-        create(name: string, indexURL: string): Promise<App>;
-        create(name: string, indexURL: string, title?: string): Promise<App>;
-        create(name: string, indexURL: string, title?: string, description?: string): Promise<App>;
-        create(options: CreateAppOptions): Promise<App>;
-
-        delete(name: string): Promise<App>;
-        get(name: string, options?: GetAppOptions): Promise<App>;
-        list(options?: ListAppOptions): Promise<App[]>;
-        update(name: string, attributes: UpdateAppAttributes): Promise<App>;
-    }
-
-    interface CreateAppOptions {
-        name: string;
-        indexURL: string;
-        title?: string;
-        description?: string;
-        icon?: string;
-        maximizeOnStart?: boolean;
-        filetypeAssociations?: string[];
-    }
-
-    interface GetAppOptions {
-        stats_period?: StatsPeriod;
-        icon_size?: null | 16 | 32 | 64 | 128 | 256 | 512;
-    }
-
-    interface ListAppOptions extends GetAppOptions { }
-
-    interface UpdateAppAttributes {
-        name?: string;
-        indexURL?: string;
-        title?: string;
-        description?: string;
-        icon?: string;
-        maximizeOnStart?: boolean;
-        filetypeAssociations?: string[];
-    }
-
-    type StatsPeriod = 'all' | 'today' | 'yesterday' | '7d' | '30d' | 'this_month' | 'last_month' | 'this_year' | 'last_year' | 'month_to_date' | 'year_to_date' | 'last_12_months';
-
-    interface App {
-        uid: string;
-        name: string;
-        icon: string;
-        description: string;
-        title: string;
-        maximize_on_start: boolean;
-        index_url: string;
-        created_at: string;
-        background: boolean;
-        filetype_associations: string[];
-        open_count: number;
-        user_count: number;
-    }
-
-    // Auth Module
-    interface Auth {
-        signIn(options?: { attempt_temp_user_creation?: boolean }): Promise<boolean>;
-        signOut(): void;
-        isSignedIn(): boolean;
-        getUser(): Promise<User>;
-    }
-
-    interface User {
-        uuid: string;
-        username: string;
-        email_confirmed: boolean;
-    }
-
-    // Drivers Module
-    interface Drivers {
-        call(interface: string, driver: string, method: string, args?: object): Promise<any>;
-    }
-
-    // FileSystem Module
-    interface FileSystem {
-        copy(source: string, destination: string, options?: CopyOptions): Promise<FSItem>;
-        delete(path: string, options?: DeleteOptions): Promise<void>;
-        getReadURL(path: string, expiresIn?: number): Promise<string>;
-        mkdir(path: string, options?: MkdirOptions): Promise<FSItem>;
-        move(source: string, destination: string, options?: MoveOptions): Promise<FSItem>;
-        read(path: string, options?: ReadOptions): Promise<Blob>;
-        readdir(path: string, options?: ReaddirOptions): Promise<FSItem[]>;
-        readdir(options?: ReaddirOptions): Promise<FSItem[]>;
-        rename(path: string, newName: string): Promise<FSItem>;
-        space(): Promise<SpaceInfo>;
-        stat(path: string): Promise<FSItem>;
-        upload(items: FileList | File[] | Blob[], dirPath?: string, options?: object): Promise<FSItem[]>;
-        write(path: string, data?: string | File | Blob, options?: WriteOptions): Promise<FSItem>;
-    }
-
-    interface CopyOptions {
-        overwrite?: boolean;
-        dedupeName?: boolean;
-        newName?: string;
-    }
-
-    interface DeleteOptions {
-        recursive?: boolean;
-        descendantsOnly?: boolean;
-    }
-
-    interface MkdirOptions {
-        overwrite?: boolean;
-        dedupeName?: boolean;
-        createMissingParents?: boolean;
-    }
-
-    interface MoveOptions extends CopyOptions {
-        createMissingParents?: boolean;
-    }
-
-    interface ReadOptions {
-        offset?: number;
-        byte_count?: number;
-    }
-
-    interface ReaddirOptions {
-        path?: string;
-        uid?: string;
-    }
-
-    interface WriteOptions {
-        overwrite?: boolean;
-        dedupeName?: boolean;
-        createMissingParents?: boolean;
-    }
-
-    interface SpaceInfo {
-        capacity: number;
-        used: number;
-    }
-
-    interface FSItem {
-        id: string;
-        uid: string;
-        name: string;
-        path: string;
-        is_dir: boolean;
-        parent_id: string;
-        parent_uid: string;
-        created: number;
-        modified: number;
-        accessed: number;
-        size: number | null;
-        writable: boolean;
-        read(): Promise<Blob>;
-        readdir(): Promise<FSItem[]>;
-    }
-
-    // Hosting Module
-    interface Hosting {
-        create(subdomain: string, dirPath?: string): Promise<Subdomain>;
-        delete(subdomain: string): Promise<boolean>;
-        get(subdomain: string): Promise<Subdomain>;
-        list(): Promise<Subdomain[]>;
-        update(subdomain: string, dirPath?: string): Promise<Subdomain>;
-    }
-
-    interface Subdomain {
-        uid: string;
-        subdomain: string;
-        root_dir: FSItem;
-    }
-
-    // KV Module
-    interface KV {
-        set(key: string, value: string | number | boolean | object | any[]): Promise<boolean>;
-        get(key: string): Promise<any>;
-        del(key: string): Promise<boolean>;
-        incr(key: string, amount?: number): Promise<number>;
-        decr(key: string, amount?: number): Promise<number>;
-        list(pattern?: string, returnValues?: boolean): Promise<string[] | KVPair[]>;
-        list(returnValues?: boolean): Promise<string[] | KVPair[]>;
-        flush(): Promise<boolean>;
-    }
-
-    interface KVPair {
-        key: string;
-        value: any;
-    }
-
-    // Networking Module
-    interface Networking {
-        fetch(url: string, options?: RequestInit): Promise<Response>;
-        Socket: typeof Socket;
-        tls: {
-            TLSSocket: typeof TLSSocket;
-        };
-    }
-
-    class Socket {
-        constructor(hostname: string, port: number);
-        write(data: ArrayBuffer | Uint8Array | string): void;
-        close(): void;
-        on(event: 'open', callback: () => void): void;
-        on(event: 'data', callback: (buffer: Uint8Array) => void): void;
-        on(event: 'error', callback: (reason: string) => void): void;
-        on(event: 'close', callback: (hadError: boolean) => void): void;
-    }
-
-    class TLSSocket extends Socket {
-        constructor(hostname: string, port: number);
-    }
-
-    // Permissions Module
-    interface Permissions {
-        grantApp(app_uid: string, permissionString: string): Promise<object>;
-        grantAppAnyUser(app_uid: string, permissionString: string): Promise<object>;
-        grantGroup(group_uid: string, permissionString: string): Promise<object>;
-        grantOrigin(origin: string, permissionString: string): Promise<object>;
-        grantUser(username: string, permissionString: string): Promise<object>;
-        revokeApp(app_uid: string, permissionString: string): Promise<object>;
-        revokeAppAnyUser(app_uid: string, permissionString: string): Promise<object>;
-        revokeGroup(group_uid: string, permissionString: string): Promise<object>;
-        revokeOrigin(origin: string, permissionString: string): Promise<object>;
-        revokeUser(username: string, permissionString: string): Promise<object>;
-    }
-
-    // UI Module
-    interface UI {
-        alert(message?: string, buttons?: AlertButton[]): Promise<string>;
-        prompt(message?: string, defaultValue?: string): Promise<string | null>;
-        authenticateWithPuter(): Promise<boolean>;
-        contextMenu(options: ContextMenuOptions): void;
-        createWindow(options?: WindowOptions): void;
-        exit(statusCode?: number): void;
-        getLanguage(): Promise<string>;
-        hideSpinner(): void;
-        launchApp(appName?: string, args?: object): Promise<AppConnection>;
-        launchApp(options: LaunchAppOptions): Promise<AppConnection>;
-        on(eventName: 'localeChanged', handler: (data: { language: string }) => void): void;
-        on(eventName: 'themeChanged', handler: (data: ThemeData) => void): void;
-        onItemsOpened(handler: (items: FSItem[]) => void): void;
-        onLaunchedWithItems(handler: (items: FSItem[]) => void): void;
-        onWindowClose(handler: () => void): void;
-        parentApp(): AppConnection | null;
-        setMenubar(options: MenubarOptions): void;
-        setWindowHeight(height: number): void;
-        setWindowPosition(x: number, y: number): void;
-        setWindowSize(width: number, height: number): void;
-        setWindowTitle(title: string): void;
-        setWindowWidth(width: number): void;
-        setWindowX(x: number): void;
-        setWindowY(y: number): void;
-        showColorPicker(defaultColor?: string): Promise<string>;
-        showColorPicker(options?: object): Promise<string>;
-        showDirectoryPicker(options?: { multiple?: boolean }): Promise<FSItem | FSItem[]>;
-        showFontPicker(defaultFont?: string): Promise<{ fontFamily: string }>;
-        showFontPicker(options?: object): Promise<{ fontFamily: string }>;
-        showOpenFilePicker(options?: FilePickerOptions): Promise<FSItem | FSItem[]>;
-        showSaveFilePicker(data?: any, defaultFileName?: string): Promise<FSItem>;
-        showSpinner(): void;
-        socialShare(url: string, message?: string, options?: { left?: number; top?: number }): void;
-        wasLaunchedWithItems(): boolean;
-    }
-
-    interface AlertButton {
-        label: string;
-        value?: string;
-        type?: 'primary' | 'success' | 'info' | 'warning' | 'danger';
-    }
-
-    interface ContextMenuOptions {
-        items: (ContextMenuItem | '-')[];
-    }
-
-    interface ContextMenuItem {
-        label: string;
-        action?: () => void;
-        icon?: string;
-        icon_active?: string;
-        disabled?: boolean;
-        items?: (ContextMenuItem | '-')[];
-    }
-
-    interface WindowOptions {
-        center?: boolean;
-        content?: string;
-        disable_parent_window?: boolean;
-        has_head?: boolean;
-        height?: number;
-        is_resizable?: boolean;
-        show_in_taskbar?: boolean;
-        title?: string;
-        width?: number;
-    }
-
-    interface LaunchAppOptions {
-        name?: string;
-        args?: object;
-    }
-
-    interface ThemeData {
-        palette: {
-            primaryHue: number;
-            primarySaturation: string;
-            primaryLightness: string;
-            primaryAlpha: number;
-            primaryColor: string;
-        };
-    }
-
-    interface MenubarOptions {
-        items: MenuItem[];
-    }
-
-    interface MenuItem {
-        label: string;
-        action?: () => void;
-        items?: MenuItem[];
-    }
-
-    interface FilePickerOptions {
-        multiple?: boolean;
-        accept?: string | string[];
-    }
-
-    interface AppConnection {
-        usesSDK: boolean;
-        on(eventName: 'message', handler: (message: any) => void): void;
-        on(eventName: 'close', handler: (data: { appInstanceID: string }) => void): void;
-        off(eventName: string, handler: Function): void;
-        postMessage(message: any): void;
-        close(): void;
-    }
-
-    // Workers Module
-    interface Workers {
-        create(workerName: string, filePath: string): Promise<WorkerDeployment>;
-        delete(workerName: string): Promise<boolean>;
-        exec(workerURL: string, options?: WorkerExecOptions): Promise<Response>;
-        get(workerName: string): Promise<WorkerInfo>;
-        list(): Promise<WorkerInfo[]>;
-    }
-
-    interface WorkerDeployment {
-        success: boolean;
-        url: string;
-        errors: any[];
-    }
-
-    interface WorkerExecOptions extends RequestInit {
-        method?: string;
-        headers?: object;
-        body?: string | object;
-        cache?: RequestCache;
-        credentials?: RequestCredentials;
-        mode?: RequestMode;
-        redirect?: RequestRedirect;
-        referrer?: string;
-        signal?: AbortSignal;
-    }
-
-    interface WorkerInfo {
-        name: string;
-        url: string;
-        file_path: string;
-        file_uid: string;
-        created_at: string;
-    }
-}
-
-declare const puter: Puter.Puter;
-
-export = Puter;

package/src/entry.js

@@ -1,9 +0,0 @@
-const goodContext = {}
-
-let puter;
-with (goodContext) {
-    puter = await import('./src/index.js');
-}
-
-
-module.exports = { puter };

package/test/ai.test.js

@@ -1,214 +0,0 @@
-/* eslint-disable */
-// TODO: Make these more compatible with eslint
-
-// Define models to test
-const TEST_MODELS = [
-    "openrouter:openai/gpt-4.1-mini",
-    "openrouter:anthropic/claude-3.5-sonnet-20240620",
-    "gpt-4o-mini",
-    "openai/gpt-4.1-nano",
-    "claude-sonnet-4-latest",
-    // Add more models as needed
-];
-
-// Core test functions that can be reused across models
-const testChatBasicPromptCore = async function(model) {
-    // Test basic string prompt with test mode enabled
-    const result = await puter.ai.chat("Hello, how are you?", { model: model });
-    
-    // Check that result is an object and not null
-    assert(typeof result === 'object', "chat should return an object");
-    assert(result !== null, "chat should not return null");
-    
-    // Check response structure
-    assert(typeof result.message === 'object', "result should have message object");
-    assert(typeof result.finish_reason === 'string', "result should have finish_reason string");
-    assert(typeof result.via_ai_chat_service === 'boolean', "result should have via_ai_chat_service boolean");
-    
-    // Check message structure
-    assert(typeof result.message.role === 'string', "message should have role string");
-    assert(result.message.role === 'assistant', "message role should be 'assistant'");
-    assert(typeof result.message.content === 'string' || Array.isArray(result.message.content), "message should have content string or an array");
-
-    // Check that toString() and valueOf() methods exist and work
-    assert(typeof result.toString === 'function', "result should have toString method");
-    assert(typeof result.valueOf === 'function', "result should have valueOf method");
-    
-    // Check that toString() and valueOf() return the message content
-    assert(result.toString() === result.message.content, "toString() should return message content");
-    assert(result.valueOf() === result.message.content, "valueOf() should return message content");
-    
-    // Content should not be empty
-    assert(result.message.content.length > 0, "message content should not be empty");
-};
-
-const testChatWithParametersCore = async function(model) {
-    // Test chat with parameters object
-    const result = await puter.ai.chat("What is 2+2?", { 
-        model: model,
-        temperature: 0.7,
-        max_tokens: 50
-    });
-    
-    // Check basic result structure
-    assert(typeof result === 'object', "chat should return an object");
-    assert(result !== null, "chat should not return null");
-    assert(typeof result.message === 'object', "result should have message object");
-    assert(typeof result.message.content === 'string' || Array.isArray(result.message.content), "result.message should have content string or an array");
-    
-    // Check that the methods work
-    assert(typeof result.toString === 'function', "result should have toString method");
-    assert(typeof result.valueOf === 'function', "result should have valueOf method");
-    
-    // Check that finish_reason is present and valid
-    const validFinishReasons = ['stop', 'length', 'function_call', 'content_filter', 'tool_calls'];
-    assert(validFinishReasons.includes(result.finish_reason), 
-        `finish_reason should be one of: ${validFinishReasons.join(', ')}`);
-    
-    // Check that via_ai_chat_service is true
-    assert(result.via_ai_chat_service === true, "via_ai_chat_service should be true");
-};
-
-const testChatWithMessageArrayCore = async function(model) {
-    // Test chat with message array format
-    const messages = [
-        { role: "system", content: "You are a helpful assistant." },
-        { role: "user", content: "Hello!" }
-    ];
-    const result = await puter.ai.chat(messages, { model: model });
-    
-    // Check basic structure
-    assert(typeof result === 'object', "chat should return an object");
-    assert(typeof result.message === 'object', "result should have message object");
-    assert(result.message.role === 'assistant', "response should be from assistant");
-    
-    // Check that content is present and not empty
-    assert(result.message.content.length > 0, "message content should not be empty");
-};
-
-const testChatStreamingCore = async function(model) {
-    // Test chat with streaming enabled
-    const result = await puter.ai.chat("Count from 1 to 5", { 
-        model: model,
-        stream: true,
-        max_tokens: 100
-    });
-    
-    // Check that result is an object and not null
-    assert(typeof result === 'object', "streaming chat should return an object");
-    assert(result !== null, "streaming chat should not return null");
-    
-    // For streaming, we need to check if it's an async iterator or has a different structure
-    // The exact structure depends on the implementation, but we should verify it's consumable
-    if (result[Symbol.asyncIterator]) {
-        // If it's an async iterator, test that we can consume it
-        let chunks = [];
-        let chunkCount = 0;
-        const maxChunks = 10; // Limit to prevent infinite loops in tests
-        
-        for await (const chunk of result) {
-            chunks.push(chunk);
-            chunkCount++;
-            
-            // Verify each chunk has expected structure
-            assert(typeof chunk === 'object', "each streaming chunk should be an object");
-            
-            // Break after reasonable number of chunks for testing
-            if (chunkCount >= maxChunks) break;
-        }
-        
-        assert(chunks.length > 0, "streaming should produce at least one chunk");
-        
-    } else {
-        // If not an async iterator, it might be a different streaming implementation
-        // Check for common streaming response patterns
-        
-        // Check basic result structure (similar to non-streaming but may have different properties)
-        assert(typeof result.message === 'object' || typeof result.content === 'string', 
-            "streaming result should have message object or content string");
-        
-        // Check that it has streaming-specific properties
-        assert(typeof result.stream === 'boolean' || result.stream === true, 
-            "streaming result should indicate it's a stream");
-        
-        // Check that toString() and valueOf() methods exist and work
-        assert(typeof result.toString === 'function', "streaming result should have toString method");
-        assert(typeof result.valueOf === 'function', "streaming result should have valueOf method");
-    }
-};
-
-// Function to generate test functions for a specific model
-const generateTestsForModel = function(model) {
-    const modelName = model.replace(/[^a-zA-Z0-9]/g, '_'); // Sanitize model name for function names
-    
-    return {
-        [`testChatBasicPrompt_${modelName}`]: {
-            name: `testChatBasicPrompt_${modelName}`,
-            description: `Test basic AI chat prompt with ${model} model and verify response structure`,
-            test: async function() {
-                try {
-                    await testChatBasicPromptCore(model);
-                    pass(`testChatBasicPrompt_${modelName} passed`);
-                } catch (error) {
-                    fail(`testChatBasicPrompt_${modelName} failed:`, error);
-                }
-            }
-        },
-        
-        [`testChatWithParameters_${modelName}`]: {
-            name: `testChatWithParameters_${modelName}`,
-            description: `Test AI chat with parameters (temperature, max_tokens) using ${model} model`,
-            test: async function() {
-                try {
-                    await testChatWithParametersCore(model);
-                    pass(`testChatWithParameters_${modelName} passed`);
-                } catch (error) {
-                    fail(`testChatWithParameters_${modelName} failed:`, error);
-                }
-            }
-        },
-        
-        [`testChatWithMessageArray_${modelName}`]: {
-            name: `testChatWithMessageArray_${modelName}`,
-            description: `Test AI chat with message array format using ${model} model`,
-            test: async function() {
-                try {
-                    await testChatWithMessageArrayCore(model);
-                    pass(`testChatWithMessageArray_${modelName} passed`);
-                } catch (error) {
-                    fail(`testChatWithMessageArray_${modelName} failed:`, error);
-                }
-            }
-        },
-        
-        [`testChatStreaming_${modelName}`]: {
-            name: `testChatStreaming_${modelName}`,
-            description: `Test AI chat with streaming enabled using ${model} model`,
-            test: async function() {
-                try {
-                    await testChatStreamingCore(model);
-                    pass(`testChatStreaming_${modelName} passed`);
-                } catch (error) {
-                    fail(`testChatStreaming_${modelName} failed:`, error);
-                }
-            }
-        },
-    };
-};
-
-// Generate all test functions for all models
-const generateAllTests = function() {
-    const allTests = [];
-    
-    TEST_MODELS.forEach(model => {
-        const modelTests = generateTestsForModel(model);
-        Object.values(modelTests).forEach(test => {
-            allTests.push(test);
-        });
-    });
-    
-    return allTests;
-};
-
-// Export the generated tests
-window.aiTests = generateAllTests();