@devscholar/node-with-gjs 0.0.2 → 0.0.4

package/__tests__/basic.test.ts

@@ -1,8 +1,6 @@
-import { jest } from '@jest/globals';
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
 
-const isLinux = process.platform === 'linux' || process.platform === 'darwin';
-
-(isLinux ? describe : describe.skip)('Basic Module Tests', () => {
+describe('Basic Module Tests', () => {
   let gjs: any;
 
   beforeAll(async () => {

package/__tests__/glib.test.ts

@@ -1,8 +1,6 @@
-import { jest } from '@jest/globals';
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
 
-const isLinux = process.platform === 'linux' || process.platform === 'darwin';
-
-(isLinux ? describe : describe.skip)('GLib Tests', () => {
+describe('GLib Tests', () => {
   let gjs: any;
   let GLib: any;
 
@@ -43,7 +41,7 @@ const isLinux = process.platform === 'linux' || process.platform === 'darwin';
   });
 });
 
-(isLinux ? describe : describe.skip)('GObject Tests', () => {
+describe('GObject Tests', () => {
   let gjs: any;
   let GObject: any;
 

package/__tests__/gtk4.test.ts

@@ -1,8 +1,6 @@
-import { jest } from '@jest/globals';
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
 
-const isLinux = process.platform === 'linux' || process.platform === 'darwin';
-
-(isLinux ? describe : describe.skip)('GTK4 GUI Tests', () => {
+describe('GTK4 GUI Tests', () => {
   let gjs: any;
   let Gtk: any;
   let GLib: any;

package/package.json

@@ -1,23 +1,35 @@
 {
   "name": "@devscholar/node-with-gjs",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "Node.js IPC Bridge for GJS",
   "main": "./dist/index.js",
   "type": "module",
+  "license": "MIT",
+  "engines": {
+    "node": ">=22.22.0"
+  },
+  "keywords": [
+    "gjs",
+    "gnome",
+    "gtk",
+    "adwaita",
+    "gui",
+    "webkit",
+    "deno",
+    "bun"
+  ],
   "exports": {
     ".": "./dist/index.js"
   },
-  "bin": {
-
-  },
+  "bin": {},
   "scripts": {
     "build": "tsc",
-    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js"
+    "test": "node --experimental-transform-types node_modules/vitest/vitest.mjs run",
+    "start": "node start.js"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",
-    "jest": "^29.7.0",
-    "ts-jest": "^29.1.0",
-    "typescript": "^5.0.0"
+    "typescript": "^5.0.0",
+    "vitest": "^3.0.0"
   }
-}
+}

package/src/ipc.ts

@@ -1,99 +1,99 @@
-// src/ipc.ts
-import * as fs from 'node:fs';
-
-// Use a global/shared read buffer to handle redundant data across calls
-let readBuffer = Buffer.alloc(0);
-
-export function readLineSync(fd: number): string | null {
-    while (true) {
-        // 1. If the buffer already contains a complete line, extract and return it with minimal overhead
-        const newlineIdx = readBuffer.indexOf(10); // 10 is the ASCII code for \n
-        if (newlineIdx !== -1) {
-            const line = readBuffer.subarray(0, newlineIdx).toString('utf8');
-            readBuffer = readBuffer.subarray(newlineIdx + 1);
-            return line;
-        }
-
-        // 2. Otherwise, try to read a large chunk from the pipe
-        const chunk = Buffer.alloc(8192); // Attempt to read 8KB each time
-        let bytesRead = 0;
-        try {
-            bytesRead = fs.readSync(fd, chunk, 0, 8192, null);
-        } catch (e) {
-            return null;
-        }
-
-        if (bytesRead === 0) {
-            if (readBuffer.length === 0) return null;
-            const line = readBuffer.toString('utf8');
-            readBuffer = Buffer.alloc(0);
-            return line;
-        }
-
-        // 3. Append the newly read data to the buffer
-        readBuffer = Buffer.concat([readBuffer, chunk.subarray(0, bytesRead)]);
-    }
-}
-
-export class IpcSync {
-    private exited: boolean = false;
-
-    constructor(
-        private fdRead: number,
-        private fdWrite: number,
-        private onEvent: (msg: any) => any 
-    ) {}
-
-    send(cmd: any): any {
-        if (this.exited) return { type: 'exit' };
-
-        try {
-            fs.writeSync(this.fdWrite, JSON.stringify(cmd) + '\n');
-        } catch (e) {
-            throw new Error("Pipe closed (Write failed)");
-        }
-
-        while (true) {
-            const line = readLineSync(this.fdRead);
-            if (line === null) throw new Error("Pipe closed (Read EOF)");
-            if (!line.trim()) continue;
-
-            let res: any;
-            try {
-                res = JSON.parse(line);
-            } catch (e) {
-                throw new Error(`Invalid JSON from host: ${line}`);
-            }
-
-            if (res.type === 'event') {
-                let result = null;
-                try {
-                    result = this.onEvent(res);
-                } catch (e) {
-                    console.error("Callback Error:", e);
-                }
-                
-                const reply = { type: 'reply', result: result };
-                try {
-                    fs.writeSync(this.fdWrite, JSON.stringify(reply) + '\n');
-                } catch {}
-                continue; 
-            }
-
-            if (res.type === 'error') throw new Error(`GJS Host Error: ${res.message}`);
-            
-            if (res.type === 'exit') {
-                this.exited = true;
-                return res;
-            }
-            
-            return res;
-        }
-    }
-
-    close() {
-        this.exited = true;
-        if (this.fdRead) try { fs.closeSync(this.fdRead); } catch {}
-        if (this.fdWrite) try { fs.closeSync(this.fdWrite); } catch {}
-    }
+// src/ipc.ts
+import * as fs from 'node:fs';
+
+// Use a global/shared read buffer to handle redundant data across calls
+let readBuffer = Buffer.alloc(0);
+
+export function readLineSync(fd: number): string | null {
+    while (true) {
+        // 1. If the buffer already contains a complete line, extract and return it with minimal overhead
+        const newlineIdx = readBuffer.indexOf(10); // 10 is the ASCII code for \n
+        if (newlineIdx !== -1) {
+            const line = readBuffer.subarray(0, newlineIdx).toString('utf8');
+            readBuffer = readBuffer.subarray(newlineIdx + 1);
+            return line;
+        }
+
+        // 2. Otherwise, try to read a large chunk from the pipe
+        const chunk = Buffer.alloc(8192); // Attempt to read 8KB each time
+        let bytesRead = 0;
+        try {
+            bytesRead = fs.readSync(fd, chunk, 0, 8192, null);
+        } catch (e) {
+            return null;
+        }
+
+        if (bytesRead === 0) {
+            if (readBuffer.length === 0) return null;
+            const line = readBuffer.toString('utf8');
+            readBuffer = Buffer.alloc(0);
+            return line;
+        }
+
+        // 3. Append the newly read data to the buffer
+        readBuffer = Buffer.concat([readBuffer, chunk.subarray(0, bytesRead)]);
+    }
+}
+
+export class IpcSync {
+    private exited: boolean = false;
+
+    constructor(
+        private fdRead: number,
+        private fdWrite: number,
+        private onEvent: (msg: any) => any 
+    ) {}
+
+    send(cmd: any): any {
+        if (this.exited) return { type: 'exit' };
+
+        try {
+            fs.writeSync(this.fdWrite, JSON.stringify(cmd) + '\n');
+        } catch (e) {
+            throw new Error("Pipe closed (Write failed)");
+        }
+
+        while (true) {
+            const line = readLineSync(this.fdRead);
+            if (line === null) throw new Error("Pipe closed (Read EOF)");
+            if (!line.trim()) continue;
+
+            let res: any;
+            try {
+                res = JSON.parse(line);
+            } catch (e) {
+                throw new Error(`Invalid JSON from host: ${line}`);
+            }
+
+            if (res.type === 'event') {
+                let result = null;
+                try {
+                    result = this.onEvent(res);
+                } catch (e) {
+                    console.error("Callback Error:", e);
+                }
+                
+                const reply = { type: 'reply', result: result };
+                try {
+                    fs.writeSync(this.fdWrite, JSON.stringify(reply) + '\n');
+                } catch {}
+                continue; 
+            }
+
+            if (res.type === 'error') throw new Error(`GJS Host Error: ${res.message}`);
+            
+            if (res.type === 'exit') {
+                this.exited = true;
+                return res;
+            }
+            
+            return res;
+        }
+    }
+
+    close() {
+        this.exited = true;
+        if (this.fdRead) try { fs.closeSync(this.fdRead); } catch {}
+        if (this.fdWrite) try { fs.closeSync(this.fdWrite); } catch {}
+    }
 }

package/start.js

@@ -0,0 +1,102 @@
+// start.js - Build and run TypeScript files
+import { spawn } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const args = process.argv.slice(2);
+let runtime = 'node';
+let tsFile = null;
+let extraArgs = [];
+
+for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith('--runtime=')) {
+        runtime = arg.split('=')[1];
+    } else if (arg.startsWith('-r=')) {
+        runtime = arg.split('=')[1];
+    } else if (arg.endsWith('.ts') || arg.endsWith('.js')) {
+        tsFile = arg;
+    } else {
+        extraArgs.push(arg);
+    }
+}
+
+if (!tsFile) {
+    console.error('Usage: node start.js <ts-file> [--runtime=node|bun|deno] [args...]');
+    console.error('Example: node start.js src/gtk/counter/counter.ts');
+    console.error('Example: node start.js app.ts --runtime=deno');
+    process.exit(1);
+}
+
+const filePath = path.resolve(tsFile);
+
+if (!fs.existsSync(filePath)) {
+    console.error(`Error: File not found: ${filePath}`);
+    process.exit(1);
+}
+
+const runtimeFlags = {
+    node: [],
+    bun: [],
+    deno: ['run', '--allow-all', '--unstable']
+};
+
+async function buildAndRun() {
+    console.log('Building TypeScript...');
+    
+    const tscProc = spawn('npx', ['tsc'], {
+        stdio: 'inherit',
+        cwd: __dirname,
+        shell: true
+    });
+    
+    await new Promise((resolve, reject) => {
+        tscProc.on('exit', (code) => {
+            if (code !== 0) {
+                console.error('Build failed with code:', code);
+                reject(new Error(`tsc exited with code ${code}`));
+            } else {
+                resolve();
+            }
+        });
+        tscProc.on('error', reject);
+    });
+    
+    console.log('Build complete. Running with', runtime, ':', tsFile);
+    
+    const ext = path.extname(tsFile);
+    const baseName = path.basename(tsFile, ext);
+    const relativePath = path.relative(path.join(__dirname, 'src'), filePath);
+    const jsFile = path.join(__dirname, 'dist', relativePath.replace(/\.ts$/, '.js'));
+    
+    const runtimeArgs = runtimeFlags[runtime] || [];
+    const runtimeCmd = runtime;
+    
+    const finalArgs = runtime === 'deno' 
+        ? [...runtimeArgs, jsFile, ...extraArgs]
+        : [...runtimeArgs, jsFile, ...extraArgs];
+    
+    const proc = spawn(runtimeCmd, finalArgs, {
+        stdio: 'inherit',
+        cwd: process.cwd(),
+        shell: true
+    });
+    
+    proc.on('exit', (code) => {
+        process.exit(code);
+    });
+    
+    proc.on('error', (err) => {
+        console.error(`Failed to start ${runtime}:`, err.message);
+        process.exit(1);
+    });
+}
+
+buildAndRun().catch((err) => {
+    console.error('Error:', err.message);
+    process.exit(1);
+});

package/dist/index.js

@@ -1,211 +0,0 @@
-// src/index.ts
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import * as cp from 'node:child_process';
-import * as os from 'node:os';
-import { fileURLToPath } from 'node:url';
-import { IpcSync } from './ipc.js';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const gcRegistry = new FinalizationRegistry((id) => {
-    try {
-        if (ipc)
-            ipc.send({ action: 'Release', targetId: id });
-    }
-    catch { }
-});
-const callbackRegistry = new Map();
-let ipc = null;
-let proc = null;
-let initialized = false;
-let reqPath = '';
-let resPath = '';
-function cleanup() {
-    if (!initialized)
-        return;
-    initialized = false;
-    if (ipc)
-        try {
-            ipc.close();
-        }
-        catch { }
-    if (proc && !proc.killed)
-        try {
-            proc.kill('SIGKILL');
-        }
-        catch { }
-    if (fs.existsSync(reqPath))
-        try {
-            fs.unlinkSync(reqPath);
-        }
-        catch { }
-    if (fs.existsSync(resPath))
-        try {
-            fs.unlinkSync(resPath);
-        }
-        catch { }
-    proc = null;
-    ipc = null;
-}
-function findGjsPath() {
-    try {
-        const result = cp.execSync('which gjs', { encoding: 'utf-8' }).trim();
-        return result || 'gjs';
-    }
-    catch {
-        return 'gjs';
-    }
-}
-function initialize() {
-    if (initialized)
-        return;
-    const token = `${process.pid}-${Date.now()}`;
-    reqPath = path.join(os.tmpdir(), `gjs-req-${token}.pipe`);
-    resPath = path.join(os.tmpdir(), `gjs-res-${token}.pipe`);
-    try {
-        cp.execSync(`mkfifo "${reqPath}"`);
-        cp.execSync(`mkfifo "${resPath}"`);
-    }
-    catch (e) {
-        console.error("Failed to create Unix FIFOs");
-        process.exit(1);
-    }
-    const scriptPath = path.join(__dirname, '..', 'scripts', 'host.js');
-    const gjsPath = findGjsPath();
-    proc = cp.spawn('bash', ['-c', `exec "${gjsPath}" -m "${scriptPath}" 3<"${reqPath}" 4>"${resPath}"`], {
-        stdio: 'inherit',
-        env: process.env
-    });
-    proc.unref();
-    process.on('beforeExit', () => { cleanup(); process.exit(0); });
-    process.on('exit', cleanup);
-    process.on('SIGINT', () => { cleanup(); process.exit(0); });
-    process.on('uncaughtException', (err) => {
-        console.error('Node.js Exception:', err);
-        cleanup();
-        process.exit(1);
-    });
-    const fdWrite = fs.openSync(reqPath, 'w');
-    const fdRead = fs.openSync(resPath, 'r');
-    ipc = new IpcSync(fdRead, fdWrite, (res) => {
-        const cb = callbackRegistry.get(res.callbackId);
-        if (cb) {
-            const wrappedArgs = (res.args || []).map((arg) => createProxy(arg));
-            return cb(...wrappedArgs);
-        }
-        return null;
-    });
-    globalThis.print = (...args) => {
-        ipc.send({ action: 'Print', args: args.map(wrapArg) });
-    };
-    initialized = true;
-}
-function wrapArg(arg) {
-    if (arg === null || arg === undefined)
-        return { type: 'null' };
-    if (arg.__ref)
-        return { type: 'ref', id: arg.__ref };
-    if (arg instanceof Uint8Array) {
-        return { type: 'uint8array', value: Array.from(arg) };
-    }
-    if (typeof arg === 'function') {
-        const cbId = `cb_${Date.now()}_${Math.random()}`;
-        callbackRegistry.set(cbId, arg);
-        return { type: 'callback', callbackId: cbId };
-    }
-    if (Array.isArray(arg))
-        return { type: 'array', value: arg.map(wrapArg) };
-    if (typeof arg === 'object') {
-        const plainObj = {};
-        for (let k in arg)
-            plainObj[k] = wrapArg(arg[k]);
-        return { type: 'object', value: plainObj };
-    }
-    return { type: 'primitive', value: arg };
-}
-function createProxy(meta) {
-    if (meta.type === 'primitive' || meta.type === 'null')
-        return meta.value;
-    if (meta.type === 'array')
-        return meta.value.map((item) => createProxy(item));
-    if (meta.type !== 'ref')
-        return undefined;
-    const id = meta.id;
-    const stub = function () { };
-    const proxy = new Proxy(stub, {
-        get: (target, prop) => {
-            if (prop === '__ref')
-                return id;
-            if (typeof prop !== 'string')
-                return undefined;
-            const val = ipc.send({ action: 'Get', targetId: id, property: prop });
-            if (val && val.type === 'function') {
-                return new Proxy(function () { }, {
-                    apply: (t, thisArg, args) => {
-                        const netArgs = args.map(wrapArg);
-                        const res = ipc.send({ action: 'Invoke', targetId: id, methodName: prop, args: netArgs });
-                        return createProxy(res);
-                    },
-                    construct: (t, args) => {
-                        const netArgs = args.map(wrapArg);
-                        const res = ipc.send({ action: 'NewProp', targetId: id, property: prop, args: netArgs });
-                        return createProxy(res);
-                    }
-                });
-            }
-            return createProxy(val);
-        },
-        set: (target, prop, value) => {
-            if (typeof prop !== 'string')
-                return false;
-            ipc.send({ action: 'Set', targetId: id, property: prop, value: wrapArg(value) });
-            return true;
-        },
-        construct: (target, args) => {
-            const netArgs = args.map(wrapArg);
-            const res = ipc.send({ action: 'New', typeId: id, args: netArgs });
-            return createProxy(res);
-        }
-    });
-    gcRegistry.register(proxy, id);
-    return proxy;
-}
-export function init() {
-    initialize();
-}
-// Internal function - not exposed to users
-function loadGiNamespace(namespace, version) {
-    initialize();
-    const res = ipc.send({ action: 'LoadNamespace', namespace, version });
-    return createProxy(res);
-}
-// Namespace cache to avoid creating multiple proxies for the same namespace
-const namespaceCache = new Map();
-// GI namespace versions
-const giVersions = {};
-// Create the gi proxy with lazy loading and caching
-const giProxy = new Proxy({}, {
-    get(_, namespace) {
-        if (namespace === 'versions') {
-            return new Proxy(giVersions, {
-                set(target, prop, value) {
-                    target[prop] = value;
-                    // Clear cache for this namespace when version changes
-                    const cacheKey = `${prop}@default`;
-                    namespaceCache.delete(cacheKey);
-                    return true;
-                }
-            });
-        }
-        const version = giVersions[namespace];
-        const cacheKey = `${namespace}@${version || 'default'}`;
-        if (!namespaceCache.has(cacheKey)) {
-            namespaceCache.set(cacheKey, loadGiNamespace(namespace, version));
-        }
-        return namespaceCache.get(cacheKey);
-    }
-});
-// The main exports object - compatible with GJS imports
-export const imports = {
-    gi: giProxy
-};

package/dist/ipc.js

@@ -1,103 +0,0 @@
-// src/ipc.ts
-import * as fs from 'node:fs';
-// Use a global/shared read buffer to handle redundant data across calls
-let readBuffer = Buffer.alloc(0);
-export function readLineSync(fd) {
-    while (true) {
-        // 1. If the buffer already contains a complete line, extract and return it with minimal overhead
-        const newlineIdx = readBuffer.indexOf(10); // 10 is the ASCII code for \n
-        if (newlineIdx !== -1) {
-            const line = readBuffer.subarray(0, newlineIdx).toString('utf8');
-            readBuffer = readBuffer.subarray(newlineIdx + 1);
-            return line;
-        }
-        // 2. Otherwise, try to read a large chunk from the pipe
-        const chunk = Buffer.alloc(8192); // Attempt to read 8KB each time
-        let bytesRead = 0;
-        try {
-            bytesRead = fs.readSync(fd, chunk, 0, 8192, null);
-        }
-        catch (e) {
-            return null;
-        }
-        if (bytesRead === 0) {
-            if (readBuffer.length === 0)
-                return null;
-            const line = readBuffer.toString('utf8');
-            readBuffer = Buffer.alloc(0);
-            return line;
-        }
-        // 3. Append the newly read data to the buffer
-        readBuffer = Buffer.concat([readBuffer, chunk.subarray(0, bytesRead)]);
-    }
-}
-export class IpcSync {
-    fdRead;
-    fdWrite;
-    onEvent;
-    exited = false;
-    constructor(fdRead, fdWrite, onEvent) {
-        this.fdRead = fdRead;
-        this.fdWrite = fdWrite;
-        this.onEvent = onEvent;
-    }
-    send(cmd) {
-        if (this.exited)
-            return { type: 'exit' };
-        try {
-            fs.writeSync(this.fdWrite, JSON.stringify(cmd) + '\n');
-        }
-        catch (e) {
-            throw new Error("Pipe closed (Write failed)");
-        }
-        while (true) {
-            const line = readLineSync(this.fdRead);
-            if (line === null)
-                throw new Error("Pipe closed (Read EOF)");
-            if (!line.trim())
-                continue;
-            let res;
-            try {
-                res = JSON.parse(line);
-            }
-            catch (e) {
-                throw new Error(`Invalid JSON from host: ${line}`);
-            }
-            if (res.type === 'event') {
-                let result = null;
-                try {
-                    result = this.onEvent(res);
-                }
-                catch (e) {
-                    console.error("Callback Error:", e);
-                }
-                const reply = { type: 'reply', result: result };
-                try {
-                    fs.writeSync(this.fdWrite, JSON.stringify(reply) + '\n');
-                }
-                catch { }
-                continue;
-            }
-            if (res.type === 'error')
-                throw new Error(`GJS Host Error: ${res.message}`);
-            if (res.type === 'exit') {
-                this.exited = true;
-                return res;
-            }
-            return res;
-        }
-    }
-    close() {
-        this.exited = true;
-        if (this.fdRead)
-            try {
-                fs.closeSync(this.fdRead);
-            }
-            catch { }
-        if (this.fdWrite)
-            try {
-                fs.closeSync(this.fdWrite);
-            }
-            catch { }
-    }
-}

package/hook.js

@@ -1,44 +0,0 @@
-// hook.js - Node.js module loader hook for gi:// protocol
-export async function resolve(specifier, context, nextResolve) {
-    if (specifier.startsWith('gi://')) {
-        return {
-            url: specifier,
-            shortCircuit: true,
-            format: 'module'
-        };
-    }
-    return nextResolve(specifier, context, nextResolve);
-}
-
-export async function load(url, context, nextLoad) {
-    if (url.startsWith('gi://')) {
-        // Safely parse 'gi://Gtk?version=4.0'
-        const bareUrl = url.replace('gi://', '');
-        const [namespacePart, queryPart] = bareUrl.split('?');
-        
-        const namespace = namespacePart;
-        let version = '';
-        
-        if (queryPart) {
-            const params = new URLSearchParams(queryPart);
-            version = params.get('version') || '';
-        }
-
-        const coreUrl = new URL('./dist/index.js', import.meta.url).href;
-        
-        const source = `
-            import { init, imports } from '${coreUrl}';
-            init();
-            imports.gi.versions['${namespace}'] = '${version}';
-            const ns = imports.gi['${namespace}'];
-            export default ns;
-        `;
-        
-        return {
-            format: 'module',
-            shortCircuit: true,
-            source: source
-        };
-    }
-    return nextLoad(url, context, nextLoad);
-}

package/jest.config.js

@@ -1,32 +0,0 @@
-export default {
-  preset: 'ts-jest/presets/default-esm',
-  testEnvironment: 'node',
-  extensionsToTreatAsEsm: ['.ts'],
-  moduleNameMapper: {
-    '^(\\.{1,2}/.*)\\.js$': '$1',
-  },
-  transform: {
-    '^.+\\.ts$': [
-      'ts-jest',
-      {
-        useESM: true,
-        tsconfig: {
-          module: 'ESNext',
-          moduleResolution: 'bundler',
-        },
-      },
-    ],
-  },
-  testMatch: [
-    '**/__tests__/**/*.ts',
-    '**/?(*.)+(spec|test).ts',
-  ],
-  collectCoverageFrom: [
-    'src/**/*.ts',
-    '!src/**/*.d.ts',
-  ],
-  coverageDirectory: 'coverage',
-  coverageReporters: ['text', 'lcov', 'html'],
-  testTimeout: 60000,
-  maxWorkers: 1,
-};

package/types/index.d.ts

@@ -1,4 +0,0 @@
-export declare function init(): void;
-export declare const imports: {
-    gi: any;
-};

package/types/ipc.d.ts

@@ -1,10 +0,0 @@
-export declare function readLineSync(fd: number): string | null;
-export declare class IpcSync {
-    private fdRead;
-    private fdWrite;
-    private onEvent;
-    private exited;
-    constructor(fdRead: number, fdWrite: number, onEvent: (msg: any) => any);
-    send(cmd: any): any;
-    close(): void;
-}