@indigoai-us/hq-cli 5.271.0 → 5.273.0-alpha.0

package/dist/commands/daemon.js

@@ -18,7 +18,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { major as semverMajor, valid as validSemver } from "semver";
 import { DEFAULT_SERVICES, SERVICE_DESCRIPTIONS, enabledServices, hqCloudUnits } from "../lib/daemon/catalog.js";
-import { applyServiceToggle, readDaemonConfig, writeDaemonConfig } from "../lib/daemon/config.js";
+import { applyServiceToggle, effectiveSyncOwner, readDaemonConfig, writeDaemonConfig } from "../lib/daemon/config.js";
 import { daemonUnitInstalled } from "../lib/daemon/handoff.js";
 import { adoptLegacyUnits, readAdoptedUnits, restoreLegacyUnits } from "../lib/daemon/migrate.js";
 import { ROOT_REFUSAL, SYSTEM_UNIT_DIR, daemonRootRefusal, installDaemonUnit, installScopeFor, uninstallDaemonUnit, } from "../lib/daemon/install.js";
@@ -27,7 +27,10 @@ import { isDaemonProcess, runningDaemonPid } from "../lib/daemon/lock.js";
 import { bundledHqCloud } from "../lib/daemon/hq-cloud.js";
 import { MACHINE_TYPE_MARKER_PATH, detectMachineType, homeFromPasswd, } from "../lib/daemon/machine-type.js";
 import { daemonPaths } from "../lib/daemon/paths.js";
+import { processCommandLine } from "../lib/daemon/lock.js";
 import { writeControlRequest } from "../lib/daemon/requests.js";
+import { isSyncRunnerCommandLine, readWatchRunnerOwnerStatus, watchRunnerOwnerStatusPath } from "../lib/daemon/sync-runner.js";
+import { getSyncModeForCompany, setSyncMode } from "./sync-mode.js";
 import { resolveDefaultHqRoot } from "../utils/cognito-session.js";
 class DaemonCommandError extends Error {
 }
