poe-code 14.0.0 → 14.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "poe-code",
-  "version": "14.0.0",
+  "version": "14.0.1",
   "description": "CLI tool to configure Poe API for developer workflows.",
   "license": "MIT",
   "type": "module",

package/packages/process-launcher/dist/launcher.js

@@ -16,8 +16,11 @@ const TEMP_WRITE_MAX_ATTEMPTS = 3;
 export async function startManagedProcess(options) {
     assertOptionalFiniteDuration(options.startupTimeoutMs, "startup timeout");
     assertOptionalFiniteDuration(options.pollIntervalMs, "poll interval");
-    const fs = options.fs ?? defaultFs();
     const spec = normalizeSpec(options.spec);
+    return await withManagedProcessOperation({ ...options, id: spec.id }, async (fs) => await startReservedProcess({ ...options, fs, spec }));
+}
+async function startReservedProcess(options) {
+    const { fs, spec } = options;
     const existing = await readManagedProcess({
         baseDir: options.baseDir,
         fs,
@@ -60,7 +63,10 @@ export async function startManagedProcess(options) {
 export async function stopManagedProcess(options) {
     assertOptionalFiniteDuration(options.stopTimeoutMs, "stop timeout");
     assertOptionalFiniteDuration(options.pollIntervalMs, "poll interval");
-    const fs = options.fs ?? defaultFs();
+    return await withManagedProcessOperation(options, async (fs) => await stopReservedProcess({ ...options, fs }));
+}
+async function stopReservedProcess(options) {
+    const { fs } = options;
     const record = await readManagedProcess({
         baseDir: options.baseDir,
         fs,
@@ -106,37 +112,75 @@ export async function stopManagedProcess(options) {
     return stopped;
 }
 export async function restartManagedProcess(options) {
-    const fs = options.fs ?? defaultFs();
-    const record = await readManagedProcess({
-        baseDir: options.baseDir,
-        fs,
-        id: options.id,
-        isPidRunning: options.isPidRunning
+    assertOptionalFiniteDuration(options.startupTimeoutMs, "startup timeout");
+    assertOptionalFiniteDuration(options.stopTimeoutMs, "stop timeout");
+    assertOptionalFiniteDuration(options.pollIntervalMs, "poll interval");
+    return await withManagedProcessOperation(options, async (fs) => {
+        const record = await readManagedProcess({
+            baseDir: options.baseDir,
+            fs,
+            id: options.id,
+            isPidRunning: options.isPidRunning
+        });
+        if (record.spec === null) {
+            throw await managedProcessNotFound(fs, options.baseDir, options.id);
+        }
+        await stopReservedProcess({
+            ...options,
+            force: false,
+            fs
+        });
+        return await startReservedProcess({
+            ...options,
+            fs,
+            spec: normalizeSpec(record.spec)
+        });
     });
-    if (record.spec === null) {
-        throw await managedProcessNotFound(fs, options.baseDir, options.id);
+}
+async function withManagedProcessOperation(options, operation) {
+    const fs = options.fs ?? defaultFs();
+    await assertProcessDirectorySafe(fs, options.baseDir, options.id);
+    await fs.mkdir(options.baseDir, { recursive: true });
+    const baseDir = path.resolve(options.baseDir);
+    const operationsDir = path.join(path.dirname(baseDir), ".process-operations", path.basename(baseDir));
+    await assertPathHasNoSymbolicLinks(fs, operationsDir);
+    await fs.mkdir(operationsDir, { recursive: true });
+    const lockPath = path.join(operationsDir, options.id);
+    const owner = `${JSON.stringify({ token: randomUUID(), pid: process.pid })}\n`;
+    try {
+        await fs.writeFile(lockPath, owner, { encoding: "utf8", flag: "wx" });
     }
-    await stopManagedProcess({
-        baseDir: options.baseDir,
-        force: false,
-        fs,
-        id: options.id,
-        isPidRunning: options.isPidRunning,
-        pollIntervalMs: options.pollIntervalMs,
-        signalProcess: options.signalProcess,
-        stopRuntimeArtifacts: options.stopRuntimeArtifacts,
-        stopTimeoutMs: options.stopTimeoutMs
-    });
-    return await startManagedProcess({
-        baseDir: options.baseDir,
-        fs,
-        isPidRunning: options.isPidRunning,
-        pollIntervalMs: options.pollIntervalMs,
-        signalProcess: options.signalProcess,
-        spawnDaemon: options.spawnDaemon,
-        spec: record.spec,
-        startupTimeoutMs: options.startupTimeoutMs
-    });
+    catch (error) {
+        if (hasOwnErrorCode(error, "EEXIST")) {
+            throw new UserError(`Managed process "${options.id}" has another operation in progress.\n` +
+                "Retry after it finishes.\n" +
+                "If the caller exited unexpectedly, confirm that all operations on this name have stopped,\n" +
+                `then remove this reservation file:\n${lockPath}`);
+        }
+        throw error;
+    }
+    let outcome;
+    try {
+        outcome = { result: await operation(fs) };
+    }
+    catch (error) {
+        outcome = { error };
+    }
+    try {
+        if (await fs.readFile(lockPath, "utf8") !== owner) {
+            throw new UserError(`Managed process operation ownership changed before release: ${lockPath}`);
+        }
+        await fs.rm(lockPath);
+    }
+    catch (releaseError) {
+        if ("error" in outcome) {
+            throw new AggregateError([outcome.error, releaseError], "Managed process operation and ownership release failed");
+        }
+        throw releaseError;
+    }
+    if ("error" in outcome)
+        throw outcome.error;
+    return outcome.result;
 }
 async function describeStartFailure(fs, baseDir, id, record) {
     const state = record.state;
@@ -339,21 +383,22 @@ function getFileId(stat) {
         : null;
 }
 export async function removeManagedProcess(options) {
-    const fs = options.fs ?? defaultFs();
-    const record = await readManagedProcess({
-        baseDir: options.baseDir,
-        fs,
-        id: options.id,
-        isPidRunning: options.isPidRunning
+    await withManagedProcessOperation(options, async (fs) => {
+        const record = await readManagedProcess({
+            baseDir: options.baseDir,
+            fs,
+            id: options.id,
+            isPidRunning: options.isPidRunning
+        });
+        if (isActiveRecord(record)) {
+            throw new Error(`Managed process "${options.id}" must be stopped before removal.`);
+        }
+        const stateStore = createStateStore(options.baseDir, fs);
+        await stateStore.remove(options.id);
+        if (record.spec !== null && options.removeRuntimeArtifacts) {
+            await options.removeRuntimeArtifacts({ record });
+        }
     });
-    if (isActiveRecord(record)) {
-        throw new Error(`Managed process "${options.id}" must be stopped before removal.`);
-    }
-    const stateStore = createStateStore(options.baseDir, fs);
-    await stateStore.remove(options.id);
-    if (record.spec !== null && options.removeRuntimeArtifacts) {
-        await options.removeRuntimeArtifacts({ record });
-    }
 }
 export async function runManagedProcess(options) {
     if (options.signal?.aborted) {