@indigoai-us/hq-cloud 5.11.3 → 5.12.0

package/src/cli/share.test.ts

@@ -1082,4 +1082,126 @@ describe("share", () => {
     const journal = JSON.parse(fs.readFileSync(journalPath, "utf-8"));
     expect(journal.files["flaky.md"]).toBeDefined();
   });
+
+  // ── personalMode ───────────────────────────────────────────────────────────
+  //
+  // The personal vault (slug "personal" in the runner's fanout plan) shares
+  // files from hqRoot DIRECTLY — not from hqRoot/companies/<slug>/. Mirrors
+  // the Rust hq-sync first-push contract in src-tauri/src/commands/personal.rs:
+  // syncRoot = hqRoot, journal slug = "personal", remote keys are hq-root-
+  // relative (e.g. ".claude/skills/foo.md", "knowledge/notes.md"). The
+  // exclusion list itself is enforced by the runner (sync-runner.ts) by only
+  // passing in the allowed top-level directories — share() trusts its
+  // `paths` input.
+  describe("personalMode", () => {
+    it("personalMode=true keys files hq-root-relative, not companies/{slug}/-relative", async () => {
+      fs.mkdirSync(path.join(tmpDir, ".claude", "skills"), { recursive: true });
+      fs.mkdirSync(path.join(tmpDir, "knowledge"), { recursive: true });
+      fs.writeFileSync(path.join(tmpDir, ".claude", "skills", "foo.md"), "skill");
+      fs.writeFileSync(path.join(tmpDir, "knowledge", "notes.md"), "note");
+
+      const result = await share({
+        paths: [
+          path.join(tmpDir, ".claude"),
+          path.join(tmpDir, "knowledge"),
+        ],
+        company: "acme",
+        vaultConfig: mockConfig,
+        hqRoot: tmpDir,
+        personalMode: true,
+        journalSlug: "personal",
+      });
+
+      expect(result.filesUploaded).toBe(2);
+      // Remote keys must be hq-root-relative, NOT prefixed with companies/personal/
+      const keys = vi.mocked(uploadFile).mock.calls.map((c) => c[2]);
+      expect(keys.sort()).toEqual([".claude/skills/foo.md", "knowledge/notes.md"]);
+    });
+
+    it("personalMode=true writes journal under the personal journalSlug", async () => {
+      fs.mkdirSync(path.join(tmpDir, "knowledge"), { recursive: true });
+      fs.writeFileSync(path.join(tmpDir, "knowledge", "notes.md"), "note");
+
+      await share({
+        paths: [path.join(tmpDir, "knowledge")],
+        company: "acme",
+        vaultConfig: mockConfig,
+        hqRoot: tmpDir,
+        personalMode: true,
+        journalSlug: "personal",
+      });
+
+      // Personal journal is keyed "personal", NOT the company's ctx.slug ("acme")
+      const personalJournalPath = path.join(stateDir, "sync-journal.personal.json");
+      const acmeJournalPath = path.join(stateDir, "sync-journal.acme.json");
+      expect(fs.existsSync(personalJournalPath)).toBe(true);
+      expect(fs.existsSync(acmeJournalPath)).toBe(false);
+
+      const journal = JSON.parse(fs.readFileSync(personalJournalPath, "utf-8"));
+      expect(journal.files["knowledge/notes.md"]).toBeDefined();
+    });
+
+    it("personalMode=true accepts files outside companies/<slug>/ (companion to the company-folder rejection)", async () => {
+      // Same fixture as the "skips files outside the company folder" test
+      // above — file at hqRoot root, NOT under companies/acme/. Without
+      // personalMode this is rejected with a "outside company folder" warning;
+      // with personalMode=true the file IS uploaded because syncRoot=hqRoot.
+      const outsideFile = path.join(tmpDir, "stray.md");
+      fs.writeFileSync(outsideFile, "stray");
+
+      const result = await share({
+        paths: [outsideFile],
+        company: "acme",
+        vaultConfig: mockConfig,
+        hqRoot: tmpDir,
+        personalMode: true,
+        journalSlug: "personal",
+      });
+
+      expect(result.filesUploaded).toBe(1);
+      expect(uploadFile).toHaveBeenCalledWith(expect.anything(), outsideFile, "stray.md");
+    });
+
+    it("personalMode=true + skipUnchanged honors the personal-journal hash", async () => {
+      fs.mkdirSync(path.join(tmpDir, "knowledge"), { recursive: true });
+      const testFile = path.join(tmpDir, "knowledge", "stable.md");
+      fs.writeFileSync(testFile, "stable content");
+
+      const { hashFile } = await import("../journal.js");
+      const hash = hashFile(testFile);
+
+      // Pre-seed the PERSONAL journal (not the per-company one) so the
+      // skipUnchanged short-circuit fires for the right slug.
+      const personalJournalPath = path.join(stateDir, "sync-journal.personal.json");
+      fs.writeFileSync(
+        personalJournalPath,
+        JSON.stringify({
+          version: "1",
+          lastSync: new Date().toISOString(),
+          files: {
+            "knowledge/stable.md": {
+              hash,
+              size: 15,
+              syncedAt: new Date().toISOString(),
+              direction: "up",
+            },
+          },
+        }),
+      );
+
+      const result = await share({
+        paths: [path.join(tmpDir, "knowledge")],
+        company: "acme",
+        vaultConfig: mockConfig,
+        hqRoot: tmpDir,
+        personalMode: true,
+        journalSlug: "personal",
+        skipUnchanged: true,
+      });
+
+      expect(result.filesUploaded).toBe(0);
+      expect(result.filesSkipped).toBe(1);
+      expect(uploadFile).not.toHaveBeenCalled();
+    });
+  });
 });

