@promptbook/cli 0.112.0-109 → 0.112.0-110

package/esm/src/cli/cli-commands/agents-server/buildAgentsServer.d.ts

@@ -34,6 +34,14 @@ export type AgentsServerBuildArtifacts = {
     readonly nodeModulesPath: string;
     readonly nextCliPath: string;
 };
+/**
+ * Runtime paths resolved for Agents Server commands before choosing build or dev execution.
+ *
+ * @private internal type of `ptbk agents-server`
+ */
+export type PreparedAgentsServerRuntime = AgentsServerBuildArtifacts & {
+    readonly isAppPathMaterialized: boolean;
+};
 /**
  * Input paths required to validate or update the cached Agents Server build.
  *
@@ -48,7 +56,15 @@ type AgentsServerBuildCacheOptions = {
  *
  * @private internal utility of `ptbk agents-server`
  */
-export declare function ensureAgentsServerBuild(options?: EnsureAgentsServerBuildOptions): Promise<AgentsServerBuildArtifacts>;
+export declare function ensureAgentsServerBuild(options?: EnsureAgentsServerBuildOptions): Promise<PreparedAgentsServerRuntime>;
+/**
+ * Resolves the runtime app and dependency paths shared by Agents Server start and dev commands.
+ *
+ * @private internal utility of `ptbk agents-server`
+ */
+export declare function prepareAgentsServerRuntime(options?: {
+    readonly appPath?: string;
+}): Promise<PreparedAgentsServerRuntime>;
 /**
  * Returns true when the production build marker and source fingerprint still match.
  *

package/esm/src/cli/cli-commands/agents-server/run.d.ts

@@ -6,6 +6,12 @@ import type { $side_effect } from '../../../utils/organization/$side_effect';
  * @private internal function of `promptbookCli`
  */
 export declare function $initializeAgentsServerStartCommand(program: Program): $side_effect;
+/**
+ * Initializes `agents-server dev` command for Promptbook CLI utilities.
+ *
+ * @private internal function of `promptbookCli`
+ */
+export declare function $initializeAgentsServerDevCommand(program: Program): $side_effect;
 /**
  * Initializes `agents-server build` command for Promptbook CLI utilities.
  *

package/esm/src/cli/cli-commands/agents-server/startAgentsServer.d.ts

@@ -1,6 +1,12 @@
 import type { ThinkingLevel } from '../coder/ThinkingLevel';
 import type { PromptRunnerAgentName } from '../common/promptRunnerCliOptions';
 import type { number_port } from '../../../types/number_positive';
+/**
+ * Next runtime mode supported by the local Agents Server foreground launcher.
+ *
+ * @private internal type of `ptbk agents-server`
+ */
+export type AgentsServerNextRuntimeMode = 'start' | 'dev';
 /**
  * Options required to start the foreground Agents Server service group.
  *
@@ -13,6 +19,7 @@ export type StartAgentsServerOptions = {
     readonly noUi: boolean;
     readonly thinkingLevel?: ThinkingLevel;
     readonly allowCredits: boolean;
+    readonly nextRuntimeMode: AgentsServerNextRuntimeMode;
     readonly isBuildForced: boolean;
 };
 /**

package/esm/src/version.d.ts

@@ -15,7 +15,7 @@ export declare const BOOK_LANGUAGE_VERSION: string_semantic_version;
 export declare const PROMPTBOOK_ENGINE_VERSION: string_promptbook_version;
 /**
  * Represents the version string of the Promptbook engine.
- * It follows semantic versioning (e.g., `0.112.0-108`).
+ * It follows semantic versioning (e.g., `0.112.0-109`).
  *
  * @generated
  */

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@promptbook/cli",
-    "version": "0.112.0-109",
+    "version": "0.112.0-110",
     "description": "Promptbook: Create persistent AI agents that turn your company's scattered knowledge into action",
     "private": false,
     "sideEffects": false,

package/src/book-components/Chat/Chat/Chat.module.css

@@ -432,6 +432,11 @@
     min-width: 0;
     min-height: 0;
     z-index: 300;
+    pointer-events: none;
+}
+
+.chatMainFlow .chatChildren > * {
+    pointer-events: auto;
 }
 
 /* Chat messages area */

package/src/cli/cli-commands/agents-server/buildAgentsServer.ts

