feat: Added new remote management commands

2026-06-11 17:00:13 +00:00 · 2026-06-08 04:23:22 +00:00
parent 31050c9cb8
commit 5922186a0e
8 changed files with 529 additions and 6 deletions
@@ -2,7 +2,14 @@ import * as fs from "fs/promises";
 import * as path from "path";
 import { decodeSettingsFromSetupURI } from "@lib/API/processSetting";
 import { configURIBase } from "@lib/common/models/shared.const";
-import { DEFAULT_SETTINGS, type FilePathWithPrefix, type ObsidianLiveSyncSettings } from "@lib/common/types";
+import {
+    DEFAULT_SETTINGS,
+    MILESTONE_DOCID,
+    type FilePathWithPrefix,
+    type ObsidianLiveSyncSettings,
+    REMOTE_COUCHDB,
+    REMOTE_MINIO,
+} from "@lib/common/types";
 import { ConnectionStringParser } from "@lib/common/ConnectionString";
 import { activateRemoteConfiguration, createRemoteConfigurationId } from "@lib/serviceFeatures/remoteConfig";
 import { stripAllPrefixes } from "@lib/string_and_binary/path";
@@ -16,6 +23,51 @@ function redactConnectionString(uri: string): string {
    return uri.replace(/\/\/([^@/]+)@/u, "//***@");
 }

+async function verifyRemoteState(
+    core: CLICommandContext["core"],
+    settings: ObsidianLiveSyncSettings
+): Promise<boolean> {
+    const replicator = core.services.replicator.getActiveReplicator();
+    if (!replicator) {
+        process.stderr.write("[Verification] No active replicator found\n");
+        return false;
+    }
+
+    if (!replicator.nodeid) {
+        await replicator.initializeDatabaseForReplication();
+    }
+
+    try {
+        let milestone: any;
+        if (settings.remoteType === REMOTE_COUCHDB) {
+            const dbRet = await (replicator as any).connectRemoteCouchDBWithSetting(settings, false, true);
+            if (typeof dbRet === "string") {
+                process.stderr.write(`[Verification] Failed to connect to remote CouchDB: ${dbRet}\n`);
+                return false;
+            }
+            milestone = await dbRet.db.get(MILESTONE_DOCID);
+        } else if (settings.remoteType === REMOTE_MINIO) {
+            milestone = await (replicator as any).client.downloadJson("_00000000-milestone.json");
+        }
+
+        if (milestone) {
+            const isLocked = !!milestone.locked;
+            const isAccepted = !!milestone.accepted_nodes?.includes(replicator.nodeid);
+            process.stderr.write(`[Verification] Remote Database: ${isLocked ? "LOCKED" : "UNLOCKED"}\n`);
+            process.stderr.write(
+                `[Verification] Current Device Node ID (${replicator.nodeid}): ${isAccepted ? "ACCEPTED" : "NOT ACCEPTED"}\n`
+            );
+            return true;
+        } else {
+            process.stderr.write("[Verification] Milestone document not found on remote.\n");
+            return false;
+        }
+    } catch (e: any) {
+        process.stderr.write(`[Verification] Failed to fetch milestone document: ${e?.message || e}\n`);
+        return false;
+    }
+}
+
 export async function runCommand(options: CLIOptions, context: CLICommandContext): Promise<boolean> {
    const { databasePath, core, settingsPath } = context;

@@ -646,7 +698,6 @@ export async function runCommand(options: CLIOptions, context: CLICommandContext
        console.error(`[Command] remote-set ${id}`);
        return true;
    }
-
    if (options.command === "remote-activate") {
        if (options.commandArgs.length < 1) {
            throw new Error("remote-activate requires one argument: <remote-id>");
@@ -676,5 +727,126 @@ export async function runCommand(options: CLIOptions, context: CLICommandContext
        return true;
    }

+    if (options.command === "mark-resolved") {
+        const id = options.commandArgs[0]?.trim();
+        if (id) {
+            let switched = false;
+            await core.services.setting.updateSettings((currentSettings) => {
+                const activated = activateRemoteConfiguration(currentSettings, id);
+                if (activated) {
+                    switched = true;
+                    return activated;
+                }
+                return currentSettings;
+            }, false);
+
+            if (!switched) {
+                process.stderr.write(`[Info] Failed to temporarily activate remote configuration: ${id}\n`);
+                return false;
+            }
+
+            await core.services.control.applySettings();
+        }
+
+        console.error(`[Command] mark-resolved${id ? ` ${id}` : ""}`);
+        await core.services.replication.markResolved();
+        const settings = core.services.setting.currentSettings();
+        await verifyRemoteState(core, settings);
+        return true;
+    }
+
+    if (options.command === "unlock-remote") {
+        const id = options.commandArgs[0]?.trim();
+        if (id) {
+            let switched = false;
+            await core.services.setting.updateSettings((currentSettings) => {
+                const activated = activateRemoteConfiguration(currentSettings, id);
+                if (activated) {
+                    switched = true;
+                    return activated;
+                }
+                return currentSettings;
+            }, false);
+
+            if (!switched) {
+                process.stderr.write(`[Info] Failed to temporarily activate remote configuration: ${id}\n`);
+                return false;
+            }
+
+            await core.services.control.applySettings();
+        }
+
+        console.error(`[Command] unlock-remote${id ? ` ${id}` : ""}`);
+        await core.services.replication.markUnlocked();
+        const settings = core.services.setting.currentSettings();
+        await verifyRemoteState(core, settings);
+        return true;
+    }
+
+    if (options.command === "lock-remote") {
+        const id = options.commandArgs[0]?.trim();
+        if (id) {
+            let switched = false;
+            await core.services.setting.updateSettings((currentSettings) => {
+                const activated = activateRemoteConfiguration(currentSettings, id);
+                if (activated) {
+                    switched = true;
+                    return activated;
+                }
+                return currentSettings;
+            }, false);
+
+            if (!switched) {
+                process.stderr.write(`[Info] Failed to temporarily activate remote configuration: ${id}\n`);
+                return false;
+            }
+
+            await core.services.control.applySettings();
+        }
+
+        console.error(`[Command] lock-remote${id ? ` ${id}` : ""}`);
+        await core.services.replication.markLocked();
+        const settings = core.services.setting.currentSettings();
+        await verifyRemoteState(core, settings);
+        return true;
+    }
+
+    if (options.command === "remote-status") {
+        const id = options.commandArgs[0]?.trim();
+        if (id) {
+            let switched = false;
+            await core.services.setting.updateSettings((currentSettings) => {
+                const activated = activateRemoteConfiguration(currentSettings, id);
+                if (activated) {
+                    switched = true;
+                    return activated;
+                }
+                return currentSettings;
+            }, false);
+
+            if (!switched) {
+                process.stderr.write(`[Info] Failed to temporarily activate remote configuration: ${id}\n`);
+                return false;
+            }
+
+            await core.services.control.applySettings();
+        }
+
+        console.error(`[Command] remote-status${id ? ` ${id}` : ""}`);
+        const replicator = core.services.replicator.getActiveReplicator();
+        if (!replicator) {
+            process.stderr.write("[Error] No active replicator found\n");
+            return false;
+        }
+        const settings = core.services.setting.currentSettings();
+        const status = await replicator.getRemoteStatus(settings);
+        if (status === false) {
+            process.stderr.write("[Error] Failed to fetch remote status\n");
+            return false;
+        }
+        process.stdout.write(JSON.stringify(status, null, 2) + "\n");
+        return true;
+    }
+
    throw new Error(`Unsupported command: ${options.command}`);
 }
@@ -28,6 +28,34 @@ function createCoreMock() {
                    updater(liveSettings);
                }),
            },
