akm-cli 0.9.0-rc.0 → 0.9.0-rc.2

package/dist/core/maintenance-barrier.js

@@ -0,0 +1,119 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+import { AsyncLocalStorage } from "node:async_hooks";
+import { randomUUID } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { ConfigError } from "./errors.js";
+import { createLockPayload, probeLock, reclaimStaleLock, releaseLock, tryAcquireLockSync } from "./file-lock.js";
+import { getMaintenanceBarrierPath } from "./paths.js";
+const heldBarrierContext = new AsyncLocalStorage();
+/**
+ * Serialize restore with the short critical section that creates every
+ * long-lived AKM lock or workflow lease. The long operation keeps its own
+ * lock/lease; this barrier is released immediately after acquisition.
+ */
+export function tryAcquireMaintenanceBarrier() {
+    const lockPath = getMaintenanceBarrierPath();
+    fs.mkdirSync(path.dirname(lockPath), { recursive: true });
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+        const ownership = tryAcquireLockSync(lockPath, createLockPayload({ purpose: "maintenance-start" }));
+        if (ownership) {
+            return () => releaseLock(ownership);
+        }
+        const probe = probeLock(lockPath);
+        if (probe.state !== "stale" || !reclaimStaleLock(lockPath, probe))
+            return undefined;
+    }
+    return undefined;
+}
+export function acquireMaintenanceBarrier() {
+    const release = tryAcquireMaintenanceBarrier();
+    if (release)
+        return release;
+    throw new ConfigError(`AKM maintenance is in progress (barrier ${getMaintenanceBarrierPath()}); retry after it completes.`, "INVALID_CONFIG_FILE");
+}
+export function withMaintenanceStartBarrier(run) {
+    if (heldBarrierContext.getStore()?.active)
+        return run();
+    const release = acquireMaintenanceBarrier();
+    const ownership = { active: true };
+    try {
+        return heldBarrierContext.run(ownership, run);
+    }
+    finally {
+        ownership.active = false;
+        release();
+    }
+}
+async function acquireMaintenanceBarrierAsync() {
+    const deadline = Date.now() + 5_000;
+    while (true) {
+        const release = tryAcquireMaintenanceBarrier();
+        if (release)
+            return release;
+        if (Date.now() >= deadline)
+            return acquireMaintenanceBarrier();
+        await new Promise((resolve) => setTimeout(resolve, 5));
+    }
+}
+export async function withMaintenanceStartBarrierAsync(run) {
+    if (heldBarrierContext.getStore()?.active)
+        return run();
+    const release = await acquireMaintenanceBarrierAsync();
+    const ownership = { active: true };
+    try {
+        return await heldBarrierContext.run(ownership, run);
+    }
+    finally {
+        ownership.active = false;
+        release();
+    }
+}
+function withMaintenanceStartBarrierSyncWait(run) {
+    if (heldBarrierContext.getStore()?.active)
+        return run();
+    const deadline = Date.now() + 5_000;
+    let release = tryAcquireMaintenanceBarrier();
+    while (!release && Date.now() < deadline) {
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 5);
+        release = tryAcquireMaintenanceBarrier();
+    }
+    if (!release)
+        release = acquireMaintenanceBarrier();
+    const ownership = { active: true };
+    try {
+        return heldBarrierContext.run(ownership, run);
+    }
+    finally {
+        ownership.active = false;
+        release();
+    }
+}
+/** Register a long-lived operation atomically with restore's blocker scan. */
+export async function acquireMaintenanceActivity(name) {
+    return withMaintenanceStartBarrierAsync(async () => {
+        const directory = path.join(path.dirname(getMaintenanceBarrierPath()), "maintenance-activities");
+        fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
+        const lockPath = path.join(directory, `${name}-${process.pid}-${randomUUID()}.lock`);
+        const ownership = tryAcquireLockSync(lockPath, createLockPayload({ purpose: name }));
+        if (!ownership) {
+            throw new ConfigError(`Could not register AKM maintenance activity at ${lockPath}.`, "INVALID_CONFIG_FILE");
+        }
+        return () => releaseLock(ownership);
+    });
+}
+/** Synchronous activity registration for synchronous database handle lifetimes. */
+export function acquireMaintenanceActivitySync(name) {
+    return withMaintenanceStartBarrierSyncWait(() => {
+        const directory = path.join(path.dirname(getMaintenanceBarrierPath()), "maintenance-activities");
+        fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
+        const lockPath = path.join(directory, `${name}-${process.pid}-${randomUUID()}.lock`);
+        const ownership = tryAcquireLockSync(lockPath, createLockPayload({ purpose: name }));
+        if (!ownership) {
+            throw new ConfigError(`Could not register AKM maintenance activity at ${lockPath}.`, "INVALID_CONFIG_FILE");
+        }
+        return () => releaseLock(ownership);
+    });
+}

