jasper-recall 0.4.0 → 0.4.1

package/cli/jasper-recall.js

@@ -198,6 +198,36 @@ function setup() {
   console.log('  1. index-digests     # Index your memory files');
   console.log('  2. recall "query"    # Search your memory');
   console.log('  3. digest-sessions   # Process session logs');
+  console.log('');
+  
+  // Check for sandboxed agents
+  const sandboxedWorkspaces = findSandboxedWorkspaces();
+  if (sandboxedWorkspaces.length > 0) {
+    console.log('📦 Sandboxed agents detected:');
+    sandboxedWorkspaces.forEach(ws => console.log(`   - ${ws}`));
+    console.log('');
+    console.log('   Configure them with: npx jasper-recall sandboxed-setup');
+    console.log('   (gives them --public-only access to shared memories)');
+    console.log('');
+  }
+}
+
+function findSandboxedWorkspaces() {
+  const openclawDir = path.join(os.homedir(), '.openclaw');
+  const workspaces = [];
+  
+  try {
+    const entries = fs.readdirSync(openclawDir);
+    for (const entry of entries) {
+      if (entry.startsWith('workspace-') && entry !== 'workspace') {
+        workspaces.push(entry.replace('workspace-', ''));
+      }
+    }
+  } catch (e) {
+    // Directory doesn't exist
+  }
+  
+  return workspaces;
 }
 
 function showHelp() {
@@ -219,8 +249,8 @@ COMMANDS:
   serve           Start HTTP API server (for sandboxed agents)
   config          Show or set configuration
   update          Check for updates
-  moltbook-setup  Configure moltbook agent with --public-only restriction
-  moltbook-verify Verify moltbook agent setup
+  sandboxed-setup   Configure sandboxed agents (email, social, calendar, etc.)
+  sandboxed-verify  Verify sandboxed agent configurations
   help            Show this help message
 
 CONFIGURATION:
@@ -313,14 +343,18 @@ switch (command) {
     };
     process.exit(runDoctor(options));
     break;
+  case 'sandboxed-setup':
+  case 'sandbox-setup':
   case 'moltbook-setup':
   case 'moltbook':
-    // Set up moltbook agent integration
+    // Interactive setup for sandboxed agents
     process.argv = [process.argv[0], process.argv[1], 'setup'];
     require('../extensions/moltbook-setup/setup.js');
     break;
+  case 'sandboxed-verify':
+  case 'sandbox-verify':
   case 'moltbook-verify':
-    // Verify moltbook agent setup
+    // Verify sandboxed agent setups
     process.argv = [process.argv[0], process.argv[1], 'verify'];
     require('../extensions/moltbook-setup/setup.js');
     break;

package/extensions/moltbook-setup/setup.js

@@ -1,9 +1,15 @@
 #!/usr/bin/env node
 /**
- * Moltbook Agent Setup for jasper-recall
+ * Sandboxed Agent Setup for jasper-recall
  * 
- * Configures a sandboxed agent to use jasper-recall with --public-only restriction.
- * This ensures the agent can only access shared/public memories, not private ones.
+ * Configures sandboxed agents to use jasper-recall with --public-only restriction.
+ * This ensures agents can only access shared/public memories, not private ones.
+ * 
+ * Use cases:
+ * - Moltbook scanner (social media engagement)
+ * - Email agent (inbox management)
+ * - Calendar agent (scheduling)
+ * - Any agent that shouldn't see private memories
  */
 
 const fs = require('fs');
@@ -11,12 +17,12 @@ const path = require('path');
 const os = require('os');
 const readline = require('readline');
 
-const MOLTBOOK_WORKSPACE = path.join(os.homedir(), '.openclaw', 'workspace-moltbook');
-const MAIN_WORKSPACE = path.join(os.homedir(), '.openclaw', 'workspace');
+const OPENCLAW_DIR = path.join(os.homedir(), '.openclaw');
+const MAIN_WORKSPACE = path.join(OPENCLAW_DIR, 'workspace');
 const RECALL_BIN = path.join(os.homedir(), '.local', 'bin', 'recall');
 
 function log(msg) {
-  console.log(`🦞 ${msg}`);
+  console.log(`🔒 ${msg}`);
 }
 
 function warn(msg) {
@@ -45,43 +51,110 @@ async function prompt(question) {
   });
 }
 