@@ -96,6 +99,7 @@ async function loadDefaults(over) {
         windowsUser: over.windowsUser ?? (platform === "win32" ? mesh.resolveWindowsUser(env) : ""),
         windowsHeadlessLauncher: over.windowsHeadlessLauncher ?? (platform === "win32" ? mesh.resolveWindowsHeadlessLauncher(env) : undefined),
         systemUnitDir: over.systemUnitDir ?? SYSTEM_UNIT_DIR,
+        syncModeClient: over.syncModeClient,
     };
 }
 function detect(d, flag, config) {
@@ -372,6 +376,135 @@ function queueRequest(d, request, what) {
     const running = runningDaemonPid(paths.lockPath, d.daemonAlive) !== null;
     d.out(running ? `Asked the daemon to ${what}.` : `Queued "${what}"; the daemon is not running, so it applies when it starts.`);
 }
+function daemonSyncModeClient(d) {
+    if (d.syncModeClient)
+        return d.syncModeClient();
+    return (async () => {
+        const [{ VaultClient }, { buildVaultConfig, ensureCognitoToken }] = await Promise.all([
+            import("@indigoai-us/hq-cloud"),
+            import("../utils/cognito-session.js"),
+        ]);
+        const token = await ensureCognitoToken();
+        return new VaultClient(buildVaultConfig(token));
+    })();
+}
+function daemonSyncStatus(d) {
+    const host = currentHost(d);
+    const { paths } = host;
+    const config = readDaemonConfig(paths.configPath);
+    const daemonPid = runningDaemonPid(paths.lockPath, d.daemonAlive);
+    const daemonState = daemonPid === null ? null : readState(paths);
+    const syncUnit = daemonState?.units.find((unit) => unit.id === "sync");
+    const hqRoot = config.hqRoot ?? d.env.HQ_ROOT?.trim();
+    let ownerStatusCandidate = null;
+    if (hqRoot) {
+        try {
+            ownerStatusCandidate = readWatchRunnerOwnerStatus(watchRunnerOwnerStatusPath(hqRoot, d.home, d.env));
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            d.err(`Could not read sync runner owner status; treating it as unavailable: ${detail}`);
+        }
+    }
+    const ownerCommandLine = ownerStatusCandidate
+        ? processCommandLine(ownerStatusCandidate.pid, { platform: d.platform, run: d.run })
+        : null;
+    const ownerStatus = ownerCommandLine && isSyncRunnerCommandLine(ownerCommandLine)
+        ? ownerStatusCandidate
+        : null;
+    return {
+        running: syncUnit?.status === "running",
+        paused: config.syncPaused === true,
+        syncOwner: effectiveSyncOwner(config, host.detected.type),
+        owner: ownerStatus?.owner ?? (syncUnit?.status === "running" ? "hq-daemon" : null),
+        runnerPid: ownerStatus?.pid ?? syncUnit?.pid ?? null,
+        hqCloudVersion: ownerStatus?.version ?? null,
+        lastHeartbeat: syncUnit?.lastHeartbeatAt ?? ownerStatus?.heartbeatAt ?? null,
+        lastPassResult: syncUnit?.lastPassResult ?? null,
+        unitStatus: syncUnit?.status ?? "not-running",
+        reason: syncUnit?.reason ?? null,
+        logPath: paths.unitLogPath("sync"),
+    };
+}
+async function runDaemonSyncStatus(d, opts) {
+    const status = daemonSyncStatus(d);
+    if (opts.json) {
+        d.out(JSON.stringify(status, null, 2));
+        return;
+    }
+    d.out(`Sync ${status.running ? "running" : status.unitStatus}${status.paused ? " (paused)" : ""}.`);
+    d.out(`Configured sync owner: ${status.syncOwner}.`);
+    d.out(`Owner: ${status.owner ?? "none"}; runner pid: ${status.runnerPid ?? "none"}; hq-cloud: ${status.hqCloudVersion ?? "unknown"}.`);
+    if (status.reason)
+        d.out(`Reason: ${status.reason}`);
+    d.out(`Log: ${status.logPath}`);
+}
+function queueDaemonSyncControl(d, request) {
+    const host = currentHost(d);
+    writeControlRequest(host.paths.requestsDir, request);
+    handOver(d, host);
+    return runningDaemonPid(host.paths.lockPath, d.daemonAlive) !== null;
+}
+async function runDaemonSyncNow(d, opts) {
+    const host = currentHost(d);
+    const config = readDaemonConfig(host.paths.configPath);
+    if (config.syncPaused)
+        throw new DaemonCommandError("sync is paused; run `hq daemon sync resume` first");
+    if (!enabledServices(host.detected.type, config).includes("sync")) {
+        throw new DaemonCommandError("sync is disabled for this machine; run `hq daemon enable sync` first");
+    }
+    const running = queueDaemonSyncControl(d, { action: "restart", unit: "sync" });
+    const result = { accepted: true, action: "restart-sync-runner", daemonRunning: running };
+    d.out(opts.json ? JSON.stringify(result, null, 2) : running ? "Asked the daemon to start a fresh sync pass." : "Queued a fresh sync pass for the next daemon start.");
+}
+async function runDaemonSyncPause(d, paused, opts) {
+    const host = currentHost(d);
+    const config = readDaemonConfig(host.paths.configPath);
+    if (config.syncPaused !== paused)
+        writeDaemonConfig(host.paths.configPath, { ...config, syncPaused: paused });
+    const daemonRunning = queueDaemonSyncControl(d, { action: "reconcile" });
+    const result = { paused, persisted: true, daemonRunning };
+    d.out(opts.json ? JSON.stringify(result, null, 2) : `Sync ${paused ? "paused" : "resumed"}${daemonRunning ? "" : "; the setting will apply when the daemon starts"}.`);
+}
+async function runDaemonSyncTakeOwnership(d, opts) {
+    const host = currentHost(d);
+    const config = readDaemonConfig(host.paths.configPath);
+    if (config.syncOwner !== "daemon")
+        writeDaemonConfig(host.paths.configPath, { ...config, syncOwner: "daemon" });
+    const daemonRunning = queueDaemonSyncControl(d, { action: "reconcile" });
+    const result = { syncOwner: "daemon", persisted: true, daemonRunning };
+    d.out(opts.json ? JSON.stringify(result, null, 2) : `Daemon sync ownership persisted${daemonRunning ? "; asked the daemon to reconcile" : "; it applies when the daemon starts"}.`);
+}
+async function runDaemonSyncModeGet(d, companySlug, opts) {
+    const result = await getSyncModeForCompany({ companySlug, vaultClient: await daemonSyncModeClient(d) });
+    const value = {
+        companySlug: result.companySlug,
+        membershipId: result.membershipId,
+        mode: result.config.syncMode,
+        isDefault: result.config.isDefault,
+        ...(result.config.updatedAt ? { updatedAt: result.config.updatedAt } : {}),
+    };
+    d.out(opts.json ? JSON.stringify(value, null, 2) : `${value.companySlug}: ${value.mode}${value.isDefault ? " (default)" : ""}`);
+}
+async function runDaemonSyncModeSet(d, companySlug, mode, opts) {
+    if (mode !== "all" && mode !== "shared") {
+        throw new DaemonCommandError(`Invalid sync mode '${mode}'. Use all or shared.`);
+    }
+    const result = await setSyncMode({
+        mode,
+        companySlug,
+        vaultClient: await daemonSyncModeClient(d),
+    });
+    const value = {
+        companySlug: result.companySlug,
+        membershipId: result.membershipId,
+        previousMode: result.previousMode,
+        mode: result.newMode,
+        isDefault: result.newConfig.isDefault,
+        ...(result.newConfig.updatedAt ? { updatedAt: result.newConfig.updatedAt } : {}),
+    };
+    d.out(opts.json ? JSON.stringify(value, null, 2) : `${value.companySlug}: ${value.previousMode} → ${value.mode}`);
+}
 async function runToggle(d, action, services) {
     const host = currentHost(d);
     const { paths } = host;
@@ -603,6 +736,45 @@ export function registerDaemonCommand(program, over = {}) {
         .description("Show the machine type and each service's state")
         .option("--json", "Print machine-readable JSON")
         .action(wrap((d, opts) => runStatus(d, opts)));
+    const sync = daemon
+        .command("sync")
+        .description("Inspect and control the daemon's company sync runner");
+    sync
+        .command("status")
+        .description("Show sync ownership, heartbeat, last pass and log path")
+        .option("--json", "Print machine-readable JSON")
+        .action(wrap((d, opts) => runDaemonSyncStatus(d, opts)));
+    sync
+        .command("now")
+        .description("Start a fresh sync pass immediately")
+        .option("--json", "Print machine-readable JSON")
+        .action(wrap((d, opts) => runDaemonSyncNow(d, opts)));
+    sync
+        .command("pause")
+        .description("Pause daemon sync until resumed")
+        .option("--json", "Print machine-readable JSON")
+        .action(wrap((d, opts) => runDaemonSyncPause(d, true, opts)));
+    sync
+        .command("resume")
+        .description("Resume daemon sync after a pause")
+        .option("--json", "Print machine-readable JSON")
+        .action(wrap((d, opts) => runDaemonSyncPause(d, false, opts)));
+    sync
+        .command("take-ownership")
+        .description("Persist daemon ownership of desktop sync and reconcile")
+        .option("--json", "Print machine-readable JSON")
+        .action(wrap((d, opts) => runDaemonSyncTakeOwnership(d, opts)));
+    const mode = sync.command("mode").description("Read or change a company's sync footprint");
+    mode
+        .command("get <company>")
+        .description("Read a company's current all/shared sync mode")
+        .option("--json", "Print machine-readable JSON")
+        .action(wrap((d, company, opts) => runDaemonSyncModeGet(d, company, opts)));
+    mode
+        .command("set <company> <mode>")
+        .description("Set a company's sync mode to all or shared")
+        .option("--json", "Print machine-readable JSON")
+        .action(wrap((d, company, mode, opts) => runDaemonSyncModeSet(d, company, mode, opts)));
     daemon
         .command("logs [unit]")
         .description("Print the supervisor log, or one service's log")

package/dist/commands/files.d.ts

@@ -62,6 +62,22 @@ export declare class FilesDeleteHttpError extends Error {
 export declare function formatFilesDeleteError(err: FilesDeleteHttpError, prefix: string): string;
 /** Injectable yes/no confirmation seam (stubbed in tests). */
 export type ConfirmFn = (message: string) => Promise<boolean>;
+/**
+ * POST /v1/files/delete. Throws FilesDeleteHttpError on any non-2xx so the one
+ * caller renders a single consistent error path.
+ *
+ * Scope is EITHER a company vault (`companyUid` set) OR the caller's personal
+ * vault (`personal: true`). For the personal case the server resolves the target
+ * person + bucket from the authenticated caller — we send NO uid, just the
+ * `personal` flag — so there is nothing for the client to get wrong or spoof.
+ */
+export declare function callDeleteEndpoint(params: {
+    token: string;
+    companyUid?: string;
+    personal?: boolean;
+    prefix: string;
+    dryRun: boolean;
+}): Promise<FilesDeleteResponse>;
 interface RunFilesDeleteParams {
     prefix: string;
     dryRun: boolean;

package/dist/commands/files.js

@@ -879,7 +879,7 @@ function realConfirm(message) {
  * person + bucket from the authenticated caller — we send NO uid, just the
  * `personal` flag — so there is nothing for the client to get wrong or spoof.
  */
-async function callDeleteEndpoint(params) {
+export async function callDeleteEndpoint(params) {
     const res = await vaultApiFetch({
         token: params.token,
         path: "/v1/files/delete",

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

@@ -70,6 +70,15 @@ export interface SetSyncModeResult {
 export interface ShowSyncModesOptions {
     vaultClient: SyncModeVaultClient;
 }
+export interface GetSyncModeOptions {
+    companySlug: string;
+    vaultClient: SyncModeVaultClient;
+}
+export interface GetSyncModeResult {
+    membershipId: string;
+    companySlug: string;
+    config: MembershipSyncConfig;
+}
 export interface ShowSyncModesRow {
     companySlug: string;
     companyName?: string;
@@ -100,6 +109,8 @@ export declare function setSyncMode(options: SetSyncModeOptions): Promise<SetSyn
  * stable table output.
  */
 export declare function showSyncModes(options: ShowSyncModesOptions): Promise<ShowSyncModesRow[]>;
+/** Read one company's effective sync mode without hiding API read failures. */
+export declare function getSyncModeForCompany(options: GetSyncModeOptions): Promise<GetSyncModeResult>;
 /**
  * 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 +

package/dist/commands/sync-mode.js

@@ -163,6 +163,36 @@ export async function showSyncModes(options) {
     rows.sort((a, b) => a.companySlug.localeCompare(b.companySlug));
     return rows;
 }
+/** Read one company's effective sync mode without hiding API read failures. */
+export async function getSyncModeForCompany(options) {
+    const { companySlug, vaultClient } = options;
+    const memberships = await vaultClient.listMyMemberships();
+    const enriched = await Promise.all(memberships.map(async (membership) => {
+        try {
+            const entity = await vaultClient.entity.get(membership.companyUid);
+            return { ok: true, membership, slug: entity.slug };
+        }
+        catch (error) {
+            return { ok: false, membership, error };
+        }
+    }));
+    const match = enriched.find((row) => row.ok && row.slug === companySlug);
+    if (!match) {
+        const failedLookup = enriched.find((row) => !row.ok);
+        if (failedLookup && !failedLookup.ok)
+            throw failedLookup.error;
+        throw new Error(`No membership found for company '${companySlug}'.`);
+    }
+    for (const failedLookup of enriched) {
+        if (!failedLookup.ok) {
+            const detail = failedLookup.error instanceof Error ? failedLookup.error.message : String(failedLookup.error);
+            console.error(`getSyncModeForCompany: entity lookup failed for membership ${failedLookup.membership.membershipKey} while resolving '${companySlug}': ${detail}`);
+        }
+    }
+    const membershipId = match.membership.membershipKey;
+    const config = await vaultClient.getMembershipSyncConfig(membershipId);
+    return { membershipId, companySlug, config };
+}
 // ── Table rendering (used by CLI action, separable for tests) ──────────────
 /**
  * Render the `--show` table as plain text. No external dep — hq-cli doesn't

package/dist/lib/checkpoint-ontology/merge-copies.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Merge numbered entity copies (`<slug> 2.md`) into their original file and
+ * delete them (CO-54, owner decision CO-D-007 option 2).
+ *
+ * Gated by `checkpoint.ontology.merge-copies`. A copy is a file named
+ * `<slug> <n>.md` next to `<slug>.md` of the same type, with the same `id`,
+ * in one duplicate group. Other members of a group are never touched.
+ *
+ * Two steps, run separately so sync can push the merged original before its
+ * copy goes away:
+ *
+ * - merge: the copy's fresh aliases, back-references and relationship lines
+ *   are added to the original, `signal_count` takes the higher value, and
+ *   entity files that link to the copy are re-pointed at the original. Every
+ *   rewritten file is recorded in the outbox before it is written, so sync
+ *   pushes it. Keys the checkpoint does not own keep the original's value.
+ * - delete: a copy is deleted from the vault, by exact key, only when merging
+ *   it again would change nothing and no entity file or signal links to it.
+ *   The vault keeps every old version. The local file goes after the vault
+ *   delete succeeds, or when the vault no longer has the key.
+ *
+ * Copies of one original merge in path order, each into the result of the
+ * previous one, and none of them counts as holding a name the others move.
+ * A copy whose body has lines the merged original lacks (prose the merge does
+ * not carry) is merged but never deleted. A copy linked from any file the
+ * merge cannot rewrite (a copy, a knowledge file, a signal) is held.
+ *
+ * A signal whose `entity_refs` names a copy holds that copy: signals are
+ * server-owned, so the ref cannot be re-pointed from here.
+ */
+import { type OntologyCompany } from "./company.js";
+import { type EntityIndex } from "./tree.js";
+export declare const MERGE_COPIES_FLAG = "checkpoint.ontology.merge-copies";
+export type CopySkipReason = "no_original" | "original_invalid" | "identity_differs" | "not_in_duplicate_group";
+export interface CopySkip {
+    copy: string;
+    reason: CopySkipReason;
+}
+export interface CopyPair {
+    type: string;
+    /** Company-relative path of the copy. */
+    copy: string;
+    /** Company-relative path of the original it merges into. */
+    original: string;
+}
+export interface CopyPlan extends CopyPair {
+    add_aliases: string[];
+    /** Copy names the original lacks that another entity already holds, so they do not move. */
+    dropped_aliases: string[];
+    add_backrefs: number;
+    add_relationship_lines: number;
+    /** The copy's higher `signal_count`, when it is higher. */
+    raise_signal_count?: number;
+    /** Keys the checkpoint does not own whose values differ; the original's value stays. */
+    kept_original_keys: string[];
+    /** Entity files that link to the copy. */
+    inbound_links: string[];
+    /** Signal files whose `entity_refs` name the copy. */
+    signal_refs: string[];
+    /** Why the copy cannot be merged or deleted from here. */
+    held?: "signal_refs" | "linked_from_unwritable" | "merge_invalid";
+    detail?: string;
+    /** Body lines of the copy the merged original lacks; a copy with any is never deleted. */
+    unmerged_body_lines: number;
+}
+export interface MergeCopiesReport {
+    company: string;
+    mode: "dry_run" | "merge" | "delete";
+    duplicate_groups_before: number;
+    duplicate_groups_after: number;
+    copies_found: number;
+    plans: CopyPlan[];
+    skipped: CopySkip[];
+    merged: string[];
+    relinked: string[];
+    deleted: string[];
+    /** Deleted copies the vault no longer had (a resumed run, or never synced). */
+    vault_already_absent: string[];
+    /** Copies still carrying content, links or refs, so not deleted this run. */
+    not_ready: {
+        copy: string;
+        reason: string;
+    }[];
+    errors: {
+        path: string;
+        error: string;
+    }[];
+    /** Entity-file links whose target file does not exist. */
+    broken_links_before: number;
+    broken_links_after: number;
+    /** Links in `company-brief.md` to a copy; the brief is re-rendered by the next checkpoint. */
+    brief_links_to_copies: string[];
+}
+/** Deletes one exact vault key; resolves to the number of objects deleted. */
+export type DeleteVaultKey = (key: string) => Promise<number>;
+export interface MergeCopiesOptions {
+    hqRoot: string;
+    company: OntologyCompany;
+    mode: "dry_run" | "merge" | "delete";
+    /** Handle at most this many copies (sorted by path). */
+    limit?: number;
+    now: Date;
+    deleteVaultKey?: DeleteVaultKey;
+}
+/** Copies in scope, and the ones skipped with a reason. Read-only. */
+export declare function findCopyPairs(index: EntityIndex): {
+    pairs: CopyPair[];
+    skipped: CopySkip[];
+};
+/**
+ * Plan, merge or delete numbered copies for one company. The dry run writes
+ * nothing; merge writes entity files only; delete removes vault keys and
+ * local copy files only.
+ */
+export declare function mergeCopies(options: MergeCopiesOptions): Promise<MergeCopiesReport>;
+//# sourceMappingURL=merge-copies.d.ts.map