@indigoai-us/hq-cloud 5.1.9 → 5.1.11

package/src/bin/sync-runner.ts

@@ -54,8 +54,24 @@ import type {
   SyncResult,
   SyncProgressEvent,
 } from "../cli/sync.js";
+import { share as defaultShare } from "../cli/share.js";
+import type { ShareOptions, ShareResult } from "../cli/share.js";
 import type { ConflictStrategy } from "../cli/conflict.js";
 
+/**
+ * Sync direction for a run.
+ *
+ * - `pull`: download-only (legacy `hq sync` behaviour, and the default for
+ *   back-compat with pre-5.1.11 callers of the runner).
+ * - `push`: upload-only. Walks the company folder and sends every file whose
+ *   local hash differs from the journal (skipUnchanged).
+ * - `both`: push first, then pull. "Sync Now" in the menubar app targets this.
+ *   Push runs first so the subsequent pull doesn't redownload files we were
+ *   about to replace; if a company aborts on push conflict, pull is skipped
+ *   for that company but the fanout continues.
+ */
+export type Direction = "pull" | "push" | "both";
+
 // ---------------------------------------------------------------------------
 // Defaults — mirror `hq-cli/src/utils/cognito-session.ts`. Inlined (not
 // imported) to avoid a circular dep between hq-cli and hq-cloud. If these
@@ -97,12 +113,27 @@ export type RunnerEvent =
     }
   | ({ type: "progress"; company: string } & Omit<Extract<SyncProgressEvent, { type: "progress" }>, "type">)
   | ({ type: "error"; company?: string } & Omit<Extract<SyncProgressEvent, { type: "error" }>, "type">)
-  | ({ type: "complete"; company: string } & SyncResult)
+  | ({
+      type: "complete";
+      company: string;
+      /**
+       * Upload counters. Always emitted (0 when the run was pull-only) so
+       * downstream consumers don't need to conditionally read the field.
+       * Tauri's `SyncCompleteEvent` ignores extra fields today; adding them
+       * to the Rust struct is a follow-up when the UI needs to surface push
+       * totals.
+       */
+      filesUploaded: number;
+      bytesUploaded: number;
+    } & SyncResult)
   | {
       type: "all-complete";
       companiesAttempted: number;
       filesDownloaded: number;
       bytesDownloaded: number;
+      /** Always emitted; 0 when no push phase ran. */
+      filesUploaded: number;
+      bytesUploaded: number;
       errors: Array<{ company: string; message: string }>;
     };
 
@@ -158,6 +189,8 @@ export interface RunnerDeps {
   createVaultClient?: (config: VaultServiceConfig) => VaultClientSurface;
   /** Sync function. Defaults to `cli/sync.sync`. */
   sync?: (options: SyncOptions) => Promise<SyncResult>;
+  /** Share function (push phase). Defaults to `cli/share.share`. */
+  share?: (options: ShareOptions) => Promise<ShareResult>;
 }
 
 // ---------------------------------------------------------------------------
