project-state-manager 1.0.1

package/dist/shared/schemas/process.schema.js

@@ -0,0 +1,119 @@
+import { z } from "zod";
+/**
+ * Schema for Process nodes (Input, Flow, Output).
+ */
+/**
+ * Individual schema for Entry node findings.
+ * Exported for GUI reuse (Story 3.1).
+ */
+export const EntryFindingsSchema = z.object({
+    type: z.literal("entry"),
+    sources: z.array(z.string()),
+    validation_rules: z.array(z.string()),
+    sensitive_data: z.boolean(),
+});
+/**
+ * Individual schema for Flow node findings.
+ * Exported for GUI reuse (Story 3.1).
+ */
+export const FlowFindingsSchema = z.object({
+    type: z.literal("flow"),
+    transformations: z.array(z.string()),
+    affected_services: z.array(z.string()),
+    side_effects: z.array(z.string()),
+});
+/**
+ * Individual schema for Exit node findings.
+ * Exported for GUI reuse (Story 3.1).
+ */
+export const ExitFindingsSchema = z.object({
+    type: z.literal("exit"),
+    destinations: z.array(z.string()),
+    response_formats: z.array(z.string()),
+    error_handling: z.array(z.string()),
+});
+/**
+ * Discriminated union of all node findings schemas.
+ */
+export const NodeFindingsSchema = z.discriminatedUnion("type", [
+    EntryFindingsSchema,
+    FlowFindingsSchema,
+    ExitFindingsSchema,
+]);
+export const ProcessNodeSchema = z.object({
+    content: z.string(),
+    status: z.enum(["todo", "in-progress", "done", "valid", "error"]),
+    lastUpdated: z.string().datetime(),
+    manuallyModified: z.boolean().optional(),
+    data: NodeFindingsSchema.optional(),
+});
+export const ProcessSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    entryPoint: z.string(),
+    nodes: z.object({
+        input: ProcessNodeSchema,
+        flow: ProcessNodeSchema,
+        output: ProcessNodeSchema,
+    }),
+    is_executable: z.boolean().default(false),
+});
+/**
+ * Schema for IPC messages between Master and Worker.
+ * Follows the standard: { type: string, data: any, timestamp: string }
+ */
+export const IPCMessageSchema = z.object({
+    type: z.string(),
+    correlationId: z.string().optional(),
+    data: z.any().optional(),
+    error: z.string().optional(),
+    timestamp: z.string().datetime(),
+});
+/**
+ * Schema for Proxy registration responses.
+ */
+export const ProxyResponseSchema = z.object({
+    port: z.number().int().positive(),
+    url: z.string().url().optional(),
+});
+/**
+ * Tool Argument Schemas
+ */
+export const DefineProcessArgsSchema = z.object({
+    name: z.string().describe('The name of the process (feature name)'),
+    entry_point: z.string().describe('The main file or directory associated with this process'),
+});
+export const DiscoverProcessArgsSchema = z.object({
+    context: z.string().describe('A keyword, file path, or description to find a relevant process'),
+});
+export const ScanNodeArgsSchema = z.object({
+    process_name: z.string().describe('The name (ID) of the process to scan'),
+    node_type: z.enum(['entry', 'flow', 'exit']).describe('The type of node to analyze (entry, flow, or exit)'),
+});
+export const SubmitNodeDataArgsSchema = z.object({
+    process_name: z.string().describe('The name (ID) of the process'),
+    node_type: z.enum(['entry', 'flow', 'exit']).describe('The type of node'),
+    findings: z.any().describe('The findings to submit (will be validated against specific schema)'),
+});
+export const CheckReadinessArgsSchema = z.object({
+    process_name: z.string().describe('The name (ID) of the process to check readiness for'),
+});
+export const HealthStatusSchema = z.object({
+    master: z.object({
+        status: z.string(),
+        uptime: z.number(),
+        memory: z.object({
+            rss: z.number(),
+            heapUsed: z.number(),
+        }),
+    }),
+    worker: z.object({
+        status: z.string(),
+        connected: z.boolean(),
+        uptime: z.number().optional(),
+        memory: z.object({
+            rss: z.number(),
+            heapUsed: z.number(),
+        }).optional(),
+    }).optional(),
+});

package/dist/src/core/error-formatter.d.ts

