@indigoai-us/hq-cli 5.17.0 → 5.18.1

package/dist/commands/sync-mode.js

@@ -0,0 +1,249 @@
+/**
+ * `hq sync mode <mode>` (US-006) — flip a membership's syncMode for a company.
+ *
+ * Subcommand of the `hq sync` group. Three call shapes:
+ *
+ *   hq sync mode shared|all|custom [--company <slug>]
+ *       Resolves the target membership for the given company (or the cwd's
+ *       active company from `.hq/config.json` if `--company` is omitted) and
+ *       calls `VaultClient.setMembershipSyncConfig`. Prints membershipId +
+ *       previous mode → new mode as a chat audit trail.
+ *
+ *   hq sync mode --show
+ *       No positional. Prints a table of every membership the caller has
+ *       with its company slug, current sync-mode, and last-updated stamp.
+ *
+ *   hq sync mode custom --paths a/,b/  (planned follow-up)
+ *       For the `custom` mode the server requires `customPaths`. This command
+ *       accepts `--paths` as a comma-separated list to forward to the API; if
+ *       omitted on `custom` the server validation will reject.
+ *
+ * Auto-detect of `--company` from cwd: best-effort via the active-company
+ * slug in `<hq-root>/.hq/config.json`. If absent, the caller must pass
+ * `--company` explicitly — there's no cwd-walk to a `companies/<slug>/`
+ * folder in this initial implementation (follow-up US could add it).
+ *
+ * Cross-package note: this command depends on `VaultClient`
+ * (`getMembershipSyncConfig` / `setMembershipSyncConfig`) added in
+ * hq-cloud US-004 (commit 41e5ee1). While that hq-cloud release is
+ * unpublished, hq-cli pins `@indigoai-us/hq-cloud` to `file:../hq-cloud`
+ * in package.json — revert that line to `^5.20.0` (or whatever the
+ * published cut is) once US-004 ships to npm.
+ */
+
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="534a51ec-53e8-5cde-98c6-5ffc1741d2c1")}catch(e){}}();
+import chalk from "chalk";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { VaultClient, } from "@indigoai-us/hq-cloud";
+import { DEFAULT_HQ_ROOT, ensureCognitoToken, buildVaultConfig, } from "../utils/cognito-session.js";
+// ── Constants ───────────────────────────────────────────────────────────────
+export const LEGAL_SYNC_MODES = [
+    "shared",
+    "all",
+    "custom",
+];
+// ── Pure helpers ────────────────────────────────────────────────────────────
+/** Throws a helpful Error if `mode` is not a legal SyncMode. */
+export function validateMode(mode) {
+    if (LEGAL_SYNC_MODES.includes(mode)) {
+        return mode;
+    }
+    throw new Error(`Invalid sync mode '${mode}'. Legal values: ${LEGAL_SYNC_MODES.join(", ")}.`);
+}
+/**
+ * Read the active company slug from `<hq-root>/.hq/config.json`. Returns
+ * undefined when the file is missing or `activeCompany` isn't set. Never
+ * throws — auto-detect is best-effort.
+ */
+export function readActiveCompanySlug(hqRoot) {
+    const configPath = path.join(hqRoot, ".hq", "config.json");
+    if (!fs.existsSync(configPath))
+        return undefined;
+    try {
+        const cfg = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+        const slug = cfg.activeCompany;
+        return typeof slug === "string" && slug.length > 0 ? slug : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Parse `--paths a/,b/c/` into trimmed non-empty entries. */
+export function parseCustomPaths(raw) {
+    if (!raw)
+        return undefined;
+    const parts = raw
+        .split(",")
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0);
+    return parts.length > 0 ? parts : undefined;
+}
+// ── Orchestrators (pure, injectable — driven by tests) ──────────────────────
+/**
+ * Resolve a membership by company slug, then PUT the new sync-mode. Returns
+ * the membershipId, the previous mode (read via GET first), and the server's
+ * fresh config (which sets `isDefault: false` once a row exists).
+ */
+export async function setSyncMode(options) {
+    const { mode, companySlug, customPaths, vaultClient } = options;
+    // 1. Find the caller's membership for this company.
+    const memberships = await vaultClient.listMyMemberships();
+    // Resolve slug → uid via entity.get on each membership's companyUid in
+    // parallel. Cheaper than a per-membership lookup loop and matches the
+    // pattern AppBar uses to render its company picker.
+    const enriched = await Promise.all(memberships.map(async (m) => {
+        try {
+            const ent = await vaultClient.entity.get(m.companyUid);
+            return { membership: m, slug: ent.slug, name: ent.name };
+        }
+        catch {
+            return { membership: m, slug: undefined, name: undefined };
+        }
+    }));
+    const match = enriched.find((row) => row.slug === companySlug);
+    if (!match) {
+        const known = enriched
+            .map((r) => r.slug)
+            .filter((s) => !!s)
+            .join(", ");
+        throw new Error(`No membership found for company '${companySlug}'. Memberships visible to you: ${known || "(none)"}.`);
+    }
+    const membershipId = match.membership.membershipKey;
+    // 2. Read the current config (server defaults to `shared`/isDefault:true
+    //    when no row exists). We surface this in the audit line.
+    const before = await vaultClient.getMembershipSyncConfig(membershipId);
+    // 3. Write the new mode.
+    const after = await vaultClient.setMembershipSyncConfig(membershipId, {
+        syncMode: mode,
+        customPaths,
+    });
+    return {
+        membershipId,
+        companySlug,
+        previousMode: before.syncMode,
+        previousWasDefault: before.isDefault,
+        newMode: after.syncMode,
+        newConfig: after,
+    };
+}
+/**
+ * Fetch every membership the caller has, resolve company slugs, and look up
+ * each effective sync-config in parallel. Returns rows sorted by slug for
+ * stable table output.
+ */
+export async function showSyncModes(options) {
+    const { vaultClient } = options;
+    const memberships = await vaultClient.listMyMemberships();
+    if (memberships.length === 0)
+        return [];
+    const rows = await Promise.all(memberships.map(async (m) => {
+        const [config, entity] = await Promise.all([
+            vaultClient.getMembershipSyncConfig(m.membershipKey).catch(() => ({
+                membershipId: m.membershipKey,
+                syncMode: "shared",
+                isDefault: true,
+            })),
+            vaultClient.entity
+                .get(m.companyUid)
+                .catch(() => ({ uid: m.companyUid, slug: m.companyUid, name: undefined })),
+        ]);
+        return {
+            companySlug: entity.slug,
+            companyName: entity.name,
+            membershipId: m.membershipKey,
+            syncMode: config.syncMode,
+            isDefault: config.isDefault,
+            updatedAt: config.updatedAt,
+        };
+    }));
+    rows.sort((a, b) => a.companySlug.localeCompare(b.companySlug));
+    return rows;
+}
+// ── Table rendering (used by CLI action, separable for tests) ──────────────
+/**
+ * Render the `--show` table as plain text. No external dep — hq-cli doesn't
+ * use cli-table3, so we hand-format columns to match the existing chalk +
+ * padEnd pattern used by `hq members list`.
+ */
+export function formatShowTable(rows) {
+    if (rows.length === 0) {
+        return "No memberships found. Run `hq onboard` or accept an invite first.";
+    }
+    const cols = ["COMPANY", "MODE", "UPDATED", "MEMBERSHIP"];
+    const data = rows.map((r) => [
+        r.companySlug,
+        r.isDefault ? `${r.syncMode} (default)` : r.syncMode,
+        r.updatedAt ?? "—",
+        r.membershipId,
+    ]);
+    const widths = cols.map((c, i) => Math.max(c.length, ...data.map((row) => row[i].length)));
+    const renderRow = (row) => row.map((cell, i) => cell.padEnd(widths[i])).join("  ");
+    const lines = [
+        chalk.bold(renderRow(cols)),
+        chalk.dim(renderRow(widths.map((w) => "─".repeat(w)))),
+        ...data.map(renderRow),
+    ];
+    return lines.join("\n");
+}
+/**
+ * Wire `hq sync mode` onto an existing `sync` Commander group. The caller
+ * (`src/index.ts`) constructs the `sync` group and calls this after
+ * `registerCloudCommands` so push/pull/status/mode all coexist.
+ */
+export function registerSyncModeCommand(syncCmd) {
+    syncCmd
+        .command("mode [mode]")
+        .description("Flip a membership's sync-mode (shared|all|custom), or --show every membership's current mode")
+        .option("--company <slug>", "Company slug (defaults to the active company in <hq-root>/.hq/config.json)")
+        .option("--show", "Print the current sync-mode for every membership the caller has")
+        .option("--paths <csv>", "Comma-separated allowed prefixes (required when mode is 'custom')")
+        .option("--hq-root <path>", `Local HQ tree root (default: ${DEFAULT_HQ_ROOT})`, DEFAULT_HQ_ROOT)
+        .action(async (modeArg, options) => {
+        try {
+            const accessToken = await ensureCognitoToken();
+            const vaultConfig = buildVaultConfig(accessToken);
+            const client = new VaultClient(vaultConfig);
+            if (options.show) {
+                if (modeArg !== undefined) {
+                    throw new Error("`--show` is incompatible with a positional <mode>. Pass one or the other.");
+                }
+                const rows = await showSyncModes({ vaultClient: client });
+                console.log(formatShowTable(rows));
+                return;
+            }
+            if (!modeArg) {
+                throw new Error(`Missing <mode>. Usage: hq sync mode <${LEGAL_SYNC_MODES.join("|")}> [--company <slug>]   or   hq sync mode --show`);
+            }
+            const mode = validateMode(modeArg);
+            const customPaths = parseCustomPaths(options.paths);
+            const companySlug = options.company ?? readActiveCompanySlug(options.hqRoot);
+            if (!companySlug) {
+                throw new Error("No company specified. Pass --company <slug> or set activeCompany in <hq-root>/.hq/config.json.");
+            }
+            const result = await setSyncMode({
+                mode,
+                companySlug,
+                customPaths,
+                vaultClient: client,
+            });
+            const prevLabel = result.previousWasDefault
+                ? `${result.previousMode} (default)`
+                : result.previousMode;
+            console.log(chalk.green("✓"), `Set sync-mode for ${chalk.bold(result.companySlug)}: ${chalk.dim(prevLabel)} → ${chalk.bold(result.newMode)}`);
+            console.log(chalk.dim(`  membershipId: ${result.membershipId}`));
+            if (result.newConfig.customPaths && result.newConfig.customPaths.length > 0) {
+                console.log(chalk.dim(`  customPaths:  ${result.newConfig.customPaths.join(", ")}`));
+            }
+            if (result.newConfig.updatedAt) {
+                console.log(chalk.dim(`  updatedAt:    ${result.newConfig.updatedAt}`));
+            }
+        }
+        catch (err) {
+            console.error(chalk.red("✗ sync mode failed:"), err instanceof Error ? err.message : String(err));
+            process.exit(1);
+        }
+    });
+}
+//# sourceMappingURL=sync-mode.js.map
+//# debugId=534a51ec-53e8-5cde-98c6-5ffc1741d2c1

package/dist/commands/sync-narrow.d.ts

@@ -0,0 +1,154 @@
+/**
+ * `hq sync narrow` (US-007) — explicit migration ritual to flip a company's
+ * membership from `syncMode: all` to `syncMode: shared`, with a dry-run
+ * preview and a dirty-file safety gate.
+ *
+ * Two call shapes:
+ *
+ *   hq sync narrow --dry-run [--company <slug>]
+ *       Resolves the membership for <slug> (or the active company), fetches
+ *       the caller's explicit grants, coalesces them, walks the local
+ *       `companies/<slug>/` tree, and prints a table:
+ *
+ *           files staying:  N
+ *           clean orphans:  N (size)
+ *           dirty orphans:  N (size)
+ *
+ *       Writes nothing — no journal, no local file, no server call beyond
+ *       the read-only GET on grants + sync-config.
+ *
+ *   hq sync narrow --apply [--yes] [--force] [--company <slug>]
+ *       Same computation, then:
+ *         - if `dirty > 0` and `--force` NOT set → abort with conflict report
+ *           and a recovery message.
+ *         - else delete clean orphans on disk, tombstone their journal
+ *           entries, optionally delete dirty orphans too (with `--force`),
+ *           then PUT sync-config to `shared`. The server's PUT writes the
+ *           authoritative `MEMBERSHIP_SYNC_CONFIG_CHANGED` audit row; the
+ *           CLI prints a local audit line as well.
+ *
+ * Refuses on already-`shared` or `custom` memberships (acceptance 5) —
+ * narrowing makes sense only as `all → shared`.
+ *
+ * Cross-package note: depends on hq-cloud helpers shipped in US-005
+ * (`coalescePrefixes`, `readJournal`/`writeJournal`, `tombstoneEntry`) and
+ * the VaultClient sync-config endpoints from US-003. While that hq-cloud
+ * release is unpublished, hq-cli pins `@indigoai-us/hq-cloud` to
+ * `file:../hq-cloud` via `pnpm.overrides`.
+ */
+import { Command } from "commander";
+import { type ExplicitGrant, type Membership, type MembershipSyncConfig, type SyncMode, type SyncJournal } from "@indigoai-us/hq-cloud";
+import { type NarrowPlan, type NarrowDirtyFile } from "../lib/local-tree-diff.js";
+/** Subset of VaultClient surface this command exercises (test seam). */
+export interface SyncNarrowVaultClient {
+    listMyMemberships(): Promise<Membership[]>;
+    getMembershipSyncConfig(membershipId: string): Promise<MembershipSyncConfig>;
+    setMembershipSyncConfig(membershipId: string, partial: {
+        syncMode: SyncMode;
+        customPaths?: string[];
+    }): Promise<MembershipSyncConfig>;
+    listMyExplicitGrants(companyUid: string): Promise<ExplicitGrant[]>;
+    entity: {
+        get(uid: string): Promise<{
+            uid: string;
+            slug: string;
+            name?: string;
+        }>;
+    };
+}
+/** Journal I/O seam — defaults to the real `readJournal`/`writeJournal`. */
+export interface JournalIO {
+    read(slug: string): SyncJournal;
+    write(slug: string, journal: SyncJournal): void;
+}
+/** Filesystem seam — defaults to real `fs` (only `unlinkSync` is exercised). */
+export interface FsIO {
+    unlinkSync(p: string): void;
+}
+/** Confirmation prompt seam — defaults to a `readline` y/N gate. */
+export type ConfirmFn = (message: string) => Promise<boolean>;
+export interface ResolveTargetInput {
+    companySlug: string;
+    vaultClient: SyncNarrowVaultClient;
+}
+export interface ResolveTargetResult {
+    membership: Membership;
+    companyUid: string;
+    companySlug: string;
+    syncConfig: MembershipSyncConfig;
+}
+/**
+ * Resolve the caller's membership for `companySlug` and read its current
+ * sync-config. Throws if the slug doesn't match any membership or if the
+ * current mode isn't eligible for narrowing (`all` → `shared` only).
+ */
+export declare function resolveNarrowTarget(input: ResolveTargetInput): Promise<ResolveTargetResult>;
+export interface ComputePlanInput {
+    hqRoot: string;
+    companySlug: string;
+    companyUid: string;
+    vaultClient: SyncNarrowVaultClient;
+    journalIO?: JournalIO;
+}
+export interface ComputePlanResult {
+    plan: NarrowPlan;
+    prospectivePrefixSet: string[];
+    grants: ExplicitGrant[];
+    journal: SyncJournal;
+}
+/**
+ * Compute the narrow plan for one company: fetch explicit grants, coalesce,
+ * read the per-company journal, walk the local tree, classify.
+ *
+ * Reads only — never mutates the journal or hits a destructive endpoint.
+ * `apply()` consumes this and performs the destructive steps.
+ */
+export declare function computeNarrowPlan(input: ComputePlanInput): Promise<ComputePlanResult>;
+export interface ApplyNarrowInput {
+    companySlug: string;
+    membershipId: string;
+    plan: NarrowPlan;
+    journal: SyncJournal;
+    vaultClient: SyncNarrowVaultClient;
+    /** If true, delete dirty orphans too (still tombstoned). */
+    force: boolean;
+    journalIO?: JournalIO;
+    fsIO?: FsIO;
+}
+export interface ApplyNarrowResult {
+    cleanDeleted: number;
+    cleanBytes: number;
+    dirtyDeleted: number;
+    dirtyBytes: number;
+    tombstoned: number;
+    newConfig: MembershipSyncConfig;
+}
+/**
+ * Apply the destructive side of a narrow:
+ *   1. Delete clean orphans (best-effort — ENOENT is ignored).
+ *   2. Tombstone their journal entries.
+ *   3. If `force`, also delete + tombstone dirty orphans.
+ *   4. Persist the journal.
+ *   5. PUT sync-config → `shared` (server writes the audit row).
+ *
+ * Order is fail-safe: if a delete throws partway, the journal write below
+ * won't run, but the in-progress deletions are already on disk — that's the
+ * "don't roll back I/O" contract from the spec. The CLI surfaces a
+ * recovery message when this throws.
+ *
+ * Pure-ish: no prompting (the CLI wrapper handles that), no console
+ * output. Just disk + network.
+ */
+export declare function applyNarrow(input: ApplyNarrowInput): Promise<ApplyNarrowResult>;
+/**
+ * Format the dirty-file conflict report shown on `--apply` when dirty files
+ * are present and `--force` is NOT set. The CLI prints this and exits
+ * non-zero so the operator can resolve before retrying.
+ */
+export declare function formatDirtyConflictReport(dirty: NarrowDirtyFile[], companySlug: string): string;
+/**
+ * Wire `hq sync narrow` onto the existing `sync` Commander group. Called
+ * from `src/index.ts` after `registerSyncModeCommand`.
+ */
+export declare function registerSyncNarrowCommand(syncCmd: Command): void;
+//# sourceMappingURL=sync-narrow.d.ts.map