@@ -239,6 +272,7 @@ interface ParsedArgs {
   company?: string;
   onConflict: ConflictStrategy;
   hqRoot: string;
+  direction: Direction;
 }
 
 function parseArgs(argv: string[]): ParsedArgs | { error: string } {
@@ -246,6 +280,7 @@ function parseArgs(argv: string[]): ParsedArgs | { error: string } {
   let company: string | undefined;
   let onConflict: ConflictStrategy = "abort";
   let hqRoot = DEFAULT_HQ_ROOT;
+  let direction: Direction = "pull";
 
   for (let i = 0; i < argv.length; i++) {
     const arg = argv[i];
@@ -267,6 +302,16 @@ function parseArgs(argv: string[]): ParsedArgs | { error: string } {
         onConflict = val;
         break;
       }
+      case "--direction": {
+        const val = argv[++i];
+        if (val !== "pull" && val !== "push" && val !== "both") {
+          return {
+            error: `--direction must be one of pull|push|both, got: ${val ?? "(missing)"}`,
+          };
+        }
+        direction = val;
+        break;
+      }
       case "--hq-root":
         hqRoot = argv[++i];
         if (!hqRoot) return { error: "--hq-root requires a value" };
@@ -286,7 +331,7 @@ function parseArgs(argv: string[]): ParsedArgs | { error: string } {
     return { error: "Pass --companies or --company <slug>" };
   }
 
-  return { companies, company, onConflict, hqRoot };
+  return { companies, company, onConflict, hqRoot, direction };
 }
 
 // ---------------------------------------------------------------------------
@@ -402,42 +447,99 @@ export async function runRunner(
 
   // ---- fanout -----------------------------------------------------------
   const syncFn = deps.sync ?? defaultSync;
-  let totalFiles = 0;
-  let totalBytes = 0;
+  const shareFn = deps.share ?? defaultShare;
+  const doPush = parsed.direction === "push" || parsed.direction === "both";
+  const doPull = parsed.direction === "pull" || parsed.direction === "both";
+  let totalDownloaded = 0;
+  let totalDownloadedBytes = 0;
+  let totalUploaded = 0;
+  let totalUploadedBytes = 0;
   const errors: Array<{ company: string; message: string }> = [];
 
   for (const target of plan) {
     const companyLabel = target.slug;
+    // Per-company event tagger — shared by push and pull phases so progress
+    // rows land on the right company regardless of which phase emitted them.
+    const tagAndEmit = (event: SyncProgressEvent): void => {
+      if (event.type === "progress") {
+        emit({
+          type: "progress",
+          company: companyLabel,
+          path: event.path,
+          bytes: event.bytes,
+          ...(event.message ? { message: event.message } : {}),
+        });
+      } else {
+        emit({
+          type: "error",
+          company: companyLabel,
+          path: event.path,
+          message: event.message,
+        });
+      }
+    };
+
     try {
-      const result = await syncFn({
-        company: target.uid,
-        vaultConfig,
-        hqRoot: parsed.hqRoot,
-        onConflict: parsed.onConflict,
-        onEvent: (event) => {
-          // Tag per-file events with the company they belong to so the
-          // menubar can route them to the right company's progress bar.
-          if (event.type === "progress") {
-            emit({
-              type: "progress",
-              company: companyLabel,
-              path: event.path,
-              bytes: event.bytes,
-              ...(event.message ? { message: event.message } : {}),
-            });
-          } else {
-            emit({
-              type: "error",
-              company: companyLabel,
-              path: event.path,
-              message: event.message,
-            });
-          }
-        },
+      let pushResult: ShareResult = {
+        filesUploaded: 0,
+        bytesUploaded: 0,
+        filesSkipped: 0,
+        aborted: false,
+      };
+      let pullResult: SyncResult = {
+        filesDownloaded: 0,
+        bytesDownloaded: 0,
+        filesSkipped: 0,
+        conflicts: 0,
+        aborted: false,
+      };
+
+      // Push first so a subsequent pull doesn't overwrite files we were about
+      // to broadcast. Uses the walk-everything-under-companies/{slug}/ entry
+      // point with `skipUnchanged` so we don't re-upload files that haven't
+      // changed since the last sync.
+      if (doPush) {
+        pushResult = await shareFn({
+          paths: [path.join(parsed.hqRoot, "companies", target.slug)],
+          company: target.uid,
+          vaultConfig,
+          hqRoot: parsed.hqRoot,
+          onConflict: parsed.onConflict,
+          skipUnchanged: true,
+          onEvent: tagAndEmit,
+        });
+      }
+
+      // Pull runs unless the push phase aborted on conflict — aborted means
+      // the user has local edits + remote drift; blindly pulling would erase
+      // whichever side `--on-conflict abort` just protected.
+      if (doPull && !pushResult.aborted) {
+        pullResult = await syncFn({
+          company: target.uid,
+          vaultConfig,
+          hqRoot: parsed.hqRoot,
+          onConflict: parsed.onConflict,
+          onEvent: tagAndEmit,
+        });
+      }
+
+      emit({
+        type: "complete",
+        company: companyLabel,
+        filesDownloaded: pullResult.filesDownloaded,
+        bytesDownloaded: pullResult.bytesDownloaded,
+        filesUploaded: pushResult.filesUploaded,
+        bytesUploaded: pushResult.bytesUploaded,
+        filesSkipped: pullResult.filesSkipped + pushResult.filesSkipped,
+        conflicts: pullResult.conflicts,
+        // Either phase aborting marks the company aborted — the UI treats
+        // `aborted: true` as "sync didn't complete cleanly for this company".
+        aborted: pullResult.aborted || pushResult.aborted,
       });
-      emit({ type: "complete", company: companyLabel, ...result });
-      totalFiles += result.filesDownloaded;
-      totalBytes += result.bytesDownloaded;
+      totalDownloaded += pullResult.filesDownloaded;
+      totalDownloadedBytes += pullResult.bytesDownloaded;
+      totalUploaded += pushResult.filesUploaded;
+      totalUploadedBytes += pushResult.bytesUploaded;
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       errors.push({ company: companyLabel, message });
@@ -454,8 +556,10 @@ export async function runRunner(
   emit({
     type: "all-complete",
     companiesAttempted: plan.length,
-    filesDownloaded: totalFiles,
-    bytesDownloaded: totalBytes,
+    filesDownloaded: totalDownloaded,
+    bytesDownloaded: totalDownloadedBytes,
+    filesUploaded: totalUploaded,
+    bytesUploaded: totalUploadedBytes,
     errors,
   });
   return 0;

package/src/cli/accept.ts

@@ -40,8 +40,8 @@ export function parseToken(tokenOrLink: string): string {
     return trimmed.slice("hq://accept/".length);
   }
 
-  // https://hq.indigoai.com/accept/<token> (future web route)
-  const httpsPrefix = "https://hq.indigoai.com/accept/";
+  // https://example.com/accept/<token> (future web route)
+  const httpsPrefix = "https://example.com/accept/";
   if (trimmed.startsWith(httpsPrefix)) {
     return trimmed.slice(httpsPrefix.length);
   }

package/src/cli/share.test.ts

@@ -19,7 +19,7 @@ vi.mock("../s3.js", () => ({
 }));
 
 import { share } from "./share.js";
-import { headRemoteFile } from "../s3.js";
+import { headRemoteFile, uploadFile } from "../s3.js";
 
 const mockConfig: VaultServiceConfig = {
   apiUrl: "https://vault-api.test",
@@ -82,8 +82,10 @@ describe("share", () => {
     delete process.env.HQ_STATE_DIR;
   });
 
-  it("shares a single file", async () => {
-    const testFile = path.join(tmpDir, "test.md");
+  it("shares a single file keyed relative to the company root", async () => {
+    const companyRoot = path.join(tmpDir, "companies", "acme");
+    fs.mkdirSync(companyRoot, { recursive: true });
+    const testFile = path.join(companyRoot, "test.md");
     fs.writeFileSync(testFile, "# Hello World");
 
     const result = await share({
@@ -95,15 +97,18 @@ describe("share", () => {
 
     expect(result.filesUploaded).toBe(1);
     expect(result.aborted).toBe(false);
+    // Remote key must be company-relative, not hqRoot-relative
+    expect(uploadFile).toHaveBeenCalledWith(expect.anything(), testFile, "test.md");
   });
 
   it("respects ignore rules", async () => {
-    fs.mkdirSync(path.join(tmpDir, ".git"));
-    fs.writeFileSync(path.join(tmpDir, ".git", "config"), "git config");
-    fs.writeFileSync(path.join(tmpDir, "readme.md"), "readme");
+    const companyRoot = path.join(tmpDir, "companies", "acme");
+    fs.mkdirSync(path.join(companyRoot, ".git"), { recursive: true });
+    fs.writeFileSync(path.join(companyRoot, ".git", "config"), "git config");
+    fs.writeFileSync(path.join(companyRoot, "readme.md"), "readme");
 
     const result = await share({
-      paths: [tmpDir],
+      paths: [companyRoot],
       company: "acme",
       vaultConfig: mockConfig,
       hqRoot: tmpDir,
@@ -113,12 +118,13 @@ describe("share", () => {
   });
 
   it("shares a directory of files", async () => {
-    fs.mkdirSync(path.join(tmpDir, "docs"));
-    fs.writeFileSync(path.join(tmpDir, "docs", "a.md"), "doc a");
-    fs.writeFileSync(path.join(tmpDir, "docs", "b.md"), "doc b");
+    const companyRoot = path.join(tmpDir, "companies", "acme");
+    fs.mkdirSync(path.join(companyRoot, "docs"), { recursive: true });
+    fs.writeFileSync(path.join(companyRoot, "docs", "a.md"), "doc a");
+    fs.writeFileSync(path.join(companyRoot, "docs", "b.md"), "doc b");
 
     const result = await share({
-      paths: [path.join(tmpDir, "docs")],
+      paths: [path.join(companyRoot, "docs")],
       company: "acme",
       vaultConfig: mockConfig,
       hqRoot: tmpDir,
@@ -127,6 +133,44 @@ describe("share", () => {
     expect(result.filesUploaded).toBe(2);
   });
 
+  it("keys nested paths relative to the company root, not hqRoot", async () => {
+    const companyRoot = path.join(tmpDir, "companies", "acme");
+    fs.mkdirSync(path.join(companyRoot, "knowledge"), { recursive: true });
+    const nested = path.join(companyRoot, "knowledge", "crawl.json");
+    fs.writeFileSync(nested, "{}");
+
+    await share({
+      paths: [nested],
+      company: "acme",
+      vaultConfig: mockConfig,
+      hqRoot: tmpDir,
+    });
+
+    // Key is "knowledge/crawl.json", not "companies/acme/knowledge/crawl.json"
+    expect(uploadFile).toHaveBeenCalledWith(expect.anything(), nested, "knowledge/crawl.json");
+  });
+
+  it("skips files outside the company folder with a warning", async () => {
+    const warnSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+    // File at hqRoot, outside companies/acme/
+    const outsideFile = path.join(tmpDir, "stray.md");
+    fs.writeFileSync(outsideFile, "stray");
+
+    const result = await share({
+      paths: [outsideFile],
+      company: "acme",
+      vaultConfig: mockConfig,
+      hqRoot: tmpDir,
+    });
+
+    expect(result.filesUploaded).toBe(0);
+    expect(uploadFile).not.toHaveBeenCalled();
+    expect(warnSpy).toHaveBeenCalledWith(
+      expect.stringMatching(/outside company folder/i),
+    );
+    warnSpy.mockRestore();
+  });
+
   it("throws when no company specified and no active company", async () => {
     fs.writeFileSync(path.join(tmpDir, "test.md"), "test");
 
@@ -140,16 +184,160 @@ describe("share", () => {
   });
 
   it("resolves active company from .hq/config.json", async () => {
+    const companyRoot = path.join(tmpDir, "companies", "acme");
+    fs.mkdirSync(companyRoot, { recursive: true });
     fs.mkdirSync(path.join(tmpDir, ".hq"), { recursive: true });
     fs.writeFileSync(path.join(tmpDir, ".hq", "config.json"), JSON.stringify({ activeCompany: "acme" }));
-    fs.writeFileSync(path.join(tmpDir, "test.md"), "test");
+    fs.writeFileSync(path.join(companyRoot, "test.md"), "test");
+
+    const result = await share({
+      paths: [path.join(companyRoot, "test.md")],
+      vaultConfig: mockConfig,
+      hqRoot: tmpDir,
+    });
+
+    expect(result.filesUploaded).toBe(1);
+  });
+
+  it("skipUnchanged=true skips files whose local hash matches the journal", async () => {
+    const companyRoot = path.join(tmpDir, "companies", "acme");
+    fs.mkdirSync(companyRoot, { recursive: true });
+    const testFile = path.join(companyRoot, "unchanged.md");
+    fs.writeFileSync(testFile, "stable content");
+
+    // Precompute the hash of the file so the journal matches exactly.
+    const { hashFile } = await import("../journal.js");
+    const hash = hashFile(testFile);
+
+    const journalPath = path.join(stateDir, "sync-journal.acme.json");
+    fs.writeFileSync(
+      journalPath,
+      JSON.stringify({
+        version: "1",
+        lastSync: new Date().toISOString(),
+        files: {
+          "unchanged.md": {
+            hash,
+            size: 15,
+            syncedAt: new Date().toISOString(),
+            direction: "up",
+          },
+        },
+      }),
+    );
+
+    const result = await share({
+      paths: [testFile],
+      company: "acme",
+      vaultConfig: mockConfig,
+      hqRoot: tmpDir,
+      skipUnchanged: true,
+    });
+
+    expect(result.filesUploaded).toBe(0);
+    expect(result.filesSkipped).toBe(1);
+    expect(uploadFile).not.toHaveBeenCalled();
+  });
+
+  it("skipUnchanged=true still uploads files whose hash differs from the journal", async () => {
+    const companyRoot = path.join(tmpDir, "companies", "acme");
+    fs.mkdirSync(companyRoot, { recursive: true });
+    const testFile = path.join(companyRoot, "changed.md");
+    fs.writeFileSync(testFile, "new content");
+
+    // Journal has a stale hash for this path — simulating "local has been
+    // edited since the last push".
+    const journalPath = path.join(stateDir, "sync-journal.acme.json");
+    fs.writeFileSync(
+      journalPath,
+      JSON.stringify({
+        version: "1",
+        lastSync: new Date().toISOString(),
+        files: {
+          "changed.md": {
+            hash: "stale-hash-from-previous-sync",
+            size: 10,
+            syncedAt: new Date().toISOString(),
+            direction: "up",
+          },
+        },
+      }),
+    );
+
+    const result = await share({
+      paths: [testFile],
+      company: "acme",
+      vaultConfig: mockConfig,
+      hqRoot: tmpDir,
+      skipUnchanged: true,
+    });
+
+    expect(result.filesUploaded).toBe(1);
+    expect(uploadFile).toHaveBeenCalledWith(expect.anything(), testFile, "changed.md");
+  });
+
+  it("skipUnchanged=false (default) uploads even when hash matches", async () => {
+    const companyRoot = path.join(tmpDir, "companies", "acme");
+    fs.mkdirSync(companyRoot, { recursive: true });
+    const testFile = path.join(companyRoot, "unchanged.md");
+    fs.writeFileSync(testFile, "stable content");
+
+    const { hashFile } = await import("../journal.js");
+    const hash = hashFile(testFile);
+
+    const journalPath = path.join(stateDir, "sync-journal.acme.json");
+    fs.writeFileSync(
+      journalPath,
+      JSON.stringify({
+        version: "1",
+        lastSync: new Date().toISOString(),
+        files: {
+          "unchanged.md": {
+            hash,
+            size: 15,
+            syncedAt: new Date().toISOString(),
+            direction: "up",
+          },
+        },
+      }),
+    );
 
     const result = await share({
-      paths: [path.join(tmpDir, "test.md")],
+      paths: [testFile],
+      company: "acme",
       vaultConfig: mockConfig,
       hqRoot: tmpDir,
+      // skipUnchanged omitted — preserves `hq share <file>` semantics
     });
 
     expect(result.filesUploaded).toBe(1);
+    expect(uploadFile).toHaveBeenCalled();
+  });
+
+  it("onEvent receives progress events instead of console output", async () => {
+    const companyRoot = path.join(tmpDir, "companies", "acme");
+    fs.mkdirSync(companyRoot, { recursive: true });
+    fs.writeFileSync(path.join(companyRoot, "a.md"), "aaa");
+    fs.writeFileSync(path.join(companyRoot, "b.md"), "bbb");
+
+    const events: Array<{ type: string; path: string; bytes?: number }> = [];
+    const result = await share({
+      paths: [companyRoot],
+      company: "acme",
+      vaultConfig: mockConfig,
+      hqRoot: tmpDir,
+      onEvent: (e) => {
+        events.push({
+          type: e.type,
+          path: e.path,
+          ...(e.type === "progress" ? { bytes: e.bytes } : {}),
+        });
+      },
+    });
+
+    expect(result.filesUploaded).toBe(2);
+    expect(events).toHaveLength(2);
+    expect(events.every((e) => e.type === "progress")).toBe(true);
+    expect(events.map((e) => e.path).sort()).toEqual(["a.md", "b.md"]);
   });
 });