@@ -0,0 +1,31 @@
+import { ZodError } from 'zod';
+/**
+ * Interface pour une erreur formatée avec suggestions.
+ */
+export interface FormattedError {
+    path: string;
+    message: string;
+    expected?: string;
+    suggestion?: string;
+}
+/**
+ * Formateur d'erreurs intelligent fournissant des suggestions contextuelles pour les agents IA.
+ */
+export declare class ErrorFormatter {
+    /**
+     * Formate une ZodError en une chaîne structurée avec des suggestions.
+     *
+     * @param error - L'instance ZodError
+     * @param nodeType - Le type de nœud (entry, flow, exit) pour le contexte
+     * @returns Une chaîne lisible par l'humain formatée pour la consommation par l'IA
+     */
+    static format(error: ZodError, nodeType: string): string;
+    /**
+     * Construit la chaîne de sortie finale avec des sections claires.
+     */
+    private static buildOutputString;
+    /**
+     * Fournit des données d'exemple basées sur le type de nœud.
+     */
+    private static getExampleData;
+}

package/dist/src/core/error-formatter.js

@@ -0,0 +1,97 @@
+/**
+ * Formateur d'erreurs intelligent fournissant des suggestions contextuelles pour les agents IA.
+ */
+export class ErrorFormatter {
+    /**
+     * Formate une ZodError en une chaîne structurée avec des suggestions.
+     *
+     * @param error - L'instance ZodError
+     * @param nodeType - Le type de nœud (entry, flow, exit) pour le contexte
+     * @returns Une chaîne lisible par l'humain formatée pour la consommation par l'IA
+     */
+    static format(error, nodeType) {
+        const formattedErrors = error.errors.map((err) => {
+            const path = err.path.join('.');
+            let suggestion = '';
+            let expected = '';
+            // Suggestions contextuelles basées sur les codes d'erreur Zod
+            switch (err.code) {
+                case 'invalid_type':
+                    expected = `${err.expected}`;
+                    suggestion = `Le champ "${path}" doit être de type ${err.expected}. Vous avez fourni ${err.received}.`;
+                    break;
+                case 'too_small':
+                    suggestion = `Le champ "${path}" est trop court ou contient trop peu d'éléments (minimum attendu: ${err.minimum}).`;
+                    break;
+                case 'too_big':
+                    suggestion = `Le champ "${path}" est trop long ou contient trop d'éléments (maximum autorisé: ${err.maximum}).`;
+                    break;
+                case 'invalid_enum_value':
+                    expected = `L'une des valeurs: ${err.options.join(', ')}`;
+                    suggestion = `La valeur fournie pour "${path}" n'est pas valide. Valeurs acceptées: ${err.options.join(', ')}.`;
+                    break;
+                case 'invalid_string':
+                    suggestion = `Le format de la chaîne pour "${path}" est invalide (attendu: ${err.validation}).`;
+                    break;
+                case 'invalid_date':
+                    suggestion = `La date fournie pour "${path}" est invalide.`;
+                    break;
+                default:
+                    suggestion = `Veuillez vérifier la structure du champ "${path}". ${err.message}`;
+            }
+            return {
+                path,
+                message: err.message,
+                expected,
+                suggestion
+            };
+        });
+        return this.buildOutputString(formattedErrors, nodeType);
+    }
+    /**
+     * Construit la chaîne de sortie finale avec des sections claires.
+     */
+    static buildOutputString(errors, nodeType) {
+        let output = `ERREUR DE VALIDATION - Noeud: ${nodeType}\n`;
+        output += `-------------------------------------------\n`;
+        errors.forEach((err) => {
+            output += `CHEMIN: ${err.path}\n`;
+            output += `PROBLEME: ${err.message}\n`;
+            if (err.expected)
+                output += `TYPE ATTENDU: ${err.expected}\n`;
+            if (err.suggestion)
+                output += `\nSUGGESTION DE CORRECTION:\n${err.suggestion}\n`;
+            output += `-------------------------------------------\n`;
+        });
+        output += `\nEXEMPLE DE DONNEES VALIDES POUR LE NOEUD "${nodeType}":\n`;
+        output += this.getExampleData(nodeType);
+        return output;
+    }
+    /**
+     * Fournit des données d'exemple basées sur le type de nœud.
+     */
+    static getExampleData(nodeType) {
+        switch (nodeType) {
+            case 'entry':
+                return JSON.stringify({
+                    sources: ["src/auth/login.ts", "src/auth/register.ts"],
+                    validation_rules: ["Vérification du format email", "Longueur minimale password"],
+                    sensitive_data: true
+                }, null, 2);
+            case 'flow':
+                return JSON.stringify({
+                    transformations: ["Hachage du mot de passe via bcrypt", "Génération du token JWT"],
+                    affected_services: ["DatabaseService", "AuthService"],
+                    side_effects: ["Log de connexion", "Mise à jour last_login"]
+                }, null, 2);
+            case 'exit':
+                return JSON.stringify({
+                    destinations: ["Client Frontend", "Audit Log"],
+                    response_formats: ["JSON { token: string, user: Object }"],
+                    error_handling: ["401 Unauthorized sur échec auth", "500 Internal Error sur DB failure"]
+                }, null, 2);
+            default:
+                return "{}";
+        }
+    }
+}

