@deeplake/hivemind 0.7.54 → 0.7.61

package/cursor/bundle/session-start.js

@@ -811,6 +811,23 @@ var DeeplakeApi = class {
       this._tablesCache = [...tables];
     return tables;
   }
+  /**
+   * Like listTables() but returns null when the list could NOT be trusted
+   * (the fetch failed / was non-cacheable). Callers gating a read on table
+   * existence use this to tell a genuinely-empty workspace ([]) apart from a
+   * failed lookup (null): on [] they can safely skip the read (no table → no
+   * 42P01), on null they must fall back to SELECT-then-catch so a transient
+   * lookup blip doesn't drop a read of a table that really exists.
+   */
+  async knownTablesOrNull() {
+    if (this._tablesCache)
+      return [...this._tablesCache];
+    const { tables, cacheable } = await this._fetchTables();
+    if (!cacheable)
+      return null;
+    this._tablesCache = [...tables];
+    return [...tables];
+  }
   async _fetchTables() {
     for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
       try {
@@ -1056,24 +1073,33 @@ async function renderContextBlock(query, input, opts = {}) {
   const log7 = opts.log ?? (() => {
   });
   try {
+    const tableExists = opts.tableExists;
     let rules = [];
-    try {
-      rules = await listRules(query, input.rulesTable, {
-        status: "active",
-        limit: Math.max(maxRules * 4, maxRules + 1)
-      });
-    } catch (rulesErr) {
-      const rmsg = rulesErr instanceof Error ? rulesErr.message : String(rulesErr);
-      log7(`render-context-block: rules unavailable (continuing): ${rmsg}`);
+    if (tableExists && !tableExists(input.rulesTable)) {
+      log7(`render-context-block: rules table "${input.rulesTable}" not present \u2014 skipping read`);
+    } else {
+      try {
+        rules = await listRules(query, input.rulesTable, {
+          status: "active",
+          limit: Math.max(maxRules * 4, maxRules + 1)
+        });
+      } catch (rulesErr) {
+        const rmsg = rulesErr instanceof Error ? rulesErr.message : String(rulesErr);
+        log7(`render-context-block: rules unavailable (continuing): ${rmsg}`);
+      }
     }
     let goals = [];
-    try {
-      goals = await listOpenGoals(query, input.goalsTable, input.currentUser, {
-        limit: Math.max(maxGoals * 4, maxGoals + 1)
-      });
-    } catch (goalsErr) {
-      const gmsg = goalsErr instanceof Error ? goalsErr.message : String(goalsErr);
-      log7(`render-context-block: goals unavailable (continuing): ${gmsg}`);
+    if (tableExists && !tableExists(input.goalsTable)) {
+      log7(`render-context-block: goals table "${input.goalsTable}" not present \u2014 skipping read`);
+    } else {
+      try {
+        goals = await listOpenGoals(query, input.goalsTable, input.currentUser, {
+          limit: Math.max(maxGoals * 4, maxGoals + 1)
+        });
+      } catch (goalsErr) {
+        const gmsg = goalsErr instanceof Error ? goalsErr.message : String(goalsErr);
+        log7(`render-context-block: goals unavailable (continuing): ${gmsg}`);
+      }
     }
     const rulesShown = rules.slice(0, maxRules);
     const rulesHidden = Math.max(0, rules.length - maxRules);
@@ -1912,21 +1938,25 @@ async function runPull(opts) {
     skillName: opts.skillName
   });
   let rows = [];
-  try {
-    rows = await opts.query(sql);
-  } catch (e) {
-    if (isMissingTableError(e?.message)) {
-      rows = [];
-    } else if (isMissingContributorsColumnError(e?.message)) {
-      const legacySql = buildPullSql({
-        tableName: opts.tableName,
-        users: opts.users,
-        skillName: opts.skillName,
-        includeContributors: false
-      });
-      rows = await opts.query(legacySql);
-    } else {
-      throw e;
+  if (opts.tableExists && !opts.tableExists(opts.tableName)) {
+    rows = [];
+  } else {
+    try {
+      rows = await opts.query(sql);
+    } catch (e) {
+      if (isMissingTableError(e?.message)) {
+        rows = [];
+      } else if (isMissingContributorsColumnError(e?.message)) {
+        const legacySql = buildPullSql({
+          tableName: opts.tableName,
+          users: opts.users,
+          skillName: opts.skillName,
+          includeContributors: false
+        });
+        rows = await opts.query(legacySql);
+      } else {
+        throw e;
+      }
     }
   }
   const latest = selectLatestPerName(rows);
@@ -2069,24 +2099,38 @@ async function autoPullSkills(deps = {}) {
     return { pulled: 0, skipped: true, reason: "not-logged-in" };
   }
   let query;
+  let discoverTableExists = async () => void 0;
   if (deps.queryFn) {
     query = deps.queryFn;
   } else {
     const api = new DeeplakeApi(config.token, config.apiUrl, config.orgId, config.workspaceId, config.skillsTableName);
     query = (sql) => api.query(sql);
+    discoverTableExists = async () => {
+      const known = await api.knownTablesOrNull();
+      return known ? (name) => known.includes(name) : void 0;
+    };
   }
   const install = deps.install ?? "global";
   const timeoutMs = deps.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   try {
-    const summary = await withTimeout(runPull({
-      query,
-      tableName: config.skillsTableName,
-      install,
-      cwd: install === "project" ? deps.cwd ?? process.cwd() : void 0,
-      users: [],
-      dryRun: false,
-      force: false
-    }), timeoutMs);
+    const summary = await withTimeout(
+      // Table discovery + pull share one budget: if `GET /tables` hangs the
+      // whole thing times out and we degrade, instead of blocking startup.
+      (async () => {
+        const tableExists = await discoverTableExists();
+        return runPull({
+          query,
+          tableName: config.skillsTableName,
+          install,
+          cwd: install === "project" ? deps.cwd ?? process.cwd() : void 0,
+          users: [],
+          dryRun: false,
+          force: false,
+          tableExists
+        });
+      })(),
+      timeoutMs
+    );
     log5(`pulled scanned=${summary.scanned} wrote=${summary.wrote} skipped=${summary.skipped}`);
     return { pulled: summary.wrote, skipped: false };
   } catch (e) {
@@ -2244,11 +2288,13 @@ async function main() {
         } else {
           log6("placeholder + schema ensure skipped (HIVEMIND_CAPTURE=false)");
         }
+        const known = await api.knownTablesOrNull();
+        const tableExists = known ? (name) => known.includes(name) : void 0;
         rulesBlock = await renderContextBlock((sql) => api.query(sql), {
           rulesTable: config.rulesTableName,
           goalsTable: config.goalsTableName,
           currentUser: config.userName
-        }, { log: log6 });
+        }, { log: log6, tableExists });
       }
     } catch (e) {
       log6(`placeholder failed: ${e.message}`);

package/cursor/bundle/shell/deeplake-shell.js

@@ -67450,6 +67450,23 @@ var DeeplakeApi = class {
       this._tablesCache = [...tables];
     return tables;
   }
+  /**
+   * Like listTables() but returns null when the list could NOT be trusted
+   * (the fetch failed / was non-cacheable). Callers gating a read on table
+   * existence use this to tell a genuinely-empty workspace ([]) apart from a
+   * failed lookup (null): on [] they can safely skip the read (no table → no
+   * 42P01), on null they must fall back to SELECT-then-catch so a transient
+   * lookup blip doesn't drop a read of a table that really exists.
+   */
+  async knownTablesOrNull() {
+    if (this._tablesCache)
+      return [...this._tablesCache];
+    const { tables, cacheable } = await this._fetchTables();
+    if (!cacheable)
+      return null;
+    this._tablesCache = [...tables];
+    return [...tables];
+  }
   async _fetchTables() {
     for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
       try {

package/hermes/bundle/capture.js

@@ -755,6 +755,23 @@ var DeeplakeApi = class {
       this._tablesCache = [...tables];
     return tables;
   }
+  /**
+   * Like listTables() but returns null when the list could NOT be trusted
+   * (the fetch failed / was non-cacheable). Callers gating a read on table
+   * existence use this to tell a genuinely-empty workspace ([]) apart from a
+   * failed lookup (null): on [] they can safely skip the read (no table → no
+   * 42P01), on null they must fall back to SELECT-then-catch so a transient
+   * lookup blip doesn't drop a read of a table that really exists.
+   */
+  async knownTablesOrNull() {
+    if (this._tablesCache)
+      return [...this._tablesCache];
+    const { tables, cacheable } = await this._fetchTables();
+    if (!cacheable)
+      return null;
+    this._tablesCache = [...tables];
+    return [...tables];
+  }
   async _fetchTables() {
     for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
       try {

package/hermes/bundle/commands/auth-login.js

@@ -1019,6 +1019,23 @@ var DeeplakeApi = class {
       this._tablesCache = [...tables];
     return tables;
   }
+  /**
+   * Like listTables() but returns null when the list could NOT be trusted
+   * (the fetch failed / was non-cacheable). Callers gating a read on table
+   * existence use this to tell a genuinely-empty workspace ([]) apart from a
+   * failed lookup (null): on [] they can safely skip the read (no table → no
+   * 42P01), on null they must fall back to SELECT-then-catch so a transient
+   * lookup blip doesn't drop a read of a table that really exists.
+   */
+  async knownTablesOrNull() {
+    if (this._tablesCache)
+      return [...this._tablesCache];
+    const { tables, cacheable } = await this._fetchTables();
+    if (!cacheable)
+      return null;
+    this._tablesCache = [...tables];
+    return [...tables];
+  }
   async _fetchTables() {
     for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
       try {

package/hermes/bundle/graph-pull-worker.js

@@ -746,6 +746,23 @@ var DeeplakeApi = class {
       this._tablesCache = [...tables];
     return tables;
   }
+  /**
+   * Like listTables() but returns null when the list could NOT be trusted
+   * (the fetch failed / was non-cacheable). Callers gating a read on table
+   * existence use this to tell a genuinely-empty workspace ([]) apart from a
+   * failed lookup (null): on [] they can safely skip the read (no table → no
+   * 42P01), on null they must fall back to SELECT-then-catch so a transient
+   * lookup blip doesn't drop a read of a table that really exists.
+   */
+  async knownTablesOrNull() {
+    if (this._tablesCache)
+      return [...this._tablesCache];
+    const { tables, cacheable } = await this._fetchTables();
+    if (!cacheable)
+      return null;
+    this._tablesCache = [...tables];
+    return [...tables];
+  }
   async _fetchTables() {
     for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
       try {

package/hermes/bundle/pre-tool-use.js

@@ -755,6 +755,23 @@ var DeeplakeApi = class {
       this._tablesCache = [...tables];
     return tables;
   }
+  /**
+   * Like listTables() but returns null when the list could NOT be trusted
+   * (the fetch failed / was non-cacheable). Callers gating a read on table
+   * existence use this to tell a genuinely-empty workspace ([]) apart from a
+   * failed lookup (null): on [] they can safely skip the read (no table → no
+   * 42P01), on null they must fall back to SELECT-then-catch so a transient
+   * lookup blip doesn't drop a read of a table that really exists.
+   */
+  async knownTablesOrNull() {
+    if (this._tablesCache)
+      return [...this._tablesCache];
+    const { tables, cacheable } = await this._fetchTables();
+    if (!cacheable)
+      return null;
+    this._tablesCache = [...tables];
+    return [...tables];
+  }
   async _fetchTables() {
     for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
       try {

package/hermes/bundle/session-start.js

@@ -810,6 +810,23 @@ var DeeplakeApi = class {
       this._tablesCache = [...tables];
     return tables;
   }
+  /**
+   * Like listTables() but returns null when the list could NOT be trusted
+   * (the fetch failed / was non-cacheable). Callers gating a read on table
+   * existence use this to tell a genuinely-empty workspace ([]) apart from a
+   * failed lookup (null): on [] they can safely skip the read (no table → no
+   * 42P01), on null they must fall back to SELECT-then-catch so a transient
+   * lookup blip doesn't drop a read of a table that really exists.
+   */
+  async knownTablesOrNull() {
+    if (this._tablesCache)
+      return [...this._tablesCache];
+    const { tables, cacheable } = await this._fetchTables();
+    if (!cacheable)
+      return null;
+    this._tablesCache = [...tables];
+    return [...tables];
+  }
   async _fetchTables() {
     for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
       try {
@@ -1055,24 +1072,33 @@ async function renderContextBlock(query, input, opts = {}) {
   const log7 = opts.log ?? (() => {
   });
   try {
+    const tableExists = opts.tableExists;
     let rules = [];
-    try {
-      rules = await listRules(query, input.rulesTable, {
-        status: "active",
-        limit: Math.max(maxRules * 4, maxRules + 1)
-      });
-    } catch (rulesErr) {
-      const rmsg = rulesErr instanceof Error ? rulesErr.message : String(rulesErr);
-      log7(`render-context-block: rules unavailable (continuing): ${rmsg}`);
+    if (tableExists && !tableExists(input.rulesTable)) {
+      log7(`render-context-block: rules table "${input.rulesTable}" not present \u2014 skipping read`);
+    } else {
+      try {
+        rules = await listRules(query, input.rulesTable, {
+          status: "active",
+          limit: Math.max(maxRules * 4, maxRules + 1)
+        });
+      } catch (rulesErr) {
+        const rmsg = rulesErr instanceof Error ? rulesErr.message : String(rulesErr);
+        log7(`render-context-block: rules unavailable (continuing): ${rmsg}`);
+      }
     }
     let goals = [];
-    try {
-      goals = await listOpenGoals(query, input.goalsTable, input.currentUser, {
-        limit: Math.max(maxGoals * 4, maxGoals + 1)
-      });
-    } catch (goalsErr) {
-      const gmsg = goalsErr instanceof Error ? goalsErr.message : String(goalsErr);
-      log7(`render-context-block: goals unavailable (continuing): ${gmsg}`);
+    if (tableExists && !tableExists(input.goalsTable)) {
+      log7(`render-context-block: goals table "${input.goalsTable}" not present \u2014 skipping read`);
+    } else {
+      try {
+        goals = await listOpenGoals(query, input.goalsTable, input.currentUser, {
+          limit: Math.max(maxGoals * 4, maxGoals + 1)
+        });
+      } catch (goalsErr) {
+        const gmsg = goalsErr instanceof Error ? goalsErr.message : String(goalsErr);
+        log7(`render-context-block: goals unavailable (continuing): ${gmsg}`);
+      }
     }
     const rulesShown = rules.slice(0, maxRules);
     const rulesHidden = Math.max(0, rules.length - maxRules);
@@ -1911,21 +1937,25 @@ async function runPull(opts) {
     skillName: opts.skillName
   });
   let rows = [];
-  try {
-    rows = await opts.query(sql);
-  } catch (e) {
-    if (isMissingTableError(e?.message)) {
-      rows = [];
-    } else if (isMissingContributorsColumnError(e?.message)) {
-      const legacySql = buildPullSql({
-        tableName: opts.tableName,
-        users: opts.users,
-        skillName: opts.skillName,
-        includeContributors: false
-      });
-      rows = await opts.query(legacySql);
-    } else {
-      throw e;
+  if (opts.tableExists && !opts.tableExists(opts.tableName)) {
+    rows = [];
+  } else {
+    try {
+      rows = await opts.query(sql);
+    } catch (e) {
+      if (isMissingTableError(e?.message)) {
+        rows = [];
+      } else if (isMissingContributorsColumnError(e?.message)) {
+        const legacySql = buildPullSql({
+          tableName: opts.tableName,
+          users: opts.users,
+          skillName: opts.skillName,
+          includeContributors: false
+        });
+        rows = await opts.query(legacySql);
+      } else {
+        throw e;
+      }
     }
   }
   const latest = selectLatestPerName(rows);
@@ -2068,24 +2098,38 @@ async function autoPullSkills(deps = {}) {
     return { pulled: 0, skipped: true, reason: "not-logged-in" };
   }
   let query;
+  let discoverTableExists = async () => void 0;
   if (deps.queryFn) {
     query = deps.queryFn;
   } else {
     const api = new DeeplakeApi(config.token, config.apiUrl, config.orgId, config.workspaceId, config.skillsTableName);
     query = (sql) => api.query(sql);
+    discoverTableExists = async () => {
+      const known = await api.knownTablesOrNull();
+      return known ? (name) => known.includes(name) : void 0;
+    };
   }
   const install = deps.install ?? "global";
   const timeoutMs = deps.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   try {
-    const summary = await withTimeout(runPull({
-      query,
-      tableName: config.skillsTableName,
-      install,
-      cwd: install === "project" ? deps.cwd ?? process.cwd() : void 0,
-      users: [],
-      dryRun: false,
-      force: false
-    }), timeoutMs);
+    const summary = await withTimeout(
+      // Table discovery + pull share one budget: if `GET /tables` hangs the
+      // whole thing times out and we degrade, instead of blocking startup.
+      (async () => {
+        const tableExists = await discoverTableExists();
+        return runPull({
+          query,
+          tableName: config.skillsTableName,
+          install,
+          cwd: install === "project" ? deps.cwd ?? process.cwd() : void 0,
+          users: [],
+          dryRun: false,
+          force: false,
+          tableExists
+        });
+      })(),
+      timeoutMs
+    );
     log5(`pulled scanned=${summary.scanned} wrote=${summary.wrote} skipped=${summary.skipped}`);
     return { pulled: summary.wrote, skipped: false };
   } catch (e) {
@@ -2229,11 +2273,13 @@ async function main() {
         } else {
           log6("placeholder + schema ensure skipped (HIVEMIND_CAPTURE=false)");
         }
+        const known = await api.knownTablesOrNull();
+        const tableExists = known ? (name) => known.includes(name) : void 0;
         rulesBlock = await renderContextBlock((sql) => api.query(sql), {
           rulesTable: config.rulesTableName,
           goalsTable: config.goalsTableName,
           currentUser: config.userName
-        }, { log: log6 });
+        }, { log: log6, tableExists });
       }
     } catch (e) {
       log6(`placeholder failed: ${e.message}`);

package/hermes/bundle/shell/deeplake-shell.js

@@ -67450,6 +67450,23 @@ var DeeplakeApi = class {
       this._tablesCache = [...tables];
     return tables;
   }
+  /**
+   * Like listTables() but returns null when the list could NOT be trusted
+   * (the fetch failed / was non-cacheable). Callers gating a read on table
+   * existence use this to tell a genuinely-empty workspace ([]) apart from a
+   * failed lookup (null): on [] they can safely skip the read (no table → no
+   * 42P01), on null they must fall back to SELECT-then-catch so a transient
+   * lookup blip doesn't drop a read of a table that really exists.
+   */
+  async knownTablesOrNull() {
+    if (this._tablesCache)
+      return [...this._tablesCache];
+    const { tables, cacheable } = await this._fetchTables();
+    if (!cacheable)
+      return null;
+    this._tablesCache = [...tables];
+    return [...tables];
+  }
   async _fetchTables() {
     for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
       try {

package/mcp/bundle/server.js

@@ -23961,6 +23961,23 @@ var DeeplakeApi = class {
       this._tablesCache = [...tables];
     return tables;
   }
+  /**
+   * Like listTables() but returns null when the list could NOT be trusted
+   * (the fetch failed / was non-cacheable). Callers gating a read on table
+   * existence use this to tell a genuinely-empty workspace ([]) apart from a
+   * failed lookup (null): on [] they can safely skip the read (no table → no
+   * 42P01), on null they must fall back to SELECT-then-catch so a transient
+   * lookup blip doesn't drop a read of a table that really exists.
+   */
+  async knownTablesOrNull() {
+    if (this._tablesCache)
+      return [...this._tablesCache];
+    const { tables, cacheable } = await this._fetchTables();
+    if (!cacheable)
+      return null;
+    this._tablesCache = [...tables];
+    return [...tables];
+  }
   async _fetchTables() {
     for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
       try {

package/openclaw/dist/index.js

@@ -772,6 +772,21 @@ var DeeplakeApi = class {
     if (cacheable) this._tablesCache = [...tables];
     return tables;
   }
+  /**
+   * Like listTables() but returns null when the list could NOT be trusted
+   * (the fetch failed / was non-cacheable). Callers gating a read on table
+   * existence use this to tell a genuinely-empty workspace ([]) apart from a
+   * failed lookup (null): on [] they can safely skip the read (no table → no
+   * 42P01), on null they must fall back to SELECT-then-catch so a transient
+   * lookup blip doesn't drop a read of a table that really exists.
+   */
+  async knownTablesOrNull() {
+    if (this._tablesCache) return [...this._tablesCache];
+    const { tables, cacheable } = await this._fetchTables();
+    if (!cacheable) return null;
+    this._tablesCache = [...tables];
+    return [...tables];
+  }
   async _fetchTables() {
     for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
       try {
@@ -1780,7 +1795,7 @@ function extractLatestVersion(body) {
   return typeof v === "string" && v.length > 0 ? v : null;
 }
 function getInstalledVersion() {
-  return "0.7.54".length > 0 ? "0.7.54" : null;
+  return "0.7.61".length > 0 ? "0.7.61" : null;
 }
 function isNewer(latest, current) {
   const parse = (v) => v.replace(/-.*$/, "").split(".").map(Number);

package/openclaw/openclaw.plugin.json

@@ -54,5 +54,5 @@
       }
     }
   },
-  "version": "0.7.54"
+  "version": "0.7.61"
 }

package/openclaw/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hivemind",
-  "version": "0.7.54",
+  "version": "0.7.61",
   "type": "module",
   "description": "Hivemind — cloud-backed persistent shared memory for AI agents, powered by DeepLake",
   "license": "Apache-2.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deeplake/hivemind",
-  "version": "0.7.54",
+  "version": "0.7.61",
   "description": "Cloud-backed persistent shared memory for AI agents powered by Deeplake",
   "type": "module",
   "repository": {
@@ -26,6 +26,7 @@
     "openclaw/openclaw.plugin.json",
     "openclaw/package.json",
     ".claude-plugin",
+    "scripts",
     "README.md",
     "LICENSE"
   ],
@@ -41,7 +42,9 @@
     "dup": "jscpd src",
     "audit:openclaw": "node scripts/audit-openclaw-bundle.mjs",
     "pack:check": "node scripts/pack-check.mjs",
+    "rebuild:native": "node scripts/ensure-tree-sitter.mjs",
     "ci": "npm run typecheck && npm run dup && npm test",
+    "postinstall": "node scripts/ensure-tree-sitter.mjs",
     "prepare": "husky && npm run build",
     "prepack": "npm run build"
   },
@@ -58,11 +61,13 @@
     "deeplake": "^0.3.30",
     "js-yaml": "^4.1.1",
     "just-bash": "^2.14.0",
-    "tree-sitter": "^0.21.1",
-    "tree-sitter-typescript": "^0.23.2",
     "yargs-parser": "^22.0.0",
     "zod": "^4.3.6"
   },
+  "optionalDependencies": {
+    "tree-sitter": "^0.21.1",
+    "tree-sitter-typescript": "^0.23.2"
+  },
   "devDependencies": {
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^25.0.0",