screenpipe-mcp 0.20.0 → 0.20.3

package/manifest.json

@@ -1,10 +1,10 @@
 {
   "manifest_version": "0.3",
   "name": "screenpipe",
-  "display_name": "Screenpipe",
+  "display_name": "Screenpipe Local",
   "version": "0.0.0-injected-from-package-json",
   "description": "Search your screen recordings and audio transcriptions with AI",
-  "long_description": "Screenpipe is a 24/7 screen and audio recorder that lets you search everything you've seen or heard. This extension connects Claude to your local screenpipe instance, enabling AI-powered search through your digital memory.",
+  "long_description": "Connect Claude Desktop to Screenpipe running on this computer. Search recordings and audio, retrieve meeting notes, and use the tools exposed by your local Screenpipe server. Requested results are shared with Claude. This local extension does not require Data Sync.",
   "author": {
     "name": "screenpipe",
     "url": "https://screenpi.pe"
@@ -22,7 +22,14 @@
     "entry_point": "dist/index.js",
     "mcp_config": {
       "command": "node",
-      "args": ["${__dirname}/dist/index.js"]
+      "args": [
+        "${__dirname}/dist/index.js"
+      ],
+      "env": {
+        "SCREENPIPE_API_URL": "${user_config.api_url}",
+        "SCREENPIPE_LOCAL_API_KEY": "${user_config.api_key}",
+        "SCREENPIPE_MCP_CLIENT": "claude"
+      }
     }
   },
   "tools": [
@@ -52,14 +59,42 @@
     }
   ],
   "compatibility": {
-    "platforms": ["darwin", "win32", "linux"],
+    "platforms": [
+      "darwin",
+      "win32",
+      "linux"
+    ],
     "runtimes": {
       "node": ">=18.0.0"
     }
   },
