@serveryyswys/node.operit 0.0.0-stage → 0.1.2

package/dist/https.d.ts

@@ -0,0 +1,296 @@
+import type { RequestOptions } from './lib/http-types';
+declare function request(input: string | RequestOptions, options?: unknown, callback?: unknown): unknown;
+declare function get(input: string | RequestOptions, options?: unknown, callback?: unknown): unknown;
+declare function createServer(): never;
+declare const api: {
+    request: typeof request;
+    get: typeof get;
+    createServer: typeof createServer;
+    Agent: {
+        new (): {
+            maxSockets: number;
+            maxFreeSockets: number;
+            readonly sockets: Record<string, unknown[]>;
+            readonly freeSockets: Record<string, unknown[]>;
+            readonly requests: Record<string, unknown[]>;
+            readonly options: Record<string, unknown>;
+            readonly maxTotalSockets: number;
+            totalSocketCount: number;
+            destroy(): void;
+        };
+    };
+    globalAgent: {
+        maxSockets: number;
+        maxFreeSockets: number;
+        readonly sockets: Record<string, unknown[]>;
+        readonly freeSockets: Record<string, unknown[]>;
+        readonly requests: Record<string, unknown[]>;
+        readonly options: Record<string, unknown>;
+        readonly maxTotalSockets: number;
+        totalSocketCount: number;
+        destroy(): void;
+    };
+    METHODS: string[];
+    STATUS_CODES: Record<number, string>;
+    ClientRequest: {
+        new (input: string | RequestOptions, options?: RequestOptions | ((response: {
+            get maxListeners(): number;
+            set maxListeners(value: number);
+            statusCode: number;
+            statusMessage: string;
+            headers: Record<string, string>;
+            rawHeaders: string[];
+            httpVersion: string;
+            httpVersionMajor: number;
+            httpVersionMinor: number;
+            complete: boolean;
+            url: string;
+            method: string | null;
+            aborted: boolean;
+            _read(size: number): void;
+            setMaxListeners(count: number): /*elided*/ any;
+            getMaxListeners(): number;
+            addListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            prependListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            once(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            prependOnceListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            addEntry(name: string | symbol, listener: (...args: unknown[]) => void, once: boolean, prepend?: boolean): /*elided*/ any;
+            emit(name: string | symbol, ...args: unknown[]): boolean;
+            removeListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            off(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            removeAllListeners(name?: string | symbol): /*elided*/ any;
+            listeners(name: string | symbol): ((...args: unknown[]) => void)[];
+            rawListeners(name: string | symbol): ((...args: unknown[]) => void)[];
+            listenerCount(name: string | symbol): number;
+            eventNames(): (string | symbol)[];
+            readable: boolean;
+            _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+            push(chunk: unknown, encoding?: string): boolean;
+            unshift(chunk: unknown): void;
+            read(size?: number): unknown;
+            setEncoding(encoding: string): /*elided*/ any;
+            pause(): /*elided*/ any;
+            resume(): /*elided*/ any;
+            isPaused(): boolean;
+            pipe<T extends import("./lib/stream-types").WritableLike>(destination: T, options?: {
+                end?: boolean;
+            }): T;
+            unpipe(destination?: import("./lib/stream-types").WritableLike): /*elided*/ any;
+            destroy(error?: Error | null): /*elided*/ any;
+            on(event: string, listener: (...args: unknown[]) => void): /*elided*/ any;
+            [Symbol.asyncIterator](): {
+                next(): Promise<{
+                    value: unknown;
+                    done: boolean;
+                }>;
+            };
+        }) => void), callback?: (response: {
+            get maxListeners(): number;
+            set maxListeners(value: number);
+            statusCode: number;
+            statusMessage: string;
+            headers: Record<string, string>;
+            rawHeaders: string[];
+            httpVersion: string;
+            httpVersionMajor: number;
+            httpVersionMinor: number;
+            complete: boolean;
+            url: string;
+            method: string | null;
+            aborted: boolean;
+            _read(size: number): void;
+            setMaxListeners(count: number): any;
+            getMaxListeners(): number;
+            addListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+            prependListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+            once(name: string | symbol, listener: (...args: unknown[]) => void): any;
+            prependOnceListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+            addEntry(name: string | symbol, listener: (...args: unknown[]) => void, once: boolean, prepend?: boolean): any;
+            emit(name: string | symbol, ...args: unknown[]): boolean;
+            removeListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+            off(name: string | symbol, listener: (...args: unknown[]) => void): any;
+            removeAllListeners(name?: string | symbol): any;
+            listeners(name: string | symbol): ((...args: unknown[]) => void)[];
+            rawListeners(name: string | symbol): ((...args: unknown[]) => void)[];
+            listenerCount(name: string | symbol): number;
+            eventNames(): (string | symbol)[];
+            readable: boolean;
+            _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+            push(chunk: unknown, encoding?: string): boolean;
+            unshift(chunk: unknown): void;
+            read(size?: number): unknown;
+            setEncoding(encoding: string): any;
+            pause(): any;
+            resume(): any;
+            isPaused(): boolean;
+            pipe<T extends import("./lib/stream-types").WritableLike>(destination: T, options?: {
+                end?: boolean;
+            }): T;
+            unpipe(destination?: import("./lib/stream-types").WritableLike): any;
+            destroy(error?: Error | null): any;
+            on(event: string, listener: (...args: unknown[]) => void): any;
+            [Symbol.asyncIterator](): {
+                next(): Promise<{
+                    value: unknown;
+                    done: boolean;
+                }>;
+            };
+        }) => void): {
+            on(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            addListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            prependListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            once(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            prependOnceListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            addEntry(name: string | symbol, listener: (...args: unknown[]) => void, once: boolean, prepend?: boolean): /*elided*/ any;
+            emit(name: string | symbol, ...args: unknown[]): boolean;
+            removeListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            off(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            removeAllListeners(name?: string | symbol): /*elided*/ any;
+            listeners(name: string | symbol): ((...args: unknown[]) => void)[];
+            rawListeners(name: string | symbol): ((...args: unknown[]) => void)[];
+            listenerCount(name: string | symbol): number;
+            eventNames(): (string | symbol)[];
+            method: string;
+            path: string;
+            protocol: string;
+            host: string;
+            readonly maxHeadersCount: number | null;
+            readonly reusedSocket: false;
+            aborted: boolean;
+            finished: boolean;
+            readonly targetUrl: string;
+            readonly headerMap: Record<string, string>;
+            bodyChunks: Uint8Array[];
+            timer: unknown;
+            setHeader(name: unknown, value: unknown): /*elided*/ any;
+            getHeader(name: unknown): string | undefined;
+            getHeaders(): Record<string, string>;
+            getHeaderNames(): string[];
+            hasHeader(name: unknown): boolean;
+            removeHeader(name: unknown): void;
+            _write(chunk: unknown, encoding: string, callback: (error?: Error | null) => void): void;
+            _final(callback: (error?: Error | null) => void): void;
+            send(): void;
+            clearTimer(): void;
+            setTimeout(milliseconds: number, callback?: () => void): /*elided*/ any;
+            abort(): void;
+            destroy(error?: Error): /*elided*/ any;
+            get maxListeners(): number;
+            set maxListeners(value: number);
+            setMaxListeners(count: number): /*elided*/ any;
+            getMaxListeners(): number;
+            writable: boolean;
+        };
+        defaultMaxListeners: number;
+        errorMonitor: symbol;
+        EventEmitter: typeof import("./events");
+        listenerCount(emitter: import("./events"), name: string | symbol): number;
+        getEventListeners(emitter: import("./events"), name: string | symbol): ((...args: unknown[]) => void)[];
+        once(emitter: import("./events"), name: string | symbol): Promise<unknown[]>;
+        on(emitter: import("./events"), name: string | symbol): void;
+    };
+    IncomingMessage: {
+        new (response: import("./lib/http-driver").HttpHostResponse): {
+            get maxListeners(): number;
+            set maxListeners(value: number);
+            statusCode: number;
+            statusMessage: string;
+            headers: Record<string, string>;
+            rawHeaders: string[];
+            httpVersion: string;
+            httpVersionMajor: number;
+            httpVersionMinor: number;
+            complete: boolean;
+            url: string;
+            method: string | null;
+            aborted: boolean;
+            _read(size: number): void;
+            setMaxListeners(count: number): /*elided*/ any;
+            getMaxListeners(): number;
+            addListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            prependListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            once(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            prependOnceListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            addEntry(name: string | symbol, listener: (...args: unknown[]) => void, once: boolean, prepend?: boolean): /*elided*/ any;
+            emit(name: string | symbol, ...args: unknown[]): boolean;
+            removeListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            off(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            removeAllListeners(name?: string | symbol): /*elided*/ any;
+            listeners(name: string | symbol): ((...args: unknown[]) => void)[];
+            rawListeners(name: string | symbol): ((...args: unknown[]) => void)[];
+            listenerCount(name: string | symbol): number;
+            eventNames(): (string | symbol)[];
+            readable: boolean;
+            _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+            push(chunk: unknown, encoding?: string): boolean;
+            unshift(chunk: unknown): void;
+            read(size?: number): unknown;
+            setEncoding(encoding: string): /*elided*/ any;
+            pause(): /*elided*/ any;
+            resume(): /*elided*/ any;
+            isPaused(): boolean;
+            pipe<T extends import("./lib/stream-types").WritableLike>(destination: T, options?: {
+                end?: boolean;
+            }): T;
+            unpipe(destination?: import("./lib/stream-types").WritableLike): /*elided*/ any;
+            destroy(error?: Error | null): /*elided*/ any;
+            on(event: string, listener: (...args: unknown[]) => void): /*elided*/ any;
+            [Symbol.asyncIterator](): {
+                next(): Promise<{
+                    value: unknown;
+                    done: boolean;
+                }>;
+            };
+        };
+        once(emitter: import("./events"), name: string | symbol): Promise<unknown[]>;
+        on(emitter: import("./events"), name: string | symbol): void;
+        defaultMaxListeners: number;
+        errorMonitor: symbol;
+        EventEmitter: typeof import("./events");
+        listenerCount(emitter: import("./events"), name: string | symbol): number;
+        getEventListeners(emitter: import("./events"), name: string | symbol): ((...args: unknown[]) => void)[];
+        from(iterable: unknown): {
+            addEntry(name: string | symbol, listener: (...args: unknown[]) => void, once: boolean, prepend?: boolean): /*elided*/ any;
+            emit(name: string | symbol, ...args: unknown[]): boolean;
+            removeListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            off(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            removeAllListeners(name?: string | symbol): /*elided*/ any;
+            listeners(name: string | symbol): ((...args: unknown[]) => void)[];
+            rawListeners(name: string | symbol): ((...args: unknown[]) => void)[];
+            listenerCount(name: string | symbol): number;
+            eventNames(): (string | symbol)[];
+            readable: boolean;
+            _read(size: number): void;
+            _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+            push(chunk: unknown, encoding?: string): boolean;
+            unshift(chunk: unknown): void;
+            read(size?: number): unknown;
+            setEncoding(encoding: string): /*elided*/ any;
+            pause(): /*elided*/ any;
+            resume(): /*elided*/ any;
+            isPaused(): boolean;
+            pipe<T extends import("./lib/stream-types").WritableLike>(destination: T, options?: {
+                end?: boolean;
+            }): T;
+            unpipe(destination?: import("./lib/stream-types").WritableLike): /*elided*/ any;
+            destroy(error?: Error | null): /*elided*/ any;
+            on(event: string, listener: (...args: unknown[]) => void): /*elided*/ any;
+            [Symbol.asyncIterator](): {
+                next(): Promise<{
+                    value: unknown;
+                    done: boolean;
+                }>;
+            };
+            get maxListeners(): number;
+            set maxListeners(value: number);
+            setMaxListeners(count: number): /*elided*/ any;
+            getMaxListeners(): number;
+            addListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            prependListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            once(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            prependOnceListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+        };
+    };
+    maxHeaderSize: number;
+};
+export = api;

package/dist/https.js

@@ -0,0 +1,50 @@
+'use strict';
+/**
+ * https 模块。
+ *
+ * 与 http 是同一套实现：TLS 由宿主那一侧处理（工具走 OkHttp），
+ * 沙箱里既没有 socket 也没有证书链可管。这里只把缺省协议改成 https:。
+ */
+const httpModule = require("./http");
+const errors_1 = require("./lib/errors");
+/**
+ * 只给"options 形式且没写明协议"的输入补上 https:。
+ *
+ * 字符串输入必须原样返回 —— 早先这里返回了 {} 把 URL 丢掉了，
+ * 结果 https.get('https://x/') 变成了 http:///。
+ */
+function withHttpsDefault(input) {
+    if (typeof input === 'string') {
+        return input;
+    }
+    if (typeof input.href === 'string' && input.href.length > 0) {
+        return input;
+    }
+    if (typeof input.protocol === 'string' && input.protocol.length > 0) {
+        return input;
+    }
+    return Object.assign({ protocol: 'https:' }, input);
+}
+function request(input, options, callback) {
+    return httpModule.request(withHttpsDefault(input), options, callback);
+}
+function get(input, options, callback) {
+    return httpModule.get(withHttpsDefault(input), options, callback);
+}
+function createServer() {
+    throw (0, errors_1.onjError)('ONJ_UNSUPPORTED', 'https.createServer() 需要监听 socket，Operit 的沙箱脚本没有这个能力；' +
+        '网络访问请用工具调用（toolCall("http_request") 或内建的 axios）。');
+}
+const api = {
+    request: request,
+    get: get,
+    createServer: createServer,
+    Agent: httpModule.Agent,
+    globalAgent: httpModule.globalAgent,
+    METHODS: httpModule.METHODS,
+    STATUS_CODES: httpModule.STATUS_CODES,
+    ClientRequest: httpModule.ClientRequest,
+    IncomingMessage: httpModule.IncomingMessage,
+    maxHeaderSize: httpModule.maxHeaderSize
+};
+module.exports = api;