@hagicode/hagiscript 0.1.10 → 0.1.11-dev.63.1.e96bae4

package/README.md

@@ -47,6 +47,7 @@ The packaged manifest currently manages:
 - `node` - managed Node.js runtime
 - `dotnet` - managed .NET and ASP.NET Core runtime
 - `npm-packages` - managed npm prefix, including `pm2`
+- `server` - released backend package metadata and PM2 launch assets for `lib/PCode.Web.dll`
 - `omniroute` - vendored bundled runtime
 - `code-server` - vendored bundled runtime
 
@@ -124,18 +125,23 @@ Lifecycle commands print the resolved manifest, managed root, changed component
 
 Hagiscript manages runtime-scoped PM2 services for:
 
+- `server`
 - `omniroute`
 - `code-server`
 
 Supported actions:
 
 - `start`
+- `restart`
 - `stop`
 - `status`
 
 Examples:
 
 ```bash
+hagiscript pm2 server start
+hagiscript pm2 server restart
+hagiscript pm2 server status
 hagiscript pm2 omniroute status
 hagiscript pm2 omniroute start
 hagiscript pm2 code-server stop
@@ -150,6 +156,28 @@ The PM2 flow is runtime-scoped:
 
 This means maintenance scripts should call `hagiscript pm2 ...` instead of a system `pm2` binary.
 
+### Released backend `server` contract
+
+The packaged runtime manifest treats `server` as a `released-service` component. The managed runtime expects a published backend package staged under:
+
+```text
+<runtime-root>/program/components/server/current/
+  lib/PCode.Web.dll
+  lib/PCode.Web.deps.json
+  lib/PCode.Web.runtimeconfig.json
+  start.sh (or the platform equivalent from the release package)
+```
+
+Hagiscript keeps mutable launch state for that service under:
+
+```text
+<runtime-root>/runtime-data/components/services/server/
+  .pm2/
+  pm2-runtime/
+```
+
+`hagiscript runtime install --components server` prepares the runtime-owned launch assets and reports whether the published payload is already staged. `hagiscript pm2 server start` then generates the final PM2 ecosystem/env files under `pm2-runtime/` and launches the released backend through the managed `dotnet` runtime.
+
 ## Runtime Environment Contract
 
 Runtime lifecycle scripts and managed services receive a stable environment contract:
@@ -226,6 +254,14 @@ npm run integration:runtime-management
 npm run integration:installed-runtime
 ```
 
+The runtime-management integration path also supports a release-oriented validation mode for CI:
+
+```bash
+HAGISCRIPT_ENABLE_RELEASED_SERVER_TEST=1 npm run integration:runtime-management
+```
+
+That mode downloads the latest public backend package from `https://github.com/HagiCode-org/releases/releases`, stages it into the managed runtime, and verifies `server` start/restart/stop/remove through HagiScript-managed PM2.
+
 ## License
 
 MIT. See [LICENSE](./LICENSE).

package/dist/commands/pm2-commands.js