package/dist/core/migration-backup.js

@@ -0,0 +1,416 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { openDatabase } from "../storage/database.js";
+import { writeFileAtomic } from "./common.js";
+import { parseConfigText, withConfigLock } from "./config/config-io.js";
+import { CURRENT_CONFIG_VERSION } from "./config/config-schema.js";
+import { ConfigError } from "./errors.js";
+import { createLockPayload, probeLock, reclaimStaleLock, releaseLock, tryAcquireLockSync } from "./file-lock.js";
+import { acquireMaintenanceActivitySync, withMaintenanceStartBarrier } from "./maintenance-barrier.js";
+import { getCacheDir, getConfigPath, getDataDir, getIndexWriterLockPath, getLockfileLockPath, getStateDbPathInDataDir, getWorkflowDbPath, } from "./paths.js";
+export const MIGRATION_BACKUP_VERSION = "0.9.0";
+const ARTIFACT_NAMES = ["config.json", "state.db", "workflow.db"];
+export function getMigrationBackupDir() {
+    return path.join(getCacheDir(), "migration-backups", MIGRATION_BACKUP_VERSION);
+}
+function migrationBackupLockPath() {
+    return path.join(getCacheDir(), "migration-backups", `${MIGRATION_BACKUP_VERSION}.lock`);
+}
+function expectedSourcePaths() {
+    return {
+        "config.json": getConfigPath(),
+        "state.db": getStateDbPathInDataDir(),
+        "workflow.db": getWorkflowDbPath(),
+    };
+}
+function sha256File(filePath) {
+    return crypto.createHash("sha256").update(fs.readFileSync(filePath)).digest("hex");
+}
+function ownerOnlyMode(filePath, directory) {
+    if (process.platform === "win32")
+        return true;
+    const mode = fs.statSync(filePath).mode & 0o777;
+    return mode === (directory ? 0o700 : 0o600);
+}
+function fsyncDirectory(directory) {
+    try {
+        const fd = fs.openSync(directory, "r");
+        try {
+            fs.fsyncSync(fd);
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+    }
+    catch (error) {
+        const code = error.code;
+        if (code !== "EINVAL" && code !== "ENOTSUP" && code !== "EISDIR" && code !== "EPERM")
+            throw error;
+    }
+}
+function parseManifest(bundlePath) {
+    const manifestPath = path.join(bundlePath, "manifest.json");
+    let value;
+    try {
+        value = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+    }
+    catch (error) {
+        throw new ConfigError(`Migration backup at ${bundlePath} is incomplete or unreadable: ${error instanceof Error ? error.message : String(error)}. Remove it only after preserving any recoverable files, then retry backup creation.`, "INVALID_CONFIG_FILE");
+    }
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new ConfigError(`Migration backup manifest at ${manifestPath} is invalid.`, "INVALID_CONFIG_FILE");
+    }
+    const manifest = value;
+    if (manifest.version !== MIGRATION_BACKUP_VERSION || typeof manifest.createdAt !== "string") {
+        throw new ConfigError(`Migration backup manifest at ${manifestPath} has an unsupported version.`, "INVALID_CONFIG_FILE");
+    }
+    const expected = expectedSourcePaths();
+    for (const name of ARTIFACT_NAMES) {
+        const artifact = manifest.artifacts?.[name];
+        if (!artifact ||
+            artifact.sourcePath !== expected[name] ||
+            typeof artifact.present !== "boolean" ||
+            !Number.isSafeInteger(artifact.byteSize) ||
+            artifact.byteSize < 0 ||
+            typeof artifact.createdAt !== "string" ||
+            (artifact.present
+                ? typeof artifact.sha256 !== "string" || artifact.sha256.length !== 64
+                : artifact.sha256 !== null)) {
+            throw new ConfigError(`Migration backup manifest has an invalid ${name} entry.`, "INVALID_CONFIG_FILE");
+        }
+    }
+    return manifest;
+}
+/** Verify the complete bundle, including source-path binding, modes, sizes, and hashes. */
+export function verifyMigrationBackup(bundlePath = getMigrationBackupDir()) {
+    if (!fs.existsSync(bundlePath) || !fs.statSync(bundlePath).isDirectory()) {
+        throw new ConfigError(`Migration backup does not exist at ${bundlePath}.`, "INVALID_CONFIG_FILE");
+    }
+    if (!ownerOnlyMode(bundlePath, true)) {
+        throw new ConfigError(`Migration backup directory ${bundlePath} must have mode 0700.`, "INVALID_CONFIG_FILE");
+    }
+    const manifest = parseManifest(bundlePath);
+    const expectedFiles = new Set(["manifest.json"]);
+    for (const name of ARTIFACT_NAMES) {
+        const artifact = manifest.artifacts[name];
+        const artifactPath = path.join(bundlePath, name);
+        if (!artifact.present) {
+            if (fs.existsSync(artifactPath)) {
+                throw new ConfigError(`Migration backup contains ${name}, but its manifest records it absent.`, "INVALID_CONFIG_FILE");
+            }
+            continue;
+        }
+        expectedFiles.add(name);
+        if (!fs.existsSync(artifactPath) || !fs.statSync(artifactPath).isFile()) {
+            throw new ConfigError(`Migration backup is missing ${artifactPath}.`, "INVALID_CONFIG_FILE");
+        }
+        if (!ownerOnlyMode(artifactPath, false)) {
+            throw new ConfigError(`Migration backup artifact ${artifactPath} must have mode 0600.`, "INVALID_CONFIG_FILE");
+        }
+        const stat = fs.statSync(artifactPath);
+        if (stat.size !== artifact.byteSize || sha256File(artifactPath) !== artifact.sha256) {
+            throw new ConfigError(`Migration backup artifact ${artifactPath} failed checksum verification.`, "INVALID_CONFIG_FILE");
+        }
+    }
+    if (!ownerOnlyMode(path.join(bundlePath, "manifest.json"), false)) {
+        throw new ConfigError(`Migration backup manifest must have mode 0600.`, "INVALID_CONFIG_FILE");
+    }
+    const extras = fs.readdirSync(bundlePath).filter((name) => !expectedFiles.has(name));
+    if (extras.length > 0) {
+        throw new ConfigError(`Migration backup contains unexpected files: ${extras.join(", ")}.`, "INVALID_CONFIG_FILE");
+    }
+    return manifest;
+}
+function acquireMigrationBackupLock() {
+    const lockPath = migrationBackupLockPath();
+    fs.mkdirSync(path.dirname(lockPath), { recursive: true, mode: 0o700 });
+    fs.chmodSync(path.dirname(lockPath), 0o700);
+    for (let attempt = 0; attempt < 50; attempt += 1) {
+        const ownership = tryAcquireLockSync(lockPath, createLockPayload());
+        if (ownership)
+            return () => releaseLock(ownership);
+        const probe = probeLock(lockPath);
+        if (probe.state === "stale" && reclaimStaleLock(lockPath, probe)) {
+            continue;
+        }
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 50);
+    }
+    throw new ConfigError(`Timed out waiting for migration backup lock at ${lockPath}.`, "INVALID_CONFIG_FILE");
+}
+function assertNotAlreadyCutOver() {
+    const configPath = getConfigPath();
+    let text;
+    try {
+        text = fs.readFileSync(configPath, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return;
+        throw error;
+    }
+    const raw = parseConfigText(text, configPath);
+    if (raw.configVersion === CURRENT_CONFIG_VERSION) {
+        throw new ConfigError(`Refusing to create a pre-0.9 migration backup from an existing ${CURRENT_CONFIG_VERSION} config at ${configPath}. Restore the original migration bundle or pre-cutover config before retrying.`, "INVALID_CONFIG_FILE");
+    }
+}
+function copyRegularArtifact(source, destination) {
+    const stat = fs.statSync(source);
+    if (!stat.isFile())
+        throw new ConfigError(`Backup source is not a regular file: ${source}`, "INVALID_CONFIG_FILE");
+    writeFileAtomic(destination, fs.readFileSync(source), 0o600);
+    fs.chmodSync(destination, 0o600);
+}
+function sqliteQuote(value) {
+    return `'${value.replaceAll("'", "''")}'`;
+}
+function backupSqlite(source, destination) {
+    const stat = fs.statSync(source);
+    if (!stat.isFile())
+        throw new ConfigError(`SQLite backup source is not a regular file: ${source}`, "INVALID_CONFIG_FILE");
+    const resolvedSource = path.resolve(source);
+    const activityName = resolvedSource === path.resolve(getWorkflowDbPath())
+        ? "workflow-db"
+        : resolvedSource === path.resolve(getStateDbPathInDataDir())
+            ? "state-db"
+            : undefined;
+    const releaseActivity = activityName ? acquireMaintenanceActivitySync(activityName) : undefined;
+    // The source was stat-verified above. Opening without Bun's `create:false`
+    // avoids bun:sqlite's SQLITE_MISUSE for that unsupported false option while
+    // retaining Node's ordinary existing-file behavior.
+    let db;
+    try {
+        db = openDatabase(source);
+        db.exec("PRAGMA busy_timeout = 10000");
+        db.exec("PRAGMA wal_checkpoint(FULL)");
+        db.exec(`VACUUM INTO ${sqliteQuote(destination)}`);
+    }
+    finally {
+        try {
+            db?.close();
+        }
+        finally {
+            releaseActivity?.();
+        }
+    }
+    fs.chmodSync(destination, 0o600);
+    const fd = fs.openSync(destination, "r");
+    try {
+        fs.fsyncSync(fd);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+function createMigrationBackupUnlocked() {
+    const bundlePath = getMigrationBackupDir();
+    if (fs.existsSync(bundlePath)) {
+        return { path: bundlePath, created: false, manifest: verifyMigrationBackup(bundlePath) };
+    }
+    assertNotAlreadyCutOver();
+    const parent = path.dirname(bundlePath);
+    fs.mkdirSync(parent, { recursive: true, mode: 0o700 });
+    fs.chmodSync(parent, 0o700);
+    const temporary = path.join(parent, `.0.9.0.tmp.${process.pid}.${crypto.randomBytes(8).toString("hex")}`);
+    fs.mkdirSync(temporary, { mode: 0o700 });
+    const createdAt = new Date().toISOString();
+    const sources = expectedSourcePaths();
+    const artifacts = {};
+    try {
+        for (const name of ARTIFACT_NAMES) {
+            const sourcePath = sources[name];
+            const destination = path.join(temporary, name);
+            let present = true;
+            try {
+                fs.statSync(sourcePath);
+            }
+            catch (error) {
+                if (error.code === "ENOENT")
+                    present = false;
+                else
+                    throw error;
+            }
+            if (present) {
+                if (name === "config.json")
+                    copyRegularArtifact(sourcePath, destination);
+                else
+                    backupSqlite(sourcePath, destination);
+            }
+            const byteSize = present ? fs.statSync(destination).size : 0;
+            artifacts[name] = {
+                sourcePath,
+                present,
+                byteSize,
+                sha256: present ? sha256File(destination) : null,
+                createdAt,
+            };
+        }
+        const manifest = { version: MIGRATION_BACKUP_VERSION, createdAt, artifacts };
+        writeFileAtomic(path.join(temporary, "manifest.json"), `${JSON.stringify(manifest, null, 2)}\n`, 0o600);
+        fs.chmodSync(path.join(temporary, "manifest.json"), 0o600);
+        fsyncDirectory(temporary);
+        fs.renameSync(temporary, bundlePath);
+        fsyncDirectory(parent);
+        return { path: bundlePath, created: true, manifest: verifyMigrationBackup(bundlePath) };
+    }
+    catch (error) {
+        fs.rmSync(temporary, { recursive: true, force: true });
+        if (fs.existsSync(bundlePath)) {
+            throw new ConfigError(`Migration backup creation raced with another writer and left ${bundlePath}. Verify or preserve it before retrying.`, "INVALID_CONFIG_FILE");
+        }
+        throw error;
+    }
+}
+function withMigrationBackupLock(fn) {
+    const release = acquireMigrationBackupLock();
+    try {
+        return fn();
+    }
+    finally {
+        release();
+    }
+}
+/** Create or verify the immutable pre-cutover bundle. Safe for raw legacy config. */
+export function createMigrationBackup() {
+    return withConfigLock(() => withMigrationBackupLock(createMigrationBackupUnlocked));
+}
+/** Used while a config mutation already owns config.json.lck. */
+export function ensureMigrationBackupWithConfigLockHeld() {
+    return withMigrationBackupLock(createMigrationBackupUnlocked);
+}
+/** Used by database migration hooks before applying the first 0.9 migration. */
+export function ensureMigrationBackup() {
+    return createMigrationBackup();
+}
+function activeRestoreLocks() {
+    const lockPaths = [getLockfileLockPath(), getIndexWriterLockPath()];
+    const configLock = path.join(path.dirname(getConfigPath()), "config.json.lck");
+    const dataDir = getDataDir();
+    for (const name of ["improve.lock", "consolidate.lock", "reflect-distill.lock", "triage.lock"]) {
+        lockPaths.push(path.join(dataDir, name));
+    }
+    const stashDirs = new Set();
+    for (const configPath of [getConfigPath(), path.join(getMigrationBackupDir(), "config.json")]) {
+        try {
+            const raw = parseConfigText(fs.readFileSync(configPath, "utf8"), configPath);
+            if (typeof raw.stashDir === "string" && raw.stashDir)
+                stashDirs.add(raw.stashDir);
+        }
+        catch {
+            // Restore still verifies the bundle. A malformed live config must not
+            // prevent recovery; it simply cannot contribute an extra stash lock path.
+        }
+    }
+    for (const stashDir of stashDirs) {
+        for (const name of ["improve.lock", "consolidate.lock", "reflect-distill.lock", "triage.lock"]) {
+            lockPaths.push(path.join(stashDir, ".akm", name));
+        }
+    }
+    for (const baseDir of [dataDir, ...[...stashDirs].map((stashDir) => path.join(stashDir, ".akm"))]) {
+        const extractLockDir = path.join(baseDir, "extract-locks");
+        try {
+            for (const entry of fs.readdirSync(extractLockDir, { withFileTypes: true })) {
+                if (entry.isFile() && entry.name.endsWith(".lock"))
+                    lockPaths.push(path.join(extractLockDir, entry.name));
+            }
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+    }
+    const activityDir = path.join(path.dirname(getLockfileLockPath()), "maintenance-activities");
+    try {
+        for (const entry of fs.readdirSync(activityDir, { withFileTypes: true })) {
+            if (entry.isFile() && entry.name.endsWith(".lock"))
+                lockPaths.push(path.join(activityDir, entry.name));
+        }
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    return [configLock, ...lockPaths].filter((lockPath) => {
+        const probe = probeLock(lockPath);
+        return probe.state === "held" && (lockPath !== configLock || probe.holderPid !== process.pid);
+    });
+}
+function activeWorkflowClaims() {
+    const workflowPath = getWorkflowDbPath();
+    if (!fs.existsSync(workflowPath))
+        return [];
+    // Restore already owns the maintenance barrier for this handle's complete
+    // lifetime. Registering a normal workflow-db activity here would re-enter
+    // that barrier and deadlock against ourselves.
+    const db = openDatabase(workflowPath, { readonly: true });
+    try {
+        const runsTable = db
+            .prepare("SELECT 1 AS present FROM sqlite_master WHERE type = 'table' AND name = 'workflow_runs'")
+            .get();
+        const blockers = [];
+        if (runsTable) {
+            const columns = new Set(db.prepare("PRAGMA table_info(workflow_runs)").all().map((row) => row.name));
+            if (columns.has("engine_lease_holder") && columns.has("engine_lease_until")) {
+                const now = new Date().toISOString();
+                blockers.push(...db
+                    .prepare(`SELECT id, engine_lease_holder AS holder, engine_lease_until AS expires
+                 FROM workflow_runs
+                 WHERE engine_lease_holder IS NOT NULL AND engine_lease_until IS NOT NULL AND engine_lease_until >= ?`)
+                    .all(now).map((lease) => `${workflowPath}#run=${lease.id},holder=${lease.holder},expires=${lease.expires}`));
+            }
+        }
+        const unitsTable = db
+            .prepare("SELECT 1 AS present FROM sqlite_master WHERE type = 'table' AND name = 'workflow_run_units'")
+            .get();
+        if (!unitsTable)
+            return blockers;
+        const unitColumns = new Set(db.prepare("PRAGMA table_info(workflow_run_units)").all().map((row) => row.name));
+        if (!unitColumns.has("claim_holder") || !unitColumns.has("claim_expires_at"))
+            return blockers;
+        const now = new Date().toISOString();
+        blockers.push(...db
+            .prepare(`SELECT run_id AS runId, unit_id AS unitId, claim_holder AS holder, claim_expires_at AS expires
+             FROM workflow_run_units
+             WHERE status = 'running' AND claim_holder IS NOT NULL
+               AND claim_expires_at IS NOT NULL AND claim_expires_at >= ?`)
+            .all(now).map((claim) => `${workflowPath}#run=${claim.runId},unit=${claim.unitId},holder=${claim.holder},expires=${claim.expires}`));
+        return blockers;
+    }
+    finally {
+        db.close();
+    }
+}
+function restoreArtifact(source, destination) {
+    fs.mkdirSync(path.dirname(destination), { recursive: true, mode: 0o700 });
+    writeFileAtomic(destination, fs.readFileSync(source), 0o600);
+    fs.chmodSync(destination, 0o600);
+}
+/** Restore exactly the manifest's original presence/absence state. */
+export function restoreMigrationBackup(confirm) {
+    if (!confirm) {
+        throw new ConfigError("Migration backup restore requires --confirm.", "INVALID_CONFIG_FILE");
+    }
+    return withConfigLock(() => withMigrationBackupLock(() => {
+        return withMaintenanceStartBarrier(() => {
+            const blockers = [...activeRestoreLocks(), ...activeWorkflowClaims()];
+            if (blockers.length > 0) {
+                throw new ConfigError(`Refusing restore while AKM locks or workflow leases are active: ${blockers.join(", ")}.`, "INVALID_CONFIG_FILE");
+            }
+            const bundlePath = getMigrationBackupDir();
+            const manifest = verifyMigrationBackup(bundlePath);
+            for (const name of ARTIFACT_NAMES) {
+                const artifact = manifest.artifacts[name];
+                if (artifact.present)
+                    restoreArtifact(path.join(bundlePath, name), artifact.sourcePath);
+                else
+                    fs.rmSync(artifact.sourcePath, { force: true });
+                fs.rmSync(`${artifact.sourcePath}-wal`, { force: true });
+                fs.rmSync(`${artifact.sourcePath}-shm`, { force: true });
+            }
+            return { path: bundlePath, created: false, manifest };
+        });
+    }));
+}

package/dist/core/paths.js

@@ -218,6 +218,9 @@ export function getDbPath(env = process.env) {
 export function getIndexWriterLockPath() {
     return path.join(getDataDir(), "index.db.write.lock");
 }
+export function getMaintenanceBarrierPath() {
+    return path.join(getDataDir(), "maintenance.barrier.lock");
+}
 export function getWorkflowDbPath() {
     return path.join(getDataDir(), "workflow.db");
 }