@indigoai-us/hq-cloud 5.14.0 → 5.15.0

package/src/cli/sync.ts

@@ -9,7 +9,7 @@ import * as fs from "fs";
 import * as path from "path";
 import type { VaultServiceConfig, SyncJournal } from "../types.js";
 import { resolveEntityContext, isExpiringSoon, refreshEntityContext } from "../context.js";
-import { downloadFile, listRemoteFiles } from "../s3.js";
+import { downloadFile, listRemoteFiles, headRemoteFile } from "../s3.js";
 import type { RemoteFile } from "../s3.js";
 import { readJournal, writeJournal, hashFile, updateEntry, getEntry, normalizeEtag } from "../journal.js";
 import { createIgnoreFilter } from "../ignore.js";
@@ -80,6 +80,10 @@ export type SyncProgressEvent =
       path: string;
       direction: "pull" | "push";
       resolution: ConflictResolution;
+    }
+  | {
+      type: "new-files";
+      files: Array<{ path: string; bytes: number; addedBy: string | null }>;
     };
 
 export interface SyncOptions {
@@ -125,6 +129,14 @@ export interface SyncResult {
    */
   conflictPaths: string[];
   aborted: boolean;
+  /**
+   * Files classified as "new" during pull — i.e. the remote file had no
+   * local counterpart at classification time. Additive field; empty array
+   * when no new files were detected or on push-only syncs.
+   */
+  newFiles: Array<{ path: string; bytes: number }>;
+  /** Convenience count: `newFiles.length`. */
+  newFilesCount: number;
 }
 
 /**
@@ -276,6 +288,7 @@ export async function sync(options: SyncOptions): Promise<SyncResult> {
       }
 
       if (resolution === "abort") {
+        emit({ type: "new-files", files: [] });
         writeJournal(journalSlug, journal);
         return {
           filesDownloaded,
@@ -284,6 +297,8 @@ export async function sync(options: SyncOptions): Promise<SyncResult> {
           conflicts,
           conflictPaths,
           aborted: true,
+          newFiles: plan.newFiles,
+          newFilesCount: plan.newFilesCount,
         };
       }
       if (resolution === "keep" || resolution === "skip") {
@@ -352,6 +367,41 @@ export async function sync(options: SyncOptions): Promise<SyncResult> {
     }
   }
 
+  // ── New-files attribution (US-002) ─────────────────────────────────────
+  // Enrich plan.newFiles with `addedBy` from S3 user metadata. HeadObject
+  // calls are best-effort and capped at 5 concurrent to avoid hammering S3.
+  const enrichedNewFiles: Array<{ path: string; bytes: number; addedBy: string | null }> = [];
+  const HEAD_CONCURRENCY = 5;
+  for (let i = 0; i < plan.newFiles.length; i += HEAD_CONCURRENCY) {
+    const batch = plan.newFiles.slice(i, i + HEAD_CONCURRENCY);
+    const results = await Promise.all(
+      batch.map(async (nf) => {
+        let addedBy: string | null = null;
+        try {
+          const head = await headRemoteFile(ctx, nf.path);
+          if (head?.metadata?.["created-by"]) {
+            addedBy = head.metadata["created-by"];
+          }
+        } catch (headErr) {
+          // Best-effort: log to console (Sentry captures via global handler)
+          // and fall through with addedBy = null.
+          try {
+            console.error(
+              `[hq-sync] HeadObject failed for ${nf.path}: ${
+                headErr instanceof Error ? headErr.message : String(headErr)
+              }`,
+            );
+          } catch {
+            // Swallow — logging must never break sync.
+          }
+        }
+        return { path: nf.path, bytes: nf.bytes, addedBy };
+      }),
+    );
+    enrichedNewFiles.push(...results);
+  }
+  emit({ type: "new-files", files: enrichedNewFiles });
+
   // Stamp lastSync on every successful run so the menubar's "Last sync · X ago"
   // ticks even when nothing transferred. updateEntry only fires on actual
   // downloads; without this, a no-op sync leaves lastSync at the time of the
@@ -366,6 +416,8 @@ export async function sync(options: SyncOptions): Promise<SyncResult> {
     conflicts,
     conflictPaths,
     aborted: false,
+    newFiles: plan.newFiles,
+    newFilesCount: plan.newFilesCount,
   };
 }
 
@@ -409,7 +461,7 @@ function hasRemoteChanged(
  * executor can hand it to `resolveConflict` without re-hashing.
  */
 type PullPlanItem =
-  | { action: "download"; remoteFile: RemoteFile; localPath: string }
+  | { action: "download"; remoteFile: RemoteFile; localPath: string; isNew: boolean }
   | { action: "skip-ignored"; remoteFile: RemoteFile; localPath: string }
   | { action: "skip-personal-mode"; remoteFile: RemoteFile; localPath: string }
   | { action: "skip-unchanged"; remoteFile: RemoteFile; localPath: string }
@@ -427,6 +479,9 @@ interface PullPlan {
   bytesToDownload: number;
   filesToSkip: number;
   filesToConflict: number;
+  /** Files classified as new (no local counterpart at classification time). */
+  newFiles: Array<{ path: string; bytes: number }>;
+  newFilesCount: number;
 }
 
 /**
@@ -463,8 +518,9 @@ function computePullPlan(
     }
 
     const journalEntry = getEntry(journal, remoteFile.key);
+    const localExists = fs.existsSync(localPath);
 
-    if (fs.existsSync(localPath)) {
+    if (localExists) {
       const localHash = hashFile(localPath);
       const localChanged = !!journalEntry && journalEntry.hash !== localHash;
       const remoteChanged =
@@ -493,17 +549,21 @@ function computePullPlan(
       // No journal entry, or remote-only changed → fall through to download.
     }
 
-    items.push({ action: "download", remoteFile, localPath });
+    items.push({ action: "download", remoteFile, localPath, isNew: !localExists });
   }
 
   let filesToDownload = 0;
   let bytesToDownload = 0;
   let filesToSkip = 0;
   let filesToConflict = 0;
+  const newFiles: Array<{ path: string; bytes: number }> = [];
   for (const item of items) {
     if (item.action === "download") {
       filesToDownload++;
       bytesToDownload += item.remoteFile.size;
+      if (item.isNew) {
+        newFiles.push({ path: item.remoteFile.key, bytes: item.remoteFile.size });
+      }
     } else if (item.action === "conflict") {
       filesToConflict++;
     } else {
@@ -517,6 +577,8 @@ function computePullPlan(
     bytesToDownload,
     filesToSkip,
     filesToConflict,
+    newFiles,
+    newFilesCount: newFiles.length,
   };
 }
 
@@ -567,5 +629,18 @@ function defaultConsoleLogger(event: SyncProgressEvent): void {
     console.error(
       `  ⚠ conflict (${event.direction}): ${event.path} — ${event.resolution}`,
     );
+  } else if (event.type === "new-files") {
+    if (event.files.length > 0) {
+      console.log(`${event.files.length} new file${event.files.length === 1 ? "" : "s"}`);
+      const MAX_SHOWN = 20;
+      const shown = event.files.slice(0, MAX_SHOWN);
+      for (const f of shown) {
+        const who = f.addedBy ? ` (added by ${f.addedBy})` : "";
+        console.log(`  + ${f.path}${who}`);
+      }
+      if (event.files.length > MAX_SHOWN) {
+        console.log(`  ... and ${event.files.length - MAX_SHOWN} more`);
+      }
+    }
   }
 }

package/src/s3.ts

@@ -214,7 +214,7 @@ export async function deleteRemoteFile(
 export async function headRemoteFile(
   ctx: EntityContext,
   key: string,
-): Promise<{ lastModified: Date; etag: string; size: number } | null> {
+): Promise<{ lastModified: Date; etag: string; size: number; metadata?: Record<string, string> } | null> {
   const client = buildClient(ctx);
   try {
     const response = await client.send(
@@ -227,6 +227,7 @@ export async function headRemoteFile(
       lastModified: response.LastModified || new Date(),
       etag: response.ETag || "",
       size: response.ContentLength || 0,
+      metadata: response.Metadata,
     };
   } catch (err: unknown) {
     if (err && typeof err === "object" && "name" in err && err.name === "NotFound") {