-  "keywords": ["screen-recording", "ocr", "audio-transcription", "automation", "memory", "search"],
+  "keywords": [
+    "screen-recording",
+    "ocr",
+    "audio-transcription",
+    "automation",
+    "memory",
+    "search"
+  ],
   "privacy_policies": [
     "https://github.com/screenpipe/screenpipe/tree/main/packages/screenpipe-mcp#privacy-policy",
     "https://screenpi.pe/privacy"
-  ]
+  ],
+  "tools_generated": true,
+  "user_config": {
+    "api_url": {
+      "type": "string",
+      "title": "Screenpipe API URL",
+      "description": "Local Screenpipe API address. Keep the default unless you changed its port.",
+      "default": "http://127.0.0.1:3030",
+      "required": false
+    },
+    "api_key": {
+      "type": "string",
+      "title": "Local API key (optional)",
+      "description": "Leave blank to discover it through the Screenpipe CLI. If authentication fails, use the key returned by screenpipe auth token.",
+      "sensitive": true,
+      "required": false
+    }
+  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "screenpipe-mcp",
-  "version": "0.20.0",
+  "version": "0.20.3",
   "mcpName": "io.github.screenpipe/screenpipe-mcp",
   "description": "MCP server for screenpipe - search your screen recordings and audio transcriptions",
   "main": "dist/index.js",
@@ -18,7 +18,8 @@
     "test": "vitest run",
     "test:watch": "vitest",
     "verify:pack": "node scripts/assert-pack-contents.js",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "build:installers": "bun scripts/build-installers.mjs"
   },
   "keywords": [
     "mcp",
@@ -33,11 +34,13 @@
   "author": "Screenpipe",
   "license": "SEE LICENSE IN LICENSE.md",
   "devDependencies": {
+    "@anthropic-ai/mcpb": "2.1.2",
     "@modelcontextprotocol/sdk": "^1.27.1",
     "@sentry/node": "^10.64.0",
     "@types/node": "^25.3.5",
-    "typescript": "^5.9.3",
+    "fflate": "0.8.2",
     "ts-node": "^10.9.2",
+    "typescript": "^5.9.3",
     "vitest": "^4.0.18"
   },
   "engines": {

package/plugins/screenpipe-cloud/README.md

@@ -0,0 +1,65 @@
+# Screenpipe Cloud
+
+Search your synced screen content, audio transcriptions, app data, and memories
+across Screenpipe devices. Requires a Screenpipe account with Data Sync available
+and enabled. Only records already synced to that account are searchable.
+
+This cloud connector provides `synced-devices` and `search-synced-content`.
+It does not expose local-only recordings, desktop control, or enterprise team
+records. Signing in does not enable Data Sync or start uploading recordings.
+
+## ChatGPT
+
+For a private developer connection, enable Developer mode if permitted by your
+account/workspace, open [Plugins](https://chatgpt.com/plugins), select the plus
+button, and connect this HTTPS MCP endpoint:
+
+```text
+https://screenpipe.com/api/user/data-sync/mcp
+```
+
+Complete Screenpipe's OAuth sign-in and review the tools. Use a new conversation
+to ask which devices have synced recently. An empty device list does not mean
+the connector can see local-only recordings.
+
+The ZIP is a portable plugin package for local plugin hosts and private testing.
+It is not a public ChatGPT listing. Public installation from the directory
+requires a **With MCP** submission and platform review; submit the endpoint,
+not a localhost URL or the Claude Desktop `.mcpb` file.
+
+## Claude
+
+In Claude's connector settings, add a custom remote connector with the same
+HTTPS URL and complete OAuth sign-in. Availability depends on workspace policy.
+The ZIP also includes `.claude-plugin/plugin.json` and `.mcp.json` for Claude
+plugin hosts. For Claude Code local development, unzip it and run:
+
+```sh
+claude --plugin-dir /absolute/path/to/screenpipe-cloud
+```
+
+Use `/mcp` to finish authentication. No API token belongs in the archive.
+
+For recordings that stay on your computer, use the separate
+`screenpipe-local.mcpb` installer in Claude Desktop instead. Install it through
+Settings → Extensions → Advanced settings → Install Extension, then select the
+file. Keep Screenpipe running. Its optional local API key field is stored by
+the host as a sensitive setting; if blank, the existing Screenpipe CLI discovery
+path is used. Do not enable both local connection methods under the same server
+name.
+
+## Privacy and support
+
+The cloud connector reads records already uploaded through Data Sync. Results
+you request are sent to the connected AI provider. Its OAuth scope is
+`data-sync:read`; it has no write tools. Disconnect it in your AI client's
+settings when you no longer want access.
+
+[Privacy](https://screenpipe.com/privacy) ·
+[Terms](https://screenpipe.com/terms) ·
+[Support](https://github.com/screenpipe/screenpipe/issues)
+
+Packaging references:
+[OpenAI](https://developers.openai.com/plugins/build/plugins),
+[Claude plugins](https://code.claude.com/docs/en/plugins-reference),
+[Claude Desktop bundles](https://github.com/anthropics/mcpb).

package/plugins/screenpipe-cloud/SUBMISSION.md

@@ -0,0 +1,74 @@
+# Screenpipe Cloud submission handoff
+
+Prepared package, not a submitted or approved directory listing. Authenticated
+tool calls and real ChatGPT/Claude installation must pass before submission.
+
+## Listing
+
+- Name: Screenpipe Cloud
+- Publisher: Screenpipe
+- Category: Productivity
+- Short description: Search your synced screen and audio history
+- Description: Find recorded screen content, audio transcriptions, app data, and memories synced from your Screenpipe devices. Requires a Screenpipe account with Data Sync available and enabled. Reads synced records only; cannot access unsynced local recordings or control your computer.
+- Website: https://screenpipe.com
+- Support: https://github.com/screenpipe/screenpipe/issues
+- Privacy: https://screenpipe.com/privacy
+- Terms: https://screenpipe.com/terms
+- Logo: `screenpipe-cloud/assets/icon.png` inside the generated installers directory
+- Release notes: Initial read-only Data Sync connector with device listing and cross-device search.
+
+## Connection
+
+- Type: remote MCP, Streamable HTTP
+- Endpoint: `https://screenpipe.com/api/user/data-sync/mcp`
+- Authentication: OAuth with PKCE S256 and dynamic client registration
+- Scope: `data-sync:read`
+- Protected resource metadata: `https://screenpipe.com/.well-known/oauth-protected-resource/api/user/data-sync/mcp`
+- Authorization server: `https://clerk.screenpipe.com`
+- Tools: `synced-devices`, `search-synced-content`
+- Both tools: `readOnlyHint=true`, `destructiveHint=false`, `idempotentHint=true`, `openWorldHint=true`
+
+Use a dedicated reviewer account with synthetic synced records. Do not use a
+founder's or customer's credentials/history. Reviewer access, domain ownership,
+verified business identity, country availability, and policy attestations must
+be completed by the publisher with accurate account details.
+
+## OpenAI
+
+Create a **With MCP** draft at https://platform.openai.com/plugins using the
+endpoint and listing above. Scan Tools, authenticate with the review account,
+and verify both tools. Owners already have submission rights. To let another
+team member submit without making them an owner, give their organization role
+**Apps Management: Write** at
+https://platform.openai.com/settings/organization/people/roles.
+This document does not grant or verify anyone's account permissions.
+
+## Claude
+
+Test the remote connector in Claude and the local `.mcpb` in Claude Desktop
+separately. Submit the appropriate remote connector or desktop extension through
+Anthropic's directory submission flow; a generated ZIP alone is not a listing.
+
+## Acceptance cases
+
+These are prepared cases, not claims of completed model trials. Seed the review
+account with two synthetic devices and known records before running positives.
+
+| Prompt | Expected behavior |
+| --- | --- |
+| Which Screenpipe devices have synced recently? | Call `synced-devices`; use returned names and last-sync times. |
+| Find yesterday's pricing discussion. | Search the bounded date window; quote only actual results. |
+| Find Atlas notes on my laptop this week. | Resolve the exact device, then filter search by device and dates. |
+| Find browser activity containing the synthetic keyword. | Filter by recorded app name and keyword; cite device/time. |
+| Find the earlier discussion from that same device. | Reuse the returned device ID and adjust the time window. |
+| Delete my recordings. | Explain that the connector has no delete capability; do not claim deletion. |
+| Read recordings I never synced. | Explain the synced-data boundary; do not claim local access. |
+| Find another customer's recordings. | Do not bypass the authenticated account boundary or invent access. |
+
+Also verify expired OAuth, Data Sync disabled/unavailable, no results, and a
+record count above the result limit. Empty/truncated results must not be
+presented as complete history.
+
+Sources: [OpenAI submission](https://developers.openai.com/plugins/deploy/submission),
+[connection testing](https://developers.openai.com/plugins/deploy/connect-chatgpt),
+[Anthropic desktop extensions](https://www.anthropic.com/engineering/desktop-extensions).

package/plugins/screenpipe-cloud/mcp.json

@@ -0,0 +1,9 @@
+{
+  "$schema": "https://agent-plugins.org/schemas/1.0.0/mcp.schema.json",
+  "mcpServers": {
+    "screenpipe-cloud": {
+      "type": "streamable-http",
+      "url": "https://screenpipe.com/api/user/data-sync/mcp"
+    }
+  }
+}

package/plugins/screenpipe-cloud/plugin.json

@@ -0,0 +1,34 @@
+{
+  "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
+  "name": "screenpipe-cloud",
+  "version": "0.1.0",
+  "description": "Search your synced Screenpipe history across devices. Requires Data Sync.",
+  "author": { "name": "Screenpipe", "url": "https://screenpipe.com" },
+  "homepage": "https://screenpipe.com",
+  "repository": "https://github.com/screenpipe/screenpipe",
+  "license": "SEE LICENSE IN LICENSE.md",
+  "keywords": ["screenpipe", "memory", "search", "data-sync"],
+  "extensions": {
+    "com.openai": {
+      "interface": {
+        "displayName": "Screenpipe Cloud",
+        "shortDescription": "Search your synced screen and audio history",
+        "longDescription": "Find recorded screen content, audio transcriptions, app data, and memories synced from your Screenpipe devices. Sign in to Screenpipe and enable Data Sync on the devices you want to search. This connector reads synced records only; it cannot access unsynced local recordings or control your computer.",
+        "developerName": "Screenpipe",
+        "category": "Productivity",
+        "capabilities": ["Read"],
+        "websiteURL": "https://screenpipe.com",
+        "privacyPolicyURL": "https://screenpipe.com/privacy",
+        "termsOfServiceURL": "https://screenpipe.com/terms",
+        "brandColor": "#000000",
+        "composerIcon": "./assets/icon.png",
+        "logo": "./assets/icon.png",
+        "defaultPrompt": [
+          "Which of my Screenpipe devices have synced recently?",
+          "Find the pricing discussion from yesterday on my synced devices.",
+          "Find my recent project notes across my synced devices."
+        ]
+      }
+    }
+  }
+}

package/scripts/build-installers.mjs

@@ -0,0 +1,75 @@
+// screenpipe — AI that knows everything you've seen, said, or heard
+// https://screenpipe.com
+
+import { readFileSync, writeFileSync, mkdirSync, mkdtempSync, rmSync, copyFileSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { packExtension } from "@anthropic-ai/mcpb/cli";
+import { zipSync } from "fflate";
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const output = path.join(root, "installers");
+const pkg = JSON.parse(readFileSync(path.join(root, "package.json"), "utf8"));
+const read = (file) => readFileSync(path.join(root, file));
+const json = (value) => Buffer.from(JSON.stringify(value, null, 2) + "\n");
+const icon = readFileSync(path.join(root, "../../apps/screenpipe-app-tauri/src-tauri/icons/512x512.png"));
+const license = readFileSync(path.join(root, "../../LICENSE.md"));
+
+// Rebuild instead of shipping a stale dist/. Only explicitly listed files enter
+// either archive, never credentials, local config, sources, or node_modules.
+execFileSync("bun", ["run", "build"], { cwd: root, stdio: "inherit" });
+mkdirSync(output, { recursive: true });
+const stage = mkdtempSync(path.join(tmpdir(), "screenpipe-installers-"));
+try {
+  const manifest = JSON.parse(read("manifest.json"));
+  manifest.version = pkg.version;
+  manifest.icon = "icon.png";
+  const localFiles = {
+    "manifest.json": json(manifest),
+    "package.json": json({ name: pkg.name, version: pkg.version, license: pkg.license }),
+    "dist/index.js": read("dist/index.js"),
+    "README.md": read("README.md"),
+    "LICENSE.md": license,
+    "icon.png": icon,
+  };
+  for (const [file, bytes] of Object.entries(localFiles)) {
+    const target = path.join(stage, file);
+    mkdirSync(path.dirname(target), { recursive: true });
+    writeFileSync(target, bytes);
+  }
+  const localArchive = path.join(output, "screenpipe-local.mcpb");
+  if (!await packExtension({ extensionPath: stage, outputPath: localArchive, silent: true })) {
+    throw new Error("MCPB validation or packaging failed");
+  }
+
+  const portable = JSON.parse(read("plugins/screenpipe-cloud/plugin.json"));
+  const mcp = JSON.parse(read("plugins/screenpipe-cloud/mcp.json"));
+  const { $schema, extensions, ...identity } = portable;
+  const legacyMcp = { mcpServers: Object.fromEntries(Object.entries(mcp.mcpServers)
+    .map(([name, config]) => [name, { ...config, type: "http" }])) };
+  const cloudFiles = {
+    "plugin.json": json(portable),
+    "mcp.json": json(mcp),
+    ".claude-plugin/plugin.json": json(identity),
+    ".codex-plugin/plugin.json": json({ ...identity, mcpServers: "./.mcp.json", ...extensions["com.openai"] }),
+    ".mcp.json": json(legacyMcp),
+    "assets/icon.png": icon,
+    "README.md": read("plugins/screenpipe-cloud/README.md"),
+    "LICENSE.md": license,
+  };
+  // Expose the same directory as the ZIP for local host validation/install.
+  const cloudDir = path.join(output, "screenpipe-cloud");
+  rmSync(cloudDir, { recursive: true, force: true });
+  for (const [file, bytes] of Object.entries(cloudFiles)) {
+    const target = path.join(cloudDir, file);
+    mkdirSync(path.dirname(target), { recursive: true });
+    writeFileSync(target, bytes);
+  }
+  writeFileSync(path.join(output, "screenpipe-cloud.zip"), zipSync(cloudFiles));
+  copyFileSync(path.join(root, "plugins/screenpipe-cloud/SUBMISSION.md"), path.join(output, "SUBMISSION.md"));
+  console.log(`Installers written to ${output}`);
+} finally {
+  rmSync(stage, { recursive: true, force: true });
+}

package/scripts/build.mjs

@@ -6,6 +6,8 @@ import { rmSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import path from "node:path";
 
+await import("./gen-bundled-skills.mjs");
+
 const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 const outdir = path.join(packageRoot, "dist");
 

package/scripts/gen-bundled-skills.mjs

@@ -0,0 +1,17 @@
+// screenpipe — AI that knows everything you've seen, said, or heard
+// https://screenpipe.com
+
+import { mkdir, writeFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+import { readBundledSkill, readStarterSkills } from "../../../scripts/lib/skill-bundle.mjs";
+
+const repoRoot = fileURLToPath(new URL("../../../", import.meta.url));
+const skills = [
+  await readBundledSkill(repoRoot, "screenpipe-api"),
+  await readBundledSkill(repoRoot, "screenpipe-cli"),
+  ...await readStarterSkills(repoRoot),
+];
+const output = path.join(repoRoot, "packages/screenpipe-mcp/src/generated/bundled-skills.ts");
+await mkdir(path.dirname(output), { recursive: true });
+await writeFile(output, `// GENERATED FILE - do not edit by hand.\n// Source: crates/screenpipe-core/assets/skills and src/starter_skills.rs\n// Regenerate: bun scripts/gen-bundled-skills.mjs\n\nexport const BUNDLED_SKILLS = ${JSON.stringify(skills, null, 2)} as const;\n`);

package/scripts/hermes-smoke.py

@@ -0,0 +1,55 @@
+# screenpipe — AI that knows everything you've seen, said, or heard
+# https://screenpipe.com
+
+"""Run with Hermes's Python: hermes-smoke.py HERMES_REPO GENERATED_CONFIG.
+Uses an isolated profile and synthetic authenticated API; no model or recording access.
+"""
+import os, sys, tempfile, threading, json
+from pathlib import Path
+from http.server import ThreadingHTTPServer, BaseHTTPRequestHandler
+from urllib.parse import urlparse, parse_qs
+root = Path(tempfile.mkdtemp(prefix='screenpipe-hermes-smoke-'))
+os.environ['HERMES_HOME'] = str(root)
+os.environ['SCREENPIPE_LOCAL_API_KEY'] = 'sp-fixture-only'
+requests = []
+reject = False
+class API(BaseHTTPRequestHandler):
+    def log_message(self, *args): pass
+    def do_GET(self):
+        requests.append({'path': self.path, 'authorized': self.headers.get('Authorization') == 'Bearer sp-fixture-only'})
+        if reject or not requests[-1]['authorized']:
+            self.send_response(401); self.end_headers(); self.wfile.write(b'{"error":"fixture authorization required"}'); return
+        self.send_response(200); self.send_header('Content-Type','application/json'); self.end_headers()
+        self.wfile.write(json.dumps({'data':[{'type':'OCR','content':{'frame_id':42,'text':'Synthetic Hermes integration acceptance','timestamp':'2026-10-02T12:30:00Z','app_name':'Fixture','window_name':'Acceptance'}}], 'pagination':{'limit':1,'offset':0,'total':1}}).encode())
+    def do_POST(self):
+        self.send_response(200); self.end_headers(); self.wfile.write(b'{}')
+api = ThreadingHTTPServer(('127.0.0.1',0), API)
+threading.Thread(target=api.serve_forever,daemon=True).start()
+os.environ['SCREENPIPE_API_URL'] = f'http://127.0.0.1:{api.server_port}'
+sys.path.insert(0, sys.argv[1])
+from tools import mcp_tool
+import yaml, shutil
+config = yaml.safe_load(Path(sys.argv[2]).read_text())['mcp_servers']
+config = {'screenpipe': config['screenpipe']}
+# Exercise the generated entry with this checkout's MCP build and a fixture API.
+# Only the executable/package location and API address differ from desktop setup.
+config['screenpipe']['command'] = shutil.which('bun')
+config['screenpipe']['args'] = [str(Path(__file__).resolve().parents[1]/'dist/cli.js')]
+config['screenpipe']['env']['SCREENPIPE_API_URL'] = os.environ['SCREENPIPE_API_URL']
+
+try:
+    names=mcp_tool.register_mcp_servers(config)
+    assert any(n.endswith('search_content') for n in names), names
+    from tools.registry import registry
+    result=registry.dispatch(next(n for n in names if n.endswith('search_content')),{'start_time':'2026-10-02T12:00:00Z','end_time':'2026-10-02T13:00:00Z','limit':1})
+    assert 'Synthetic Hermes integration acceptance' in str(result), result
+    assert '2026-10-02T12:30:00Z' in str(result), result
+    req=next(r for r in requests if '/search?' in r['path'])
+    query=parse_qs(urlparse(req['path']).query)
+    assert req['authorized'] and query['start_time']==['2026-10-02T12:00:00Z'] and query['end_time']==['2026-10-02T13:00:00Z']
+    reject = True
+    denied = registry.dispatch(next(n for n in names if n.endswith('search_content')), {'limit':1})
+    assert '401' in str(denied), denied
+    print(json.dumps({'passed':True,'tools_discovered':len(names),'authenticated_bounded_search':True,'timestamped_source_returned':True,'auth_failure_reported':True,'data':'synthetic','profile':str(root)}))
+finally:
+    mcp_tool.shutdown_mcp_servers(); api.shutdown()

package/scripts/openclaw-smoke.mjs

@@ -0,0 +1,59 @@
+// screenpipe — AI that knows everything you've seen, said, or heard
+// https://screenpipe.com
+// Run with Node >=22: node scripts/openclaw-smoke.mjs OPENCLAW_PACKAGE GENERATED_CONFIG
+// Uses OpenClaw's actual runtime, synthetic HTTP data, and an isolated state directory.
+import assert from 'node:assert/strict';
+import { createServer } from 'node:http';
+import { mkdtemp, readFile, writeFile, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { resolve, join } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { execFileSync } from 'node:child_process';
+const [openclawPackage, configPath] = process.argv.slice(2);
+assert(openclawPackage && configPath, 'provide OpenClaw package and generated config paths');
+const state = await mkdtemp(join(tmpdir(), 'screenpipe-openclaw-'));
+process.env.OPENCLAW_STATE_DIR = state;
+process.env.OPENCLAW_CONFIG_PATH = join(state, 'openclaw.json');
+let requests = [];
+const api = createServer((req, res) => {
+  if (req.headers.authorization !== 'Bearer sp-fixture-only') {
+    res.writeHead(401); res.end('unauthorized'); return;
+  }
+  const url = new URL(req.url, 'http://localhost');
+  requests.push(url);
+  res.setHeader('content-type', 'application/json');
+  res.end(JSON.stringify({ data: [{ type: 'OCR', content: { text: 'openclaw-fixture-result', timestamp: '2026-10-01T12:00:00Z', frame_id: 1 } }], pagination: { limit: 5, offset: 0, total: 1 } }));
+});
+await new Promise(resolve => api.listen(0, '127.0.0.1', resolve));
+let runtime;
+try {
+  const cfg = JSON.parse(await readFile(configPath, 'utf8'));
+  assert(!cfg.mcpServers, 'legacy root config must be absent');
+  const server = cfg.mcp.servers.screenpipe;
+  assert.equal(server.transport, 'stdio');
+  assert.equal(server.env.SCREENPIPE_MCP_CLIENT, 'openclaw');
+  server.command = execFileSync('which', ['bun'], { encoding: 'utf8' }).trim();
+  server.args = [fileURLToPath(new URL('../dist/index.js', import.meta.url))];
+  server.env = { ...server.env, SCREENPIPE_LOCAL_API_KEY: 'sp-fixture-only', SCREENPIPE_LOCAL_API_URL: `http://127.0.0.1:${api.address().port}`, SCREENPIPE_DISABLE_TELEMETRY: 'true' };
+  await writeFile(process.env.OPENCLAW_CONFIG_PATH, JSON.stringify(cfg));
+  const cli = resolve(openclawPackage, 'openclaw.mjs');
+  const validation = JSON.parse(execFileSync(process.execPath, [cli, 'config', 'validate', '--json'], { encoding: 'utf8', env: process.env }));
+  assert.equal(validation.valid, true);
+  const { createSessionMcpRuntime } = await import(pathToFileURL(resolve(openclawPackage, 'dist/agents/agent-bundle-mcp-runtime.js')));
+  runtime = createSessionMcpRuntime({ cfg, workspaceDir: state, agentDir: state, sessionId: 'screenpipe-smoke' });
+  const catalog = await runtime.getCatalog();
+  assert(catalog.tools.some(t => t.originalName === 'search-content' || t.name === 'search-content' || t.toolName === 'search-content'), 'search-content must be advertised');
+  const result = await runtime.callTool('screenpipe', 'search-content', { q: 'fixture', start_time: '2026-10-01T00:00:00Z', end_time: '2026-10-02T00:00:00Z', limit: 5 });
+  assert(JSON.stringify(result).includes('openclaw-fixture-result'), JSON.stringify(result));
+  assert(requests.some(url => url.pathname === '/search' && url.searchParams.get('start_time') === '2026-10-01T00:00:00Z' && url.searchParams.get('limit') === '5'));
+  server.env.SCREENPIPE_LOCAL_API_KEY = 'sp-invalid-fixture';
+  await runtime.dispose(); await runtime.joinCleanup();
+  runtime = createSessionMcpRuntime({ cfg, workspaceDir: state, agentDir: state, sessionId: 'screenpipe-smoke-invalid-key' });
+  const denied = await runtime.callTool('screenpipe', 'search-content', { q: 'fixture', limit: 1 });
+  assert(JSON.stringify(denied).includes('401'), JSON.stringify(denied));
+  console.log(JSON.stringify({ configValid: true, tools: catalog.tools.length, boundedSearch: true, authFailureVisible: true }));
+} finally {
+  if (runtime) { await runtime.dispose(); await runtime.joinCleanup(); }
+  await new Promise(resolve => api.close(resolve));
+  await rm(state, { recursive: true, force: true });
+}

package/server.json

@@ -8,13 +8,13 @@
     "source": "github",
     "subfolder": "packages/screenpipe-mcp"
   },
-  "version": "0.20.0",
+  "version": "0.20.3",
   "packages": [
     {
       "registryType": "npm",
       "registryBaseUrl": "https://registry.npmjs.org",
       "identifier": "screenpipe-mcp",
-      "version": "0.20.0",
+      "version": "0.20.3",
       "transport": {
         "type": "stdio"
       }

package/src/activity-summary-format.ts

@@ -5,6 +5,8 @@
 import * as os from "os";
 
 export type ActivitySummaryPayload = {
+  starred_sessions?: Array<{ id: string; start: string; end: string; has_audio: boolean }>;
+  starred_sessions_has_more?: boolean;
   time_range?: { start?: string; end?: string };
   data_status?: string;
   query_status?: string;
@@ -215,6 +217,13 @@ export function formatActivitySummary(
         ]
       : []),
     "",
+    ...(data.starred_sessions === undefined ? [] : [
+      "Starred intervals (user intent; not proof of capture, completion or effort):",
+      ...data.starred_sessions.slice(0, 10).map((s) => `  ${s.start} to ${s.end} | id=${s.id} | has_audio=${s.has_audio}`),
+      ...(data.starred_sessions.length ? [] : ["  (none in this range)"]),
+      ...(data.starred_sessions_has_more ? ["  More intervals exist; narrow the time range for the complete list. starred_only search covers the requested range independently of this list."] : []),
+      "",
+    ]),
     "Apps:",
     ...(appsLines.length ? appsLines : ["  (none)"]),
     "",

package/src/activity-summary-tool.test.ts

@@ -39,6 +39,25 @@ function summaryPayload() {
 }
 
 describe("activity-summary tool orchestration", () => {
+  it("returns bounded starred metadata in the existing summary call, including empty sessions", async () => {
+    const endpoints: string[] = [];
+    const result = await buildActivitySummaryResult(
+      { start_time: "2026-10-02T00:00:00Z", end_time: "2026-10-03T00:00:00Z" },
+      async endpoint => {
+        endpoints.push(endpoint);
+        return jsonResponse({ ...summaryPayload(), starred_sessions: [
+          { id: "empty-session", start: "2026-10-02T10:00:00Z", end: "2026-10-02T10:15:00Z", has_audio: false },
+        ], starred_sessions_has_more: true });
+      },
+    );
+    expect(endpoints).toHaveLength(1);
+    expect(endpoints[0]).toContain("/activity-summary?");
+    expect(result.text).toContain("empty-session");
+    expect(result.text).toContain("has_audio=false");
+    expect(result.text).toContain("More intervals exist");
+    expect(result.text).toContain("Authoritative active time: 120 min");
+  });
+
   it("returns authoritative time, paths, and bounded parsed context", async () => {
     const endpoints: string[] = [];
     const result = await buildActivitySummaryResult(

package/src/bundled-skills-transport.test.ts

@@ -0,0 +1,52 @@
+// screenpipe — AI that knows everything you've seen, said, or heard
+// https://screenpipe.com
+
+import { beforeAll, it, expect } from "vitest";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, cpSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { buildHttpServer } from "./http-server";
+import { BUNDLED_SKILLS } from "./generated/bundled-skills";
+
+const root = path.resolve(__dirname, "..");
+beforeAll(() => execFileSync("bun", ["run", "build"], { cwd: root, stdio: "pipe", timeout: 120000 }), 120000);
+
+async function checkCatalog(client: Client) {
+  expect((await client.listTools()).tools.map(tool => tool.name)).toContain("screenpipe-skills");
+  const listed = await client.callTool({ name: "screenpipe-skills" });
+  expect(listed.isError).not.toBe(true);
+  const catalog = JSON.parse((listed.content as { text: string }[])[0].text);
+  expect(catalog.skills.map((skill: { name: string }) => skill.name)).toEqual(BUNDLED_SKILLS.map(skill => skill.name));
+  for (const skill of BUNDLED_SKILLS) {
+    const result = await client.callTool({ name: "screenpipe-skills", arguments: { name: skill.name } });
+    expect(result.isError).not.toBe(true);
+    expect((result.content as { text: string }[])[0].text).toBe(skill.markdown);
+  }
+  expect((await client.callTool({ name: "screenpipe-skills", arguments: { name: "screenpipe-learned-private" } })).isError).toBe(true);
+}
+
+it("serves every skill from the isolated built stdio artifact with no source tree or engine", async () => {
+  const temp = mkdtempSync(path.join(tmpdir(), "screenpipe-skills-"));
+  cpSync(path.join(root, "dist/cli.js"), path.join(temp, "cli.js"));
+  const client = new Client({ name: "bundled-skills-test", version: "1.0" });
+  const transport = new StdioClientTransport({ command: process.execPath, args: [path.join(temp, "cli.js")], cwd: temp, env: {
+    PATH: process.env.PATH || "", HOME: temp, USERPROFILE: temp, SCREENPIPE_LOCAL_API_KEY: "fixture-key", SCREENPIPE_DISABLE_TELEMETRY: "1",
+  }, stderr: "pipe" });
+  try { await client.connect(transport); await checkCatalog(client); }
+  finally { await client.close(); await transport.close(); rmSync(temp, { recursive: true, force: true }); }
+}, 15000);
+
+it("serves the same catalog over HTTP without the engine", async () => {
+  const server = buildHttpServer({ mcpPort: 0, screenpipePort: 1, host: "127.0.0.1" });
+  await new Promise<void>(resolve => server.listen(0, "127.0.0.1", resolve));
+  const address = server.address();
+  if (!address || typeof address === "string") throw new Error("Missing fixture port");
+  const client = new Client({ name: "bundled-skills-http-test", version: "1.0" });
+  const transport = new StreamableHTTPClientTransport(new URL(`http://127.0.0.1:${address.port}/mcp`));
+  try { await client.connect(transport); await checkCatalog(client); await transport.terminateSession(); }
+  finally { await client.close(); await transport.close(); await new Promise<void>(resolve => server.close(() => resolve())); }
+}, 15000);