rigscope 0.1.1 → 0.1.3

package/dist/ops.cjs

@@ -962,7 +962,7 @@ function findHubLock(databasePath) {
     `${absolute}.hub.lock`,
     (0, import_node_path2.join)(parent, "hub.lock"),
     (0, import_node_path2.join)(parent, "hub.pid")
-    // `run/hub.lock` is the v2 component supervisor lease, not a database
+    // `run/hub.lock` is the component supervisor lease, not a database
     // lease. Treating it as a hub lock would make an upgrade's own held lease
     // look like a live hub during database backup/restore.
   ];
@@ -1517,8 +1517,6 @@ var import_node_child_process = require("node:child_process");
 var import_node_os = require("node:os");
 var import_node_path4 = require("node:path");
 var import_node_crypto5 = require("node:crypto");
-var RELEASE_FORMAT_VERSION = 1;
-var INSTALL_STATE_FORMAT_VERSION = 1;
 var HUB_SHUTDOWN_DEADLINE_MS = 5e3;
 var COLLECTOR_SHUTDOWN_DEADLINE_MS = 3e3;
 var RELEASE_ENTRYPOINTS = {
@@ -1581,6 +1579,17 @@ var PRIVATE_FILE_PATTERNS = [
   /(^|\/)id_(rsa|ed25519)(\.pub)?$/,
   /\.(log|pid|lock|tmp)$/
 ];
+var INSTALL_STATE_KEYS = /* @__PURE__ */ new Set([
+  "prefix",
+  "stateDir",
+  "database",
+  "currentVersion",
+  "previousVersion",
+  "releases",
+  "backups",
+  "lastActivation",
+  "updatedAt"
+]);
 function assertSafeRelativePath(path, label) {
   if (typeof path !== "string" || path.length === 0 || path.length > 1024) {
     throw new OperationsError("invalid-manifest", `${label} has an empty or oversized path`);
@@ -1675,7 +1684,6 @@ function manifestForPackage(packageJson, version, now) {
   const name = typeof packageJson.name === "string" && packageJson.name.length > 0 ? packageJson.name : "rigscope";
   const dependencies = packageJson.dependencies !== null && typeof packageJson.dependencies === "object" ? Object.keys(packageJson.dependencies).filter((key) => /^[A-Za-z0-9@/._-]+$/.test(key)) : [];
   return {
-    formatVersion: RELEASE_FORMAT_VERSION,
     name,
     version: validateVersion(version),
     createdAt: new Date(now()).toISOString(),
@@ -1777,8 +1785,11 @@ function extractArchive(archive, destination) {
 function validateManifest(root) {
   const manifestPath = (0, import_node_path4.join)(root, "manifest.json");
   const raw = readJsonObject(manifestPath);
-  if (raw.formatVersion !== RELEASE_FORMAT_VERSION) {
-    throw new OperationsError("invalid-manifest", `unsupported release manifest format ${String(raw.formatVersion)}`);
+  if (Object.prototype.hasOwnProperty.call(raw, "formatVersion")) {
+    throw new OperationsError(
+      "invalid-manifest",
+      "release manifest uses an unfinished pre-canonical format; repackage the release without a format version"
+    );
   }
   if (typeof raw.name !== "string" || raw.name.length === 0 || raw.name.length > 128) {
     throw new OperationsError("invalid-manifest", "manifest name is invalid");
@@ -1839,7 +1850,6 @@ function validateManifest(root) {
     }
   }
   const manifest = {
-    formatVersion: 1,
     name: raw.name,
     version,
     createdAt: typeof raw.createdAt === "string" ? raw.createdAt : "",
@@ -2003,7 +2013,6 @@ function missingProductionDependencies(releaseDir, manifest) {
 }
 function installStateDefaults(prefix, stateDir, database) {
   return {
-    formatVersion: INSTALL_STATE_FORMAT_VERSION,
     prefix,
     stateDir,
     database,
@@ -2015,40 +2024,158 @@ function installStateDefaults(prefix, stateDir, database) {
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
+function installStateError(path, detail) {
+  throw new OperationsError("invalid-state", `${detail}: ${path}`);
+}
+function isPlainRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function stateObject(value, path, field) {
+  if (!isPlainRecord(value)) installStateError(path, `installation state ${field} must be a JSON object`);
+  return value;
+}
+function stateString(value, path, field) {
+  if (typeof value !== "string" || value.length === 0) {
+    installStateError(path, `installation state ${field} must be a nonempty string`);
+  }
+  return value;
+}
+function stateInteger(value, path, field) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    installStateError(path, `installation state ${field} must be a nonnegative integer`);
+  }
+  return value;
+}
+function stateNullableInteger(value, path, field) {
+  return value === null ? null : stateInteger(value, path, field);
+}
+function stateVersion(value, path, field) {
+  if (value === null) return null;
+  if (typeof value !== "string") installStateError(path, `installation state ${field} must be a version string or null`);
+  try {
+    return validateVersion(value);
+  } catch {
+    return installStateError(path, `installation state ${field} has an invalid version`);
+  }
+}
+function requiredStateVersion(value, path, field) {
+  const version = stateVersion(value, path, field);
+  if (version === null) installStateError(path, `installation state ${field} must be a version string`);
+  return version;
+}
 function readInstallState(path, defaults) {
   if (!(0, import_node_fs4.existsSync)(path)) return defaults;
   const { value } = readJsonFile(path);
-  if (value === null || typeof value !== "object" || value.formatVersion !== INSTALL_STATE_FORMAT_VERSION) {
-    throw new OperationsError("invalid-state", `installation state has an unsupported format: ${path}`);
+  if (!isPlainRecord(value)) installStateError(path, "installation state must be a JSON object");
+  for (const key of ["formatVersion", "version"]) {
+    if (Object.prototype.hasOwnProperty.call(value, key)) {
+      throw new OperationsError(
+        "invalid-state",
+        `installation state uses an unfinished pre-canonical format; stop the installation and reset or reinstall it without migration: ${path}`
+      );
+    }
+  }
+  for (const key of Object.keys(value)) {
+    if (!INSTALL_STATE_KEYS.has(key)) {
+      installStateError(path, `installation state contains unsupported field ${JSON.stringify(key)}`);
+    }
   }
   if (value.prefix !== defaults.prefix || value.stateDir !== defaults.stateDir) {
     throw new OperationsError("invalid-state", "installation state belongs to a different prefix or state directory");
   }
-  const backups = {};
-  if (value.backups !== null && typeof value.backups === "object" && !Array.isArray(value.backups)) {
-    for (const [key, entry] of Object.entries(value.backups)) {
-      if (entry === null || typeof entry !== "object" || Array.isArray(entry)) continue;
-      const record = entry;
-      if (typeof record.path !== "string" || !Number.isSafeInteger(record.schemaVersion)) continue;
-      backups[key] = {
-        path: record.path,
-        schemaVersion: record.schemaVersion,
-        fromSchema: Number.isSafeInteger(record.fromSchema) ? record.fromSchema : null,
-        toSchema: Number.isSafeInteger(record.toSchema) ? record.toSchema : record.schemaVersion,
-        createdAt: typeof record.createdAt === "string" ? record.createdAt : ""
-      };
+  const database = stateString(value.database, path, "database");
+  const currentVersion = stateVersion(value.currentVersion, path, "currentVersion");
+  const previousVersion = stateVersion(value.previousVersion, path, "previousVersion");
+  const updatedAt = stateString(value.updatedAt, path, "updatedAt");
+  const releases = {};
+  for (const [version, rawEntry] of Object.entries(stateObject(value.releases, path, "releases"))) {
+    try {
+      validateVersion(version);
+    } catch {
+      installStateError(path, `installation state releases contains an invalid release version ${JSON.stringify(version)}`);
     }
+    const entry = stateObject(rawEntry, path, `releases.${version}`);
+    releases[version] = {
+      schemaVersion: stateInteger(entry.schemaVersion, path, `releases.${version}.schemaVersion`),
+      installedAt: stateString(entry.installedAt, path, `releases.${version}.installedAt`)
+    };
+  }
+  const backups = {};
+  for (const [version, rawEntry] of Object.entries(stateObject(value.backups, path, "backups"))) {
+    const entry = stateObject(rawEntry, path, `backups.${version}`);
+    backups[version] = {
+      path: stateString(entry.path, path, `backups.${version}.path`),
+      schemaVersion: stateInteger(entry.schemaVersion, path, `backups.${version}.schemaVersion`),
+      fromSchema: stateNullableInteger(entry.fromSchema, path, `backups.${version}.fromSchema`),
+      toSchema: stateInteger(entry.toSchema, path, `backups.${version}.toSchema`),
+      createdAt: stateString(entry.createdAt, path, `backups.${version}.createdAt`)
+    };
+  }
+  let lastActivation = null;
+  if (value.lastActivation !== null) {
+    const entry = stateObject(value.lastActivation, path, "lastActivation");
+    lastActivation = {
+      version: requiredStateVersion(entry.version, path, "lastActivation.version"),
+      previousVersion: stateVersion(entry.previousVersion, path, "lastActivation.previousVersion"),
+      schemaVersion: stateInteger(entry.schemaVersion, path, "lastActivation.schemaVersion"),
+      backupPath: entry.backupPath === null ? null : stateString(entry.backupPath, path, "lastActivation.backupPath"),
+      backupSchemaVersion: stateNullableInteger(
+        entry.backupSchemaVersion,
+        path,
+        "lastActivation.backupSchemaVersion"
+      ),
+      activatedAt: stateString(entry.activatedAt, path, "lastActivation.activatedAt")
+    };
   }
   return {
-    ...defaults,
-    ...value,
-    database: typeof value.database === "string" ? value.database : defaults.database,
-    releases: value.releases !== null && typeof value.releases === "object" && !Array.isArray(value.releases) ? value.releases : {},
-    backups
+    prefix: defaults.prefix,
+    stateDir: defaults.stateDir,
+    database,
+    currentVersion,
+    previousVersion,
+    releases,
+    backups,
+    lastActivation,
+    updatedAt
+  };
+}
+function canonicalInstallState(state) {
+  const releases = {};
+  for (const [version, record] of Object.entries(state.releases)) {
+    releases[version] = { schemaVersion: record.schemaVersion, installedAt: record.installedAt };
+  }
+  const backups = {};
+  for (const [version, record] of Object.entries(state.backups)) {
+    backups[version] = {
+      path: record.path,
+      schemaVersion: record.schemaVersion,
+      fromSchema: record.fromSchema,
+      toSchema: record.toSchema,
+      createdAt: record.createdAt
+    };
+  }
+  return {
+    prefix: state.prefix,
+    stateDir: state.stateDir,
+    database: state.database,
+    currentVersion: state.currentVersion,
+    previousVersion: state.previousVersion,
+    releases,
+    backups,
+    lastActivation: state.lastActivation === null ? null : {
+      version: state.lastActivation.version,
+      previousVersion: state.lastActivation.previousVersion,
+      schemaVersion: state.lastActivation.schemaVersion,
+      backupPath: state.lastActivation.backupPath,
+      backupSchemaVersion: state.lastActivation.backupSchemaVersion,
+      activatedAt: state.lastActivation.activatedAt
+    },
+    updatedAt: state.updatedAt
   };
 }
 function writeInstallState(path, state) {
-  writePrivateFile(path, `${JSON.stringify({ ...state, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2)}
+  const canonical = { ...canonicalInstallState(state), updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  writePrivateFile(path, `${JSON.stringify(canonical, null, 2)}
 `);
 }
 function releaseDirFor(prefix, version) {
@@ -2268,6 +2395,8 @@ async function installRelease(options) {
   ensurePublicDir(releasesDir);
   const source = resolvePath(options.source, "release source");
   const sourceStat = (0, import_node_fs4.lstatSync)(source);
+  const statePath = (0, import_node_path4.join)(stateDir, "install-state.json");
+  const state = readInstallState(statePath, installStateDefaults(prefix, stateDir, database));
   const stage = (0, import_node_path4.join)(releasesDir, `.stage-${(0, import_node_crypto5.randomUUID)()}`);
   try {
     if (sourceStat.isFile()) {
@@ -2309,8 +2438,6 @@ async function installRelease(options) {
       hubEnv: env.hubEnv,
       collectorEnv: env.collectorEnv
     });
-    const statePath = (0, import_node_path4.join)(stateDir, "install-state.json");
-    const state = readInstallState(statePath, installStateDefaults(prefix, stateDir, database));
     state.releases[manifest.version] = {
       schemaVersion: manifest.schemaVersion,
       installedAt: new Date(now()).toISOString()
@@ -4266,8 +4393,8 @@ function readGaps(db, machineId, fromMs, toMs) {
     "SELECT from_ms, to_ms, dropped, reason FROM gaps WHERE machine_id = ? AND to_ms >= ? AND from_ms <= ? ORDER BY from_ms LIMIT ?"
   ).all(machineId, fromMs, toMs, MAX_GAPS);
   const missing = db.db.prepare(
-    "WITH ordered AS ( SELECT captured_at_ms, LAG(captured_at_ms) OVER (PARTITION BY machine_id ORDER BY captured_at_ms) AS prev_ms, expected_interval_ms FROM sample_receipts WHERE machine_id = ? AND captured_at_ms >= ? AND captured_at_ms <= ? ) SELECT prev_ms AS from_ms, captured_at_ms AS to_ms FROM ordered WHERE prev_ms IS NOT NULL AND captured_at_ms - prev_ms > MAX(15000, 3 * COALESCE(expected_interval_ms, 5000)) ORDER BY captured_at_ms LIMIT ?"
-  ).all(machineId, fromMs, toMs, MAX_GAPS);
+    "WITH before_window AS ( SELECT captured_at_ms, expected_interval_ms FROM sample_receipts WHERE machine_id = ? AND captured_at_ms < ? ORDER BY captured_at_ms DESC LIMIT 1 ), in_window AS ( SELECT captured_at_ms, expected_interval_ms FROM sample_receipts WHERE machine_id = ? AND captured_at_ms >= ? AND captured_at_ms <= ? ), ordered AS ( SELECT captured_at_ms, expected_interval_ms, LAG(captured_at_ms) OVER (ORDER BY captured_at_ms) AS prev_ms FROM (SELECT * FROM before_window UNION ALL SELECT * FROM in_window) ) SELECT MAX(prev_ms, ?) AS from_ms, captured_at_ms AS to_ms FROM ordered WHERE prev_ms IS NOT NULL AND captured_at_ms > ? AND captured_at_ms - prev_ms > MAX(15000, 3 * COALESCE(expected_interval_ms, 5000)) ORDER BY captured_at_ms LIMIT ?"
+  ).all(machineId, fromMs, machineId, fromMs, toMs, fromMs, fromMs, MAX_GAPS);
   const gaps = [
     ...dropped.map((row) => ({
       fromMs: Number(row.from_ms),