-async function setup() {
+async function interactiveSetup() {
   console.log('');
-  log('Moltbook Agent — jasper-recall Integration Setup');
-  console.log('='.repeat(55));
+  log('Sandboxed Agent Setup — jasper-recall Integration');
+  console.log('='.repeat(60));
   console.log('');
-  console.log('  This configures the moltbook-scanner agent to use jasper-recall');
-  console.log('  with the --public-only restriction for privacy.');
+  console.log('  This configures a sandboxed agent to use jasper-recall with');
+  console.log('  privacy restrictions (--public-only).');
   console.log('');
-  console.log('  What it does:');
-  console.log('    1. Creates ~/bin/recall wrapper (forces --public-only)');
-  console.log('    2. Symlinks shared/ folder from main workspace');
-  console.log('    3. Verifies jasper-recall is installed');
+  console.log('  🔒 Privacy: Sandboxed agents can ONLY see [public] memories.');
+  console.log('              They cannot access your private notes or secrets.');
   console.log('');
-
-  // Check prerequisites
-  if (!fs.existsSync(MOLTBOOK_WORKSPACE)) {
-    error(`Moltbook workspace not found: ${MOLTBOOK_WORKSPACE}`);
-    console.log('  Create it first or check your OpenClaw agent config.');
-    process.exit(1);
+  
+  // List existing workspaces
+  const workspaces = findAgentWorkspaces();
+  
+  if (workspaces.length === 0) {
+    console.log('  No sandboxed agent workspaces found.');
+    console.log('');
+    console.log('  To create one, add an agent to your openclaw.json:');
+    console.log('');
+    showAgentExample();
+    return;
+  }
+  
+  console.log('  Found agent workspaces:');
+  workspaces.forEach((ws, i) => {
+    const status = checkWorkspaceStatus(ws.path);
+    const statusIcon = status.configured ? '✅' : '⚪';
+    console.log(`    ${i + 1}. ${statusIcon} ${ws.name} (${ws.path})`);
+  });
+  console.log('');
+  
+  const choice = await prompt('  Configure which agent? (number, or "skip" to exit): ');
+  
+  if (choice.toLowerCase() === 'skip' || choice === '') {
+    console.log('\n  Skipped.\n');
+    return;
+  }
+  
+  const index = parseInt(choice, 10) - 1;
+  if (isNaN(index) || index < 0 || index >= workspaces.length) {
+    error('Invalid selection');
+    return;
   }
+  
+  const selected = workspaces[index];
+  await setupWorkspace(selected.path, selected.name);
+}
 
-  if (!fs.existsSync(RECALL_BIN)) {
-    error(`jasper-recall not installed: ${RECALL_BIN}`);
-    console.log('  Install it first: npx jasper-recall setup');
-    process.exit(1);
+function findAgentWorkspaces() {
+  const workspaces = [];
+  
+  // Look for workspace-* directories
+  try {
+    const entries = fs.readdirSync(OPENCLAW_DIR);
+    for (const entry of entries) {
+      if (entry.startsWith('workspace-') && entry !== 'workspace') {
+        const wsPath = path.join(OPENCLAW_DIR, entry);
+        if (fs.statSync(wsPath).isDirectory()) {
+          workspaces.push({
+            name: entry.replace('workspace-', ''),
+            path: wsPath
+          });
+        }
+      }
+    }
+  } catch (e) {
+    // Directory doesn't exist or not readable
   }
+  
+  return workspaces;
+}
 
-  const proceed = await prompt('  Continue? (y/n): ');
-  if (proceed.toLowerCase() !== 'y' && proceed.toLowerCase() !== 'yes') {
-    console.log('\n  Setup cancelled.\n');
-    process.exit(0);
+function checkWorkspaceStatus(wsPath) {
+  const wrapperPath = path.join(wsPath, 'bin', 'recall');
+  const sharedPath = path.join(wsPath, 'shared');
+  
+  let configured = false;
+  
+  if (fs.existsSync(wrapperPath)) {
+    const content = fs.readFileSync(wrapperPath, 'utf8');
+    configured = content.includes('--public-only');
   }
+  
+  return {
+    configured,
+    hasWrapper: fs.existsSync(wrapperPath),
+    hasShared: fs.existsSync(sharedPath)
+  };
+}
 
+async function setupWorkspace(wsPath, name) {
   console.log('');
-
+  log(`Configuring ${name}...`);
+  
+  // Check prerequisites
+  if (!fs.existsSync(RECALL_BIN)) {
+    error(`jasper-recall not installed: ${RECALL_BIN}`);
+    console.log('  Run the main setup first: npx jasper-recall setup');
+    return;
+  }
+  
   // Step 1: Create bin directory and wrapper
-  const binDir = path.join(MOLTBOOK_WORKSPACE, 'bin');
+  const binDir = path.join(wsPath, 'bin');
   const wrapperPath = path.join(binDir, 'recall');
   
   fs.mkdirSync(binDir, { recursive: true });
@@ -95,11 +168,11 @@ exec ${RECALL_BIN} "$@" --public-only
 
   fs.writeFileSync(wrapperPath, wrapperScript);
   fs.chmodSync(wrapperPath, '755');
-  success(`Created recall wrapper: ${wrapperPath}`);
+  success(`Created recall wrapper: bin/recall`);
 
   // Step 2: Create shared folder symlink
   const sharedSource = path.join(MAIN_WORKSPACE, 'memory', 'shared');
-  const sharedTarget = path.join(MOLTBOOK_WORKSPACE, 'shared');
+  const sharedTarget = path.join(wsPath, 'shared');
 
   // Ensure source exists
   fs.mkdirSync(sharedSource, { recursive: true });
@@ -109,8 +182,6 @@ exec ${RECALL_BIN} "$@" --public-only
     const stat = fs.lstatSync(sharedTarget);
     if (stat.isSymbolicLink()) {
       fs.unlinkSync(sharedTarget);
-    } else if (stat.isDirectory()) {
-      warn(`${sharedTarget} is a directory, not a symlink. Skipping.`);
     }
   } catch (e) {
     // Doesn't exist, that's fine
@@ -118,58 +189,106 @@ exec ${RECALL_BIN} "$@" --public-only
 
   if (!fs.existsSync(sharedTarget)) {
     fs.symlinkSync(sharedSource, sharedTarget);
-    success(`Created symlink: shared/ → ${sharedSource}`);
+    success(`Created symlink: shared/ → main workspace`);
+  }
+
+  // Step 3: Check if AGENTS.md exists and suggest update
+  const agentsMd = path.join(wsPath, 'AGENTS.md');
+  if (fs.existsSync(agentsMd)) {
+    const content = fs.readFileSync(agentsMd, 'utf8');
+    if (!content.includes('public-only') && !content.includes('--public-only')) {
+      warn('Consider adding recall restrictions to AGENTS.md');
+      console.log('');
+      console.log('  Suggested addition:');
+      console.log('  ```');
+      console.log('  ## Memory Access');
+      console.log('  Use `~/bin/recall "query"` for memory search.');
+      console.log('  This wrapper enforces --public-only (you cannot see private memories).');
+      console.log('  ```');
+    }
   }
 
-  // Step 3: Verify setup
   console.log('');
-  log('Verifying setup...');
-  
-  const issues = verify({ quiet: true });
+  success(`${name} configured!`);
+  console.log('');
+  console.log('  The agent can now use:');
+  console.log(`    ~/bin/recall "query"  — searches public memories only`);
+  console.log(`    shared/               — symlink to shared memory folder`);
+  console.log('');
+}
+
+function showAgentExample() {
+  console.log(`  Example openclaw.json agent config:
   
-  if (issues.length === 0) {
-    console.log('');
-    console.log('='.repeat(55));
-    success('Setup complete!');
-    console.log('');
-    console.log('  The moltbook-scanner agent can now use:');
-    console.log('    ~/bin/recall "query"  — searches public memories only');
-    console.log('    shared/               — symlink to main agent\'s shared memory');
-    console.log('');
-    console.log('  Test it:');
-    console.log(`    ${wrapperPath} "test query"`);
-    console.log('');
-  } else {
-    console.log('');
-    warn('Setup completed with issues:');
-    issues.forEach(issue => console.log(`  - ${issue}`));
+  {
+    "agents": {
+      "list": [
+        {
+          "id": "email-agent",
+          "workspace": "~/.openclaw/workspace-email",
+          "model": { "primary": "anthropic/claude-sonnet-4-5" },
+          "sandbox": {
+            "mode": "all",
+            "workspaceAccess": "rw"
+          },
+          "tools": {
+            "profile": "minimal",
+            "allow": ["read", "write", "exec", "web_fetch"]
+          }
+        }
+      ]
+    }
   }
+
+  Common sandboxed agent use cases:
+  
+  📧 Email Agent
+     - Checks inbox, drafts replies, summarizes threads
+     - Sandbox: Only email API access, no filesystem
+     - Memory: Sees [public] context about projects
+  
+  📱 Social Agent (Moltbook, Twitter, etc.)
+     - Monitors feeds, engages with posts
+     - Sandbox: Only that platform's API
+     - Memory: Sees [public] product info for authentic engagement
+  
+  📅 Calendar Agent
+     - Manages scheduling, sends reminders
+     - Sandbox: Only calendar API
+     - Memory: Sees [public] project timelines
+  
+  🔍 Research Agent
+     - Web searches, summarizes articles
+     - Sandbox: Read-only web access
+     - Memory: Sees [public] research context
+  
+  After creating the workspace, run:
+    npx jasper-recall sandboxed-setup
+`);
 }
 
-function verify(options = {}) {
+function verify(wsPath, options = {}) {
   const { quiet = false } = options;
   const issues = [];
 
   if (!quiet) {
     console.log('');
-    log('Moltbook Agent — jasper-recall Verification');
-    console.log('='.repeat(55));
+    log('Verifying sandboxed agent setup...');
     console.log('');
   }
 
   // Check 1: Workspace exists
-  if (!fs.existsSync(MOLTBOOK_WORKSPACE)) {
-    issues.push(`Workspace missing: ${MOLTBOOK_WORKSPACE}`);
+  if (!fs.existsSync(wsPath)) {
+    issues.push(`Workspace missing: ${wsPath}`);
   } else if (!quiet) {
-    success(`Workspace exists: ${MOLTBOOK_WORKSPACE}`);
+    success(`Workspace exists`);
   }
 
-  // Check 2: Recall wrapper exists and is executable
-  const wrapperPath = path.join(MOLTBOOK_WORKSPACE, 'bin', 'recall');
+  // Check 2: Recall wrapper exists and is correct
+  const wrapperPath = path.join(wsPath, 'bin', 'recall');
   if (!fs.existsSync(wrapperPath)) {
-    issues.push(`Recall wrapper missing: ${wrapperPath}`);
+    issues.push(`Recall wrapper missing: bin/recall`);
   } else {
-    // Check it has --public-only
     const content = fs.readFileSync(wrapperPath, 'utf8');
     if (!content.includes('--public-only')) {
       issues.push('Recall wrapper missing --public-only flag!');
@@ -179,16 +298,14 @@ function verify(options = {}) {
   }
 
   // Check 3: Shared folder is a symlink
-  const sharedPath = path.join(MOLTBOOK_WORKSPACE, 'shared');
+  const sharedPath = path.join(wsPath, 'shared');
   try {
     const stat = fs.lstatSync(sharedPath);
     if (!stat.isSymbolicLink()) {
-      issues.push(`shared/ is not a symlink (should link to main workspace)`);
-    } else {
+      issues.push(`shared/ is not a symlink`);
+    } else if (!quiet) {
       const target = fs.readlinkSync(sharedPath);
-      if (!quiet) {
-        success(`shared/ symlink → ${target}`);
-      }
+      success(`shared/ → ${target}`);
     }
   } catch (e) {
     issues.push(`shared/ folder missing`);
@@ -196,33 +313,20 @@ function verify(options = {}) {
 
   // Check 4: jasper-recall is installed
   if (!fs.existsSync(RECALL_BIN)) {
-    issues.push(`jasper-recall not installed: ${RECALL_BIN}`);
+    issues.push(`jasper-recall not installed`);
   } else if (!quiet) {
-    success(`jasper-recall installed: ${RECALL_BIN}`);
-  }
-
-  // Check 5: AGENTS.md mentions recall restrictions
-  const agentsMd = path.join(MOLTBOOK_WORKSPACE, 'AGENTS.md');
-  if (fs.existsSync(agentsMd)) {
-    const content = fs.readFileSync(agentsMd, 'utf8');
-    if (!content.includes('public-only') && !content.includes('public_only')) {
-      issues.push('AGENTS.md should document --public-only restriction');
-    } else if (!quiet) {
-      success('AGENTS.md documents recall restrictions');
-    }
+    success(`jasper-recall installed`);
   }
 
   if (!quiet) {
     console.log('');
     if (issues.length === 0) {
-      console.log('='.repeat(55));
-      success('All checks passed! Moltbook agent is properly configured.');
+      success('All checks passed!');
     } else {
-      console.log('='.repeat(55));
       warn(`Found ${issues.length} issue(s):`);
       issues.forEach(issue => console.log(`  ❌ ${issue}`));
       console.log('');
-      console.log('  Run setup to fix: npx jasper-recall moltbook-setup');
+      console.log('  Run setup to fix: npx jasper-recall sandboxed-setup');
     }
     console.log('');
   }
@@ -230,27 +334,71 @@ function verify(options = {}) {
   return issues;
 }
 
+async function verifyInteractive() {
+  const workspaces = findAgentWorkspaces();
+  
+  if (workspaces.length === 0) {
+    console.log('');
+    warn('No sandboxed agent workspaces found.');
+    console.log('');
+    return;
+  }
+  
+  console.log('');
+  log('Sandboxed Agent Verification');
+  console.log('='.repeat(60));
+  
+  for (const ws of workspaces) {
+    console.log('');
+    console.log(`  📁 ${ws.name}`);
+    const issues = verify(ws.path, { quiet: true });
+    if (issues.length === 0) {
+      console.log(`     ✅ Properly configured`);
+    } else {
+      console.log(`     ⚠️  ${issues.length} issue(s):`);
+      issues.forEach(issue => console.log(`        - ${issue}`));
+    }
+  }
+  
+  console.log('');
+}
+
 function showHelp() {
   console.log(`
-Moltbook Agent — jasper-recall Integration
+Sandboxed Agent Setup — jasper-recall Integration
 
 USAGE:
-  npx jasper-recall moltbook-setup    Configure moltbook agent
-  npx jasper-recall moltbook-verify   Verify configuration
+  npx jasper-recall sandboxed-setup    Interactive setup for any sandboxed agent
+  npx jasper-recall sandboxed-verify   Check all sandboxed agents
+  npx jasper-recall moltbook-setup     (alias) Setup for moltbook specifically
+  npx jasper-recall moltbook-verify    (alias) Verify moltbook specifically
 
 WHAT IT DOES:
-  Sets up the moltbook-scanner agent to use jasper-recall with privacy
-  restrictions. The agent can only access shared/public memories, not
-  private ones from the main workspace.
+  Configures sandboxed agents to use jasper-recall with privacy restrictions.
+  Agents can only access [public] tagged memories, not private ones.
 
-COMPONENTS:
-  ~/bin/recall     Wrapper script that forces --public-only flag
-  shared/          Symlink to main workspace's shared memory folder
+COMPONENTS CREATED:
+  bin/recall     Wrapper script that forces --public-only flag
+  shared/        Symlink to main workspace's shared memory folder
+
+USE CASES:
+  📧 Email Agent      — inbox management, drafts, summaries
+  📱 Social Agent     — moltbook, twitter engagement
+  📅 Calendar Agent   — scheduling, reminders
+  🔍 Research Agent   — web searches, article summaries
 
 PRIVACY MODEL:
-  Main agent tags memories as [public] or [private] in daily notes.
-  sync-shared.py extracts [public] content to memory/shared/.
-  Sandboxed agents can ONLY search the shared collection.
+  1. Main agent tags memories as [public] or [private] in daily notes
+  2. sync-shared extracts [public] content to memory/shared/
+  3. Sandboxed agents can ONLY search the shared collection
+
+EXAMPLE:
+  # Main agent daily note
+  ## 2026-02-11 [public] - Shipped jasper-recall v0.4.0
+  New sandboxed agent setup feature.
+
+  ## 2026-02-11 [private] - Personal context
+  This stays private, sandboxed agents can't see it.
 `);
 }
 
@@ -260,14 +408,17 @@ const command = process.argv[2];
 switch (command) {
   case 'setup':
   case 'install':
-    setup().catch(err => {
+    interactiveSetup().catch(err => {
       error(err.message);
       process.exit(1);
     });
     break;
   case 'verify':
   case 'check':
-    verify();
+    verifyInteractive().catch(err => {
+      error(err.message);
+      process.exit(1);
+    });
     break;
   case 'help':
   case '--help':

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jasper-recall",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "Local RAG system for AI agent memory using ChromaDB and sentence-transformers",
   "main": "src/index.js",
   "bin": {