@@ -176,6 +176,15 @@ export type AgentsServerBuildArtifacts = {
     readonly nextCliPath: string;
 };
 
+/**
+ * Runtime paths resolved for Agents Server commands before choosing build or dev execution.
+ *
+ * @private internal type of `ptbk agents-server`
+ */
+export type PreparedAgentsServerRuntime = AgentsServerBuildArtifacts & {
+    readonly isAppPathMaterialized: boolean;
+};
+
 /**
  * Input paths required to validate or update the cached Agents Server build.
  *
@@ -193,39 +202,64 @@ type AgentsServerBuildCacheOptions = {
  */
 export async function ensureAgentsServerBuild(
     options: EnsureAgentsServerBuildOptions = {},
-): Promise<AgentsServerBuildArtifacts> {
+): Promise<PreparedAgentsServerRuntime> {
     const environment = options.environment ?? process.env;
-    const nextCliPath = resolveNextCliPath();
-    const nodeModulesPath = resolveNodeModulesPath(nextCliPath);
-    const appPath = await resolveAgentsServerBuildAppPath({
-        sourceAppPath: options.appPath ?? (await resolveAgentsServerAppPath()),
-        nodeModulesPath,
+    const preparedRuntime = await prepareAgentsServerRuntime({
+        appPath: options.appPath,
     });
-    const buildEnvironment = createAgentsServerRuntimeEnvironment(environment, nodeModulesPath, {
-        isNextValidationIgnored: isAgentsServerAppPathMaterialized(appPath),
+    const buildEnvironment = createAgentsServerRuntimeEnvironment(environment, preparedRuntime.nodeModulesPath, {
+        isNextValidationIgnored: preparedRuntime.isAppPathMaterialized,
     });
 
     if (
         !options.isBuildForced &&
         (await isAgentsServerBuildCacheCurrent({
-            appPath,
+            appPath: preparedRuntime.appPath,
             environment: buildEnvironment,
         }))
     ) {
         options.onBuildEvent?.('Using the cached Agents Server Next app build.');
-        return { appPath, nextCliPath, nodeModulesPath };
+        return preparedRuntime;
     }
 
     options.onBuildEvent?.('Building the Agents Server Next app.');
     await runNextBuild({
-        appPath,
+        appPath: preparedRuntime.appPath,
         environment: buildEnvironment,
-        nextCliPath,
+        nextCliPath: preparedRuntime.nextCliPath,
         onBuildOutput: options.onBuildOutput,
     });
-    await writeAgentsServerBuildCache({ appPath, environment: buildEnvironment });
+    await writeAgentsServerBuildCache({
+        appPath: preparedRuntime.appPath,
+        environment: buildEnvironment,
+    });
+
+    return preparedRuntime;
+}
 
-    return { appPath, nextCliPath, nodeModulesPath };
+/**
+ * Resolves the runtime app and dependency paths shared by Agents Server start and dev commands.
+ *
+ * @private internal utility of `ptbk agents-server`
+ */
+export async function prepareAgentsServerRuntime(
+    options: {
+        readonly appPath?: string;
+    } = {},
+): Promise<PreparedAgentsServerRuntime> {
+    const nextCliPath = resolveNextCliPath();
+    const nodeModulesPath = resolveNodeModulesPath(nextCliPath);
+    const appPath = await resolveAgentsServerBuildAppPath({
+        sourceAppPath: options.appPath ?? (await resolveAgentsServerAppPath()),
+        nodeModulesPath,
+    });
+
+    return {
+        appPath,
+        nextCliPath,
+        nodeModulesPath,
+        isAppPathMaterialized: isAgentsServerAppPathMaterialized(appPath),
+    };
 }
 
 /**

package/src/cli/cli-commands/agents-server/run.ts

@@ -17,23 +17,39 @@ import {
     PROMPT_RUNNER_DESCRIPTION,
 } from '../common/promptRunnerCliOptions';
 import { ensureAgentsServerBuild } from './buildAgentsServer';
-import { loadAgentsServerProjectEnvironment, startAgentsServer } from './startAgentsServer';
+import {
+    loadAgentsServerProjectEnvironment,
+    startAgentsServer,
+    type AgentsServerNextRuntimeMode,
+} from './startAgentsServer';
 
 /**
- * Default port used by `ptbk agents-server start`.
+ * Default port used by `ptbk agents-server start` and `ptbk agents-server dev`.
  *
  * @private internal constant of `ptbk agents-server`
  */
 const DEFAULT_AGENTS_SERVER_PORT = '4440';
 
 /**
- * CLI options accepted by `ptbk agents-server start`.
+ * CLI options accepted by `ptbk agents-server start` and `ptbk agents-server dev`.
  *
  * @private internal type of `ptbk agents-server`
  */
-type AgentsServerStartCliOptions = PromptRunnerSelectionCliOptions & {
+type AgentsServerRuntimeCliOptions = PromptRunnerSelectionCliOptions & {
     readonly port: string;
-    readonly forceBuild: boolean;
+    readonly forceBuild?: boolean;
+};
+
+/**
+ * Shared command definition for one Agents Server runtime subcommand.
+ *
+ * @private internal type of `ptbk agents-server`
+ */
+type AgentsServerRuntimeCommandDefinition = {
+    readonly commandName: 'start' | 'dev';
+    readonly description: string;
+    readonly nextRuntimeMode: AgentsServerNextRuntimeMode;
+    readonly isForceBuildSupported: boolean;
 };
 
 /**
@@ -42,19 +58,59 @@ type AgentsServerStartCliOptions = PromptRunnerSelectionCliOptions & {
  * @private internal function of `promptbookCli`
  */
 export function $initializeAgentsServerStartCommand(program: Program): $side_effect {
-    const command = program.command('start');
-    command.description(
-        spaceTrim(`
-            Start the Agents Server web app and the local coding-agent message runners
+    initializeAgentsServerRuntimeCommand(program, {
+        commandName: 'start',
+        description: createAgentsServerRuntimeCommandDescription(
+            'Start the Agents Server web app and the local coding-agent message runners',
+        ),
+        nextRuntimeMode: 'start',
+        isForceBuildSupported: true,
+    });
+}
 
-            ${PROMPT_RUNNER_DESCRIPTION}
+/**
+ * Initializes `agents-server dev` command for Promptbook CLI utilities.
+ *
+ * @private internal function of `promptbookCli`
+ */
+export function $initializeAgentsServerDevCommand(program: Program): $side_effect {
+    initializeAgentsServerRuntimeCommand(program, {
+        commandName: 'dev',
+        description: createAgentsServerRuntimeCommandDescription(
+            'Start the Agents Server web app in development mode with hot reloading and the local coding-agent message runners',
+        ),
+        nextRuntimeMode: 'dev',
+        isForceBuildSupported: false,
+    });
+}
 
-            The current working directory stores:
-            - Agent runner folders in \`.promptbook/agents-server/agents\`
-            - Foreground service logs in \`.logs\`
-        `),
+/**
+ * Initializes `agents-server build` command for Promptbook CLI utilities.
+ *
+ * @private internal function of `promptbookCli`
+ */
+export function $initializeAgentsServerBuildCommand(program: Program): $side_effect {
+    const command = program.command('build');
+    command.description('Build the Agents Server Next app for later local startup');
+    command.action(
+        handleActionErrors(async () => {
+            console.info(colors.gray('Building Promptbook Agents Server.'));
+            loadAgentsServerProjectEnvironment(process.cwd());
+            await ensureAgentsServerBuild({ isBuildForced: true });
+        }),
     );
+}
 
+/**
+ * Registers one shared Agents Server runtime command backed by either `next start` or `next dev`.
+ */
+function initializeAgentsServerRuntimeCommand(
+    program: Program,
+    definition: AgentsServerRuntimeCommandDefinition,
+): $side_effect {
+    const command = program.command(definition.commandName);
+
+    command.description(definition.description);
     addPromptRunnerSelectionOptions(command);
     addPromptRunnerRuntimeOptions(command);
     command.addOption(
@@ -62,18 +118,21 @@ export function $initializeAgentsServerStartCommand(program: Program): $side_eff
             .env('PORT')
             .default(DEFAULT_AGENTS_SERVER_PORT),
     );
-    command.option('--force-build', 'Rebuild the Agents Server Next app before startup', false);
+
+    if (definition.isForceBuildSupported) {
+        command.option('--force-build', 'Rebuild the Agents Server Next app before startup', false);
+    }
 
     command.action(
         handleActionErrors(
             async (cliOptions) => {
-                const options = cliOptions as AgentsServerStartCliOptions;
+                const options = cliOptions as AgentsServerRuntimeCliOptions;
                 const port = parseAgentsServerPort(options.port);
                 const runnerOptions = normalizePromptRunnerSelectionCliOptions(options, {
                     isAgentRequired: true,
                 });
 
-                console.info(colors.gray(`Starting Promptbook Agents Server on port ${port}.`));
+                console.info(colors.gray(createAgentsServerRuntimeStartupMessage(port, definition.nextRuntimeMode)));
                 await startAgentsServer({
                     port,
                     agentName: runnerOptions.agentName!,
@@ -81,7 +140,8 @@ export function $initializeAgentsServerStartCommand(program: Program): $side_eff
                     noUi: runnerOptions.noUi,
                     thinkingLevel: runnerOptions.thinkingLevel,
                     allowCredits: runnerOptions.allowCredits,
-                    isBuildForced: options.forceBuild,
+                    nextRuntimeMode: definition.nextRuntimeMode,
+                    isBuildForced: definition.isForceBuildSupported && options.forceBuild === true,
                 });
             },
             {
@@ -92,20 +152,32 @@ export function $initializeAgentsServerStartCommand(program: Program): $side_eff
 }
 
 /**
- * Initializes `agents-server build` command for Promptbook CLI utilities.
- *
- * @private internal function of `promptbookCli`
+ * Creates the shared help description for Agents Server runtime commands.
  */
-export function $initializeAgentsServerBuildCommand(program: Program): $side_effect {
-    const command = program.command('build');
-    command.description('Build the Agents Server Next app for later local startup');
-    command.action(
-        handleActionErrors(async () => {
-            console.info(colors.gray('Building Promptbook Agents Server.'));
-            loadAgentsServerProjectEnvironment(process.cwd());
-            await ensureAgentsServerBuild({ isBuildForced: true });
-        }),
-    );
+function createAgentsServerRuntimeCommandDescription(summary: string): string {
+    return spaceTrim(`
+        ${summary}
+
+        ${PROMPT_RUNNER_DESCRIPTION}
+
+        The current working directory stores:
+        - Agent runner folders in \`.promptbook/agents-server/agents\`
+        - Foreground service logs in \`.logs\`
+    `);
+}
+
+/**
+ * Creates the startup log line for one Agents Server runtime mode.
+ */
+function createAgentsServerRuntimeStartupMessage(
+    port: number_port,
+    nextRuntimeMode: AgentsServerNextRuntimeMode,
+): string {
+    if (nextRuntimeMode === 'dev') {
+        return `Starting Promptbook Agents Server on port ${port} in development mode.`;
+    }
+
+    return `Starting Promptbook Agents Server on port ${port}.`;
 }
 
 /**

package/src/cli/cli-commands/agents-server/startAgentsServer.ts

@@ -17,6 +17,8 @@ import type { CoderRunUiHandle } from '../../../../scripts/run-codex-prompts/ui/
 import {
     createAgentsServerRuntimeEnvironment,
     ensureAgentsServerBuild,
+    prepareAgentsServerRuntime,
+    type PreparedAgentsServerRuntime,
     resolveAgentsServerAppPath,
 } from './buildAgentsServer';
 import { DEFAULT_LOCAL_AGENT_RUNNER_MAX_FAILED_ATTEMPTS } from '../../../../apps/agents-server/src/constants/serverLimits';
@@ -112,6 +114,13 @@ const PTBK_HOSTNAME_ENV = 'PTBK_HOSTNAME';
  */
 const LOCAL_USER_CHAT_WORKER_TOKEN_BYTE_LENGTH = 32;
 
+/**
+ * Next runtime mode supported by the local Agents Server foreground launcher.
+ *
+ * @private internal type of `ptbk agents-server`
+ */
+export type AgentsServerNextRuntimeMode = 'start' | 'dev';
+
 /**
  * Options required to start the foreground Agents Server service group.
  *
@@ -124,6 +133,7 @@ export type StartAgentsServerOptions = {
     readonly noUi: boolean;
     readonly thinkingLevel?: ThinkingLevel;
     readonly allowCredits: boolean;
+    readonly nextRuntimeMode: AgentsServerNextRuntimeMode;
     readonly isBuildForced: boolean;
 };
 
@@ -178,6 +188,17 @@ type AgentsServerSupervisorState = {
     };
 };
 
+/**
+ * Prepared Next runtime and child environment used by one foreground launch.
+ *
+ * @private internal type of `ptbk agents-server`
+ */
+type PreparedAgentsServerLaunch = {
+    readonly runtimeArtifacts: PreparedAgentsServerRuntime;
+    readonly runtimeChildEnvironment: AgentsServerChildEnvironment;
+    readonly runtimePaths: AgentsServerRuntimePaths;
+};
+
 /**
  * Local runner limits loaded from the running Agents Server app.
  *
@@ -216,52 +237,31 @@ export async function startAgentsServer(options: StartAgentsServerOptions): Prom
     process.once('exit', processExitHandler);
 
     try {
-        const buildArtifacts = await ensureAgentsServerBuild({
-            appPath: runtimePaths.appPath,
-            environment: childEnvironment,
-            isBuildForced: options.isBuildForced,
-            onBuildEvent: (event) => {
-                logRunnerEvent(logStreams.runner, event);
-                forwardChildOutput(`${event}\n`, {
-                    label: 'next-build',
-                    logStream: logStreams.next,
-                    state,
-                });
-            },
-            onBuildOutput: (chunk) => {
-                forwardChildOutput(chunk, {
-                    label: 'next-build',
-                    logStream: logStreams.next,
-                    state,
-                });
-            },
-        });
-        const runtimeChildEnvironment = createAgentsServerRuntimeEnvironment(
+        const preparedLaunch = await prepareAgentsServerLaunch({
             childEnvironment,
-            buildArtifacts.nodeModulesPath,
-        ) as AgentsServerChildEnvironment;
-        const builtRuntimePaths: AgentsServerRuntimePaths = {
-            ...runtimePaths,
-            appPath: buildArtifacts.appPath,
-        };
+            logStreams,
+            options,
+            runtimePaths,
+            state,
+        });
 
         nextServerProcess = startNextServer({
-            nextCliPath: buildArtifacts.nextCliPath,
+            nextCliPath: preparedLaunch.runtimeArtifacts.nextCliPath,
             options,
-            runtimePaths: builtRuntimePaths,
-            childEnvironment: runtimeChildEnvironment,
+            runtimePaths: preparedLaunch.runtimePaths,
+            childEnvironment: preparedLaunch.runtimeChildEnvironment,
             logStreams,
             state,
         });
         const localAgentRunnerLimits = await waitForLocalAgentRunnerLimits({
             port: options.port,
-            environment: runtimeChildEnvironment,
+            environment: preparedLaunch.runtimeChildEnvironment,
             logStreams,
             state,
         });
         stopUserChatJobWorkerPump = startUserChatJobWorkerPump({
             port: options.port,
-            environment: runtimeChildEnvironment,
+            environment: preparedLaunch.runtimeChildEnvironment,
             logStreams,
             state,
         });
@@ -290,6 +290,70 @@ export async function startAgentsServer(options: StartAgentsServerOptions): Prom
     }
 }
 
+/**
+ * Prepares the shared Next runtime for either production start or hot-reloading development mode.
+ */
+async function prepareAgentsServerLaunch(options: {
+    readonly childEnvironment: AgentsServerChildEnvironment;
+    readonly logStreams: AgentsServerLogStreams;
+    readonly options: StartAgentsServerOptions;
+    readonly runtimePaths: AgentsServerRuntimePaths;
+    readonly state: AgentsServerSupervisorState;
+}): Promise<PreparedAgentsServerLaunch> {
+    const runtimeArtifacts =
+        options.options.nextRuntimeMode === 'start'
+            ? await ensureAgentsServerBuild({
+                  appPath: options.runtimePaths.appPath,
+                  environment: options.childEnvironment,
+                  isBuildForced: options.options.isBuildForced,
+                  onBuildEvent: (event) => {
+                      logRunnerEvent(options.logStreams.runner, event);
+                      forwardChildOutput(`${event}\n`, {
+                          label: 'next-build',
+                          logStream: options.logStreams.next,
+                          state: options.state,
+                      });
+                  },
+                  onBuildOutput: (chunk) => {
+                      forwardChildOutput(chunk, {
+                          label: 'next-build',
+                          logStream: options.logStreams.next,
+                          state: options.state,
+                      });
+                  },
+              })
+            : await prepareAgentsServerDevelopmentRuntime(options.runtimePaths.appPath, options.logStreams.runner);
+
+    return {
+        runtimeArtifacts,
+        runtimeChildEnvironment: createAgentsServerRuntimeEnvironment(
+            options.childEnvironment,
+            runtimeArtifacts.nodeModulesPath,
+            {
+                isNextValidationIgnored: runtimeArtifacts.isAppPathMaterialized,
+            },
+        ) as AgentsServerChildEnvironment,
+        runtimePaths: {
+            ...options.runtimePaths,
+            appPath: runtimeArtifacts.appPath,
+        },
+    };
+}
+
+/**
+ * Resolves the hot-reloading Next runtime without running the production build step.
+ */
+async function prepareAgentsServerDevelopmentRuntime(
+    appPath: string,
+    runnerLogStream: WriteStream,
+): Promise<PreparedAgentsServerRuntime> {
+    logRunnerEvent(runnerLogStream, 'Preparing the Agents Server Next development runtime.');
+
+    return prepareAgentsServerRuntime({
+        appPath,
+    });
+}
+
 /**
  * Loads launch-directory `.env` values without overriding explicit process environment.
  *
@@ -318,7 +382,7 @@ async function resolveAgentsServerRuntimePaths(): Promise<AgentsServerRuntimePat
 }
 
 /**
- * Starts the production Next server and wires its logs into the foreground dashboard.
+ * Starts the configured Next server mode and wires its logs into the foreground dashboard.
  */
 function startNextServer(options: {
     readonly nextCliPath: string;
@@ -328,8 +392,13 @@ function startNextServer(options: {
     readonly logStreams: AgentsServerLogStreams;
     readonly state: AgentsServerSupervisorState;
 }): ChildProcess {
-    logRunnerEvent(options.logStreams.runner, 'Starting the Agents Server Next process.');
-    const nextArguments = [options.nextCliPath, 'start', '--port', String(options.options.port)];
+    const nextRuntimeModeLabel = describeAgentsServerNextRuntimeMode(options.options.nextRuntimeMode);
+
+    logRunnerEvent(
+        options.logStreams.runner,
+        `Starting the Agents Server Next process in ${nextRuntimeModeLabel} mode.`,
+    );
+    const nextArguments = [options.nextCliPath, options.options.nextRuntimeMode, '--port', String(options.options.port)];
     const hostname = options.childEnvironment[PTBK_HOSTNAME_ENV]?.trim();
 
     if (hostname) {
@@ -367,6 +436,13 @@ function startNextServer(options: {
     return commandProcess;
 }
 
+/**
+ * Converts one Next runtime mode into a readable label for logs.
+ */
+function describeAgentsServerNextRuntimeMode(nextRuntimeMode: AgentsServerNextRuntimeMode): string {
+    return nextRuntimeMode === 'dev' ? 'development' : 'production';
+}
+
 /**
  * Connects child stdout/stderr to the persisted Next log and visible terminal output.
  */

package/src/cli/cli-commands/agents-server.ts

@@ -5,7 +5,11 @@ import type {
 import { spaceTrim } from 'spacetrim';
 import type { $side_effect } from '../../utils/organization/$side_effect';
 import { $initializeAgentsServerInitCommand } from './agents-server/init';
-import { $initializeAgentsServerBuildCommand, $initializeAgentsServerStartCommand } from './agents-server/run';
+import {
+    $initializeAgentsServerBuildCommand,
+    $initializeAgentsServerDevCommand,
+    $initializeAgentsServerStartCommand,
+} from './agents-server/run';
 
 /**
  * Initializes `agents-server` command with subcommands for Promptbook CLI utilities.
@@ -20,12 +24,14 @@ export function $initializeAgentsServerCommand(program: Program): $side_effect {
 
             Subcommands:
             - build: Build the web server for later local startup
+            - dev: Start the web server in development mode with hot reloading
             - init: Initialize local web server configuration
             - start: Start the web server and local coding-agent message runners
         `),
     );
 
     $initializeAgentsServerBuildCommand(agentsServerCommand);
+    $initializeAgentsServerDevCommand(agentsServerCommand);
     $initializeAgentsServerInitCommand(agentsServerCommand);
     $initializeAgentsServerStartCommand(agentsServerCommand);