@iskra-bun/process-kit 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @iskra-bun/process-kit
+
+## 0.1.0
+
+### Minor Changes
+
+- Initial public release.

package/README.md

@@ -0,0 +1,29 @@
+# @iskra-bun/process-kit
+
+Gestion de procesos externos (scripts de Python, binarios) para Iskra. Soporta modos daemon, oneshot y stdio, con ciclo de vida y validacion de configuracion.
+
+## Instalacion
+
+```bash
+bun add @iskra-bun/process-kit @iskra-bun/core
+```
+
+## Uso rapido
+
+```typescript
+import { App } from '@iskra-bun/core'
+import { ProcessManager } from '@iskra-bun/process-kit'
+
+const app = new App({ name: 'mi-app' })
+app.register(new ProcessManager({ command: 'python', args: ['worker.py'], mode: 'daemon' }))
+
+await app.start()
+```
+
+## Documentacion
+
+Guia completa: [docs/process-kit.md](../../docs/process-kit.md)
+
+## Licencia
+
+AGPL-3.0-or-later

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+import { Driver, App } from '@iskra-bun/core';
+
+declare class ProcessManager implements Driver {
+    name: string;
+    private app;
+    private processes;
+    private stopping;
+    init(app: App): void;
+    start(): Promise<void>;
+    private readStdOut;
+    private processLine;
+    private handleExit;
+    private spawnProcess;
+    private readStdErr;
+    send(name: string, data: any): Promise<void>;
+    stop(): Promise<void>;
+}
+
+export { ProcessManager };

package/dist/index.js

