@gobi-ai/cli 0.6.9 → 0.6.10

package/dist/commands/sync.js

@@ -55,6 +55,8 @@ const EMPTY_STATE = {
     cursor: null,
     syncfilesHash: null,
     patterns: [],
+    privatePatterns: [],
+    privatefilesHash: null,
     hashCache: {},
 };
 function openDb(gobiDir) {
@@ -84,6 +86,8 @@ export function loadSyncState(gobiDir) {
                 cursor: parsed.cursor ?? null,
                 syncfilesHash: parsed.syncfilesHash ?? null,
                 patterns: parsed.patterns ?? [],
+                privatePatterns: parsed.privatePatterns ?? [],
+                privatefilesHash: parsed.privatefilesHash ?? null,
                 hashCache: parsed.hashCache ?? {},
             };
             saveSyncState(gobiDir, state);
@@ -108,6 +112,8 @@ export function loadSyncState(gobiDir) {
             cursor: metaMap.cursor ? Number(metaMap.cursor) : EMPTY_STATE.cursor,
             syncfilesHash: metaMap.syncfiles_hash || EMPTY_STATE.syncfilesHash,
             patterns: metaMap.patterns ? JSON.parse(metaMap.patterns) : EMPTY_STATE.patterns,
+            privatePatterns: metaMap.private_patterns ? JSON.parse(metaMap.private_patterns) : EMPTY_STATE.privatePatterns,
+            privatefilesHash: metaMap.privatefiles_hash || EMPTY_STATE.privatefilesHash,
             hashCache,
         };
     }
