@exaudeus/workrail 3.24.3 → 3.25.0

package/dist/daemon/workflow-runner.js

@@ -0,0 +1,573 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DAEMON_SOUL_DEFAULT = exports.DAEMON_SESSIONS_DIR = void 0;
+exports.readDaemonSessionState = readDaemonSessionState;
+exports.readAllDaemonSessions = readAllDaemonSessions;
+exports.runStartupRecovery = runStartupRecovery;
+exports.buildSystemPrompt = buildSystemPrompt;
+exports.runWorkflow = runWorkflow;
+require("reflect-metadata");
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+const os = __importStar(require("node:os"));
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+const node_crypto_1 = require("node:crypto");
+const pi_mono_loader_js_1 = require("./pi-mono-loader.js");
+const start_js_1 = require("../mcp/handlers/v2-execution/start.js");
+const index_js_1 = require("../mcp/handlers/v2-execution/index.js");
+const execAsync = (0, node_util_1.promisify)(node_child_process_1.exec);
+const BASH_TIMEOUT_MS = 5 * 60 * 1000;
+const WORKFLOW_TIMEOUT_MS = 30 * 60 * 1000;
+exports.DAEMON_SESSIONS_DIR = path.join(os.homedir(), '.workrail', 'daemon-sessions');
+const MAX_ORPHAN_AGE_MS = 2 * 60 * 60 * 1000;
+const WORKRAIL_DIR = path.join(os.homedir(), '.workrail');
+const WORKSPACE_CONTEXT_MAX_BYTES = 32 * 1024;
+const WORKSPACE_CONTEXT_CANDIDATE_PATHS = [
+    '.claude/CLAUDE.md',
+    'CLAUDE.md',
+    'AGENTS.md',
+    '.github/AGENTS.md',
+];
+exports.DAEMON_SOUL_DEFAULT = `\
+- Write code that follows the patterns already established in the codebase
+- Never skip tests. Run existing tests before and after changes
+- Prefer small, focused changes over large rewrites
+- If a step asks you to write code, write actual code -- do not write pseudocode or placeholders
+- Commit your work when you complete a logical unit`;
+const DAEMON_SOUL_TEMPLATE = `\
+# WorkRail Daemon Soul
+#
+# This file is injected into every WorkRail Auto daemon session system prompt under
+# "## Agent Rules and Philosophy". Edit it to customize the agent's behavior for
+# your environment: coding conventions, commit style, tool preferences, etc.
+#
+# Changes take effect on the next daemon session -- no restart required.
+#
+# The defaults below reflect general best practices. Override them freely.
+
+${exports.DAEMON_SOUL_DEFAULT}
+`;
+async function persistTokens(sessionId, continueToken, checkpointToken) {
+    await fs.mkdir(exports.DAEMON_SESSIONS_DIR, { recursive: true });
+    const sessionPath = path.join(exports.DAEMON_SESSIONS_DIR, `${sessionId}.json`);
+    const state = JSON.stringify({ continueToken, checkpointToken, ts: Date.now() }, null, 2);
+    const tmp = `${sessionPath}.tmp`;
+    await fs.writeFile(tmp, state, 'utf8');
+    await fs.rename(tmp, sessionPath);
+}
+async function readDaemonSessionState(sessionId) {
+    const sessionPath = path.join(exports.DAEMON_SESSIONS_DIR, `${sessionId}.json`);
+    try {
+        const raw = await fs.readFile(sessionPath, 'utf8');
+        const parsed = JSON.parse(raw);
+        return { continueToken: parsed.continueToken, checkpointToken: parsed.checkpointToken };
+    }
+    catch {
+        return null;
+    }
+}
+async function readAllDaemonSessions(sessionsDir = exports.DAEMON_SESSIONS_DIR) {
+    let entries;
+    try {
+        entries = await fs.readdir(sessionsDir);
+    }
+    catch (err) {
+        const isEnoent = err instanceof Error && 'code' in err && err.code === 'ENOENT';
+        if (!isEnoent) {
+            console.warn(`[WorkflowRunner] Could not read sessions directory ${sessionsDir}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        return [];
+    }
+    const sessions = [];
+    for (const entry of entries) {
+        if (!entry.endsWith('.json'))
+            continue;
+        const sessionId = entry.slice(0, -5);
+        const filePath = path.join(sessionsDir, entry);
+        try {
+            const raw = await fs.readFile(filePath, 'utf8');
+            const parsed = JSON.parse(raw);
+            if (typeof parsed.continueToken !== 'string' || typeof parsed.ts !== 'number') {
+                console.warn(`[WorkflowRunner] Skipping malformed session file: ${filePath}`);
+                continue;
+            }
+            sessions.push({
+                sessionId,
+                continueToken: parsed.continueToken,
+                checkpointToken: typeof parsed.checkpointToken === 'string' ? parsed.checkpointToken : null,
+                ts: parsed.ts,
+            });
+        }
+        catch (err) {
+            console.warn(`[WorkflowRunner] Skipping unreadable session file ${filePath}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    return sessions;
+}
+async function runStartupRecovery(sessionsDir = exports.DAEMON_SESSIONS_DIR) {
+    const sessions = await readAllDaemonSessions(sessionsDir);
+    if (sessions.length === 0) {
+        await clearStrayTmpFiles(sessionsDir);
+        return;
+    }
+    console.log(`[WorkflowRunner] Startup recovery: found ${sessions.length} orphaned session(s).`);
+    const now = Date.now();
+    let cleared = 0;
+    for (const session of sessions) {
+        const ageMs = now - session.ts;
+        const isStale = ageMs > MAX_ORPHAN_AGE_MS;
+        const ageSec = Math.round(ageMs / 1000);
+        const label = isStale ? 'stale orphaned session' : 'orphaned session';
+        console.log(`[WorkflowRunner] Clearing ${label}: sessionId=${session.sessionId} age=${ageSec}s`);
+        try {
+            await fs.unlink(path.join(sessionsDir, `${session.sessionId}.json`));
+            cleared++;
+        }
+        catch (err) {
+            const isEnoent = err instanceof Error && 'code' in err && err.code === 'ENOENT';
+            if (!isEnoent) {
+                console.warn(`[WorkflowRunner] Could not clear session file ${session.sessionId}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+    }
+    await clearStrayTmpFiles(sessionsDir);
+    console.log(`[WorkflowRunner] Startup recovery complete: cleared ${cleared}/${sessions.length} orphaned session(s).`);
+}
+async function clearStrayTmpFiles(sessionsDir) {
+    let entries;
+    try {
+        entries = await fs.readdir(sessionsDir);
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (!entry.endsWith('.tmp'))
+            continue;
+        try {
+            await fs.unlink(path.join(sessionsDir, entry));
+            console.log(`[WorkflowRunner] Cleared stray temp file: ${entry}`);
+        }
+        catch {
+        }
+    }
+}
+async function loadDaemonSoul() {
+    const soulPath = path.join(WORKRAIL_DIR, 'daemon-soul.md');
+    try {
+        return await fs.readFile(soulPath, 'utf8');
+    }
+    catch (err) {
+        const isEnoent = err instanceof Error && 'code' in err && err.code === 'ENOENT';
+        if (isEnoent) {
+            try {
+                await fs.mkdir(WORKRAIL_DIR, { recursive: true });
+                await fs.writeFile(soulPath, DAEMON_SOUL_TEMPLATE, 'utf8');
+                console.log(`[WorkflowRunner] Created daemon-soul.md template at ${soulPath}`);
+            }
+            catch (writeErr) {
+                console.warn(`[WorkflowRunner] Warning: could not write daemon-soul.md template: ${writeErr instanceof Error ? writeErr.message : String(writeErr)}`);
+            }
+        }
+        else {
+            console.warn(`[WorkflowRunner] Warning: could not read daemon-soul.md: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        return exports.DAEMON_SOUL_DEFAULT;
+    }
+}
+async function loadWorkspaceContext(workspacePath) {
+    const parts = [];
+    let combinedBytes = 0;
+    let truncated = false;
+    for (const relativePath of WORKSPACE_CONTEXT_CANDIDATE_PATHS) {
+        if (truncated)
+            break;
+        const fullPath = path.join(workspacePath, relativePath);
+        let content;
+        try {
+            content = await fs.readFile(fullPath, 'utf8');
+        }
+        catch (err) {
+            const isEnoent = err instanceof Error && 'code' in err && err.code === 'ENOENT';
+            if (!isEnoent) {
+                console.warn(`[WorkflowRunner] Skipping ${fullPath}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+            continue;
+        }
+        const contentBytes = Buffer.byteLength(content, 'utf8');
+        if (combinedBytes + contentBytes > WORKSPACE_CONTEXT_MAX_BYTES) {
+            const remaining = WORKSPACE_CONTEXT_MAX_BYTES - combinedBytes;
+            const truncatedContent = content.slice(0, remaining);
+            parts.push(`### ${relativePath}\n${truncatedContent}`);
+            truncated = true;
+        }
+        else {
+            parts.push(`### ${relativePath}\n${content}`);
+            combinedBytes += contentBytes;
+        }
+    }
+    if (parts.length === 0)
+        return null;
+    let combined = parts.join('\n\n');
+    if (truncated) {
+        combined += '\n\n[Workspace context truncated: combined size exceeded 32 KB limit. Some files may be missing.]';
+    }
+    console.log(`[WorkflowRunner] Injecting workspace context from: ${WORKSPACE_CONTEXT_CANDIDATE_PATHS.filter((p) => parts.some((part) => part.startsWith(`### ${p}`))).join(', ')}`);
+    return combined;
+}
+let _schemas = null;
+async function getSchemas() {
+    if (_schemas)
+        return _schemas;
+    const { Type } = await (0, pi_mono_loader_js_1.loadPiAi)();
+    _schemas = {
+        ContinueWorkflowParams: Type.Object({
+            continueToken: Type.String({
+                description: 'The continueToken from the previous start_workflow or continue_workflow call. Round-trip exactly as received.',
+            }),
+            intent: Type.Optional(Type.Union([Type.Literal('advance'), Type.Literal('rehydrate')], {
+                description: 'advance: I completed this step. rehydrate: remind me what the current step is.',
+            })),
+            notesMarkdown: Type.Optional(Type.String({
+                description: 'Notes on what you did in this step (10-30 lines, markdown).',
+            })),
+            context: Type.Optional(Type.Record(Type.String(), Type.Unknown(), {
+                description: 'Updated context variables (only changed values).',
+            })),
+        }),
+        BashParams: Type.Object({
+            command: Type.String({ description: 'Shell command to execute' }),
+            cwd: Type.Optional(Type.String({ description: 'Working directory for the command' })),
+        }),
+        ReadParams: Type.Object({
+            filePath: Type.String({ description: 'Absolute path to the file to read' }),
+        }),
+        WriteParams: Type.Object({
+            filePath: Type.String({ description: 'Absolute path to the file to write' }),
+            content: Type.String({ description: 'Content to write to the file' }),
+        }),
+    };
+    return _schemas;
+}
+function makeContinueWorkflowTool(sessionId, ctx, onAdvance, onComplete, schemas) {
+    return {
+        name: 'continue_workflow',
+        description: 'Advance the WorkRail workflow to the next step. Call this after completing all work ' +
+            'required by the current step. Include your notes in notesMarkdown.',
+        parameters: schemas['ContinueWorkflowParams'],
+        label: 'Continue Workflow',
+        execute: async (_toolCallId, params) => {
+            const result = await (0, index_js_1.executeContinueWorkflow)({
+                continueToken: params.continueToken,
+                intent: (params.intent ?? 'advance'),
+                output: params.notesMarkdown
+                    ? { notesMarkdown: params.notesMarkdown }
+                    : undefined,
+                context: params.context,
+            }, ctx);
+            if (result.isErr()) {
+                throw new Error(`continue_workflow failed: ${result.error.kind} -- ${JSON.stringify(result.error)}`);
+            }
+            const out = result.value.response;
+            const continueToken = out.continueToken ?? '';
+            const checkpointToken = out.checkpointToken ?? null;
+            if (continueToken) {
+                await persistTokens(sessionId, continueToken, checkpointToken);
+            }
+            if (out.isComplete) {
+                onComplete('Workflow session complete.');
+                return {
+                    content: [{ type: 'text', text: 'Workflow complete. All steps have been executed.' }],
+                    details: out,
+                };
+            }
+            const pending = out.pending;
+            const stepText = pending
+                ? `## Next step: ${pending.title}\n\n${pending.prompt}\n\ncontinueToken: ${continueToken}`
+                : `Step advanced. continueToken: ${continueToken}`;
+            onAdvance(stepText, continueToken);
+            return {
+                content: [{ type: 'text', text: stepText }],
+                details: out,
+            };
+        },
+    };
+}
+function makeBashTool(workspacePath, schemas) {
+    return {
+        name: 'Bash',
+        description: 'Execute a shell command. Throws on non-zero exit code. ' +
+            `Maximum execution time: ${BASH_TIMEOUT_MS / 1000}s.`,
+        parameters: schemas['BashParams'],
+        label: 'Bash',
+        execute: async (_toolCallId, params) => {
+            const cwd = params.cwd ?? workspacePath;
+            const { stdout, stderr } = await execAsync(params.command, {
+                cwd,
+                timeout: BASH_TIMEOUT_MS,
+            });
+            const output = [stdout, stderr].filter(Boolean).join('\n');
+            return {
+                content: [{ type: 'text', text: output || '(no output)' }],
+                details: { stdout, stderr },
+            };
+        },
+    };
+}
+function makeReadTool(schemas) {
+    return {
+        name: 'Read',
+        description: 'Read the contents of a file at the given absolute path.',
+        parameters: schemas['ReadParams'],
+        label: 'Read',
+        execute: async (_toolCallId, params) => {
+            const content = await fs.readFile(params.filePath, 'utf8');
+            return {
+                content: [{ type: 'text', text: content }],
+                details: { filePath: params.filePath, length: content.length },
+            };
+        },
+    };
+}
+function makeWriteTool(schemas) {
+    return {
+        name: 'Write',
+        description: 'Write content to a file at the given absolute path. Creates parent directories if needed.',
+        parameters: schemas['WriteParams'],
+        label: 'Write',
+        execute: async (_toolCallId, params) => {
+            await fs.mkdir(path.dirname(params.filePath), { recursive: true });
+            await fs.writeFile(params.filePath, params.content, 'utf8');
+            return {
+                content: [{ type: 'text', text: `Written ${params.content.length} bytes to ${params.filePath}` }],
+                details: { filePath: params.filePath, length: params.content.length },
+            };
+        },
+    };
+}
+function buildSystemPrompt(trigger, sessionState, soulContent, workspaceContext) {
+    const lines = [
+        'You are WorkRail Auto, an autonomous agent that executes workflows step by step.',
+        '',
+        '## Your tools',
+        '- `continue_workflow`: Advance to the next step. Call this after completing each step\'s work.',
+        '  Always include your notes in notesMarkdown and round-trip the continueToken exactly.',
+        '- `Bash`: Run shell commands. Use for building, testing, running scripts.',
+        '- `Read`: Read files.',
+        '- `Write`: Write files.',
+        '',
+        '## Execution contract',
+        '1. Read the step carefully. Do ALL the work the step asks for.',
+        '2. Call `continue_workflow` with your notes. Include the continueToken exactly.',
+        '3. Repeat until the workflow reports it is complete.',
+        '4. Do NOT skip steps. Do NOT call `continue_workflow` without completing the step\'s work.',
+        '',
+        `<workrail_session_state>${sessionState}</workrail_session_state>`,
+        '',
+        '## Agent Rules and Philosophy',
+        soulContent,
+        '',
+        `## Workspace: ${trigger.workspacePath}`,
+    ];
+    if (workspaceContext !== null) {
+        lines.push('');
+        lines.push('## Workspace Context (from AGENTS.md / CLAUDE.md)');
+        lines.push(workspaceContext);
+    }
+    if (trigger.referenceUrls && trigger.referenceUrls.length > 0) {
+        lines.push('');
+        lines.push('## Reference documents');
+        lines.push('Before starting, fetch and read these reference documents: ' +
+            trigger.referenceUrls.join(' '));
+        lines.push('If you cannot fetch any of these documents, note their unavailability and proceed.');
+    }
+    return lines.join('\n');
+}
+function buildUserMessage(text) {
+    return {
+        role: 'user',
+        content: text,
+        timestamp: Date.now(),
+    };
+}
+async function runWorkflow(trigger, ctx, apiKey, daemonRegistry) {
+    const sessionId = (0, node_crypto_1.randomUUID)();
+    console.log(`[WorkflowRunner] Session started: sessionId=${sessionId} workflowId=${trigger.workflowId}`);
+    daemonRegistry?.register(sessionId, trigger.workflowId);
+    let model;
+    try {
+        const { getModel } = await (0, pi_mono_loader_js_1.loadPiAi)();
+        if (trigger.agentConfig?.model) {
+            const slashIdx = trigger.agentConfig.model.indexOf('/');
+            if (slashIdx === -1) {
+                throw new Error(`agentConfig.model must be in "provider/model-id" format, got: "${trigger.agentConfig.model}"`);
+            }
+            const provider = trigger.agentConfig.model.slice(0, slashIdx);
+            const modelId = trigger.agentConfig.model.slice(slashIdx + 1);
+            model = getModel(provider, modelId);
+        }
+        else {
+            const usesBedrock = !!process.env['AWS_PROFILE'] || !!process.env['AWS_ACCESS_KEY_ID'];
+            if (usesBedrock) {
+                model = getModel('amazon-bedrock', 'us.anthropic.claude-sonnet-4-6');
+            }
+            else {
+                model = getModel('anthropic', 'claude-sonnet-4-5');
+            }
+        }
+    }
+    catch (err) {
+        daemonRegistry?.unregister(sessionId, 'failed');
+        return {
+            _tag: 'error',
+            workflowId: trigger.workflowId,
+            message: `Model not found: ${err instanceof Error ? err.message : String(err)}`,
+            stopReason: 'error',
+        };
+    }
+    let isComplete = false;
+    let pendingSteerText = null;
+    const onAdvance = (stepText, _continueToken) => {
+        pendingSteerText = stepText;
+        daemonRegistry?.heartbeat(sessionId);
+    };
+    const onComplete = (_notes) => {
+        isComplete = true;
+    };
+    const startResult = await (0, start_js_1.executeStartWorkflow)({ workflowId: trigger.workflowId, workspacePath: trigger.workspacePath, goal: trigger.goal }, ctx, { is_autonomous: 'true' });
+    if (startResult.isErr()) {
+        daemonRegistry?.unregister(sessionId, 'failed');
+        return {
+            _tag: 'error',
+            workflowId: trigger.workflowId,
+            message: `start_workflow failed: ${startResult.error.kind} -- ${JSON.stringify(startResult.error)}`,
+            stopReason: 'error',
+        };
+    }
+    const firstStep = startResult.value.response;
+    const startContinueToken = firstStep.continueToken ?? '';
+    const startCheckpointToken = firstStep.checkpointToken ?? null;
+    if (startContinueToken) {
+        await persistTokens(sessionId, startContinueToken, startCheckpointToken);
+    }
+    if (firstStep.isComplete) {
+        await fs.unlink(path.join(exports.DAEMON_SESSIONS_DIR, `${sessionId}.json`)).catch(() => { });
+        daemonRegistry?.unregister(sessionId, 'completed');
+        return { _tag: 'success', workflowId: trigger.workflowId, stopReason: 'stop' };
+    }
+    const schemas = await getSchemas();
+    const tools = [
+        makeContinueWorkflowTool(sessionId, ctx, onAdvance, onComplete, schemas),
+        makeBashTool(trigger.workspacePath, schemas),
+        makeReadTool(schemas),
+        makeWriteTool(schemas),
+    ];
+    const [soulContent, workspaceContext] = await Promise.all([
+        loadDaemonSoul(),
+        loadWorkspaceContext(trigger.workspacePath),
+    ]);
+    const contextJson = trigger.context
+        ? `\n\nTrigger context:\n\`\`\`json\n${JSON.stringify(trigger.context, null, 2)}\n\`\`\``
+        : '';
+    const initialPrompt = (firstStep.pending?.prompt ?? 'No step content available') +
+        `\n\ncontinueToken: ${startContinueToken}` +
+        contextJson;
+    const { Agent } = await (0, pi_mono_loader_js_1.loadPiAgentCore)();
+    const agent = new Agent({
+        initialState: {
+            systemPrompt: buildSystemPrompt(trigger, '', soulContent, workspaceContext),
+            model,
+            tools,
+        },
+        getApiKey: async (_provider) => apiKey ?? '',
+        toolExecution: 'sequential',
+    });
+    const unsubscribe = agent.subscribe(async (event) => {
+        if (event.type !== 'turn_end')
+            return;
+        if (pendingSteerText !== null && !isComplete) {
+            const text = pendingSteerText;
+            pendingSteerText = null;
+            agent.steer(buildUserMessage(text));
+        }
+    });
+    let stopReason = 'stop';
+    let errorMessage;
+    try {
+        const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error('Workflow timed out')), WORKFLOW_TIMEOUT_MS));
+        await Promise.race([agent.prompt(buildUserMessage(initialPrompt)), timeoutPromise])
+            .catch((err) => {
+            agent.abort();
+            throw err;
+        });
+        const messages = agent.state.messages;
+        let lastAssistant;
+        for (let i = messages.length - 1; i >= 0; i--) {
+            const m = messages[i];
+            if ('role' in m && m.role === 'assistant') {
+                lastAssistant = m;
+                break;
+            }
+        }
+        stopReason = lastAssistant?.stopReason ?? 'stop';
+        errorMessage = lastAssistant?.errorMessage;
+    }
+    catch (err) {
+        errorMessage = err instanceof Error ? err.message : String(err);
+        stopReason = 'error';
+    }
+    finally {
+        unsubscribe();
+    }
+    if (stopReason === 'error' || errorMessage) {
+        daemonRegistry?.unregister(sessionId, 'failed');
+        return {
+            _tag: 'error',
+            workflowId: trigger.workflowId,
+            message: errorMessage ?? 'Agent stopped with error reason',
+            stopReason,
+        };
+    }
+    await fs.unlink(path.join(exports.DAEMON_SESSIONS_DIR, `${sessionId}.json`)).catch(() => {
+    });
+    daemonRegistry?.unregister(sessionId, 'completed');
+    return {
+        _tag: 'success',
+        workflowId: trigger.workflowId,
+        stopReason,
+    };
+}

package/dist/infrastructure/session/HttpServer.js

@@ -531,7 +531,7 @@ let HttpServer = class HttpServer {
                 reject(error);
             });
             const listenPort = this.port;
-            this.server.listen(listenPort, () => {
+            this.server.listen(listenPort, '127.0.0.1', () => {
                 this.baseUrl = `http://localhost:${listenPort}`;
                 this.printBanner();
                 resolve();
@@ -552,7 +552,7 @@ let HttpServer = class HttpServer {
                             reject(error);
                         }
                     });
-                    this.server.listen(this.port, () => {
+                    this.server.listen(this.port, '127.0.0.1', () => {
                         resolve();
                     });
                 });