@@ -0,0 +1,152 @@
+// src/spawner.ts
+var ProcessManager = class {
+  name = "ProcessManager";
+  app = null;
+  processes = /* @__PURE__ */ new Map();
+  stopping = false;
+  init(app) {
+    this.app = app;
+  }
+  async start() {
+    if (!this.app) return;
+    const processConfigs = this.app.config.processes;
+    if (!processConfigs) {
+      this.app.logger.debug("No processes configured.");
+      return;
+    }
+    this.app.logger.info(`Starting ${Object.keys(processConfigs).length} processes...`);
+    for (const [name, config] of Object.entries(processConfigs)) {
+      this.spawnProcess(name, config);
+    }
+  }
+  async readStdOut(name, stream) {
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          this.processLine(name, line);
+        }
+      }
+    } catch (err) {
+    }
+  }
+  processLine(name, line) {
+    try {
+      const json = JSON.parse(line);
+      this.app?.emit("process:message", { name, message: json });
+    } catch {
+      this.app?.emit("process:log", { name, text: line });
+    }
+  }
+  handleExit(name, exitCode, signalCode) {
+    if (this.stopping) return;
+    const procInfo = this.processes.get(name);
+    if (!procInfo) return;
+    this.app?.logger.warn(`Process ${name} exited with code ${exitCode}`);
+    this.processes.delete(name);
+    if (procInfo.config.restartOnCrash) {
+      const maxRestarts = procInfo.config.maxRestarts ?? 10;
+      const cooldown = procInfo.config.restartCooldown ?? 6e4;
+      const uptime = Date.now() - procInfo.startedAt;
+      const restarts = uptime > cooldown ? 1 : procInfo.restarts + 1;
+      if (restarts > maxRestarts) {
+        this.app?.logger.error(`Process ${name} exceeded max restarts (${maxRestarts}). Not restarting.`);
+        this.app?.emit("process:max-restarts", { name, restarts: procInfo.restarts, maxRestarts });
+        return;
+      }
+      this.app?.logger.info(`Restarting process: ${name} (Attempt ${restarts}/${maxRestarts})`);
+      setTimeout(() => {
+        this.spawnProcess(name, procInfo.config, restarts);
+      }, 1e3);
+    }
+  }
+  // Updated spawn signature to track restarts
+  spawnProcess(name, config, restarts = 0) {
+    if (this.stopping || !this.app) return;
+    this.app.logger.info(`Spawning process: ${name} (${config.command} ${config.args?.join(" ") || ""})`);
+    try {
+      const proc = Bun.spawn(
+        [config.command, ...config.args || []],
+        {
+          env: { ...process.env, ...config.env },
+          stdout: config.mode === "stdio" ? "pipe" : "inherit",
+          stderr: config.mode === "stdio" ? "pipe" : "inherit",
+          stdin: config.mode === "stdio" ? "pipe" : "ignore",
+          onExit: (proc2, exitCode, signalCode, error) => {
+            this.handleExit(name, exitCode || 0, signalCode || 0);
+          }
+        }
+      );
+      this.processes.set(name, {
+        process: proc,
+        config,
+        name,
+        restarts,
+        startedAt: Date.now()
+      });
+      if (config.mode === "stdio") {
+        if (proc.stdout) this.readStdOut(name, proc.stdout);
+        if (proc.stderr) this.readStdErr(name, proc.stderr);
+      }
+    } catch (err) {
+      this.app.logger.error({ err }, `Failed to spawn process: ${name}`);
+    }
+  }
+  async readStdErr(name, stream) {
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        const text = decoder.decode(value, { stream: true });
+        if (text.trim()) {
+          this.app?.emit("process:error", { name, text });
+        }
+      }
+    } catch (err) {
+    }
+  }
+  // Send data to process stdin
+  async send(name, data) {
+    const procInfo = this.processes.get(name);
+    if (!procInfo) {
+      this.app?.logger.warn(`Cannot send message to non-existent process: ${name}`);
+      return;
+    }
+    if (procInfo.config.mode !== "stdio" || !procInfo.process.stdin) {
+      this.app?.logger.warn(`Cannot send message to process ${name} (mode is not stdio or stdin is closed)`);
+      return;
+    }
+    const stdin = procInfo.process.stdin;
+    try {
+      const message = typeof data === "string" ? data : JSON.stringify(data);
+      stdin.write(message + "\n");
+      stdin.flush();
+    } catch (err) {
+      this.app?.logger.error({ err }, `Failed to write to process ${name}`);
+    }
+  }
+  async stop() {
+    this.stopping = true;
+    this.app?.logger.info("Stopping all processes...");
+    for (const [name, info] of this.processes) {
+      if (!info.process.killed) {
+        info.process.kill();
+      }
+    }
+    this.processes.clear();
+  }
+};
+export {
+  ProcessManager
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/spawner.ts"],"sourcesContent":["import type { App, Driver, ProcessConfig } from '@iskra-bun/core';\nimport { Subprocess } from 'bun';\n\ninterface RunningProcess {\n    process: Subprocess;\n    config: ProcessConfig;\n    name: string;\n    restarts: number;\n    startedAt: number;\n}\n\nexport class ProcessManager implements Driver {\n    name = 'ProcessManager';\n    private app: App | null = null;\n    private processes: Map<string, RunningProcess> = new Map();\n    private stopping = false;\n\n    init(app: App) {\n        this.app = app;\n    }\n\n    async start() {\n        if (!this.app) return;\n        const processConfigs = this.app.config.processes;\n\n        if (!processConfigs) {\n            this.app.logger.debug('No processes configured.');\n            return;\n        }\n\n        this.app.logger.info(`Starting ${Object.keys(processConfigs).length} processes...`);\n\n        for (const [name, config] of Object.entries(processConfigs)) {\n            this.spawnProcess(name, config);\n        }\n    }\n\n    private async readStdOut(name: string, stream: ReadableStream) {\n        const reader = stream.getReader();\n        const decoder = new TextDecoder();\n        let buffer = '';\n\n        try {\n            while (true) {\n                const { done, value } = await reader.read();\n                if (done) break;\n\n                buffer += decoder.decode(value, { stream: true });\n\n                const lines = buffer.split('\\n');\n                // Keep the last chunk if it's not a complete line (doesn't end with \\n)\n                buffer = lines.pop() || '';\n\n                for (const line of lines) {\n                    if (!line.trim()) continue;\n                    this.processLine(name, line);\n                }\n            }\n        } catch (err) {\n            // Stream closed or error\n        }\n    }\n\n    private processLine(name: string, line: string) {\n        try {\n            // Try to parse as JSON Event\n            const json = JSON.parse(line);\n            this.app?.emit('process:message', { name, message: json });\n        } catch {\n            // Fallback to raw log\n            this.app?.emit('process:log', { name, text: line });\n        }\n    }\n\n    private handleExit(name: string, exitCode: number, signalCode: number) {\n        if (this.stopping) return;\n\n        const procInfo = this.processes.get(name);\n        if (!procInfo) return;\n\n        this.app?.logger.warn(`Process ${name} exited with code ${exitCode}`);\n\n        // Remove from map so we don't try to kill it again on stop()\n        this.processes.delete(name);\n\n        if (procInfo.config.restartOnCrash) {\n            const maxRestarts = procInfo.config.maxRestarts ?? 10;\n            const cooldown = procInfo.config.restartCooldown ?? 60000;\n            const uptime = Date.now() - procInfo.startedAt;\n\n            // If the process ran longer than the cooldown, consider it stable and reset the counter\n            const restarts = uptime > cooldown ? 1 : procInfo.restarts + 1;\n\n            if (restarts > maxRestarts) {\n                this.app?.logger.error(`Process ${name} exceeded max restarts (${maxRestarts}). Not restarting.`);\n                this.app?.emit('process:max-restarts', { name, restarts: procInfo.restarts, maxRestarts });\n                return;\n            }\n\n            this.app?.logger.info(`Restarting process: ${name} (Attempt ${restarts}/${maxRestarts})`);\n\n            setTimeout(() => {\n                this.spawnProcess(name, procInfo.config, restarts);\n            }, 1000);\n        }\n    }\n\n    // Updated spawn signature to track restarts\n    private spawnProcess(name: string, config: ProcessConfig, restarts = 0) {\n        if (this.stopping || !this.app) return;\n\n        this.app.logger.info(`Spawning process: ${name} (${config.command} ${config.args?.join(' ') || ''})`);\n\n        try {\n            const proc = Bun.spawn(\n                [config.command, ...(config.args || [])],\n                {\n                    env: { ...process.env, ...config.env },\n                    stdout: config.mode === 'stdio' ? 'pipe' : 'inherit',\n                    stderr: config.mode === 'stdio' ? 'pipe' : 'inherit',\n                    stdin: config.mode === 'stdio' ? 'pipe' : 'ignore',\n                    onExit: (proc, exitCode, signalCode, error) => {\n                        this.handleExit(name, exitCode || 0, signalCode || 0);\n                    }\n                }\n            );\n\n            this.processes.set(name, {\n                process: proc,\n                config,\n                name,\n                restarts,\n                startedAt: Date.now(),\n            });\n\n            if (config.mode === 'stdio') {\n                if (proc.stdout) this.readStdOut(name, proc.stdout);\n                if (proc.stderr) this.readStdErr(name, proc.stderr);\n            }\n\n        } catch (err) {\n            this.app.logger.error({ err }, `Failed to spawn process: ${name}`);\n        }\n    }\n\n    private async readStdErr(name: string, stream: ReadableStream) {\n        const reader = stream.getReader();\n        const decoder = new TextDecoder();\n\n        try {\n            while (true) {\n                const { done, value } = await reader.read();\n                if (done) break;\n                const text = decoder.decode(value, { stream: true });\n                if (text.trim()) {\n                    this.app?.emit('process:error', { name, text });\n                }\n            }\n        } catch (err) {\n            // Stream closed\n        }\n    }\n\n    // Send data to process stdin\n    async send(name: string, data: any) {\n        const procInfo = this.processes.get(name);\n        if (!procInfo) {\n            this.app?.logger.warn(`Cannot send message to non-existent process: ${name}`);\n            return;\n        }\n\n        if (procInfo.config.mode !== 'stdio' || !procInfo.process.stdin) {\n            this.app?.logger.warn(`Cannot send message to process ${name} (mode is not stdio or stdin is closed)`);\n            return;\n        }\n\n        // Bun's Subprocess.stdin is a FileSink\n        const stdin = procInfo.process.stdin as any;\n\n        try {\n            // If data is object, stringify it and add newline\n            const message = typeof data === 'string' ? data : JSON.stringify(data);\n            stdin.write(message + '\\n');\n            stdin.flush();\n        } catch (err) {\n            this.app?.logger.error({ err }, `Failed to write to process ${name}`);\n        }\n    }\n\n    async stop() {\n        this.stopping = true;\n        this.app?.logger.info('Stopping all processes...');\n\n        for (const [name, info] of this.processes) {\n            if (!info.process.killed) {\n                info.process.kill();\n            }\n        }\n        this.processes.clear();\n    }\n}\n"],"mappings":"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","names":["proc"]}

package/package.json

@@ -0,0 +1,55 @@
+{
+    "name": "@iskra-bun/process-kit",
+    "version": "0.1.0",
+    "description": "Gestion de procesos externos (Python, binarios) para Iskra.",
+    "keywords": [
+        "iskra",
+        "bun",
+        "typescript",
+        "process",
+        "python",
+        "ipc"
+    ],
+    "author": "Joan Lascano",
+    "license": "AGPL-3.0-or-later",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/fearful/iskra.git",
+        "directory": "packages/process-kit"
+    },
+    "homepage": "https://github.com/fearful/iskra/tree/main/packages/process-kit#readme",
+    "bugs": "https://github.com/fearful/iskra/issues",
+    "type": "module",
+    "main": "./dist/index.js",
+    "module": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "exports": {
+        ".": {
+            "source": "./src/index.ts",
+            "bun": "./src/index.ts",
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js",
+            "default": "./dist/index.js"
+        }
+    },
+    "files": [
+        "dist",
+        "src",
+        "README.md",
+        "CHANGELOG.md"
+    ],
+    "publishConfig": {
+        "access": "public"
+    },
+    "scripts": {
+        "test": "bun test",
+        "build": "tsup --config ../../tsup.config.ts"
+    },
+    "dependencies": {
+        "@iskra-bun/core": "0.1.0",
+        "zod": "^3.24.1"
+    },
+    "devDependencies": {
+        "@types/node": "^22.10.2"
+    }
+}

package/src/index.ts

@@ -0,0 +1 @@
+export { ProcessManager } from './spawner';

package/src/spawner.ts

@@ -0,0 +1,201 @@
+import type { App, Driver, ProcessConfig } from '@iskra-bun/core';
+import { Subprocess } from 'bun';
+
+interface RunningProcess {
+    process: Subprocess;
+    config: ProcessConfig;
+    name: string;
+    restarts: number;
+    startedAt: number;
+}
+
+export class ProcessManager implements Driver {
+    name = 'ProcessManager';
+    private app: App | null = null;
+    private processes: Map<string, RunningProcess> = new Map();
+    private stopping = false;
+
+    init(app: App) {
+        this.app = app;
+    }
+
+    async start() {
+        if (!this.app) return;
+        const processConfigs = this.app.config.processes;
+
+        if (!processConfigs) {
+            this.app.logger.debug('No processes configured.');
+            return;
+        }
+
+        this.app.logger.info(`Starting ${Object.keys(processConfigs).length} processes...`);
+
+        for (const [name, config] of Object.entries(processConfigs)) {
+            this.spawnProcess(name, config);
+        }
+    }
+
+    private async readStdOut(name: string, stream: ReadableStream) {
+        const reader = stream.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) break;
+
+                buffer += decoder.decode(value, { stream: true });
+
+                const lines = buffer.split('\n');
+                // Keep the last chunk if it's not a complete line (doesn't end with \n)
+                buffer = lines.pop() || '';
+
+                for (const line of lines) {
+                    if (!line.trim()) continue;
+                    this.processLine(name, line);
+                }
+            }
+        } catch (err) {
+            // Stream closed or error
+        }
+    }
+
+    private processLine(name: string, line: string) {
+        try {
+            // Try to parse as JSON Event
+            const json = JSON.parse(line);
+            this.app?.emit('process:message', { name, message: json });
+        } catch {
+            // Fallback to raw log
+            this.app?.emit('process:log', { name, text: line });
+        }
+    }
+
+    private handleExit(name: string, exitCode: number, signalCode: number) {
+        if (this.stopping) return;
+
+        const procInfo = this.processes.get(name);
+        if (!procInfo) return;
+
+        this.app?.logger.warn(`Process ${name} exited with code ${exitCode}`);
+
+        // Remove from map so we don't try to kill it again on stop()
+        this.processes.delete(name);
+
+        if (procInfo.config.restartOnCrash) {
+            const maxRestarts = procInfo.config.maxRestarts ?? 10;
+            const cooldown = procInfo.config.restartCooldown ?? 60000;
+            const uptime = Date.now() - procInfo.startedAt;
+
+            // If the process ran longer than the cooldown, consider it stable and reset the counter
+            const restarts = uptime > cooldown ? 1 : procInfo.restarts + 1;
+
+            if (restarts > maxRestarts) {
+                this.app?.logger.error(`Process ${name} exceeded max restarts (${maxRestarts}). Not restarting.`);
+                this.app?.emit('process:max-restarts', { name, restarts: procInfo.restarts, maxRestarts });
+                return;
+            }
+
+            this.app?.logger.info(`Restarting process: ${name} (Attempt ${restarts}/${maxRestarts})`);
+
+            setTimeout(() => {
+                this.spawnProcess(name, procInfo.config, restarts);
+            }, 1000);
+        }
+    }
+
+    // Updated spawn signature to track restarts
+    private spawnProcess(name: string, config: ProcessConfig, restarts = 0) {
+        if (this.stopping || !this.app) return;
+
+        this.app.logger.info(`Spawning process: ${name} (${config.command} ${config.args?.join(' ') || ''})`);
+
+        try {
+            const proc = Bun.spawn(
+                [config.command, ...(config.args || [])],
+                {
+                    env: { ...process.env, ...config.env },
+                    stdout: config.mode === 'stdio' ? 'pipe' : 'inherit',
+                    stderr: config.mode === 'stdio' ? 'pipe' : 'inherit',
+                    stdin: config.mode === 'stdio' ? 'pipe' : 'ignore',
+                    onExit: (proc, exitCode, signalCode, error) => {
+                        this.handleExit(name, exitCode || 0, signalCode || 0);
+                    }
+                }
+            );
+
+            this.processes.set(name, {
+                process: proc,
+                config,
+                name,
+                restarts,
+                startedAt: Date.now(),
+            });
+
+            if (config.mode === 'stdio') {
+                if (proc.stdout) this.readStdOut(name, proc.stdout);
+                if (proc.stderr) this.readStdErr(name, proc.stderr);
+            }
+
+        } catch (err) {
+            this.app.logger.error({ err }, `Failed to spawn process: ${name}`);
+        }
+    }
+
+    private async readStdErr(name: string, stream: ReadableStream) {
+        const reader = stream.getReader();
+        const decoder = new TextDecoder();
+
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) break;
+                const text = decoder.decode(value, { stream: true });
+                if (text.trim()) {
+                    this.app?.emit('process:error', { name, text });
+                }
+            }
+        } catch (err) {
+            // Stream closed
+        }
+    }
+
+    // Send data to process stdin
+    async send(name: string, data: any) {
+        const procInfo = this.processes.get(name);
+        if (!procInfo) {
+            this.app?.logger.warn(`Cannot send message to non-existent process: ${name}`);
+            return;
+        }
+
+        if (procInfo.config.mode !== 'stdio' || !procInfo.process.stdin) {
+            this.app?.logger.warn(`Cannot send message to process ${name} (mode is not stdio or stdin is closed)`);
+            return;
+        }
+
+        // Bun's Subprocess.stdin is a FileSink
+        const stdin = procInfo.process.stdin as any;
+
+        try {
+            // If data is object, stringify it and add newline
+            const message = typeof data === 'string' ? data : JSON.stringify(data);
+            stdin.write(message + '\n');
+            stdin.flush();
+        } catch (err) {
+            this.app?.logger.error({ err }, `Failed to write to process ${name}`);
+        }
+    }
+
+    async stop() {
+        this.stopping = true;
+        this.app?.logger.info('Stopping all processes...');
+
+        for (const [name, info] of this.processes) {
+            if (!info.process.killed) {
+                info.process.kill();
+            }
+        }
+        this.processes.clear();
+    }
+}