v0.1.15: Fetch and write remote items during push

When pushing local changes, now also:
1. Fetches remote items from shards that don't exist locally
2. Returns them as pulledData in the push result
3. Sync handler writes them to disk after successful push

This fixes the issue where push would merge remote data into the
manifest but never download it to the local filesystem, causing
sessions/messages from other machines to not appear locally.

Author: ErcinDedeoglu

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "oc-sync",
-  "version": "0.1.14",
+  "version": "0.1.15",
   "description": "Sync OpenCode data across machines using a private GitHub repository with vector clock conflict resolution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package.json

@@ -62,7 +62,8 @@ async function handleSyncSuccess(
   const newState = state.engine?.getLocalState();
 
   // Write pulled data to local filesystem
-  if (result.action === 'pulled' || result.action === 'merged') {
+  // This includes data from pull, merge, AND remote items fetched during push
+  if (result.action === 'pulled' || result.action === 'merged' || result.action === 'pushed') {
     syncLog(
       `[WRITE] Action: ${result.action}, pulledData: ${result.pulledData ? 'present' : 'missing'}`
     );

src/plugin/sync-handler.ts

@@ -26,6 +26,7 @@ import {
   extractTombstoneIds,
   fetchResolvedShards,
 } from './helpers.js';
+import { fetchRemoteItemsNotLocal } from './remote-fetch.js';
 
 export interface OperationContext {
   backend: StorageBackend;
@@ -44,7 +45,7 @@ export async function executePushOperation(
   ctx: PushContext,
   data: CategoryData[],
   remote?: Manifest
-): Promise<{ result: SyncResult; newState: LocalSyncState }> {
+): Promise<{ result: SyncResult; newState: LocalSyncState; remoteItems?: CategoryData[] }> {
   const existing = (await ctx.backend.listFiles()).map((f) => f.filename);
 
   // Pre-fetch shards for sharded categories to enable proper merging
@@ -64,7 +65,22 @@ export async function executePushOperation(
     toStorageFiles(files, MANIFEST_FILENAME, JSON.stringify(manifest, null, 2))
   );
   const newState = buildLocalState(manifest, data, ctx.getStorageId(), ctx.config.machineId);
-  return { result: buildPushResult(changedCategories), newState };
+
+  // Fetch remote items we don't have locally (for writing to disk)
+  const remoteItems = resolvedShards
+    ? await fetchRemoteItemsNotLocal(ctx.backend, resolvedShards, data)
+    : undefined;
+
+  const result = buildPushResult({
+    changedCategories,
+    pulledData: remoteItems && remoteItems.length > 0 ? remoteItems : undefined,
+  });
+
+  // Only include remoteItems in return if there are any
+  if (remoteItems && remoteItems.length > 0) {
+    return { result, newState, remoteItems };
+  }
+  return { result, newState };
 }
 
 /** Execute a pull operation and return updated local state */

src/sync/engine/operations.ts

@@ -0,0 +1,113 @@
+/**
+ * Remote Fetch Helpers
+ *
+ * Functions to fetch remote items during push operations.
+ */
+
+import type { StorageBackend } from '../../storage/index.js';
+import type { SyncCategory } from '../../types/index.js';
+import type { CategoryData, ItemCategoryData, ResolvedShard } from '../operations/types.js';
+import { unpackItem } from '../item-packer.js';
+import { syncLog } from './logger.js';
+
+/** Info about a remote file to fetch */
+interface RemoteFetchInfo {
+  category: SyncCategory;
+  itemId: string;
+  filename: string;
+  checksum: string;
+}
+
+/** Build a map of local item IDs per category */
+function buildLocalItemIdMap(localData: CategoryData[]): Map<SyncCategory, Set<string>> {
+  const map = new Map<SyncCategory, Set<string>>();
+  for (const cat of localData) {
+    if (cat.type === 'items') {
+      const set = map.get(cat.category) ?? new Set<string>();
+      for (const id of Object.keys(cat.items)) {
+        set.add(id);
+      }
+      map.set(cat.category, set);
+    }
+  }
+  return map;
+}
+
+/** Collect files to fetch from shards (excluding local and tombstoned items) */
+function collectFilesToFetch(
+  shards: Record<SyncCategory, ResolvedShard>,
+  localItemIds: Map<SyncCategory, Set<string>>
+): RemoteFetchInfo[] {
+  const filesToFetch: RemoteFetchInfo[] = [];
+
+  for (const [category, shard] of Object.entries(shards) as [SyncCategory, ResolvedShard][]) {
+    const localIds = localItemIds.get(category) ?? new Set<string>();
+    const tombstoneIds = new Set(Object.keys(shard.tombstones));
+
+    for (const [itemId, info] of Object.entries(shard.items)) {
+      if (!localIds.has(itemId) && !tombstoneIds.has(itemId)) {
+        filesToFetch.push({ category, itemId, filename: info.filename, checksum: info.checksum });
+      }
+    }
+  }
+
+  return filesToFetch;
+}
+
+/** Process downloaded content and group by category */
+function processDownloadedContent(
+  filesToFetch: RemoteFetchInfo[],
+  contents: Record<string, string | null>
+): Map<SyncCategory, { items: Record<string, string>; checksums: Record<string, string> }> {
+  const categoryItems = new Map<
+    SyncCategory,
+    { items: Record<string, string>; checksums: Record<string, string> }
+  >();
+
+  for (const { category, itemId, filename, checksum } of filesToFetch) {
+    const content = contents[filename];
+    if (!content) continue;
+
+    try {
+      const unpacked = unpackItem(filename, content, checksum);
+      let catData = categoryItems.get(category);
+      if (!catData) {
+        catData = { items: {}, checksums: {} };
+        categoryItems.set(category, catData);
+      }
+      catData.items[itemId] = unpacked.content;
+      catData.checksums[itemId] = checksum;
+    } catch (error) {
+      console.error(`Failed to unpack remote item ${itemId}:`, error);
+    }
+  }
+
+  return categoryItems;
+}
+
+/** Fetch remote items from shards that don't exist in local data */
+export async function fetchRemoteItemsNotLocal(
+  backend: StorageBackend,
+  shards: Record<SyncCategory, ResolvedShard>,
+  localData: CategoryData[]
+): Promise<CategoryData[]> {
+  const localItemIds = buildLocalItemIdMap(localData);
+  const filesToFetch = collectFilesToFetch(shards, localItemIds);
+
+  if (filesToFetch.length === 0) return [];
+
+  syncLog(`[PUSH] Fetching ${String(filesToFetch.length)} remote items to write locally`);
+  const contents = await backend.getFiles(filesToFetch.map((f) => f.filename));
+  const categoryItems = processDownloadedContent(filesToFetch, contents);
+
+  // Convert to CategoryData[]
+  const result: CategoryData[] = [];
+  for (const [category, { items, checksums }] of categoryItems) {
+    if (Object.keys(items).length > 0) {
+      syncLog(`[PUSH] Downloaded ${String(Object.keys(items).length)} remote ${category} items`);
+      result.push({ category, type: 'items', items, checksums } as ItemCategoryData);
+    }
+  }
+
+  return result;
+}

src/sync/engine/remote-fetch.ts

@@ -6,16 +6,34 @@
 
 import type { SyncResult, ConflictInfo, SyncCategory } from '../../types/index.js';
 
+/** Options for building push result */
+export interface BuildPushResultOptions {
+  changedCategories: SyncCategory[];
+  pulledData?: unknown;
+}
+
 /**
  * Build a success result for push operations.
  */
-export function buildPushResult(changedCategories: SyncCategory[]): SyncResult {
-  return {
+export function buildPushResult(
+  changedCategoriesOrOpts: SyncCategory[] | BuildPushResultOptions
+): SyncResult {
+  // Support both old signature (array) and new signature (options object)
+  const opts = Array.isArray(changedCategoriesOrOpts)
+    ? { changedCategories: changedCategoriesOrOpts }
+    : changedCategoriesOrOpts;
+
+  const { changedCategories, pulledData } = opts;
+  const result: SyncResult = {
     success: true,
     action: 'pushed',
     message: `Pushed ${String(changedCategories.length)} categories`,
     changedCategories,
   };
+  if (pulledData) {
+    result.pulledData = pulledData;
+  }
+  return result;
 }
 
 /** Options for building pull result */