package/dist/src/core/signal-calculator.d.ts

@@ -0,0 +1,12 @@
+import { Process } from '../../shared/schemas/process.schema.js';
+/**
+ * Calculates if a process is ready for implementation (executable).
+ *
+ * Logic: A process is executable if all three fundamental nodes
+ * (Input, Flow, Output) are present, marked as 'done' or 'valid',
+ * AND contain valid findings data.
+ *
+ * @param process - The process state to evaluate
+ * @returns boolean indicating if the process is executable
+ */
+export declare function calculateExecutableSignal(process: Process): boolean;

package/dist/src/core/signal-calculator.js

@@ -0,0 +1,19 @@
+/**
+ * Calculates if a process is ready for implementation (executable).
+ *
+ * Logic: A process is executable if all three fundamental nodes
+ * (Input, Flow, Output) are present, marked as 'done' or 'valid',
+ * AND contain valid findings data.
+ *
+ * @param process - The process state to evaluate
+ * @returns boolean indicating if the process is executable
+ */
+export function calculateExecutableSignal(process) {
+    const { input, flow, output } = process.nodes;
+    // Rule 1: All three fundamental nodes must be 'done' or 'valid'
+    // Rule 2: All three fundamental nodes must have findings data attached
+    const isInputReady = (input.status === 'done' || input.status === 'valid') && !!input.data;
+    const isFlowReady = (flow.status === 'done' || flow.status === 'valid') && !!flow.data;
+    const isOutputReady = (output.status === 'done' || output.status === 'valid') && !!output.data;
+    return isInputReady && isFlowReady && isOutputReady;
+}

package/dist/src/core/yaml-engine.d.ts

@@ -0,0 +1,15 @@
+import { Process } from '../../shared/schemas/process.schema.js';
+export declare class YamlEngine {
+    private psmDir;
+    private onSaveCallback?;
+    constructor(psmDir?: string);
+    onSave(callback: (process: Process) => void): void;
+    init(): void;
+    saveProcess(process: Process): Promise<void>;
+    private notifyUpdate;
+    loadProcess(id: string): Promise<Process | null>;
+    private ensureDir;
+    listProcesses(): Promise<string[]>;
+    getAllProcesses(): Promise<Process[]>;
+    updateNode(processId: string, nodeType: string, content: string, isManual?: boolean): Promise<Process>;
+}

package/dist/src/core/yaml-engine.js

