camstack 1.2.76 → 1.2.77

package/dist/cli.js

@@ -38,7 +38,7 @@ async function runServe(args) {
     ...typeof values.data === "string" ? { data: values.data } : {}
   };
   Object.assign(process.env, buildServeEnv(opts));
-  await import("./launcher-WOTGVQN3.js");
+  await import("./launcher-JYQ4AMYP.js");
 }
 
 // src/commands/agent.ts
@@ -83,7 +83,7 @@ async function runAgent(args) {
     ...typeof values.port === "string" ? { port: values.port } : {}
   };
   Object.assign(process.env, buildAgentEnv(opts));
-  await import("./launcher-WOTGVQN3.js");
+  await import("./launcher-JYQ4AMYP.js");
 }
 
 // src/commands/setup.ts

package/dist/{launcher-WOTGVQN3.js → launcher-JYQ4AMYP.js}

@@ -67743,6 +67743,86 @@ var require_device_manager_addon = __commonJS({
         });
       }
       /** Drop the device's row. Idempotent. */
+      /**
+      * Exchange the ids of two devices, carrying their children with them.
+      *
+      * ## Why this exists as a primitive
+      *
+      * Replacing a camera means the new hardware has to become the device the rest
+      * of the system already knows. Everything general about a camera is keyed on
+      * the NUMERIC id and on nothing else — the recording path on disk is
+      * `<deviceId>/profile/…`, the hour ledger, the media store and zone ownership
+      * carry `deviceId` and not one `stableId` between them, and all four
+      * ecosystem exports (Home Assistant, Alexa, HomeKit, Google) key on it too.
+      * Moving that work is the expensive, lossy operation. Moving the NUMBER is
+      * two rows.
+      *
+      * ## Children are re-pointed, not renumbered
+      *
+      * A child keeps its own id and follows its parent: every row whose
+      * `parentDeviceId` was `a` now names `b`, and the reverse. Renumbering the
+      * children as well would move THEIR general work for no reason — the
+      * accessory's own recordings and rules are keyed on the child id, which is
+      * not the id being inherited.
+      *
+      * ## There are no transactions here, so the ORDER is the safety
+      *
+      * The backing store is a collection API (`set` / `delete` / `updateWhere`);
+      * there is no rollback to lean on. So the sequence is chosen to make every
+      * crash point LOUD rather than plausible: `a` first moves to a freshly
+      * allocated id, which the monotonic counter guarantees was never used and
+      * will never be reused. A crash before the end therefore leaves a device
+      * missing from its number and a stray at an unfamiliar one — visible in the
+      * device list at a glance. What it can never leave is two rows on one number,
+      * or a row that looks correct while its children point elsewhere.
+      *
+      * The caller holds {@link DeviceMetaStore.withMetaWriteLock}. This method does
+      * not take it: taking it here would deadlock the migration that has to disable
+      * functions on both devices in the same critical section.
+      */
+      async swapIds(a, b, tempId) {
+        if (a === b) throw new Error(`[device-manager] swapIds: ${a} and ${b} are the same device`);
+        await this.declare();
+        const rowA = await this.get(a);
+        const rowB = await this.get(b);
+        if (rowA === null) throw new Error(`[device-manager] swapIds: device ${a} does not exist`);
+        if (rowB === null) throw new Error(`[device-manager] swapIds: device ${b} does not exist`);
+        if (await this.get(tempId) !== null) throw new Error(`[device-manager] swapIds: temp id ${tempId} is taken`);
+        const childrenOfA = (await this.listByParent(a)).map((r) => r.meta.id);
+        const childrenOfB = (await this.listByParent(b)).map((r) => r.meta.id);
+        await this.moveRow(rowA, tempId);
+        await this.moveRow(rowB, a);
+        await this.moveRow({
+          ...rowA,
+          meta: {
+            ...rowA.meta,
+            id: tempId
+          }
+        }, b);
+        for (const childId of childrenOfA) await this.patch(childId, { parentDeviceId: b });
+        for (const childId of childrenOfB) await this.patch(childId, { parentDeviceId: a });
+        this.logger.info("device ids swapped", {
+          tags: { deviceId: a },
+          meta: {
+            a,
+            b,
+            childrenOfA,
+            childrenOfB
+          }
+        });
+      }
+      /** Rewrite a row under a new id and drop the old key. Not exported: the only
+      *  legitimate reason to move a row is {@link swapIds}. */
+      async moveRow(row, toId) {
+        await this.upsert({
+          ...row.meta,
+          id: toId
+        }, {
+          registered: row.registered,
+          metadata: row.metadata
+        });
+        await this.remove(row.meta.id);
+      }
       async remove(deviceId) {
         await this.declare();
         await this.backend.delete({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "camstack",
-  "version": "1.2.76",
+  "version": "1.2.77",
   "description": "CLI tool for managing and running CamStack server",
   "keywords": [
     "camstack",