+            replication: {
+                markResolved: vi.fn(async () => {}),
+                markUnlocked: vi.fn(async () => {}),
+                markLocked: vi.fn(async () => {}),
+            },
+            replicator: {
+                getActiveReplicator: vi.fn(() => ({
+                    nodeid: "test-node-id",
+                    initializeDatabaseForReplication: vi.fn(async () => {}),
+                    connectRemoteCouchDBWithSetting: vi.fn(async () => ({
+                        db: {
+                            get: vi.fn(async (id) => {
+                                if (id.includes("milestone")) {
+                                    return {
+                                        locked: false,
+                                        accepted_nodes: ["test-node-id"],
+                                    };
+                                }
+                                throw new Error("not found");
+                            }),
+                        },
+                    })),
+                    getRemoteStatus: vi.fn(async () => ({
+                        db_name: "test-db",
+                        doc_count: 42,
+                    })),
+                })),
+            },
        },
        serviceModules: {
            fileHandler: {
@@ -572,4 +600,139 @@ describe("runCommand abnormal cases", () => {
        const exported2 = export2Lines.length > 0 ? export2Lines[export2Lines.length - 1] : "";
        expect(exported2).toBe(roundTripInput);
    });
+
+    describe("mark-resolved and unlock-remote commands", () => {
+        it("mark-resolved without args runs on active database", async () => {
+            const core = createCoreMock();
+            const result = await runCommand(makeOptions("mark-resolved", []), {
+                ...context,
+                core,
+            });
+            expect(result).toBe(true);
+            expect(core.services.replication.markResolved).toHaveBeenCalledTimes(1);
+            expect(core.services.control.applySettings).not.toHaveBeenCalled();
+        });
+
+        it("mark-resolved with remote-id temporarily activates it and runs markResolved", async () => {
+            const core = createCoreMock();
+            const settings = core.services.setting.currentSettings();
+            settings.remoteConfigurations.r1 = {
+                id: "r1",
+                name: "R1",
+                uri: "sls+https://example.com/db1",
+                isEncrypted: false,
+            };
+
+            const result = await runCommand(makeOptions("mark-resolved", ["r1"]), {
+                ...context,
+                core,
+            });
+            expect(result).toBe(true);
+            expect(core.services.replication.markResolved).toHaveBeenCalledTimes(1);
+            expect(core.services.control.applySettings).toHaveBeenCalledTimes(1);
+            expect(settings.activeConfigurationId).toBe("r1");
+            expect(core.services.setting.updateSettings).toHaveBeenCalledWith(expect.any(Function), false);
+        });
+
+        it("unlock-remote without args runs on active database", async () => {
+            const core = createCoreMock();
+            const result = await runCommand(makeOptions("unlock-remote", []), {
+                ...context,
+                core,
+            });
+            expect(result).toBe(true);
+            expect(core.services.replication.markUnlocked).toHaveBeenCalledTimes(1);
+            expect(core.services.control.applySettings).not.toHaveBeenCalled();
+        });
+
+        it("unlock-remote with remote-id temporarily activates it and runs markUnlocked", async () => {
+            const core = createCoreMock();
+            const settings = core.services.setting.currentSettings();
+            settings.remoteConfigurations.r1 = {
+                id: "r1",
+                name: "R1",
+                uri: "sls+https://example.com/db1",
+                isEncrypted: false,
+            };
+
+            const result = await runCommand(makeOptions("unlock-remote", ["r1"]), {
+                ...context,
+                core,
+            });
+            expect(result).toBe(true);
+            expect(core.services.replication.markUnlocked).toHaveBeenCalledTimes(1);
+            expect(core.services.control.applySettings).toHaveBeenCalledTimes(1);
+            expect(settings.activeConfigurationId).toBe("r1");
+            expect(core.services.setting.updateSettings).toHaveBeenCalledWith(expect.any(Function), false);
+        });
+
+        it("lock-remote without args runs on active database", async () => {
+            const core = createCoreMock();
+            const result = await runCommand(makeOptions("lock-remote", []), {
+                ...context,
+                core,
+            });
+            expect(result).toBe(true);
+            expect(core.services.replication.markLocked).toHaveBeenCalledTimes(1);
+            expect(core.services.control.applySettings).not.toHaveBeenCalled();
+        });
+
+        it("lock-remote with remote-id temporarily activates it and runs markLocked", async () => {
+            const core = createCoreMock();
+            const settings = core.services.setting.currentSettings();
+            settings.remoteConfigurations.r1 = {
+                id: "r1",
+                name: "R1",
+                uri: "sls+https://example.com/db1",
+                isEncrypted: false,
+            };
+
+            const result = await runCommand(makeOptions("lock-remote", ["r1"]), {
+                ...context,
+                core,
+            });
+            expect(result).toBe(true);
+            expect(core.services.replication.markLocked).toHaveBeenCalledTimes(1);
+            expect(core.services.control.applySettings).toHaveBeenCalledTimes(1);
+            expect(settings.activeConfigurationId).toBe("r1");
+            expect(core.services.setting.updateSettings).toHaveBeenCalledWith(expect.any(Function), false);
+        });
+
+        it("remote-status without args outputs status of active remote configuration", async () => {
+            const core = createCoreMock();
+            const stdout = captureStdout();
+            const result = await runCommand(makeOptions("remote-status", []), {
+                ...context,
+                core,
+            });
+            expect(result).toBe(true);
+            const fullOutput = stdout.spy.mock.calls.map((c) => c[0]).join("");
+            const parsedStatus = JSON.parse(fullOutput);
+            expect(parsedStatus.db_name).toBe("test-db");
+            expect(parsedStatus.doc_count).toBe(42);
+        });
+
+        it("remote-status with remote-id temporarily activates it and outputs status", async () => {
+            const core = createCoreMock();
+            const settings = core.services.setting.currentSettings();
+            settings.remoteConfigurations.r1 = {
+                id: "r1",
+                name: "R1",
+                uri: "sls+https://example.com/db1",
+                isEncrypted: false,
+            };
+            const stdout = captureStdout();
+            const result = await runCommand(makeOptions("remote-status", ["r1"]), {
+                ...context,
+                core,
+            });
+            expect(result).toBe(true);
+            const fullOutput = stdout.spy.mock.calls.map((c) => c[0]).join("");
+            const parsedStatus = JSON.parse(fullOutput);
+            expect(parsedStatus.db_name).toBe("test-db");
+            expect(parsedStatus.doc_count).toBe(42);
+            expect(settings.activeConfigurationId).toBe("r1");
+            expect(core.services.setting.updateSettings).toHaveBeenCalledWith(expect.any(Function), false);
+        });
+    });
 });
@@ -26,6 +26,10 @@ export type CLICommand =
    | "remote-export"
    | "remote-set"
    | "remote-activate"
+    | "mark-resolved"
+    | "unlock-remote"
+    | "lock-remote"
+    | "remote-status"
    | "init-settings";

 export interface CLIOptions {
@@ -79,5 +83,9 @@ export const VALID_COMMANDS = new Set([
    "remote-export",
    "remote-set",
    "remote-activate",
+    "mark-resolved",
+    "unlock-remote",
+    "lock-remote",
+    "remote-status",
    "init-settings",
 ] as const);