@@ -0,0 +1,162 @@
+import fs from 'fs';
+import path from 'path';
+import YAML from 'yaml';
+import { ProcessSchema } from '../../shared/schemas/process.schema.js';
+import { calculateExecutableSignal } from './signal-calculator.js';
+export class YamlEngine {
+    psmDir;
+    onSaveCallback;
+    constructor(psmDir = '.psm') {
+        this.psmDir = psmDir;
+    }
+    onSave(callback) {
+        this.onSaveCallback = callback;
+    }
+    init() {
+        if (!fs.existsSync(this.psmDir)) {
+            fs.mkdirSync(this.psmDir, { recursive: true });
+        }
+    }
+    async saveProcess(process) {
+        const validated = ProcessSchema.parse(process);
+        // Story 4.1: Recalculate executable signal before saving
+        validated.is_executable = calculateExecutableSignal(validated);
+        // NFR6: Prevent Path Traversal by sanitizing ID and validating it doesn't contain path separators
+        const safeId = path.basename(validated.id);
+        if (safeId !== validated.id || validated.id.includes('..')) {
+            throw new Error(`Invalid process ID: ${validated.id}`);
+        }
+        const filePath = path.join(this.psmDir, `${safeId}.yaml`);
+        const lockPath = `${filePath}.lock`;
+        this.ensureDir();
+        // Robust file-based locking with staleness detection
+        const lockTimeout = 5000; // 5 seconds
+        const retryInterval = 100;
+        const maxAttempts = 50;
+        let attempts = 0;
+        let locked = false;
+        while (attempts < maxAttempts) {
+            try {
+                // Atomic creation of lock file
+                fs.writeFileSync(lockPath, global.process.pid.toString(), { flag: 'wx' });
+                locked = true;
+                break;
+            }
+            catch (err) {
+                if (err.code === 'EEXIST') {
+                    // Check if lock is stale
+                    try {
+                        const stats = fs.statSync(lockPath);
+                        const age = Date.now() - stats.mtimeMs;
+                        if (age > lockTimeout) {
+                            try {
+                                fs.unlinkSync(lockPath);
+                                continue; // Retry immediately after clearing stale lock
+                            }
+                            catch (unlinkErr) {
+                                // Ignore error if another process already deleted it
+                            }
+                        }
+                    }
+                    catch (statErr) {
+                        if (statErr.code === 'ENOENT') {
+                            continue; // Lock was deleted by another process, retry acquisition
+                        }
+                        throw statErr;
+                    }
+                    await new Promise(resolve => setTimeout(resolve, retryInterval));
+                    attempts++;
+                }
+                else {
+                    throw err;
+                }
+            }
+        }
+        if (!locked) {
+            throw new Error(`Could not acquire lock for ${filePath} after ${maxAttempts} attempts`);
+        }
+        try {
+            const yamlContent = YAML.stringify(validated);
+            fs.writeFileSync(filePath, yamlContent, 'utf8');
+            // Notify (to be integrated with IPC Hub later)
+            this.notifyUpdate(validated);
+        }
+        finally {
+            if (locked && fs.existsSync(lockPath)) {
+                try {
+                    fs.unlinkSync(lockPath);
+                }
+                catch (err) {
+                    // Ignore unlink errors in finally
+                }
+            }
+        }
+    }
+    notifyUpdate(updatedProcess) {
+        if (this.onSaveCallback) {
+            this.onSaveCallback(updatedProcess);
+        }
+        if (global.process.env.DEBUG) {
+            console.error(`[YamlEngine] State updated for ${updatedProcess.id}`);
+        }
+    }
+    async loadProcess(id) {
+        // NFR6: Prevent Path Traversal
+        const safeId = path.basename(id);
+        if (safeId !== id || id.includes('..')) {
+            throw new Error(`Invalid process ID: ${id}`);
+        }
+        const filePath = path.join(this.psmDir, `${safeId}.yaml`);
+        if (!fs.existsSync(filePath)) {
+            return null;
+        }
+        const yamlContent = fs.readFileSync(filePath, 'utf8');
+        const data = YAML.parse(yamlContent);
+        return ProcessSchema.parse(data);
+    }
+    ensureDir() {
+        if (!fs.existsSync(this.psmDir)) {
+            fs.mkdirSync(this.psmDir, { recursive: true });
+        }
+    }
+    async listProcesses() {
+        if (!fs.existsSync(this.psmDir)) {
+            return [];
+        }
+        const files = fs.readdirSync(this.psmDir);
+        return files
+            .filter(file => file.endsWith('.yaml'))
+            .map(file => file.replace('.yaml', ''));
+    }
+    async getAllProcesses() {
+        const ids = await this.listProcesses();
+        const processPromises = ids.map(id => this.loadProcess(id));
+        const results = await Promise.all(processPromises);
+        return results.filter((p) => p !== null);
+    }
+    async updateNode(processId, nodeType, content, isManual = false) {
+        const process = await this.loadProcess(processId);
+        if (!process) {
+            throw new Error(`Process not found: ${processId}`);
+        }
+        // Map node type
+        let targetKey;
+        if (nodeType === 'entry' || nodeType === 'input')
+            targetKey = 'input';
+        else if (nodeType === 'flow')
+            targetKey = 'flow';
+        else if (nodeType === 'exit' || nodeType === 'output')
+            targetKey = 'output';
+        else
+            throw new Error(`Invalid node type: ${nodeType}`);
+        // Update node content
+        process.nodes[targetKey].content = content;
+        process.nodes[targetKey].lastUpdated = new Date().toISOString();
+        if (isManual) {
+            process.nodes[targetKey].manuallyModified = true;
+        }
+        // Re-validate and save
+        await this.saveProcess(process);
+        return process;
+    }
+}

