@indigoai-us/hq-cli 5.345.160 → 5.345.162

package/dist/commands/sync-held.js

@@ -0,0 +1,191 @@
+/**
+ * `hq sync held` and `hq sync release-held` (feedback_3bf773c5).
+ *
+ * After a different person signs in on the same computer, hq-cloud holds every
+ * upload and cloud delete for each sync scope (the personal vault and each
+ * company) until the signed-in person reviews what is held and releases it.
+ * These commands are the person's way to see the hold and make that decision.
+ *
+ * The hq-cloud exports (`listPushIdentityFences`, `releasePushIdentityFences`)
+ * ship after the hq-cloud version this CLI pins, so they are feature-detected
+ * on the module namespace, the same way `lib/hq-cloud-manifest.ts` does it. A
+ * static named import of a missing ESM export would stop every command that
+ * loads this file.
+ */
+import * as hqCloud from "@indigoai-us/hq-cloud";
+import chalk from "chalk";
+import * as readline from "node:readline/promises";
+import { VaultClient, PERSONAL_VAULT_JOURNAL_SLUG, getStateDir } from "@indigoai-us/hq-cloud";
+import { buildVaultConfig, cognitoSubjectFromToken, ensureCognitoToken } from "../utils/cognito-session.js";
+import { decodeJwtPayload } from "../utils/person-token-cache.js";
+import { resolveCanonicalPersonUid } from "./cloud.js";
+export const HELD_UNAVAILABLE_MESSAGE = "this HQ build cannot list or release held uploads yet; update HQ and try again";
+export function fenceExports(mod = hqCloud) {
+    const list = mod.listPushIdentityFences;
+    const release = mod.releasePushIdentityFences;
+    if (typeof list !== "function" || typeof release !== "function")
+        return undefined;
+    return {
+        listPushIdentityFences: list,
+        releasePushIdentityFences: release,
+    };
+}
+export function scopeLabel(slug) {
+    return slug === PERSONAL_VAULT_JOURNAL_SLUG || slug === "personal" ? "personal vault" : `company ${slug}`;
+}
+function describe(scope) {
+    const since = new Date(scope.sinceMs).toISOString();
+    const lines = [`  ${scopeLabel(scope.slug)}: held since ${since}`];
+    if (scope.held) {
+        lines.push(`    ${scope.held.count} file${scope.held.count === 1 ? "" : "s"} waiting to upload (last checked ${scope.held.at})`);
+        for (const sample of scope.held.samplePaths.slice(0, 20))
+            lines.push(`      ${sample}`);
+        if (scope.held.count > Math.min(20, scope.held.samplePaths.length))
+            lines.push("      ...");
+    }
+    return lines;
+}
+export async function runSyncHeld(deps, json = false) {
+    if (!deps.exports) {
+        deps.log(`${chalk.red("✗")} ${HELD_UNAVAILABLE_MESSAGE}`);
+        return 1;
+    }
+    const scopes = deps.exports.listPushIdentityFences(deps.stateDir);
+    if (json) {
+        deps.log(JSON.stringify({ scopes }));
+        return 0;
+    }
+    if (scopes.length === 0) {
+        deps.log("No uploads are held on this computer.");
+        return 0;
+    }
+    deps.log("Someone else was signed in on this computer, so these uploads are held:");
+    for (const scope of scopes)
+        for (const line of describe(scope))
+            deps.log(line);
+    deps.log("");
+    deps.log("Nothing has been uploaded or deleted in the cloud. If these files are yours, run `hq sync release-held`.");
+    return 0;
+}
+export async function runReleaseHeld(deps, options) {
+    if (!deps.exports) {
+        deps.log(`${chalk.red("✗")} ${HELD_UNAVAILABLE_MESSAGE}`);
+        return 1;
+    }
+    let scopes = deps.exports.listPushIdentityFences(deps.stateDir);
+    if (options.personal)
+        scopes = scopes.filter((scope) => scope.slug === PERSONAL_VAULT_JOURNAL_SLUG || scope.slug === "personal");
+    if (options.company)
+        scopes = scopes.filter((scope) => scope.slug === options.company);
+    if (scopes.length === 0) {
+        deps.log(options.json ? JSON.stringify({ released: [] }) : "No held uploads match.");
+        return 0;
+    }
+    const needPersonal = scopes.some((scope) => scope.slug === PERSONAL_VAULT_JOURNAL_SLUG || scope.slug === "personal");
+    const snapshot = await deps.identity({ needPersonal, interactive: true });
+    const identities = [snapshot.sub, ...(snapshot.personalUid ? [snapshot.personalUid] : [])];
+    const mine = scopes.filter((scope) => identities.includes(scope.uid));
+    if (mine.length === 0) {
+        deps.log(options.json
+            ? JSON.stringify({ released: [], reason: "not-yours" })
+            : "These held uploads belong to a different signed-in person. Sign in as that person to release them.");
+        return 1;
+    }
+    if (!options.json) {
+        deps.log("Releasing these uploads sends the files below to the cloud as yours:");
+        for (const scope of mine)
+            for (const line of describe(scope))
+                deps.log(line);
+    }
+    if (!options.yes) {
+        const ok = await deps.confirm("Are these files yours to upload? [y/N] ");
+        if (!ok) {
+            deps.log(options.json ? JSON.stringify({ released: [] }) : "Nothing released.");
+            return 1;
+        }
+    }
+    // Re-read the signed-in identity right before releasing, without a sign-in.
+    // If the account changed since the snapshot (including during the prompt),
+    // release nothing: the scopes were judged against the earlier account.
+    const current = await deps.identity({ needPersonal, interactive: false });
+    if (current.sub !== snapshot.sub || current.personalUid !== snapshot.personalUid) {
+        deps.log(options.json
+            ? JSON.stringify({ released: [], reason: "identity-changed" })
+            : "The signed-in account changed while releasing. Nothing was released; run the command again.");
+        return 1;
+    }
+    const released = deps.exports.releasePushIdentityFences(deps.stateDir, identities, mine.map((scope) => scope.slug));
+    deps.log(options.json
+        ? JSON.stringify({ released })
+        : `Released ${released.map(scopeLabel).join(", ")}. The next sync uploads these files.`);
+    return 0;
+}
+async function confirmOnTty(question) {
+    if (process.stdin.isTTY !== true || process.stdout.isTTY !== true)
+        return false;
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const answer = await rl.question(question);
+        return /^y(es)?$/i.test(answer.trim());
+    }
+    finally {
+        rl.close();
+    }
+}
+/**
+ * The signed-in identity from the session token `ensureCognitoToken` selects
+ * (person or machine, the same choice every vault call makes). The personal
+ * vault uid is resolved with that same token: an agent principal uses its own
+ * entity uid, as the sync runner does; a person uses the canonical person
+ * entity.
+ */
+export async function resolveHeldIdentity(options, io) {
+    const token = await io.ensureToken(options.interactive);
+    const { sub, entityUid } = cognitoSubjectFromToken(token);
+    if (!sub)
+        throw new Error("could not read the signed-in account from the session; run `hq login` and try again");
+    if (!options.needPersonal)
+        return { sub };
+    const entityType = decodeJwtPayload(token)?.["custom:entityType"];
+    if (entityType === "agent" && entityUid)
+        return { sub, personalUid: entityUid };
+    const personalUid = await resolveCanonicalPersonUid({
+        listMyMemberships: async () => [],
+        listPersonEntities: () => io.listPersons(token),
+        getEntity: async () => null,
+    });
+    return { sub, personalUid };
+}
+export function createDefaultSyncHeldDeps() {
+    const tty = process.stdin.isTTY === true && process.stdout.isTTY === true;
+    return {
+        exports: fenceExports(),
+        stateDir: getStateDir(),
+        identity: (options) => resolveHeldIdentity({ needPersonal: options.needPersonal, interactive: options.interactive && tty }, {
+            ensureToken: (interactive) => ensureCognitoToken({ interactive }),
+            listPersons: async (token) => (await new VaultClient(buildVaultConfig(token)).entity.listByType("person")),
+        }),
+        confirm: confirmOnTty,
+        log: (line) => console.log(line),
+    };
+}
+export function registerSyncHeldCommands(syncCmd) {
+    syncCmd
+        .command("held")
+        .description("Show uploads held because someone else was signed in on this computer")
+        .option("--json", "Print the held scopes as JSON")
+        .action(async (options) => {
+        process.exitCode = await runSyncHeld(createDefaultSyncHeldDeps(), options.json === true);
+    });
+    syncCmd
+        .command("release-held")
+        .description("Confirm held files are yours and let sync upload them")
+        .option("--company <slug>", "Release only this company")
+        .option("--personal", "Release only the personal vault")
+        .option("--yes", "Do not ask for confirmation")
+        .option("--json", "Print the result as JSON")
+        .action(async (options) => {
+        process.exitCode = await runReleaseHeld(createDefaultSyncHeldDeps(), options);
+    });
+}
+//# sourceMappingURL=sync-held.js.map