@@ -123,6 +129,8 @@ export function saveSyncState(gobiDir, state) {
             upsert.run("cursor", state.cursor !== null ? String(state.cursor) : "");
             upsert.run("syncfiles_hash", state.syncfilesHash ?? "");
             upsert.run("patterns", JSON.stringify(state.patterns));
+            upsert.run("private_patterns", JSON.stringify(state.privatePatterns));
+            upsert.run("privatefiles_hash", state.privatefilesHash ?? "");
             db.exec("DELETE FROM hash_cache");
             const insert = db.prepare("INSERT INTO hash_cache (path, hash, mtime, size) VALUES (?, ?, ?, ?)");
             for (const [path, entry] of Object.entries(state.hashCache)) {
@@ -282,21 +290,6 @@ async function webdriveSync(baseUrl, vaultSlug, body, token) {
     }
     return (await res.json());
 }
-async function webdrivePrivatefiles(baseUrl, vaultSlug, patterns, token) {
-    const url = `${baseUrl}/api/v1/vaults/${vaultSlug}/privatefiles`;
-    const res = await fetch(url, {
-        method: "POST",
-        headers: {
-            Authorization: `Bearer ${token}`,
-            "Content-Type": "application/json",
-        },
-        body: JSON.stringify({ patterns }),
-    });
-    if (!res.ok) {
-        throw new Error(`Privatefiles request failed: HTTP ${res.status}: ${await res.text()}`);
-    }
-    return (await res.json());
-}
 // ─── Conflict Resolution ──────────────────────────────────────────────────────
 function formatDate(ms) {
     return new Date(ms).toLocaleString();
@@ -346,10 +339,11 @@ function matchesPaths(filePath, paths) {
     return false;
 }
 // ─── Core Sync ────────────────────────────────────────────────────────────────
-async function performSync(baseUrl, vaultSlug, state, syncfilesChanges, localFiles, opts, token) {
+async function performSync(baseUrl, vaultSlug, state, syncfilesChanges, privatefilesChanges, localFiles, opts, token) {
     const body = {
         cursor: state.cursor,
         syncfilesChanges,
+        privatefilesChanges,
         clientFiles: localFiles,
         uploadOnly: opts.uploadOnly,
         downloadOnly: opts.downloadOnly,
@@ -371,19 +365,6 @@ export async function runSync(opts) {
     }
     const token = opts.authToken ?? (await getValidToken());
     // Sync privatefiles with server
-    if (!opts.dryRun) {
-        try {
-            const localPrivatePatterns = readPrivatefiles(gobiDir);
-            const privateresp = await webdrivePrivatefiles(baseUrl, vaultSlug, localPrivatePatterns, token);
-            if (!opts.uploadOnly && privateresp.patterns.length > 0) {
-                await writeFile(join(gobiDir, "privatefiles"), privateresp.patterns.join("\n") + "\n");
-            }
-        }
-        catch (err) {
-            if (!jsonMode)
-                console.error(`Warning: Failed to sync privatefiles: ${err.message}`);
-        }
-    }
     // Read syncfiles whitelist
     const { patterns: currPatterns, contentHash: currSyncfilesHash } = readSyncfiles(gobiDir);
     if (currPatterns.length === 0 && !jsonMode) {
@@ -391,7 +372,45 @@ export async function runSync(opts) {
             "Add gitignore-style patterns to .gobi/syncfiles to select files for sync.");
     }
     const isWhitelisted = buildWhitelistMatcher(currPatterns);
-    const syncfilesChanges = computeSyncfilesChanges(state.patterns, currPatterns);
+    // On bootstrap (no prior state), fetch server's current syncfiles so removals
+    // relative to the server are captured correctly in the delta.
+    let baseSyncPatterns = state.patterns;
+    if (!opts.dryRun && state.syncfilesHash === null) {
+        try {
+            const serverContent = await webdriveGet(baseUrl, vaultSlug, ".gobi/syncfiles", token);
+            baseSyncPatterns = serverContent
+                .toString("utf-8")
+                .split("\n")
+                .map((l) => l.trim())
+                .filter((l) => l.length > 0 && !l.startsWith("#"));
+            process.stderr.write(`[gobi-sync] bootstrap: fetched server syncfiles, patterns=${JSON.stringify(baseSyncPatterns)}\n`);
+        }
+        catch {
+            baseSyncPatterns = []; // server has no syncfiles yet
+        }
+    }
+    const syncfilesChanges = computeSyncfilesChanges(baseSyncPatterns, currPatterns);
+    // Compute privatefiles delta (supports removals via sync endpoint)
+    const currPrivatePatterns = readPrivatefiles(gobiDir);
+    // On bootstrap (no prior state), fetch server's current patterns so we can compute
+    // correct removals. Without this, patterns the user deleted would stay on the server
+    // because we'd have no baseline to diff against.
+    let basePrivatePatterns = state.privatePatterns;
+    if (!opts.dryRun && state.privatefilesHash === null) {
+        try {
+            const serverContent = await webdriveGet(baseUrl, vaultSlug, ".gobi/privatefiles", token);
+            basePrivatePatterns = serverContent
+                .toString("utf-8")
+                .split("\n")
+                .map((l) => l.trim())
+                .filter((l) => l.length > 0 && !l.startsWith("#"));
+            process.stderr.write(`[gobi-sync] bootstrap: fetched server privatefiles, patterns=${JSON.stringify(basePrivatePatterns)}\n`);
+        }
+        catch {
+            basePrivatePatterns = []; // server has no privatefiles yet
+        }
+    }
+    const privatefilesChanges = computeSyncfilesChanges(basePrivatePatterns, currPrivatePatterns);
     // Walk local files (only whitelisted, non-ignored)
     if (!jsonMode)
         process.stdout.write("Scanning local files...");
@@ -440,7 +459,7 @@ export async function runSync(opts) {
         process.stdout.write("Syncing with server...");
     let syncResp;
     try {
-        syncResp = await performSync(baseUrl, vaultSlug, state, syncfilesChanges, clientFilesForSync, opts, token);
+        syncResp = await performSync(baseUrl, vaultSlug, state, syncfilesChanges, privatefilesChanges, clientFilesForSync, opts, token);
     }
     catch (err) {
         if (err instanceof GobiError && err.status === 409) {
@@ -452,8 +471,10 @@ export async function runSync(opts) {
             state.cursor = null;
             state.hashCache = {};
             state.patterns = []; // reset so retry sends currPatterns as syncfilesChanges.added
+            state.privatePatterns = []; // reset so retry sends currPrivatePatterns as privatefilesChanges.added
             const retryChanges = computeSyncfilesChanges([], currPatterns);
-            syncResp = await performSync(baseUrl, vaultSlug, state, retryChanges, clientFilesForSync, opts, token);
+            const retryPrivateChanges = computeSyncfilesChanges([], currPrivatePatterns);
+            syncResp = await performSync(baseUrl, vaultSlug, state, retryChanges, retryPrivateChanges, clientFilesForSync, opts, token);
         }
         else {
             throw err;
@@ -579,14 +600,55 @@ export async function runSync(opts) {
                 console.error(`  Error [${entry.action}] ${entry.path}: ${msg}`);
         }
     }
+    // Download syncfiles from server if the server's hash changed since last sync
+    let effectivePatterns = currPatterns;
+    process.stderr.write(`[gobi-sync] syncfiles: state=${state.syncfilesHash ?? "null"} server=${syncResp.syncfilesHash ?? "null"}\n`);
+    if (!opts.dryRun && syncResp.syncfilesHash && syncResp.syncfilesHash !== state.syncfilesHash) {
+        process.stderr.write(`[gobi-sync] syncfiles hash changed — downloading from server\n`);
+        try {
+            const syncfilesContent = await webdriveGet(baseUrl, vaultSlug, ".gobi/syncfiles", token);
+            await writeFile(join(gobiDir, "syncfiles"), syncfilesContent);
+            const { patterns: newPatterns } = readSyncfiles(gobiDir);
+            effectivePatterns = newPatterns;
+            process.stderr.write(`[gobi-sync] syncfiles downloaded OK, patterns=${JSON.stringify(newPatterns)}\n`);
+            if (!jsonMode)
+                console.log("  Updated local syncfiles from server.");
+        }
+        catch (err) {
+            process.stderr.write(`[gobi-sync] syncfiles download FAILED: ${err.message}\n`);
+            if (!jsonMode)
+                console.error(`Warning: Failed to download syncfiles from server: ${err.message}`);
+        }
+    }
+    // Download privatefiles from server if the server's hash changed since last sync
+    let effectivePrivatePatterns = currPrivatePatterns;
+    process.stderr.write(`[gobi-sync] privatefiles: state=${state.privatefilesHash ?? "null"} server=${syncResp.privatefilesHash ?? "null"}\n`);
+    if (!opts.dryRun && syncResp.privatefilesHash && syncResp.privatefilesHash !== state.privatefilesHash) {
+        process.stderr.write(`[gobi-sync] privatefiles hash changed — downloading from server\n`);
+        try {
+            const privatefilesContent = await webdriveGet(baseUrl, vaultSlug, ".gobi/privatefiles", token);
+            await writeFile(join(gobiDir, "privatefiles"), privatefilesContent);
+            effectivePrivatePatterns = readPrivatefiles(gobiDir);
+            process.stderr.write(`[gobi-sync] privatefiles downloaded OK, patterns=${JSON.stringify(effectivePrivatePatterns)}\n`);
+            if (!jsonMode)
+                console.log("  Updated local privatefiles from server.");
+        }
+        catch (err) {
+            process.stderr.write(`[gobi-sync] privatefiles download FAILED: ${err.message}\n`);
+            if (!jsonMode)
+                console.error(`Warning: Failed to download privatefiles from server: ${err.message}`);
+        }
+    }
     // Persist state (always, even on partial failures)
     const finalCursor = Math.max(syncResp.cursor, maxMutationCursor !== null ? maxMutationCursor : 0);
     state.cursor = finalCursor;
-    state.syncfilesHash = currSyncfilesHash;
+    state.syncfilesHash = syncResp.syncfilesHash || currSyncfilesHash;
     // If the server returned an empty syncfilesHash the vault was deleted server-side
     // (empty patterns path). Reset patterns so the next sync re-registers them as "added",
     // which lets the 409 retry resurrect the vault.
-    state.patterns = syncResp.syncfilesHash === "" ? [] : currPatterns;
+    state.patterns = syncResp.syncfilesHash === "" ? [] : effectivePatterns;
+    state.privatePatterns = effectivePrivatePatterns;
+    state.privatefilesHash = syncResp.privatefilesHash || state.privatefilesHash;
     saveSyncState(gobiDir, state);
     // Output summary
     const result = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gobi-ai/cli",
-  "version": "0.6.9",
+  "version": "0.6.10",
   "description": "CLI client for the Gobi collaborative knowledge platform",
   "license": "MIT",
   "type": "module",

package/skills/gobi/SKILL.md

@@ -10,12 +10,12 @@ description: >-
 allowed-tools: Bash(gobi:*)
 metadata:
   author: gobi-ai
-  version: "0.6.9"
+  version: "0.6.10"
 ---
 
 # gobi-cli
 
-A CLI client for the Gobi collaborative knowledge platform (v0.6.9).
+A CLI client for the Gobi collaborative knowledge platform (v0.6.10).
 
 ## Prerequisites