DenchClaw App Store API: Persistent State for Your Apps

// Store a value
await dench.store.set("selected_pipeline", "Q1 2026");
 
// Retrieve a value
const pipeline = await dench.store.get("selected_pipeline");
// Returns: "Q1 2026" or null if not set
 
// Check if a key exists
const exists = await dench.store.has("selected_pipeline");
 
// Delete a value
await dench.store.delete("selected_pipeline");
 
// List all keys in the app's store
const keys = await dench.store.keys();
// Returns: ["selected_pipeline", "chart_type", ...]
 
// Clear all values for this app
await dench.store.clear();

// Store an object
await dench.store.set("filter_config", {
  stage: "Proposal",
  owner: "Sarah",
  minValue: 10000,
  dateRange: "this_quarter"
});
 
// Retrieve it
const config = await dench.store.get("filter_config");
// Returns the original object (automatically parsed)
console.log(config.stage);  // "Proposal"
 
// Store an array
await dench.store.set("recent_searches", [
  "enterprise leads",
  "SF contacts",
  "open deals Q2"
]);

// Store a secret (encrypted at rest)
await dench.store.set("apollo_api_key", "api_abc123...", { secret: true });
 
// Retrieve a secret (same API as normal values)
const apiKey = await dench.store.get("apollo_api_key");
 
// Secrets work the same way but are encrypted in the store file
// They're not visible in plaintext if someone opens the store file directly

// Load saved preferences on app startup
async function loadPreferences() {
  const prefs = await dench.store.get("user_preferences") || {
    chartType: "bar",
    sortField: "Close Date",
    showArchived: false
  };
 
  applyPreferences(prefs);
}
 
// Save when user changes settings
function savePreferences() {
  const prefs = {
    chartType: currentChartType,
    sortField: currentSortField,
    showArchived: showArchivedToggle.checked
  };
 
  dench.store.set("user_preferences", prefs);
}

const CACHE_TTL = 3600000;  // 1 hour in milliseconds
 
async function getCompanyEnrichment(domain) {
  const cacheKey = `clearbit:${domain}`;
  const cached = await dench.store.get(cacheKey);
 
  if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
    return cached.data;
  }
 
  // Fetch fresh data
  const apiKey = await dench.store.get("clearbit_api_key");
  const response = await dench.http.fetch(
    `https://company.clearbit.com/v2/companies/find?domain=${domain}`,
    { headers: { Authorization: `Bearer ${apiKey}` } }
  );
  const data = await response.json();
 
  // Cache with timestamp
  await dench.store.set(cacheKey, {
    data,
    timestamp: Date.now()
  });
 
  return data;
}

// Save open tabs state
window.addEventListener("beforeunload", async () => {
  await dench.store.set("open_tabs", {
    activeTab: currentTab,
    openPanels: openPanelIds,
    scrollPosition: window.scrollY
  });
});
 
// Restore on load
window.addEventListener("load", async () => {
  const state = await dench.store.get("open_tabs");
  if (state) {
    restoreTabs(state.activeTab, state.openPanels);
    window.scrollTo(0, state.scrollPosition);
  }
});

// Track progress in a multi-step import wizard
class ImportWizard {
  async saveProgress(step, data) {
    await dench.store.set("import_wizard_state", {
      currentStep: step,
      data,
      startedAt: new Date().toISOString()
    });
  }
 
  async loadProgress() {
    return await dench.store.get("import_wizard_state");
  }
 
  async clearProgress() {
    await dench.store.delete("import_wizard_state");
  }
}

// See all keys and their values (for debugging)
const allKeys = await dench.store.keys();
for (const key of allKeys) {
  const value = await dench.store.get(key);
  console.log(key, typeof value, JSON.stringify(value).slice(0, 100));
}
 
// Export all store data
const exported = {};
for (const key of await dench.store.keys()) {
  exported[key] = await dench.store.get(key);
}
console.log(JSON.stringify(exported, null, 2));