yeow-api 0.2.7 → 0.2.8

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "yeow-api",
-    "version": "0.2.7",
-    "description": "Yeow API �?TypeScript OOP wrappers over the task protocol",
+    "version": "0.2.8",
+    "description": "Yeow API �?TypeScript OOP wrappers over the task protocol",
     "type": "module",
     "main": "./src/index.ts",
     "types": "./src/index.ts",
@@ -9,5 +9,4 @@
         "src/"
     ],
     "license": "MIT"
-}
-
+}

package/src/fs.ts

@@ -1,33 +1,52 @@
-import { call } from './task.js';
+function _sendFs(payload) {
+    const raw = $send('fs', JSON.stringify(payload));
+    if (!raw) return undefined;
+    const r = JSON.parse(raw);
+    if (r.err) throw new Error(r.err);
+    return r;
+}
+
+export function readFile(path) {
+    return new Promise((resolve, reject) => {
+        try { const r = _sendFs({ t: 'readFile', p: { path } }); resolve(r.data); } catch(e) { reject(e); }
+    });
+}
 
-/**
- * Async file system operations. Paths are resolved relative to the server root.
- * All sync variants have the `Sync` suffix.
- */
+export function readFileSync(path) {
+    return _sendFs({ t: 'readFile', p: { path } }).data;
+}
+
+export function writeFile(path, data) {
+    return new Promise((resolve, reject) => {
+        try { _sendFs({ t: 'writeFile', p: { path, data } }); resolve(); } catch(e) { reject(e); }
+    });
+}
 
-export function readFile(path: string): Promise<string> {
-    return call('fs.readFile', { path }) as Promise<string>;
+export function writeFileSync(path, data) {
+    _sendFs({ t: 'writeFile', p: { path, data } });
 }
 
-export function readFileSync(path: string): string {
-    return call('fs.readFile', { path }) as string;
+export function existsSync(path) {
+    const r = _sendFs({ t: 'exists', p: { path } });
+    return r === true || String(r) === 'true';
 }
 
-export function writeFile(path: string, data: string): Promise<void> {
-    return call('fs.writeFile', { path, data }) as Promise<void>;
+export function deleteFile(path) {
+    return new Promise((resolve, reject) => {
+        try { const r = _sendFs({ t: 'delete', p: { path } }); resolve(r === true || String(r) === 'true'); } catch(e) { reject(e); }
+    });
 }
 
-export function writeFileSync(path: string, data: string): void {
-    call('fs.writeFile', { path, data });
+export function mkdir(path) {
+    return new Promise((resolve, reject) => {
+        try { _sendFs({ t: 'mkdir', p: { path } }); resolve(); } catch(e) { reject(e); }
+    });
 }
 
-export function existsSync(path: string): boolean {
-    return call('fs.exists', { path }) as boolean;
+export function list(path) {
+    return new Promise((resolve, reject) => {
+        try { const r = _sendFs({ t: 'list', p: { path } }); resolve(r); } catch(e) { reject(e); }
+    });
 }
 
-export const fs = {
-    readFile, readFileSync,
-    writeFile, writeFileSync,
-    existsSync,
-    // ... more to come
-};
+export const fs = { readFile, readFileSync, writeFile, writeFileSync, existsSync, deleteFile, mkdir, list };

package/src/http.ts

@@ -1,69 +1,63 @@
-import { call, post } from './task.js';
-
-const _servers: Set<string> = new Set();
+const _servers = new Set();
+
+function _sendHttp(payload) {
+    const raw = $send('http', JSON.stringify(payload));
+    if (!raw) return undefined;
+    const r = JSON.parse(raw);
+    if (r.err) throw new Error(r.err);
+    return r;
+}
 
-/**
- * Start an HTTP server on a random available port.
- * The callback receives: { connId, serverId, method, path, query, headers, body }
- * Response is sent via http.respond(task: { serverId, connId, status?, headers?, body? })
- */
-export function listen(
-    callback: (req: HttpRequest) => void,
-    port?: number
-): Promise<{ serverId: string; port: number }> {
+export function listen(callback, port) {
     return new Promise((resolve, reject) => {
-        const cbId = (globalThis as any)._registerCallback((payload: HttpRequest) => {
+        const cbId = _registerCallback((payload) => {
             callback(payload);
         }, { persistent: true });
 
-        const result = call('http.listen', {
-            pluginName: (globalThis as any).__plugin?.name || 'unknown',
-            callbackId: String(cbId),
-            port: port || 0,
-        }) as { serverId: string; port: number };
-
-        _servers.add(result.serverId);
-        resolve(result);
+        try {
+            const result = _sendHttp({ t: 'listen', p: {
+                pluginName: __plugin?.name || 'unknown',
+                callbackId: String(cbId),
+                port: port || 0,
+            }});
+            _servers.add(result.serverId);
+            resolve(result);
+        } catch(e) { reject(e); }
     });
 }
 
-/**
- * Send an HTTP response to a pending connection.
- */
-export function respond(serverId: string, connId: string, options: {
-    status?: number; headers?: Record<string, string>; body?: string;
-}): Promise<void> {
-    return call('http.respond', {
-        serverId,
-        connId,
-        status: options.status || 200,
-        headers: options.headers || {},
-        body: options.body || '',
-    }) as Promise<void>;
+export function respond(serverId, connId, opts = {}) {
+    return new Promise((resolve, reject) => {
+        try {
+            _sendHttp({ t: 'respond', p: { serverId, connId, ...opts }});
+            resolve();
+        } catch(e) { reject(e); }
+    });
 }
 
-/**
- * Stop an HTTP server and release its port.
- */
-export function close(serverId: string): Promise<void> {
+export function close(serverId) {
     _servers.delete(serverId);
-    return call('http.close', { serverId }) as Promise<void>;
+    return new Promise((resolve, reject) => {
+        try { _sendHttp({ t: 'close', p: { serverId }}); resolve(); } catch(e) { reject(e); }
+    });
 }
 
-/** Auto-close all servers when the plugin is disabled. */
-(globalThis as any)._registerCallback(() => {
+_registerCallback(() => {
     for (const id of _servers) {
-        try { call('http.close', { serverId: id }); } catch {}
+        try { _sendHttp({ t: 'close', p: { serverId: id }}); } catch {}
     }
     _servers.clear();
 }, { persistent: true });
 
-export interface HttpRequest {
-    connId: string;
-    serverId: string;
-    method: string;
-    path: string;
-    query: string;
-    headers: Record<string, string>;
-    body: string;
+export function request(url, opts = {}) {
+    return new Promise((resolve, reject) => {
+        try {
+            const result = _sendHttp({ t: 'request', p: { url, ...opts }});
+            resolve(result);
+        } catch(e) { reject(e); }
+    });
+}
+
+export function requestSync(url, opts = {}) {
+    return _sendHttp({ t: 'request', p: { url, ...opts }});
 }

package/src/index.ts

@@ -5,3 +5,5 @@ export { registerCommand } from './command.js';
 export type { CommandOptions, CommandPayload, CommandSender } from './command.js';
 export { eventOn, eventOff } from './event.js';
 export { broadcast, getMotd, getVersion } from './server.js';
+export { fs, readFile, readFileSync, writeFile, writeFileSync, existsSync, deleteFile, mkdir, list } from './fs.js';
+export { listen, respond, close, request, requestSync } from './http.js';