@playcraft/cli 0.1.51 → 0.1.53-beta

package/dist/workspace-runtime/server/endpoints.js

@@ -0,0 +1,21 @@
+import { chmod, rename, writeFile } from 'node:fs/promises';
+import { applySandboxEndpointPatch } from '@playcraft/common/cloud-workspace/runtime';
+import { wakeSourceEventUploader } from './source-uploader.js';
+/** Persist the new public entrance, then publish it to the running process. A restart is not required. */
+export async function applyRuntimeEndpointPatch(state, patch) {
+    const next = applySandboxEndpointPatch(state.config, patch);
+    const changed = next.publicBaseUrl !== state.config.publicBaseUrl;
+    const result = { changed, publicBaseUrl: next.publicBaseUrl };
+    if (!changed)
+        return result;
+    if (!state.configPath) {
+        throw new Error('endpoint_config_path_missing');
+    }
+    const temporary = `${state.configPath}.${process.pid}.tmp`;
+    await writeFile(temporary, `${JSON.stringify(next)}\n`, { mode: 0o600 });
+    await chmod(temporary, 0o600);
+    await rename(temporary, state.configPath);
+    state.config = next;
+    wakeSourceEventUploader(state);
+    return result;
+}

package/dist/workspace-runtime/server/execution-group.js

@@ -0,0 +1,90 @@
+import { wakeSourceEventUploader } from './source-uploader.js';
+function enqueue(state, action) {
+    const run = state.executionQueue.then(action, action);
+    state.executionQueue = run.then(() => undefined, () => undefined);
+    return run;
+}
+function processAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code !== 'ESRCH';
+    }
+}
+function requireRestartable(state) {
+    const native = state.native;
+    if (!native?.executionProcess || !native.replaceProcess) {
+        throw new Error('execution_group_unavailable');
+    }
+    return native;
+}
+async function demoteSessions(state) {
+    await state.journal.replaceSessions(state.journal.listSessions().map((session) => ({ ...session, recoverability: 'history_only' })));
+}
+async function advanceEpoch(state, input) {
+    const runtimeEpoch = state.runtimeEpoch + 1;
+    await state.journal.writeExecutionEpoch({
+        runtimeEpoch,
+        pid: input.pid,
+        startedAt: input.startedAt,
+        previousPid: input.previousPid,
+        previousRuntimeEpoch: state.runtimeEpoch,
+        stopConfirmed: input.stopConfirmed,
+    });
+    state.runtimeEpoch = runtimeEpoch;
+    wakeSourceEventUploader(state);
+    await demoteSessions(state);
+}
+export async function replaceExecutionGroup(state, options) {
+    return enqueue(state, async () => {
+        const native = requireRestartable(state);
+        const previous = native.executionProcess();
+        if (!previous)
+            throw new Error('execution_group_missing');
+        const next = await native.replaceProcess();
+        await advanceEpoch(state, {
+            pid: next.pid,
+            startedAt: next.startedAt,
+            previousPid: previous.pid,
+            stopConfirmed: false,
+        });
+        if (options.confirmStop)
+            await confirmStopped(state, previous.pid);
+        return {
+            runtimeEpoch: state.runtimeEpoch,
+            stopConfirmed: state.journal.executionGroup().stopConfirmed,
+            pid: next.pid,
+            previousPid: previous.pid,
+        };
+    });
+}
+export async function confirmExecutionGroupStopped(state, previousPid) {
+    return enqueue(state, () => confirmStopped(state, previousPid));
+}
+async function confirmStopped(state, previousPid) {
+    const group = state.journal.executionGroup();
+    if (!group.replaced || group.previousPid !== previousPid || processAlive(previousPid))
+        return false;
+    await state.journal.setExecutionStopConfirmed(true);
+    wakeSourceEventUploader(state);
+    return true;
+}
+export async function handleExecutionGroupCrash(state, exitedPid) {
+    return enqueue(state, async () => {
+        const group = state.journal.executionGroup();
+        if (group.pid !== exitedPid)
+            return;
+        const native = state.native;
+        if (!native?.replaceProcess)
+            return;
+        const next = await native.replaceProcess();
+        await advanceEpoch(state, {
+            pid: next.pid,
+            startedAt: next.startedAt,
+            previousPid: exitedPid,
+            stopConfirmed: true,
+        });
+    });
+}