package/src/cli/share.ts

@@ -193,6 +193,23 @@ export interface ShareOptions {
    * this engine. The runner pipes Cognito idToken claims through here.
    */
   author?: UploadAuthor;
+  /**
+   * When true, share() targets the caller's person-entity bucket: syncRoot
+   * is `hqRoot` itself (NOT `hqRoot/companies/<slug>/`), so remote keys are
+   * hq-root-relative (e.g. ".claude/skills/foo.md", "knowledge/notes.md") to
+   * match the Rust hq-sync first-push contract in
+   * `src-tauri/src/commands/personal.rs`. The exclusion of top-level dirs
+   * (.git, companies, core, data, personal, repos, workspace) is enforced
+   * by the runner — share() trusts its `paths` input.
+   */
+  personalMode?: boolean;
+  /**
+   * Override for the per-slug journal file name. Defaults to `ctx.slug`. The
+   * runner passes `journalSlug: "personal"` for the personal slot so the TS
+   * push and the Rust personal first-push share idempotency state under one
+   * `sync-journal.personal.json` file.
+   */
+  journalSlug?: string;
 }
 
 export interface ShareResult {
@@ -263,9 +280,17 @@ export async function share(options: ShareOptions): Promise<ShareResult> {
   // Remote keys are company-relative; the on-disk scoping prefix is
   // companies/{slug}/. Anything outside this folder gets skipped to avoid
   // leaking cross-company state into the vault.
-  const syncRoot = path.join(hqRoot, "companies", ctx.slug);
+  //
+  // In personalMode the syncRoot is `hqRoot` itself — remote keys are
+  // hq-root-relative to match the Rust personal first-push (which uploads
+  // every non-excluded top-level dir under ~/HQ). The exclusion list is
+  // enforced upstream by the runner; share() just trusts `paths`.
+  const syncRoot = options.personalMode === true
+    ? hqRoot
+    : path.join(hqRoot, "companies", ctx.slug);
   const shouldSync = createIgnoreFilter(hqRoot);
-  const journal = readJournal(ctx.slug);
+  const journalSlug = options.journalSlug ?? ctx.slug;
+  const journal = readJournal(journalSlug);
 
   let filesUploaded = 0;
   let bytesUploaded = 0;
@@ -457,7 +482,7 @@ export async function share(options: ShareOptions): Promise<ShareResult> {
   // See cli/sync.ts: stamp lastSync on completion so a no-op share still
   // ticks the "Last sync" indicator.
   journal.lastSync = new Date().toISOString();
-  writeJournal(ctx.slug, journal);
+  writeJournal(journalSlug, journal);
 
   return {
     filesUploaded,