@indigoai-us/hq-cli 5.345.171 → 5.345.173

package/dist/commands/sync-core.js

@@ -0,0 +1,126 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { ensureSyncCoreBinary } from "../lib/sync-core/release.js";
+import { readCompanyRolloutFlag } from "../lib/sync-core/flag.js";
+import { reconcileSyncCore } from "../lib/sync-core/reconcile.js";
+import { readSyncCoreRolloutState, syncCoreRolloutStatePath } from "../lib/sync-core/rollout-state.js";
+import { readVaultSyncSwitches } from "../lib/vault-sync-switches.js";
+function defaultDeps() {
+    return {
+        home: os.homedir(),
+        env: process.env,
+        platform: process.platform,
+        arch: process.arch,
+        out: (line) => console.log(line),
+        err: (line) => console.error(line),
+    };
+}
+async function resolveHqRoot(flag, env) {
+    const configured = flag?.trim() || env.HQ_ROOT?.trim();
+    if (configured) {
+        const root = path.resolve(configured);
+        if (!fs.existsSync(path.join(root, "companies")))
+            throw new Error(`${root} is not an HQ folder (no companies/ inside it)`);
+        return root;
+    }
+    const { readDaemonConfig } = await import("../lib/daemon/config.js");
+    const { daemonPaths } = await import("../lib/daemon/paths.js");
+    const fromDaemon = readDaemonConfig(daemonPaths(os.homedir(), env).configPath).hqRoot;
+    if (fromDaemon && fs.existsSync(path.join(fromDaemon, "companies")))
+        return fromDaemon;
+    const { resolveDefaultHqRoot } = await import("../utils/cognito-session.js");
+    const fallback = resolveDefaultHqRoot();
+    if (fallback && fs.existsSync(path.join(fallback, "companies")))
+        return fallback;
+    throw new Error("no HQ folder found; pass --hq-root <path>");
+}
+export async function runSyncCoreReconcile(opts, d = defaultDeps()) {
+    const hqRoot = await resolveHqRoot(opts.hqRoot, d.env);
+    const [{ VaultClient }, { buildVaultConfig, ensureCognitoIdToken, machineTokenCacheFile, wantsMachineCognitoTokens }] = await Promise.all([import("@indigoai-us/hq-cloud"), import("../utils/cognito-session.js")]);
+    const token = await ensureCognitoIdToken({ interactive: false });
+    const machine = wantsMachineCognitoTokens({});
+    const tokenFile = path.resolve(opts.tokenFile?.trim() || (machine ? machineTokenCacheFile(d.home, d.env) : path.join(d.home, ".hq", "cognito-tokens.json")));
+    if (!fs.existsSync(tokenFile))
+        throw new Error(`the token file ${tokenFile} does not exist`);
+    const client = new VaultClient(buildVaultConfig(token));
+    const { resolveCanonicalPersonUid } = await import("./cloud.js");
+    const result = await reconcileSyncCore({
+        home: d.home,
+        hqRoot,
+        tokenFile,
+        companiesOnly: opts.companiesOnly === true || machine,
+        listMemberships: async () => (await client.listMyMemberships()).map((m) => ({ companyUid: m.companyUid })),
+        resolvePersonUid: () => resolveCanonicalPersonUid({
+            listMyMemberships: () => client.listMyMemberships(),
+            listPersonEntities: () => client.entity.listByType("person"),
+            getEntity: async () => null,
+        }),
+        readRolloutFlag: (companyUid) => readCompanyRolloutFlag(companyUid, token, { env: d.env }),
+        ensureBinary: (release) => ensureSyncCoreBinary({ home: d.home, platform: d.platform, arch: d.arch, release, env: d.env }),
+        log: opts.json ? () => { } : d.out,
+    });
+    if (opts.json)
+        d.out(JSON.stringify(result.state, null, 2));
+    else if (result.state.vaults.length === 0)
+        d.out("no vault on this machine is switched to the new sync engine");
+    return result;
+}
+export function runSyncCoreStatus(opts, d = defaultDeps()) {
+    const state = readSyncCoreRolloutState(d.home);
+    if (opts.json) {
+        d.out(JSON.stringify(state, null, 2));
+        return;
+    }
+    if (!state) {
+        d.out(`no rollout state yet (${syncCoreRolloutStatePath(d.home)})`);
+        return;
+    }
+    const switches = readVaultSyncSwitches(d.home);
+    d.out(`engine ${state.release} at ${state.binaryPath}, last read ${state.readAt}`);
+    if (state.error)
+        d.out(`warning: ${state.error}`);
+    for (const vault of state.vaults) {
+        const legacyOff = vault.kind === "personal" ? switches.personalOff : switches.offCompanies.has(vault.slug ?? "");
+        d.out(`  ${vault.uid}  ${vault.kind}${vault.slug ? ` ${vault.slug}` : ""}  ${vault.phase === "full" ? "full" : "read-only"}  legacy sync ${legacyOff ? "off" : "still on"}  home ${vault.engineHome}`);
+        if (vault.plan) {
+            const p = vault.plan;
+            d.out(`    plan ${p.at}: ${p.remoteRows} server rows, ${p.localFiles} local files; would upload ${p.uploads}, download ${p.downloads}, delete ${p.deletes}, write ${p.conflicts} conflict or merge copies`);
+        }
+        if (vault.hold)
+            d.out(`    held read-only: ${vault.hold}`);
+    }
+    for (const skip of state.skipped ?? [])
+        d.out(`  ${skip.uid}  skipped on this machine: ${skip.reason}`);
+    if (state.vaults.length === 0)
+        d.out("  no vault is switched to the new sync engine");
+}
+export function registerSyncCoreCommand(program, over = {}) {
+    const deps = () => ({ ...defaultDeps(), ...over });
+    const syncCore = program
+        .command("sync-core", { hidden: true })
+        .description("Move this machine's vaults between the current sync and the new sync engine, following each company's switch");
+    syncCore
+        .command("reconcile")
+        .description("Read each company's switch, install the engine when needed, and write the engine homes and legacy off-switches")
+        .option("--hq-root <path>", "HQ folder (default: the daemon's)")
+        .option("--companies-only", "Never move the personal vault (agent boxes)")
+        .option("--token-file <path>", "Token file the engine reads (default: this user's hq sign-in)")
+        .option("--json", "Print the written rollout state as JSON")
+        .action(async (opts) => {
+        const d = deps();
+        try {
+            await runSyncCoreReconcile(opts, d);
+        }
+        catch (error) {
+            d.err(error instanceof Error ? error.message : String(error));
+            process.exitCode = 1;
+        }
+    });
+    syncCore
+        .command("status")
+        .description("Show which vaults are on the new sync engine on this machine")
+        .option("--json", "Print JSON")
+        .action((opts) => runSyncCoreStatus(opts, deps()));
+}
+//# sourceMappingURL=sync-core.js.map