@@ -30,10 +30,10 @@ function parseManagedPm2Service(value) {
     throw new InvalidArgumentError(`Unsupported managed PM2 service "${value}". Supported services: ${supportedPm2Services.join(", ")}.`);
 }
 function parseManagedPm2Action(value) {
-    if (value === "start" || value === "stop" || value === "status") {
+    if (value === "start" || value === "stop" || value === "restart" || value === "status") {
         return value;
     }
-    throw new InvalidArgumentError(`Unsupported PM2 action "${value}". Supported actions: start, stop, status.`);
+    throw new InvalidArgumentError(`Unsupported PM2 action "${value}". Supported actions: start, stop, restart, status.`);
 }
 function validatePathOption(value, optionName) {
     if (value === undefined) {

package/dist/commands/pm2-commands.js.map

@@ -1 +1 @@
-{"version":3,"file":"pm2-commands.js","sourceRoot":"","sources":["../../src/commands/pm2-commands.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,oBAAoB,EAAE,MAAM,WAAW,CAAA;AACzD,OAAO,EACL,0BAA0B,EAC1B,oBAAoB,EACpB,oBAAoB,EAGrB,MAAM,2BAA2B,CAAA;AAOlC,MAAM,UAAU,mBAAmB,CAAC,OAAgB;IAClD,OAAO;SACJ,OAAO,CAAC,KAAK,CAAC;SACd,WAAW,CAAC,6CAA6C,CAAC;SAC1D,QAAQ,CAAC,WAAW,EAAE,sBAAsB,EAAE,sBAAsB,CAAC;SACrE,QAAQ,CAAC,UAAU,EAAE,YAAY,EAAE,qBAAqB,CAAC;SACzD,MAAM,CAAC,wBAAwB,EAAE,uCAAuC,CAAC;SACzE,MAAM,CAAC,uBAAuB,EAAE,+BAA+B,CAAC;SAChE,MAAM,CACL,KAAK,EACH,OAA8B,EAC9B,MAAwB,EACxB,OAA0B,EAC1B,OAAgB,EAChB,EAAE;QACF,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,MAAM,oBAAoB,CAAC;gBACxC,YAAY,EAAE,kBAAkB,CAAC,OAAO,CAAC,YAAY,EAAE,iBAAiB,CAAC;gBACzE,WAAW,EAAE,kBAAkB,CAAC,OAAO,CAAC,WAAW,EAAE,gBAAgB,CAAC;gBACtE,OAAO;gBACP,MAAM;aACP,CAAC,CAAA;YAEF,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,0BAA0B,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;QACjE,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,KAAK,CAAC,cAAc,CAAC,KAAK,CAAC,EAAE,EAAE,QAAQ,EAAE,CAAC,EAAE,CAAC,CAAA;QACvD,CAAC;IACH,CAAC,CACF,CAAA;AACL,CAAC;AAED,SAAS,sBAAsB,CAAC,KAAa;IAC3C,IAAK,oBAA0C,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;QAChE,OAAO,KAA8B,CAAA;IACvC,CAAC;IAED,MAAM,IAAI,oBAAoB,CAC5B,oCAAoC,KAAK,0BAA0B,oBAAoB,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CACtG,CAAA;AACH,CAAC;AAED,SAAS,qBAAqB,CAAC,KAAa;IAC1C,IAAI,KAAK,KAAK,OAAO,IAAI,KAAK,KAAK,MAAM,IAAI,KAAK,KAAK,QAAQ,EAAE,CAAC;QAChE,OAAO,KAAK,CAAA;IACd,CAAC;IAED,MAAM,IAAI,oBAAoB,CAC5B,2BAA2B,KAAK,4CAA4C,CAC7E,CAAA;AACH,CAAC;AAED,SAAS,kBAAkB,CACzB,KAAyB,EACzB,UAAkB;IAElB,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QACxB,OAAO,SAAS,CAAA;IAClB,CAAC;IAED,MAAM,UAAU,GAAG,KAAK,CAAC,IAAI,EAAE,CAAA;IAC/B,IAAI,CAAC,UAAU,EAAE,CAAC;QAChB,MAAM,IAAI,oBAAoB,CAAC,GAAG,UAAU,4BAA4B,CAAC,CAAA;IAC3E,CAAC;IAED,IAAI,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;QAC9B,MAAM,IAAI,oBAAoB,CAAC,GAAG,UAAU,iCAAiC,CAAC,CAAA;IAChF,CAAC;IAED,OAAO,UAAU,CAAA;AACnB,CAAC;AAED,SAAS,cAAc,CAAC,KAAc;IACpC,OAAO,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA;AAC/D,CAAC"}
+{"version":3,"file":"pm2-commands.js","sourceRoot":"","sources":["../../src/commands/pm2-commands.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,oBAAoB,EAAE,MAAM,WAAW,CAAA;AACzD,OAAO,EACL,0BAA0B,EAC1B,oBAAoB,EACpB,oBAAoB,EAGrB,MAAM,2BAA2B,CAAA;AAOlC,MAAM,UAAU,mBAAmB,CAAC,OAAgB;IAClD,OAAO;SACJ,OAAO,CAAC,KAAK,CAAC;SACd,WAAW,CAAC,6CAA6C,CAAC;SAC1D,QAAQ,CAAC,WAAW,EAAE,sBAAsB,EAAE,sBAAsB,CAAC;SACrE,QAAQ,CAAC,UAAU,EAAE,YAAY,EAAE,qBAAqB,CAAC;SACzD,MAAM,CAAC,wBAAwB,EAAE,uCAAuC,CAAC;SACzE,MAAM,CAAC,uBAAuB,EAAE,+BAA+B,CAAC;SAChE,MAAM,CACL,KAAK,EACH,OAA8B,EAC9B,MAAwB,EACxB,OAA0B,EAC1B,OAAgB,EAChB,EAAE;QACF,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,MAAM,oBAAoB,CAAC;gBACxC,YAAY,EAAE,kBAAkB,CAAC,OAAO,CAAC,YAAY,EAAE,iBAAiB,CAAC;gBACzE,WAAW,EAAE,kBAAkB,CAAC,OAAO,CAAC,WAAW,EAAE,gBAAgB,CAAC;gBACtE,OAAO;gBACP,MAAM;aACP,CAAC,CAAA;YAEF,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,0BAA0B,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;QACjE,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,KAAK,CAAC,cAAc,CAAC,KAAK,CAAC,EAAE,EAAE,QAAQ,EAAE,CAAC,EAAE,CAAC,CAAA;QACvD,CAAC;IACH,CAAC,CACF,CAAA;AACL,CAAC;AAED,SAAS,sBAAsB,CAAC,KAAa;IAC3C,IAAK,oBAA0C,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;QAChE,OAAO,KAA8B,CAAA;IACvC,CAAC;IAED,MAAM,IAAI,oBAAoB,CAC5B,oCAAoC,KAAK,0BAA0B,oBAAoB,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CACtG,CAAA;AACH,CAAC;AAED,SAAS,qBAAqB,CAAC,KAAa;IAC1C,IAAI,KAAK,KAAK,OAAO,IAAI,KAAK,KAAK,MAAM,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,QAAQ,EAAE,CAAC;QACvF,OAAO,KAAK,CAAA;IACd,CAAC;IAED,MAAM,IAAI,oBAAoB,CAC5B,2BAA2B,KAAK,qDAAqD,CACtF,CAAA;AACH,CAAC;AAED,SAAS,kBAAkB,CACzB,KAAyB,EACzB,UAAkB;IAElB,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QACxB,OAAO,SAAS,CAAA;IAClB,CAAC;IAED,MAAM,UAAU,GAAG,KAAK,CAAC,IAAI,EAAE,CAAA;IAC/B,IAAI,CAAC,UAAU,EAAE,CAAC;QAChB,MAAM,IAAI,oBAAoB,CAAC,GAAG,UAAU,4BAA4B,CAAC,CAAA;IAC3E,CAAC;IAED,IAAI,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;QAC9B,MAAM,IAAI,oBAAoB,CAAC,GAAG,UAAU,iCAAiC,CAAC,CAAA;IAChF,CAAC;IAED,OAAO,UAAU,CAAA;AACnB,CAAC;AAED,SAAS,cAAc,CAAC,KAAc;IACpC,OAAO,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA;AAC/D,CAAC"}

package/dist/index.d.ts

@@ -9,7 +9,7 @@ export { getDefaultManagedNodeRuntimeDirectory, installNodeRuntime, resolveManag
 export { verifyNodeRuntime, type NodeRuntimeVerificationResult } from "./runtime/node-verify.js";
 export { createNpmSyncPlan, loadNpmSyncManifest, normalizeGlobalInventory, syncNpmGlobals, validateNpmSyncManifest, type InstalledGlobalPackages, type NpmSyncActionKind, type NpmSyncActionResult, type NpmSyncCommandKind, type NpmSyncFallbackEvent, type NpmSyncFallbackPolicy, type NpmSyncManifest, type NpmSyncManifestEntry, type NpmSyncPlannedAction, type NpmSyncRuntimeMetadata, type NpmSyncSummary } from "./runtime/npm-sync.js";
 export { buildToolSyncPackageSet, builtInToolSyncCatalog, normalizeToolSyncEntry, validateToolSyncCatalog, type CustomAgentCliToolInput, type ToolSyncCatalogEntry, type ToolSyncGroupId, type ToolSyncPackageConstraint, type ToolSyncRequirement, type ToolSyncSelection } from "./runtime/tool-sync-catalog.js";
-export { getDefaultRuntimeManifestPath, loadRuntimeManifest, type LoadedRuntimeManifest, type RuntimeComponentDefinition, type RuntimeLifecyclePhase, type RuntimeManifestPaths } from "./runtime/runtime-manifest.js";
+export { getDefaultRuntimeManifestPath, loadRuntimeManifest, type LoadedRuntimeManifest, type RuntimeComponentDefinition, type RuntimeLifecyclePhase, type RuntimeManifestPaths, type RuntimeReleasedServiceDefinition } from "./runtime/runtime-manifest.js";
 export { defaultRuntimeRoot, getComponentConfigDirectory, getComponentLogsDirectory, getComponentManagedRoot, getComponentPm2Home, getComponentRuntimeDataHome, resolveRuntimePaths, type ResolvedRuntimePaths } from "./runtime/runtime-paths.js";
 export { createInitialRuntimeState, mergeRuntimeState, readRuntimeState, writeRuntimeState, type RuntimeComponentState, type RuntimeOperationState, type RuntimeState } from "./runtime/runtime-state.js";
 export { renderManagedPm2StatusText, resolveManagedPm2ServiceDefinition, runManagedPm2Command, supportedPm2Services, type ManagedPm2Action, type ManagedPm2CommandResult, type ManagedPm2CommandOptions, type ManagedPm2ServiceName, type ManagedPm2Status, type ResolvedManagedPm2ServiceDefinition } from "./runtime/pm2-manager.js";

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAE3D,OAAO,EACL,kBAAkB,EAClB,WAAW,EACX,cAAc,EAEf,MAAM,cAAc,CAAC;AAQtB,MAAM,UAAU,iBAAiB;IAC/B,OAAO;QACL,WAAW;QACX,OAAO,EAAE,cAAc;QACvB,MAAM,EAAE,YAAY;KACrB,CAAC;AACJ,CAAC;AAED,OAAO,EACL,qCAAqC,EACrC,kBAAkB,EAClB,yBAAyB,EAG1B,MAAM,6BAA6B,CAAC;AACrC,OAAO,EACL,iBAAiB,EAElB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,iBAAiB,EACjB,mBAAmB,EACnB,wBAAwB,EACxB,cAAc,EACd,uBAAuB,EAYxB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,uBAAuB,EACvB,sBAAsB,EACtB,sBAAsB,EACtB,uBAAuB,EAOxB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EACL,6BAA6B,EAC7B,mBAAmB,EAKpB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EACL,kBAAkB,EAClB,2BAA2B,EAC3B,yBAAyB,EACzB,uBAAuB,EACvB,mBAAmB,EACnB,2BAA2B,EAC3B,mBAAmB,EAEpB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EACL,yBAAyB,EACzB,iBAAiB,EACjB,gBAAgB,EAChB,iBAAiB,EAIlB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EACL,0BAA0B,EAC1B,kCAAkC,EAClC,oBAAoB,EACpB,oBAAoB,EAOrB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,8BAA8B,EAC9B,yBAAyB,EACzB,4BAA4B,EAC5B,kBAAkB,EACnB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EACL,cAAc,EACd,oBAAoB,EACpB,iBAAiB,EACjB,aAAa,EACb,sBAAsB,EACtB,mBAAmB,EACnB,aAAa,EAKd,MAAM,8BAA8B,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAE3D,OAAO,EACL,kBAAkB,EAClB,WAAW,EACX,cAAc,EAEf,MAAM,cAAc,CAAC;AAQtB,MAAM,UAAU,iBAAiB;IAC/B,OAAO;QACL,WAAW;QACX,OAAO,EAAE,cAAc;QACvB,MAAM,EAAE,YAAY;KACrB,CAAC;AACJ,CAAC;AAED,OAAO,EACL,qCAAqC,EACrC,kBAAkB,EAClB,yBAAyB,EAG1B,MAAM,6BAA6B,CAAC;AACrC,OAAO,EACL,iBAAiB,EAElB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,iBAAiB,EACjB,mBAAmB,EACnB,wBAAwB,EACxB,cAAc,EACd,uBAAuB,EAYxB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,uBAAuB,EACvB,sBAAsB,EACtB,sBAAsB,EACtB,uBAAuB,EAOxB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EACL,6BAA6B,EAC7B,mBAAmB,EAMpB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EACL,kBAAkB,EAClB,2BAA2B,EAC3B,yBAAyB,EACzB,uBAAuB,EACvB,mBAAmB,EACnB,2BAA2B,EAC3B,mBAAmB,EAEpB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EACL,yBAAyB,EACzB,iBAAiB,EACjB,gBAAgB,EAChB,iBAAiB,EAIlB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EACL,0BAA0B,EAC1B,kCAAkC,EAClC,oBAAoB,EACpB,oBAAoB,EAOrB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,8BAA8B,EAC9B,yBAAyB,EACzB,4BAA4B,EAC5B,kBAAkB,EACnB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EACL,cAAc,EACd,oBAAoB,EACpB,iBAAiB,EACjB,aAAa,EACb,sBAAsB,EACtB,mBAAmB,EACnB,aAAa,EAKd,MAAM,8BAA8B,CAAC"}

package/dist/runtime/pm2-manager.d.ts

@@ -1,9 +1,9 @@
 import type { CommandRunner } from "./command-launch.js";
 import { type LoadedRuntimeManifest, type RuntimeComponentDefinition } from "./runtime-manifest.js";
 import { type ResolvedRuntimePaths } from "./runtime-paths.js";
-export declare const supportedPm2Services: readonly ["omniroute", "code-server"];
+export declare const supportedPm2Services: readonly ["server", "omniroute", "code-server"];
 export type ManagedPm2ServiceName = (typeof supportedPm2Services)[number];
-export type ManagedPm2Action = "start" | "stop" | "status";
+export type ManagedPm2Action = "start" | "stop" | "restart" | "status" | "delete";
 export type ManagedPm2Status = "online" | "stopped" | "errored" | "missing" | "unknown";
 export interface ManagedPm2CommandOptions {
     manifestPath?: string;
@@ -12,6 +12,7 @@ export interface ManagedPm2CommandOptions {
     action: ManagedPm2Action;
     runner?: CommandRunner;
 }
+type ManagedPm2LaunchStrategy = "node-script" | "released-service";
 export interface ResolvedManagedPm2ServiceDefinition {
     service: ManagedPm2ServiceName;
     component: RuntimeComponentDefinition;
@@ -29,6 +30,11 @@ export interface ResolvedManagedPm2ServiceDefinition {
     pm2Home: string;
     pm2Binary: string;
     nodePath: string;
+    launchStrategy: ManagedPm2LaunchStrategy;
+    dotnetPath?: string;
+    runtimeFilesDir?: string;
+    ecosystemPath?: string;
+    envFilePath?: string;
 }
 export interface ManagedPm2CommandResult {
     service: ManagedPm2ServiceName;
@@ -45,6 +51,9 @@ export interface ManagedPm2CommandResult {
     pid: number | null;
     stdout: string;
     stderr: string;
+    launchStrategy: ManagedPm2LaunchStrategy;
+    dotnetPath?: string;
+    runtimeFilesDir?: string;
 }
 export declare class ManagedPm2Error extends Error {
     constructor(message: string, options?: ErrorOptions);
@@ -52,3 +61,4 @@ export declare class ManagedPm2Error extends Error {
 export declare function runManagedPm2Command(options: ManagedPm2CommandOptions): Promise<ManagedPm2CommandResult>;
 export declare function resolveManagedPm2ServiceDefinition(manifest: LoadedRuntimeManifest, paths: ResolvedRuntimePaths, service: ManagedPm2ServiceName): Promise<ResolvedManagedPm2ServiceDefinition>;
 export declare function renderManagedPm2StatusText(result: ManagedPm2CommandResult): string;
+export {};

package/dist/runtime/pm2-manager.js

@@ -1,18 +1,20 @@
-import { access } from "node:fs/promises";
+import { access, mkdir, writeFile } from "node:fs/promises";
 import { basename, extname, join } from "node:path";
 import process from "node:process";
-import { runCommand } from "./command-launch.js";
-import { buildManagedRuntimeEnvironment, } from "./runtime-executor.js";
+import { CommandExecutionError, runCommand } from "./command-launch.js";
+import { buildManagedRuntimeEnvironment } from "./runtime-executor.js";
 import { getRuntimeExecutablePaths } from "./node-verify.js";
 import { loadRuntimeManifest } from "./runtime-manifest.js";
 import { getComponentConfigDirectory, getComponentManagedRoot, getComponentPm2Home, getComponentRuntimeDataHome, resolveManagedPath, resolveRuntimePaths } from "./runtime-paths.js";
-export const supportedPm2Services = ["omniroute", "code-server"];
+export const supportedPm2Services = ["server", "omniroute", "code-server"];
 export class ManagedPm2Error extends Error {
     constructor(message, options) {
         super(message, options);
         this.name = "ManagedPm2Error";
     }
 }
+const DEFAULT_PM2_STATUS_RETRY_DELAY_MS = 500;
+const DEFAULT_PM2_STATUS_MAX_RETRIES = 3;
 export async function runManagedPm2Command(options) {
     const manifest = await loadRuntimeManifest({ manifestPath: options.manifestPath });
     const paths = resolveRuntimePaths(manifest, { runtimeRoot: options.runtimeRoot });
@@ -20,11 +22,27 @@ export async function runManagedPm2Command(options) {
     const runner = options.runner ?? runCommand;
     switch (options.action) {
         case "start":
-            await runPm2(definition, buildPm2StartArgs(definition), runner);
+            if (definition.launchStrategy === "released-service") {
+                await prepareReleasedServicePm2Files(definition);
+            }
+            await executePm2(definition, buildPm2ActionArgs(definition, "start"), runner);
             return readManagedPm2Status(definition, "start", runner);
+        case "restart":
+            if (definition.launchStrategy === "released-service") {
+                await prepareReleasedServicePm2Files(definition);
+            }
+            await executePm2(definition, buildPm2ActionArgs(definition, "restart"), runner);
+            return readManagedPm2Status(definition, "restart", runner);
         case "stop":
-            await runPm2(definition, ["stop", definition.appName], runner);
+            await executePm2(definition, buildPm2ActionArgs(definition, "stop"), runner, {
+                allowMissingProcess: true
+            });
             return readManagedPm2Status(definition, "stop", runner);
+        case "delete":
+            await executePm2(definition, buildPm2ActionArgs(definition, "delete"), runner, {
+                allowMissingProcess: true
+            });
+            return readManagedPm2Status(definition, "delete", runner);
         case "status":
             return readManagedPm2Status(definition, "status", runner);
     }
@@ -39,16 +57,58 @@ export async function resolveManagedPm2ServiceDefinition(manifest, paths, servic
     const runtimeDataHome = getComponentRuntimeDataHome(paths, component.name, component.runtimeDataDir);
     const componentConfigDir = getComponentConfigDirectory(paths, component.name, component.runtimeDataDir);
     const pm2Home = getComponentPm2Home(paths, component.name, component.runtimeDataDir, component.pm2?.pm2Home);
-    const script = resolveManagedPath(component.pm2?.script ?? defaultPm2Script(component.name), componentRoot);
-    const cwd = resolveManagedPath(component.pm2?.cwd ?? ".", componentRoot);
     const nodePath = getRuntimeExecutablePaths(paths.nodeRuntime).nodePath;
     const pm2Entrypoint = getManagedPm2Entrypoint(paths.npmPrefix);
     await Promise.all([
-        validateManagedPath(script, `Managed launcher for ${service} is missing`),
-        validateManagedPath(cwd, `Managed working directory for ${service} is missing`),
         validateManagedPath(pm2Entrypoint, "Managed PM2 binary is missing. Install the runtime npm-packages component first."),
         validateManagedPath(nodePath, "Managed Node runtime is missing. Install the runtime node component first.")
     ]);
+    if (component.type === "released-service") {
+        const releasedService = component.releasedService;
+        if (!releasedService) {
+            throw new ManagedPm2Error(`Runtime manifest component ${component.name} is missing releasedService metadata.`);
+        }
+        const cwd = resolveManagedPath(releasedService.workingDirectory, componentRoot);
+        const script = resolveManagedPath(releasedService.dllPath, componentRoot);
+        const runtimeFilesDir = join(runtimeDataHome, releasedService.runtimeFilesDir ?? "pm2-runtime");
+        const ecosystemPath = join(runtimeFilesDir, "ecosystem.config.cjs");
+        const envFilePath = join(runtimeFilesDir, ".env");
+        const dotnetPath = join(paths.dotnetRuntime, "current", process.platform === "win32" ? "dotnet.exe" : "dotnet");
+        await Promise.all([
+            validateManagedPath(script, `Managed released-service payload for ${service} is missing.`),
+            validateManagedPath(cwd, `Managed working directory for ${service} is missing.`),
+            validateManagedPath(dotnetPath, "Managed .NET runtime is missing. Install the runtime dotnet component first.")
+        ]);
+        return {
+            service,
+            component,
+            manifestDir: manifest.manifestDir,
+            paths,
+            appName: component.pm2?.appName ?? `hagicode-${component.name}`,
+            cwd,
+            script,
+            args: component.pm2?.args ?? [],
+            env: component.pm2?.env ?? {},
+            runtimeHome: paths.runtimeHome,
+            runtimeDataHome,
+            componentRoot,
+            componentConfigDir,
+            pm2Home,
+            pm2Binary: pm2Entrypoint,
+            nodePath,
+            launchStrategy: "released-service",
+            dotnetPath,
+            runtimeFilesDir,
+            ecosystemPath,
+            envFilePath
+        };
+    }
+    const script = resolveManagedPath(component.pm2?.script ?? defaultPm2Script(component.name), componentRoot);
+    const cwd = resolveManagedPath(component.pm2?.cwd ?? ".", componentRoot);
+    await Promise.all([
+        validateManagedPath(script, `Managed launcher for ${service} is missing.`),
+        validateManagedPath(cwd, `Managed working directory for ${service} is missing.`)
+    ]);
     return {
         service,
         component,
@@ -65,7 +125,8 @@ export async function resolveManagedPm2ServiceDefinition(manifest, paths, servic
         componentConfigDir,
         pm2Home,
         pm2Binary: pm2Entrypoint,
-        nodePath
+        nodePath,
+        launchStrategy: "node-script"
     };
 }
 export function renderManagedPm2StatusText(result) {
@@ -74,12 +135,15 @@ export function renderManagedPm2StatusText(result) {
         `Action: ${result.action}`,
         `App: ${result.appName}`,
         `Status: ${result.status}`,
+        `Launch strategy: ${result.launchStrategy}`,
         `Runtime home: ${result.runtimeHome}`,
         `Runtime data home: ${result.runtimeDataHome}`,
         `PM2 home: ${result.pm2Home}`,
         `Script: ${result.script}`,
         `Working directory: ${result.cwd}`,
         `PM2 binary: ${result.pm2Binary}`,
+        ...(result.dotnetPath ? [`Dotnet: ${result.dotnetPath}`] : []),
+        ...(result.runtimeFilesDir ? [`Runtime files: ${result.runtimeFilesDir}`] : []),
         `PID: ${result.pid ?? "n/a"}`
     ].join("\n");
 }
@@ -90,26 +154,87 @@ function assertSupportedPm2Service(service) {
     throw new ManagedPm2Error(`Unsupported managed PM2 service "${service}". Supported services: ${supportedPm2Services.join(", ")}.`);
 }
 async function readManagedPm2Status(definition, action, runner) {
-    const result = await runPm2(definition, ["jlist"], runner);
-    const statusEntry = parsePm2Status(result, definition.appName);
-    return {
-        service: definition.service,
-        action,
-        appName: definition.appName,
-        cwd: definition.cwd,
-        script: definition.script,
-        runtimeHome: definition.runtimeHome,
-        runtimeDataHome: definition.runtimeDataHome,
+    let result;
+    let parsed;
+    for (let attempt = 0; attempt <= DEFAULT_PM2_STATUS_MAX_RETRIES; attempt += 1) {
+        result = await executePm2(definition, ["jlist"], runner);
+        parsed = parseManagedPm2Status(result, definition.appName);
+        if (parsed.kind === "status") {
+            return {
+                service: definition.service,
+                action,
+                appName: definition.appName,
+                cwd: definition.cwd,
+                script: definition.script,
+                runtimeHome: definition.runtimeHome,
+                runtimeDataHome: definition.runtimeDataHome,
+                pm2Home: definition.pm2Home,
+                pm2Binary: definition.pm2Binary,
+                exists: parsed.statusEntry !== null,
+                status: parsed.statusEntry?.status ?? "missing",
+                pid: parsed.statusEntry?.pid ?? null,
+                stdout: result.stdout,
+                stderr: result.stderr,
+                launchStrategy: definition.launchStrategy,
+                dotnetPath: definition.dotnetPath,
+                runtimeFilesDir: definition.runtimeFilesDir
+            };
+        }
+        if (parsed.kind === "failure") {
+            throw new ManagedPm2Error(parsed.message);
+        }
+        const retriesRemaining = DEFAULT_PM2_STATUS_MAX_RETRIES - attempt;
+        if (retriesRemaining <= 0) {
+            throw new ManagedPm2Error(`Managed PM2 status output could not be normalized after ${attempt + 1} attempt${attempt === 0 ? "" : "s"} during PM2 bootstrap. Last PM2 output: ${parsed.summary}`);
+        }
+        await sleep(DEFAULT_PM2_STATUS_RETRY_DELAY_MS);
+    }
+    throw new ManagedPm2Error(`Managed PM2 status output could not be normalized for ${definition.appName}.`);
+}
+async function executePm2(definition, args, runner, options = {}) {
+    const env = buildManagedRuntimeEnvironment({
+        component: definition.component,
+        manifest: { manifestDir: definition.manifestDir },
+        paths: definition.paths,
+        componentRoot: definition.componentRoot,
+        componentConfigDir: definition.componentConfigDir,
+        componentDataHome: definition.runtimeDataHome,
         pm2Home: definition.pm2Home,
-        pm2Binary: definition.pm2Binary,
-        exists: statusEntry !== null,
-        status: statusEntry?.status ?? "missing",
-        pid: statusEntry?.pid ?? null,
-        stdout: result.stdout,
-        stderr: result.stderr
-    };
+        scriptBasename: basename(definition.script)
+    }, { ...process.env, ...definition.env });
+    try {
+        return await runner(definition.nodePath, [definition.pm2Binary, ...args], {
+            cwd: definition.cwd,
+            env,
+            maxBuffer: 10 * 1024 * 1024
+        });
+    }
+    catch (error) {
+        if (options.allowMissingProcess &&
+            error instanceof CommandExecutionError &&
+            /not found|doesn't exist|process or namespace/i.test(`${error.context.stderr}\n${error.context.stdout}`)) {
+            return {
+                command: error.context.command,
+                args: error.context.args,
+                stdout: error.context.stdout,
+                stderr: error.context.stderr,
+                cwd: error.context.cwd,
+                exitCode: error.context.exitCode,
+                signal: error.context.signal,
+                timedOut: error.context.timedOut
+            };
+        }
+        throw new ManagedPm2Error(error instanceof Error ? error.message : String(error), error instanceof Error ? { cause: error } : undefined);
+    }
 }
-async function runPm2(definition, args, runner) {
+async function prepareReleasedServicePm2Files(definition) {
+    if (definition.launchStrategy !== "released-service" ||
+        !definition.runtimeFilesDir ||
+        !definition.ecosystemPath ||
+        !definition.envFilePath ||
+        !definition.dotnetPath) {
+        return;
+    }
     const env = buildManagedRuntimeEnvironment({
         component: definition.component,
         manifest: { manifestDir: definition.manifestDir },
@@ -120,25 +245,91 @@ async function runPm2(definition, args, runner) {
         pm2Home: definition.pm2Home,
         scriptBasename: basename(definition.script)
     }, { ...process.env, ...definition.env });
-    return runner(definition.nodePath, [definition.pm2Binary, ...args], {
-        cwd: definition.cwd,
-        env,
-        maxBuffer: 10 * 1024 * 1024
-    });
+    await mkdir(definition.runtimeFilesDir, { recursive: true });
+    await writeFile(definition.envFilePath, buildPm2EnvFile(env), "utf8");
+    await writeFile(definition.ecosystemPath, buildReleasedServiceEcosystemConfig(definition), "utf8");
 }
-function parsePm2Status(result, appName) {
-    const parsed = parsePm2ProcessList(result);
-    if (!Array.isArray(parsed)) {
-        throw new ManagedPm2Error(`Managed PM2 status returned an unexpected payload for ${appName}.`);
+function buildReleasedServiceEcosystemConfig(definition) {
+    if (!definition.dotnetPath || !definition.envFilePath) {
+        throw new ManagedPm2Error(`Released-service PM2 launch files are unavailable for ${definition.service}.`);
     }
-    const entry = parsed.find((value) => isPm2ProcessRecord(value) && value.name === appName);
-    if (!entry || !isPm2ProcessRecord(entry)) {
-        return null;
+    const args = [definition.script, ...definition.args];
+    return [
+        "module.exports = {",
+        "  apps: [",
+        "    {",
+        `      name: ${JSON.stringify(definition.appName)},`,
+        `      script: ${JSON.stringify(definition.dotnetPath)},`,
+        `      args: ${JSON.stringify(args)},`,
+        `      cwd: ${JSON.stringify(definition.cwd)},`,
+        '      interpreter: "none",',
+        '      exec_mode: "fork",',
+        "      autorestart: true,",
+        "      watch: false,",
+        `      env_file: ${JSON.stringify(definition.envFilePath)}`,
+        "    }",
+        "  ]",
+        "};",
+        ""
+    ].join("\n");
+}
+function buildPm2EnvFile(env) {
+    return (Object.entries(env)
+        .filter(([key, value]) => key.trim().length > 0 && value !== undefined)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, value]) => `${key}=${String(value).replace(/\r?\n/g, "\\n")}`)
+        .join("\n") + "\n");
+}
+function parseManagedPm2Status(result, appName) {
+    const trimmedStdout = result.stdout.trim();
+    const trimmedStderr = result.stderr.trim();
+    if (!trimmedStdout) {
+        if (!trimmedStderr) {
+            return {
+                kind: "status",
+                statusEntry: null
+            };
+        }
+        if (isRetryablePm2BootstrapOutput(result.stdout, result.stderr)) {
+            return {
+                kind: "bootstrap",
+                summary: summarizePm2Output(result)
+            };
+        }
+        return {
+            kind: "failure",
+            message: "Managed PM2 status output was empty on stdout and could not be normalized from stderr."
+        };
+    }
+    try {
+        const parsed = parsePm2ProcessList(result);
+        const entry = parsed.find((value) => isPm2ProcessRecord(value) && value.name === appName);
+        if (!entry || !isPm2ProcessRecord(entry)) {
+            return {
+                kind: "status",
+                statusEntry: null
+            };
+        }
+        return {
+            kind: "status",
+            statusEntry: {
+                status: normalizePm2Status(entry.pm2_env?.status),
+                pid: typeof entry.pid === "number" ? entry.pid : null
+            }
+        };
+    }
+    catch (error) {
+        if (isRetryablePm2BootstrapOutput(result.stdout, result.stderr)) {
+            return {
+                kind: "bootstrap",
+                summary: summarizePm2Output(result)
+            };
+        }
+        return {
+            kind: "failure",
+            message: `Managed PM2 status returned invalid JSON: ${error instanceof Error ? error.message : String(error)} (${summarizePm2Output(result)})`
+        };
     }
-    return {
-        status: normalizePm2Status(entry.pm2_env?.status),
-        pid: typeof entry.pid === "number" ? entry.pid : null
-    };
 }
 function parsePm2ProcessList(result) {
     const directCandidates = [result.stdout.trim(), `${result.stdout}\n${result.stderr}`.trim()].filter(Boolean);
@@ -152,7 +343,7 @@ function parsePm2ProcessList(result) {
             return extracted;
         }
     }
-    throw new ManagedPm2Error(`Managed PM2 status returned invalid JSON: ${summarizePm2Output(result)}`);
+    throw new Error("No JSON array payload was found in PM2 output.");
 }
 function extractPm2JsonArray(output) {
     for (let index = 0; index < output.length; index += 1) {
@@ -184,6 +375,20 @@ function summarizePm2Output(result) {
         .join(" | ")
         .slice(0, 400);
 }
+function isRetryablePm2BootstrapOutput(stdout, stderr) {
+    const combined = `${stdout}\n${stderr}`.toLowerCase();
+    return [
+        "[pm2] spawning",
+        "[pm2] launching",
+        "[pm2] starting",
+        "[pm2] pm2 successfully daemonized",
+        "spawning pm2 daemon",
+        "pm2 home",
+        "rpc socket",
+        "pub socket",
+        "daemon launched"
+    ].some((marker) => combined.includes(marker));
+}
 function normalizePm2Status(value) {
     switch (value) {
         case "online":
@@ -212,31 +417,55 @@ function defaultPm2Script(componentName) {
 function toPm2Args(args) {
     return args.length > 0 ? ["--", ...args] : [];
 }
-function buildPm2StartArgs(definition) {
-    if (isNodeLauncherScript(definition.script)) {
-        return [
-            "start",
-            definition.script,
-            "--name",
-            definition.appName,
-            "--cwd",
-            definition.cwd,
-            "--interpreter",
-            definition.nodePath,
-            "--update-env",
-            ...toPm2Args(definition.args)
-        ];
+function buildPm2ActionArgs(definition, action) {
+    if (definition.launchStrategy === "released-service") {
+        if (!definition.ecosystemPath) {
+            throw new ManagedPm2Error(`Released-service PM2 ecosystem file is unavailable for ${definition.service}.`);
+        }
+        switch (action) {
+            case "start":
+                return ["start", definition.ecosystemPath, "--only", definition.appName, "--update-env"];
+            case "restart":
+                return ["reload", definition.ecosystemPath, "--update-env"];
+            case "stop":
+                return ["stop", definition.appName];
+            case "delete":
+                return ["delete", definition.appName];
+        }
+    }
+    switch (action) {
+        case "start":
+            if (isNodeLauncherScript(definition.script)) {
+                return [
+                    "start",
+                    definition.script,
+                    "--name",
+                    definition.appName,
+                    "--cwd",
+                    definition.cwd,
+                    "--interpreter",
+                    definition.nodePath,
+                    "--update-env",
+                    ...toPm2Args(definition.args)
+                ];
+            }
+            return [
+                "start",
+                definition.script,
+                "--name",
+                definition.appName,
+                "--cwd",
+                definition.cwd,
+                "--update-env",
+                ...toPm2Args(definition.args)
+            ];
+        case "restart":
+            return ["restart", definition.appName, "--update-env"];
+        case "stop":
+            return ["stop", definition.appName];
+        case "delete":
+            return ["delete", definition.appName];
     }
-    return [
-        "start",
-        definition.script,
-        "--name",
-        definition.appName,
-        "--cwd",
-        definition.cwd,
-        "--update-env",
-        ...toPm2Args(definition.args)
-    ];
 }
 function isNodeLauncherScript(scriptPath) {
     const extension = extname(scriptPath).toLowerCase();
@@ -255,4 +484,7 @@ async function validateManagedPath(pathValue, message) {
         throw new ManagedPm2Error(message, error instanceof Error ? { cause: error } : undefined);
     }
 }
+async function sleep(ms) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+}
 //# sourceMappingURL=pm2-manager.js.map