package/dist/src/gui-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/gui-worker.js

@@ -0,0 +1,221 @@
+import { serve } from "@hono/node-server";
+import { serveStatic } from "@hono/node-server/serve-static";
+import { Hono } from "hono";
+import { streamSSE } from "hono/streaming";
+import { ProxyClient } from "./infra/proxy-client.js";
+import { IPCMessageSchema } from "../shared/schemas/process.schema.js";
+import path from "path";
+import fs from "fs";
+import { fileURLToPath } from "url";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+// Resolve root directory reliably (works in both dev and compiled mode)
+function findProjectRoot(startDir) {
+    let current = startDir;
+    while (current !== path.dirname(current)) {
+        if (fs.existsSync(path.join(current, "gui")) || fs.existsSync(path.join(current, "package.json"))) {
+            return current;
+        }
+        current = path.dirname(current);
+    }
+    return startDir;
+}
+const rootDir = findProjectRoot(__dirname);
+const staticRoot = path.join(rootDir, "gui/dist");
+const absoluteStaticRoot = path.resolve(staticRoot);
+const app = new Hono();
+let proxyClient = null;
+const sseControllers = new Set();
+// Tracking for IPC request-response
+const pendingRequests = new Map();
+/**
+ * Setup IPC error handlers
+ */
+function setupIpcErrorHandlers() {
+    process.on('error', (err) => {
+        if (err.code === 'ERR_IPC_CHANNEL_CLOSED') {
+            console.error('[DEBUG] [GUI-WORKER] IPC channel closed.');
+            return;
+        }
+        console.error(`[DEBUG] [GUI-WORKER] Process error: ${err.message}`);
+    });
+    process.on('disconnect', () => {
+        console.error('[DEBUG] [GUI-WORKER] Disconnected from parent, exiting.');
+        process.exit(0);
+    });
+    process.on('message', (msg) => {
+        // Handle responses from Master
+        if (msg && msg.correlationId && pendingRequests.has(msg.correlationId)) {
+            const { resolve } = pendingRequests.get(msg.correlationId);
+            pendingRequests.delete(msg.correlationId);
+            resolve(msg);
+            return;
+        }
+        if (msg && msg.type === 'GET_HEALTH') {
+            const memory = process.memoryUsage();
+            process.send({
+                type: 'HEALTH_RESPONSE',
+                correlationId: msg.correlationId,
+                data: {
+                    status: 'ok',
+                    uptime: process.uptime(),
+                    memory: {
+                        rss: memory.rss,
+                        heapUsed: memory.heapUsed,
+                    },
+                },
+                timestamp: new Date().toISOString()
+            });
+            return;
+        }
+        if (msg && (msg.type === 'STATE_UPDATED' || msg.type === 'INITIAL_STATE')) {
+            const typeLabel = msg.type === 'STATE_UPDATED' ? `update for ${msg.data.id}` : `initial state (${msg.data.processes.length} items)`;
+            for (const controller of sseControllers) {
+                try {
+                    controller.writeSSE({
+                        data: JSON.stringify(msg),
+                        event: "message",
+                    });
+                }
+                catch (err) {
+                    sseControllers.delete(controller);
+                }
+            }
+        }
+    });
+}
+// Routes API
+app.get("/proxy/health", (c) => {
+    const memory = process.memoryUsage();
+    return c.json({
+        status: "ok",
+        proxy: proxyClient ? proxyClient.getStatus() : (process.env.PROXY_URL ? "error" : "fallback"),
+        uptime: process.uptime(),
+        memory: {
+            rss: memory.rss,
+            heapUsed: memory.heapUsed,
+        },
+        ipc: process.connected ? "connected" : "disconnected",
+        timestamp: new Date().toISOString(),
+    });
+});
+app.get("/api/events", (c) => {
+    return streamSSE(c, async (stream) => {
+        sseControllers.add(stream);
+        stream.onAbort(() => {
+            sseControllers.delete(stream);
+        });
+        if (process.send) {
+            process.send({ type: "GET_INITIAL_STATE", timestamp: new Date().toISOString() });
+        }
+        await stream.writeSSE({ data: "connected", event: "ping" });
+        while (true) {
+            await stream.sleep(30000);
+            try {
+                await stream.writeSSE({ data: "ping", event: "ping" });
+            }
+            catch (e) {
+                sseControllers.delete(stream);
+                break;
+            }
+        }
+    });
+});
+app.post("/api/update-node", async (c) => {
+    const body = await c.req.json();
+    const { processName, nodeType, content } = body;
+    if (!processName || !nodeType || content === undefined) {
+        return c.json({ error: "Missing required fields" }, 400);
+    }
+    if (!process.send) {
+        return c.json({ error: "IPC not available" }, 500);
+    }
+    const correlationId = Math.random().toString(36).substring(7);
+    const message = {
+        type: "UPDATE_NODE",
+        correlationId,
+        data: { processName, nodeType, content },
+        timestamp: new Date().toISOString()
+    };
+    return new Promise((resolve) => {
+        const timeout = setTimeout(() => {
+            if (pendingRequests.has(correlationId)) {
+                pendingRequests.delete(correlationId);
+                resolve(c.json({ error: "Request timed out" }, 504));
+            }
+        }, 5000);
+        pendingRequests.set(correlationId, {
+            resolve: (msg) => {
+                clearTimeout(timeout);
+                if (msg.error)
+                    resolve(c.json({ error: msg.error }, 400));
+                else
+                    resolve(c.json({ success: true, process: msg.data?.process }));
+            },
+            reject: (err) => {
+                clearTimeout(timeout);
+                resolve(c.json({ error: err.message }, 500));
+            }
+        });
+        process.send(message);
+    });
+});
+// Service Statique
+app.use("/assets/*", serveStatic({ root: path.relative(process.cwd(), absoluteStaticRoot) }));
+// Fallback SPA
+app.get("/*", (c, next) => {
+    const urlPath = c.req.path;
+    if (urlPath.startsWith('/api') || urlPath.startsWith('/proxy') || urlPath.startsWith('/assets')) {
+        return next();
+    }
+    try {
+        const indexPath = path.join(absoluteStaticRoot, "index.html");
+        if (fs.existsSync(indexPath)) {
+            const html = fs.readFileSync(indexPath, "utf8");
+            return c.html(html);
+        }
+        return c.text("GUI Build non trouvé à " + absoluteStaticRoot, 404);
+    }
+    catch (err) {
+        return next();
+    }
+});
+async function startServer() {
+    const fallbackPort = parseInt(process.env.FIXED_GUI_PORT || "4000", 10);
+    const proxyUrl = process.env.PROXY_URL;
+    const appPath = process.env.APP_PATH || "/psm-gui";
+    const appName = process.env.APP_NAME || "Project State Manager GUI";
+    let finalPort = fallbackPort;
+    let publicUrl = `http://localhost:${fallbackPort}`;
+    let isProxied = false;
+    if (proxyUrl) {
+        proxyClient = new ProxyClient(proxyUrl);
+        const result = await proxyClient.register({ path: appPath, name: appName }, fallbackPort);
+        isProxied = result.success;
+        finalPort = result.port;
+        if (isProxied)
+            publicUrl = result.url || `${proxyUrl}${appPath}`;
+    }
+    const cleanup = async () => {
+        if (proxyClient)
+            await proxyClient.unregister();
+        process.exit(0);
+    };
+    process.on("SIGTERM", cleanup);
+    process.on("SIGINT", cleanup);
+    setupIpcErrorHandlers();
+    serve({ fetch: app.fetch, port: finalPort }, (info) => {
+        console.error(`[DEBUG] [GUI-WORKER] Dashboard server listening on port ${info.port}`);
+        if (process.send) {
+            const message = {
+                type: "READY",
+                data: { port: info.port, isProxied, url: publicUrl },
+                timestamp: new Date().toISOString()
+            };
+            process.send(IPCMessageSchema.parse(message));
+        }
+    });
+}
+startServer().catch((err) => {
+    console.error(`[DEBUG] [GUI-WORKER] Failed to start: ${err.message}`);
+    process.exit(1);
+});

package/dist/src/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};