@cargo-ai/cdk 1.0.6 → 1.0.8

package/build/src/deploy/executors.live.js

@@ -27,6 +27,161 @@ async function waitForDeployment(api, uuid, attemptsLeft = 150) {
     await sleep(2000);
     return waitForDeployment(api, uuid, attemptsLeft - 1);
 }
+// Upsert the play row (create or update), returning its uuid + backing workflow
+// uuid. Builds the create/update payload internally (used only here).
+async function upsertPlay(api, spec, prior) {
+    // Play has no slug — identity is purely the prior state uuid.
+    const base = {
+        name: str(spec["name"]),
+        description: optStr(spec["description"]),
+        modelUuid: str(spec["modelUuid"]),
+        changeKinds: spec["changeKinds"],
+        runCreationRule: spec["runCreationRule"],
+        filter: spec["filter"],
+        sort: spec["sort"],
+        limit: spec["limit"],
+        trackingColumnSlugs: spec["trackingColumnSlugs"],
+        schedule: spec["schedule"],
+        folderUuid: optStr(spec["folderUuid"]),
+    };
+    if (prior !== undefined) {
+        // play.update rejects modelUuid (a play's model is fixed at
+        // creation) — strip it from the update payload.
+        const { modelUuid: _modelUuid, ...updateBase } = base;
+        await api.orchestration.play.update({
+            uuid: prior.uuid,
+            ...updateBase,
+        });
+        return {
+            uuid: prior.uuid,
+            workflowUuid: prior.outputs["workflowUuid"],
+        };
+    }
+    const created = await api.orchestration.play.create(base);
+    return {
+        uuid: created.play.uuid,
+        workflowUuid: created.play.workflowUuid,
+    };
+}
+// Ensure the agent row exists (create or update) and return its uuid. The
+// config release (full desired state) is deployed separately by the caller.
+async function ensureAgentRow(api, spec, prior) {
+    const description = optStr(spec["description"]);
+    if (prior !== undefined) {
+        await api.ai.agent.update({
+            uuid: prior.uuid,
+            name: str(spec["name"]),
+            icon: spec["icon"],
+            description: description === undefined ? null : description,
+            triggers: mapAgentTriggers(spec["triggers"]),
+        });
+        return prior.uuid;
+    }
+    const created = await api.ai.agent.create({
+        name: str(spec["name"]),
+        icon: spec["icon"],
+        description,
+        triggers: mapAgentTriggers(spec["triggers"]),
+        folderUuid: optStr(spec["folderUuid"]),
+    });
+    return created.agent.uuid;
+}
+// Upsert the tool row (create or update), returning its uuid + backing workflow
+// uuid. Builds the create/update payload internally (used only here).
+async function upsertTool(api, spec, prior) {
+    const triggers = mapToolTriggers(spec["triggers"]);
+    const publicForm = spec["publicForm"];
+    const description = optStr(spec["description"]);
+    if (prior !== undefined) {
+        await api.orchestration.tool.update({
+            uuid: prior.uuid,
+            name: str(spec["name"]),
+            icon: spec["icon"],
+            description: description === undefined ? null : description,
+            triggers,
+            publicForm,
+        });
+        return {
+            toolUuid: prior.uuid,
+            workflowUuid: prior.outputs["workflowUuid"],
+        };
+    }
+    const created = await api.orchestration.tool.create({
+        name: str(spec["name"]),
+        icon: spec["icon"],
+        description,
+        triggers,
+        folderUuid: optStr(spec["folderUuid"]),
+    });
+    const toolUuid = created.tool.uuid;
+    const workflowUuid = created.tool.workflowUuid;
+    // publicForm isn't a create param — apply it via update when set.
+    if (publicForm !== null && publicForm !== undefined) {
+        await api.orchestration.tool.update({ uuid: toolUuid, publicForm });
+    }
+    return { toolUuid, workflowUuid };
+}
+// Upsert the worker row (create, update, or recover a same-slug slot),
+// returning its uuid and whether an existing slot was adopted.
+async function upsertWorker(api, spec, prior, slug) {
+    const triggers = mapWorkerTriggers(spec["triggers"]);
+    const description = optStr(spec["description"]);
+    if (prior !== undefined) {
+        await api.hosting.worker.update({ uuid: prior.uuid, triggers });
+        return { uuid: prior.uuid, adopted: false };
+    }
+    // Recover our own slot if a prior deploy created it but crashed before
+    // persisting (e.g. a failed build). The slug is CDK-chosen, so a worker
+    // with the same slug is *probably* ours — reuse it instead of
+    // conflicting. We can't be certain it isn't a foreign same-slug worker,
+    // so mark it adopted: destroy will release (not delete) it.
+    const { workers } = await api.hosting.worker.list();
+    const existing = workers.find((w) => w.slug === slug);
+    if (existing !== undefined) {
+        await api.hosting.worker.update({ uuid: existing.uuid, triggers });
+        return { uuid: existing.uuid, adopted: true };
+    }
+    const created = await api.hosting.worker.create({
+        name: str(spec["name"]),
+        slug,
+        description: description === undefined ? null : description,
+        folderUuid: optStr(spec["folderUuid"]),
+        triggers,
+    });
+    return { uuid: created.worker.uuid, adopted: false };
+}
+// Resolve the app's slot: reuse the prior uuid, recover a same-slug slot, or
+// create it. Returns the uuid and whether an existing slot was adopted.
+async function resolveAppSlot(api, spec, prior, slug) {
+    if (prior !== undefined)
+        return { uuid: prior.uuid, adopted: false };
+    // Recover our own slot if a prior deploy created it but crashed before
+    // persisting — same-slug app is *probably* ours (the slug is
+    // CDK-chosen). We can't be certain, so mark it adopted: destroy will
+    // release (not delete) it.
+    const { apps } = await api.hosting.app.list();
+    const existing = apps.find((a) => a.slug === slug);
+    if (existing !== undefined) {
+        return { uuid: existing.uuid, adopted: true };
+    }
+    const created = await api.hosting.app.create({
+        name: str(spec["name"]),
+        slug,
+        description: optStr(spec["description"]),
+        folderUuid: optStr(spec["folderUuid"]),
+    });
+    return { uuid: created.app.uuid, adopted: false };
+}
+// Read a context file's current content through the runtime; undefined when it
+// doesn't exist yet (read 404s).
+async function readContextFile(api, path) {
+    try {
+        return (await api.context.runtime.read({ path })).content;
+    }
+    catch {
+        return undefined; // new file — read 404s
+    }
+}
 export function liveExecutors(api) {
     // Resolve the dataset uuid auto-created alongside a connector — needed when a
     // connector is ADOPTED (create returns it directly; list/adopt does not).
@@ -49,9 +204,9 @@ export function liveExecutors(api) {
                 await api.connection.connector.update({
                     uuid: prior.uuid,
                     name: str(spec["name"]),
-                    config: config ?? null,
-                    rateLimit: rateLimit ?? null,
-                    cacheTtlMilliseconds: cacheTtlMilliseconds ?? null,
+                    config: config === undefined ? null : config,
+                    rateLimit: rateLimit === undefined ? null : rateLimit,
+                    cacheTtlMilliseconds: cacheTtlMilliseconds === undefined ? null : cacheTtlMilliseconds,
                 });
                 // Preserve the adopted marker so destroy keeps releasing (not deleting).
                 const out = {
@@ -64,9 +219,9 @@ export function liveExecutors(api) {
                 return out;
             }
             const explicitAdopt = spec["adopt"] === true;
-            const adopt = explicitAdopt ||
+            const adopt = explicitAdopt === true ||
                 (await api.connection.connector.existsBySlug({ slug })).exists;
-            if (adopt) {
+            if (adopt === true) {
                 const { connectors } = await api.connection.connector.list({
                     integrationSlug,
                 });
@@ -74,10 +229,11 @@ export function liveExecutors(api) {
                 // workspace already treats as default for this integration, falling back
                 // to a slug match. Implicit adopt (a same-slug connector already exists)
                 // recovers that exact slot, so it stays a strict slug match.
-                const found = explicitAdopt
-                    ? (connectors.find((c) => c.isDefault === true) ??
-                        connectors.find((c) => c.slug === slug))
-                    : connectors.find((c) => c.slug === slug);
+                const defaultConnector = connectors.find((c) => c.isDefault === true);
+                const slugMatch = connectors.find((c) => c.slug === slug);
+                const found = explicitAdopt === true && defaultConnector !== undefined
+                    ? defaultConnector
+                    : slugMatch;
                 if (found === undefined) {
                     throw new Error(explicitAdopt
                         ? `no connector found to adopt for integration "${integrationSlug}"`
@@ -107,6 +263,7 @@ export function liveExecutors(api) {
         async model(spec, prior) {
             const slug = str(spec["slug"]);
             const datasetUuid = str(spec["datasetUuid"]);
+            const description = optStr(spec["description"]);
             const schedule = spec["schedule"];
             // Unification is not part of CreateModelPayload — it's set through an
             // update, both when the model is first created and on later syncs. Left
@@ -119,9 +276,9 @@ export function liveExecutors(api) {
                 await api.storage.model.update({
                     uuid: prior.uuid,
                     name: str(spec["name"]),
-                    description: optStr(spec["description"]) ?? null,
+                    description: description === undefined ? null : description,
                     config: spec["config"] ?? {},
-                    schedule: schedule ?? null,
+                    schedule: schedule === undefined ? null : schedule,
                     unification,
                 });
                 const out = { uuid: prior.uuid };
@@ -147,7 +304,7 @@ export function liveExecutors(api) {
             const created = await api.storage.model.create({
                 slug,
                 name: str(spec["name"]),
-                description: optStr(spec["description"]),
+                description,
                 datasetUuid,
                 extractorSlug: str(spec["extractorSlug"]),
                 config: spec["config"] ?? {},
@@ -165,45 +322,16 @@ export function liveExecutors(api) {
             return { uuid: created.model.uuid };
         },
         async play(spec, prior) {
-            // Play has no slug — identity is purely the prior state uuid.
-            const base = {
-                name: str(spec["name"]),
-                description: optStr(spec["description"]),
-                modelUuid: str(spec["modelUuid"]),
-                changeKinds: spec["changeKinds"],
-                runCreationRule: spec["runCreationRule"],
-                filter: spec["filter"],
-                sort: spec["sort"],
-                limit: spec["limit"],
-                trackingColumnSlugs: spec["trackingColumnSlugs"],
-                schedule: spec["schedule"],
-                folderUuid: optStr(spec["folderUuid"]),
-            };
-            let uuid;
-            let workflowUuid;
-            if (prior !== undefined) {
-                // play.update rejects modelUuid (a play's model is fixed at creation) —
-                // strip it from the update payload.
-                const { modelUuid: _modelUuid, ...updateBase } = base;
-                await api.orchestration.play.update({
-                    uuid: prior.uuid,
-                    ...updateBase,
-                });
-                uuid = prior.uuid;
-                workflowUuid = prior.outputs["workflowUuid"];
-            }
-            else {
-                const created = await api.orchestration.play.create(base);
-                uuid = created.play.uuid;
-                workflowUuid = created.play.workflowUuid;
-            }
+            const { uuid, workflowUuid } = await upsertPlay(api, spec, prior);
             // Deploy the play's backing workflow graph as its release, if provided.
             const nodes = spec["nodes"];
             if (nodes !== undefined && workflowUuid !== undefined) {
                 await api.orchestration.draftRelease.deploy({
                     workflowUuid,
                     nodes: nodes,
-                    formFields: (spec["formFields"] ?? null),
+                    formFields: (spec["formFields"] === undefined
+                        ? null
+                        : spec["formFields"]),
                 });
             }
             const result = { uuid };
@@ -223,27 +351,7 @@ export function liveExecutors(api) {
             // NOTE: agent + release are two calls. A crash between them orphans the
             // agent (no slug to re-find it). Acceptable for v1; a partial-persist hook
             // would close the window.
-            let agentUuid;
-            if (prior !== undefined) {
-                agentUuid = prior.uuid;
-                await api.ai.agent.update({
-                    uuid: agentUuid,
-                    name: str(spec["name"]),
-                    icon: spec["icon"],
-                    description: optStr(spec["description"]) ?? null,
-                    triggers: mapAgentTriggers(spec["triggers"]),
-                });
-            }
-            else {
-                const created = await api.ai.agent.create({
-                    name: str(spec["name"]),
-                    icon: spec["icon"],
-                    description: optStr(spec["description"]),
-                    triggers: mapAgentTriggers(spec["triggers"]),
-                    folderUuid: optStr(spec["folderUuid"]),
-                });
-                agentUuid = created.agent.uuid;
-            }
+            const agentUuid = await ensureAgentRow(api, spec, prior);
             // ── phase B: deploy the config release (full desired state) ──
             // No explicit version — the backend auto-bumps (an explicit wrong value
             // throws invalidReleaseVersion).
@@ -308,37 +416,7 @@ export function liveExecutors(api) {
         async tool(spec, prior) {
             const nodes = spec["nodes"];
             const formFields = spec["formFields"];
-            const triggers = mapToolTriggers(spec["triggers"]);
-            const publicForm = spec["publicForm"];
-            let toolUuid;
-            let workflowUuid;
-            if (prior !== undefined) {
-                toolUuid = prior.uuid;
-                workflowUuid = prior.outputs["workflowUuid"];
-                await api.orchestration.tool.update({
-                    uuid: toolUuid,
-                    name: str(spec["name"]),
-                    icon: spec["icon"],
-                    description: optStr(spec["description"]) ?? null,
-                    triggers,
-                    publicForm,
-                });
-            }
-            else {
-                const created = await api.orchestration.tool.create({
-                    name: str(spec["name"]),
-                    icon: spec["icon"],
-                    description: optStr(spec["description"]),
-                    triggers,
-                    folderUuid: optStr(spec["folderUuid"]),
-                });
-                toolUuid = created.tool.uuid;
-                workflowUuid = created.tool.workflowUuid;
-                // publicForm isn't a create param — apply it via update when set.
-                if (publicForm !== null && publicForm !== undefined) {
-                    await api.orchestration.tool.update({ uuid: toolUuid, publicForm });
-                }
-            }
+            const { toolUuid, workflowUuid } = await upsertTool(api, spec, prior);
             // Deploy the backing workflow's graph as the tool's release.
             await api.orchestration.draftRelease.deploy({
                 workflowUuid,
@@ -384,36 +462,7 @@ export function liveExecutors(api) {
         async worker(spec, prior) {
             const files = readBundle(str(spec["path"]));
             const slug = str(spec["slug"]);
-            const triggers = mapWorkerTriggers(spec["triggers"]);
-            let uuid;
-            let adopted = false;
-            if (prior !== undefined) {
-                uuid = prior.uuid;
-                await api.hosting.worker.update({ uuid, triggers });
-            }
-            else {
-                // Recover our own slot if a prior deploy created it but crashed before
-                // persisting (e.g. a failed build). The slug is CDK-chosen, so a worker
-                // with the same slug is *probably* ours — reuse it instead of
-                // conflicting. We can't be certain it isn't a foreign same-slug worker,
-                // so mark it adopted: destroy will release (not delete) it.
-                const { workers } = await api.hosting.worker.list();
-                const existing = workers.find((w) => w.slug === slug);
-                if (existing !== undefined) {
-                    uuid = existing.uuid;
-                    adopted = true;
-                    await api.hosting.worker.update({ uuid, triggers });
-                }
-                else {
-                    uuid = (await api.hosting.worker.create({
-                        name: str(spec["name"]),
-                        slug,
-                        description: optStr(spec["description"]) ?? null,
-                        folderUuid: optStr(spec["folderUuid"]),
-                        triggers,
-                    })).worker.uuid;
-                }
-            }
+            const { uuid, adopted } = await upsertWorker(api, spec, prior, slug);
             await syncEnvVars(api, { kind: "worker", workerUuid: uuid }, spec["env"]);
             const { deployment } = await api.hosting.deployment.create({
                 kind: "worker",
@@ -430,38 +479,14 @@ export function liveExecutors(api) {
                 uuid,
                 url: promoted.url,
             };
-            if (adopted)
+            if (adopted === true)
                 out["adopted"] = "true";
             return out;
         },
         async app(spec, prior) {
             const files = readBundle(str(spec["path"]));
             const slug = str(spec["slug"]);
-            let uuid;
-            let adopted = false;
-            if (prior !== undefined) {
-                uuid = prior.uuid;
-            }
-            else {
-                // Recover our own slot if a prior deploy created it but crashed before
-                // persisting — same-slug app is *probably* ours (the slug is
-                // CDK-chosen). We can't be certain, so mark it adopted: destroy will
-                // release (not delete) it.
-                const { apps } = await api.hosting.app.list();
-                const existing = apps.find((a) => a.slug === slug);
-                if (existing !== undefined) {
-                    uuid = existing.uuid;
-                    adopted = true;
-                }
-                else {
-                    uuid = (await api.hosting.app.create({
-                        name: str(spec["name"]),
-                        slug,
-                        description: optStr(spec["description"]),
-                        folderUuid: optStr(spec["folderUuid"]),
-                    })).app.uuid;
-                }
-            }
+            const { uuid, adopted } = await resolveAppSlot(api, spec, prior, slug);
             await syncEnvVars(api, { kind: "app", appUuid: uuid }, spec["env"]);
             const { deployment } = await api.hosting.deployment.create({
                 kind: "app",
@@ -478,7 +503,7 @@ export function liveExecutors(api) {
                 uuid,
                 url: promoted.url,
             };
-            if (adopted)
+            if (adopted === true)
                 out["adopted"] = "true";
             return out;
         },
@@ -549,13 +574,7 @@ export function liveExecutors(api) {
             const files = (spec["files"] ?? {});
             const { repository } = await api.context.repository.get();
             for (const [path, content] of Object.entries(files)) {
-                let current;
-                try {
-                    current = (await api.context.runtime.read({ path })).content;
-                }
-                catch {
-                    current = undefined; // new file — read 404s
-                }
+                const current = await readContextFile(api, path);
                 if (current !== content) {
                     await api.context.runtime.write({
                         path,
@@ -586,7 +605,9 @@ export function liveExecutors(api) {
                 await api.revenueOrganization.capacity.update({
                     uuid: prior.uuid,
                     ...base,
-                    filter: (spec["filter"] ?? null),
+                    filter: (spec["filter"] === undefined
+                        ? null
+                        : spec["filter"]),
                 });
                 return carryAdopted({ uuid: prior.uuid }, prior);
             }
@@ -635,10 +656,14 @@ export function liveExecutors(api) {
                     uuid: prior.uuid,
                     name,
                     filter: spec["filter"],
-                    sort: (spec["sort"] ?? null),
-                    limit: (spec["limit"] ?? null),
-                    trackingColumnSlugs: (spec["trackingColumnSlugs"] ?? null),
-                    columnSlugs: (spec["columnSlugs"] ?? null),
+                    sort: (spec["sort"] === undefined ? null : spec["sort"]),
+                    limit: (spec["limit"] === undefined ? null : spec["limit"]),
+                    trackingColumnSlugs: (spec["trackingColumnSlugs"] === undefined
+                        ? null
+                        : spec["trackingColumnSlugs"]),
+                    columnSlugs: (spec["columnSlugs"] === undefined
+                        ? null
+                        : spec["columnSlugs"]),
                 });
                 return carryAdopted({ uuid: prior.uuid }, prior);
             }
@@ -670,22 +695,25 @@ export function liveExecutors(api) {
             const fromModelUuid = str(spec["fromModelUuid"]);
             const { model } = await api.storage.model.get(fromModelUuid);
             const datasetUuid = model.datasetUuid;
+            const fromPropertySlug = optStr(spec["fromPropertySlug"]);
+            const toPropertySlug = optStr(spec["toPropertySlug"]);
             const row = {
                 fromModelUuid,
                 fromColumnSlug: str(spec["fromColumnSlug"]),
-                fromPropertySlug: optStr(spec["fromPropertySlug"]) ?? null,
+                fromPropertySlug: fromPropertySlug === undefined ? null : fromPropertySlug,
                 toModelUuid: str(spec["toModelUuid"]),
                 toColumnSlug: str(spec["toColumnSlug"]),
-                toPropertySlug: optStr(spec["toPropertySlug"]) ?? null,
+                toPropertySlug: toPropertySlug === undefined ? null : toPropertySlug,
                 fromSelectedColumnSlugs: null,
                 toSelectedColumnSlugs: null,
                 relation: spec["relation"],
             };
             const { relationships } = await api.storage.relationship.all();
+            const priorUuid = prior === undefined ? undefined : prior.uuid;
             // Every row in this dataset except the one we manage — kept verbatim (with
             // its uuid) so `set` updates it in place rather than deleting it.
             const others = relationships
-                .filter((r) => r.fromDatasetUuid === datasetUuid && r.uuid !== prior?.uuid)
+                .filter((r) => r.fromDatasetUuid === datasetUuid && r.uuid !== priorUuid)
                 .map(toSetInput);
             const ours = prior === undefined ? row : { ...row, uuid: prior.uuid };
             const { relationships: after } = await api.storage.relationship.set({
@@ -713,16 +741,17 @@ export function liveExecutors(api) {
 // so `set` updates it in place instead of deleting it. `all()` returns nullable
 // fields as `undefined` while `set()` expects `null`, so normalize each here.
 function toSetInput(relationship) {
+    const { fromPropertySlug = null, toPropertySlug = null, fromSelectedColumnSlugs = null, toSelectedColumnSlugs = null, } = relationship;
     return {
         uuid: relationship.uuid,
         fromModelUuid: relationship.fromModelUuid,
         fromColumnSlug: relationship.fromColumnSlug,
-        fromPropertySlug: relationship.fromPropertySlug ?? null,
+        fromPropertySlug,
         toModelUuid: relationship.toModelUuid,
         toColumnSlug: relationship.toColumnSlug,
-        toPropertySlug: relationship.toPropertySlug ?? null,
-        fromSelectedColumnSlugs: relationship.fromSelectedColumnSlugs ?? null,
-        toSelectedColumnSlugs: relationship.toSelectedColumnSlugs ?? null,
+        toPropertySlug,
+        fromSelectedColumnSlugs,
+        toSelectedColumnSlugs,
         relation: relationship.relation,
     };
 }

package/build/src/deploy/import.js

@@ -58,7 +58,7 @@ export async function importResource(root, api, workspaceUuid, id, uuid,
 // The repo's resources. Defaults to loading them from `root`; injectable so
 // the import logic is testable without the tsx file loader.
 nodes) {
-    const resolved = nodes ?? (await loadResources(root));
+    const resolved = nodes !== undefined ? nodes : await loadResources(root);
     const entry = compile({ nodes: resolved }).plan.find((p) => p.id === id);
     if (entry === undefined) {
         throw new Error(`no resource "${id}" found in code — import targets a code resource id like "agent:sdr".`);
@@ -71,7 +71,7 @@ nodes) {
     const stateEntry = { hash: entry.hash, uuid, outputs };
     // Confirm it's actually there (and capture a drift baseline).
     const live = await liveReaders(api)[kind](stateEntry);
-    if (!live.exists) {
+    if (live.exists === false) {
         throw new Error(`${kind} ${uuid} was not found in the workspace — nothing to import.`);
     }
     if (live.fingerprint !== undefined)

package/build/src/deploy/index.js

@@ -40,7 +40,7 @@ export async function deploy(root, workspaceUuid, executors) {
             `selected ${workspaceUuid} — refusing to deploy (would orphan resources).`);
     }
     const nodes = await loadResources(root);
-    const state = prior ?? emptyState(workspaceUuid);
+    const state = prior !== undefined ? prior : emptyState(workspaceUuid);
     const result = await apply({ nodes, state }, executors, (next) => writeState(root, next));
     return {
         state: result.state,

package/build/src/deploy/lock.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lock.d.ts","sourceRoot":"","sources":["../../../src/deploy/lock.ts"],"names":[],"mappings":"AAcA,MAAM,MAAM,IAAI,GAAG;IAAE,OAAO,EAAE,MAAM,IAAI,CAAA;CAAE,CAAC;AAsC3C;;;;GAIG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,KAAK,UAAQ,GACZ,IAAI,CA6DN"}
+{"version":3,"file":"lock.d.ts","sourceRoot":"","sources":["../../../src/deploy/lock.ts"],"names":[],"mappings":"AAcA,MAAM,MAAM,IAAI,GAAG;IAAE,OAAO,EAAE,MAAM,IAAI,CAAA;CAAE,CAAC;AAsC3C;;;;GAIG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,KAAK,UAAQ,GACZ,IAAI,CAgEN"}

package/build/src/deploy/lock.js

@@ -51,11 +51,13 @@ export function acquireLock(root, command, force = false) {
         command,
     };
     const payload = `${JSON.stringify(me, null, 2)}\n`;
-    let attempts = 0;
-    for (;;) {
+    // Create the lock file, stealing a stale/forced one and retrying per steal;
+    // gives up after 6 attempts. A successful write returns; the original loop's
+    // `break` maps to this `return`.
+    const acquire = (attempts) => {
         try {
             writeFileSync(path, payload, { flag: "wx" }); // atomic create-or-fail
-            break;
+            return;
         }
         catch (error) {
             if (error.code !== "EEXIST")
@@ -63,7 +65,7 @@ export function acquireLock(root, command, force = false) {
             // The lock file exists (EEXIST). Only steal it when we can positively
             // confirm it's free, or the caller forced it.
             const existing = readLock(path);
-            if (!force) {
+            if (force === false) {
                 if (existing === undefined) {
                     // Present but unreadable — a live holder mid-write, or a corrupt
                     // file. Fail closed: never steal a lock we can't inspect.
@@ -77,17 +79,18 @@ export function acquireLock(root, command, force = false) {
                 }
             }
             rmSync(path, { force: true }); // forced, or readable + confirmed stale
-            attempts += 1;
-            if (attempts > 5) {
+            if (attempts + 1 > 5) {
                 throw new Error("could not acquire the cargo.state lock");
             }
+            acquire(attempts + 1);
         }
-    }
-    let released = false;
+    };
+    acquire(0);
+    const releaseState = { released: false };
     const release = () => {
-        if (released)
+        if (releaseState.released)
             return;
-        released = true;
+        releaseState.released = true;
         const current = readLock(path);
         if (current !== undefined &&
             current.pid === me.pid &&

package/build/src/deploy/readers.live.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"readers.live.d.ts","sourceRoot":"","sources":["../../../src/deploy/readers.live.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,eAAe,CAAC;AAGzC,OAAO,EAA8B,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAoD5E,wBAAgB,WAAW,CAAC,GAAG,EAAE,GAAG,GAAG,WAAW,CA2TjD"}
+{"version":3,"file":"readers.live.d.ts","sourceRoot":"","sources":["../../../src/deploy/readers.live.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,eAAe,CAAC;AAGzC,OAAO,EAA8B,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAoD5E,wBAAgB,WAAW,CAAC,GAAG,EAAE,GAAG,GAAG,WAAW,CAoUjD"}