openclaw-crawleo-skill 0.1.0

package/examples/live-usage-template.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+
+import { createCrawleoClient, CrawleoError } from '../src/index.js';
+
+const enableLiveExample = process.env.CRAWLEO_ENABLE_LIVE_EXAMPLE === '1';
+const apiKey = process.env.CRAWLEO_API_KEY;
+
+if (!enableLiveExample || !apiKey) {
+  console.log('Skipping live Crawleo example: set CRAWLEO_ENABLE_LIVE_EXAMPLE=1 and CRAWLEO_API_KEY to run it.');
+  process.exit(0);
+}
+
+const client = createCrawleoClient({ apiKey });
+
+try {
+  const result = await client.search({
+    query: 'Crawleo web intelligence',
+    max_pages: 1
+  });
+
+  console.log(JSON.stringify({
+    ok: true,
+    endpoint: '/search',
+    topLevelFields: Object.keys(result || {})
+  }, null, 2));
+} catch (error) {
+  if (error instanceof CrawleoError) {
+    console.error(JSON.stringify(error.toJSON(), null, 2));
+    process.exit(1);
+  }
+
+  console.error('Unexpected live Crawleo example failure.');
+  process.exit(1);
+}

package/examples/offline-fake-fetch.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+
+import { createCrawleoClient } from '../src/index.js';
+
+const calls = [];
+
+const client = createCrawleoClient({
+  apiKey: 'offline-example-key',
+  fetch: async (url, init) => {
+    const requestUrl = new URL(url);
+    calls.push({ path: requestUrl.pathname, method: init.method });
+
+    return {
+      ok: true,
+      status: 200,
+      headers: new Map([['content-type', 'application/json']]),
+      async text() {
+        return JSON.stringify({
+          ok: true,
+          path: requestUrl.pathname,
+          query: Object.fromEntries(requestUrl.searchParams.entries())
+        });
+      }
+    };
+  }
+});
+
+await client.search({ query: 'ai agents', max_pages: 1, markdown: true });
+await client.googleSearch({ q: 'best CRM software', type: 'news', tbs: 'qdr:d' });
+await client.googleMaps({ q: 'restaurants in Paris', hl: 'fr' });
+await client.crawl({ urls: ['https://example.com'], markdown: true });
+await client.headfulBrowser({ urls: 'https://example.com', output_format: 'markdown' });
+
+const expectedPaths = ['/search', '/google-search', '/google-maps', '/crawl', '/headful-browser'];
+const actualPaths = calls.map((call) => call.path);
+
+if (JSON.stringify(actualPaths) !== JSON.stringify(expectedPaths)) {
+  throw new Error(`Unexpected wrapper paths: ${actualPaths.join(', ')}`);
+}
+
+console.log(`Offline Crawleo wrapper example passed for ${calls.length} endpoints.`);

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "openclaw-crawleo-skill",
+  "version": "0.1.0",
+  "description": "Self-contained OpenClaw skill package for Crawleo web search and crawling capabilities.",
+  "type": "module",
+  "private": false,
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "exports": {
+    ".": "./src/index.js"
+  },
+  "files": [
+    "LICENSE",
+    "SKILL.md",
+    "skill.json",
+    "contracts/",
+    "examples/",
+    "scripts/",
+    "src/",
+    "test/",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "node --test",
+    "test:live": "node --test test/live.test.js",
+    "verify:contracts": "node scripts/verify-contracts.js",
+    "verify:examples": "node examples/offline-fake-fetch.js && node examples/live-usage-template.js",
+    "verify:final": "node scripts/verify-final.js",
+    "verify:scaffold": "node scripts/verify-scaffold.js"
+  },
+  "keywords": [
+    "openclaw",
+    "crawleo",
+    "skill",
+    "web-search",
+    "web-crawling"
+  ],
+  "dependencies": {},
+  "devDependencies": {}
+}

package/scripts/verify-contracts.js

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+const contractPath = path.join('contracts', 'crawleo-endpoints.json');
+const markdownPath = path.join('contracts', 'crawleo-endpoints.md');
+
+const requiredEndpoints = ['/search', '/google-search', '/google-maps', '/crawl', '/headful-browser'];
+const requiredTools = ['search_web', 'google_search', 'google_maps', 'crawl_web', 'headful_browser'];
+const requiredEndpointFields = [
+  'id',
+  'name',
+  'method',
+  'path',
+  'url',
+  'mcp_tool',
+  'description',
+  'sources',
+  'cost',
+  'parameters',
+  'examples',
+  'response_shape',
+  'errors',
+  'ambiguities'
+];
+
+function fail(message) {
+  console.error(`FAIL: ${message}`);
+  process.exitCode = 1;
+}
+
+function assert(condition, message) {
+  if (!condition) fail(message);
+}
+
+function countValues(values) {
+  return values.reduce((counts, value) => {
+    counts[value] = (counts[value] || 0) + 1;
+    return counts;
+  }, {});
+}
+
+assert(fs.existsSync(contractPath), `${contractPath} does not exist`);
+assert(fs.existsSync(markdownPath), `${markdownPath} does not exist`);
+
+let contract;
+try {
+  contract = JSON.parse(fs.readFileSync(contractPath, 'utf8'));
+} catch (error) {
+  fail(`${contractPath} is not valid JSON: ${error.message}`);
+  contract = { endpoints: [] };
+}
+
+const markdown = fs.existsSync(markdownPath) ? fs.readFileSync(markdownPath, 'utf8') : '';
+const endpoints = Array.isArray(contract.endpoints) ? contract.endpoints : [];
+const endpointPaths = endpoints.map((endpoint) => endpoint.path);
+const endpointPathCounts = countValues(endpointPaths);
+
+for (const endpointPath of requiredEndpoints) {
+  assert(endpointPathCounts[endpointPath] === 1, `expected exactly one contract for ${endpointPath}, found ${endpointPathCounts[endpointPath] || 0}`);
+  assert(markdown.includes(endpointPath), `${markdownPath} does not mention ${endpointPath}`);
+}
+
+const toolNames = endpoints.map((endpoint) => endpoint.mcp_tool).filter(Boolean);
+const mcpTools = contract.mcp && Array.isArray(contract.mcp.tools) ? contract.mcp.tools.map((tool) => tool.name) : [];
+const allTools = [...toolNames, ...mcpTools];
+
+for (const toolName of requiredTools) {
+  assert(allTools.includes(toolName), `missing MCP tool ${toolName}`);
+  assert(markdown.includes(toolName), `${markdownPath} does not mention MCP tool ${toolName}`);
+}
+
+for (const endpoint of endpoints) {
+  for (const field of requiredEndpointFields) {
+    assert(Object.prototype.hasOwnProperty.call(endpoint, field), `${endpoint.path || endpoint.id || 'unknown endpoint'} missing field ${field}`);
+  }
+
+  assert(endpoint.method === 'GET', `${endpoint.path} method must be GET per Crawleo docs`);
+  assert(typeof endpoint.url === 'string' && endpoint.url.startsWith('https://api.crawleo.dev/'), `${endpoint.path} url must use Crawleo API base URL`);
+  assert(Array.isArray(endpoint.sources) && endpoint.sources.length > 0, `${endpoint.path} must include source links`);
+  assert(Array.isArray(endpoint.parameters) && endpoint.parameters.length > 0, `${endpoint.path} must include parameters`);
+  assert(endpoint.parameters.some((parameter) => parameter.name === 'x-api-key' && parameter.in === 'header'), `${endpoint.path} must include x-api-key header parameter`);
+  assert(Array.isArray(endpoint.examples) && endpoint.examples.length > 0, `${endpoint.path} must include examples`);
+  assert(endpoint.response_shape && Array.isArray(endpoint.response_shape.top_level_fields) && endpoint.response_shape.top_level_fields.length > 0, `${endpoint.path} must include response top-level fields`);
+  assert(Array.isArray(endpoint.ambiguities) && endpoint.ambiguities.length > 0, `${endpoint.path} must include ambiguity notes, even if only to say no ambiguity is known`);
+}
+
+assert(markdown.includes('not specified in Crawleo docs'), `${markdownPath} must preserve required ambiguity phrase`);
+assert(JSON.stringify(contract).includes('not specified in Crawleo docs'), `${contractPath} must preserve required ambiguity phrase`);
+
+if (process.exitCode) {
+  console.error('Crawleo contract verification failed.');
+  process.exit(process.exitCode);
+}
+
+console.log(`Crawleo contract verification passed: ${requiredEndpoints.length} endpoints and ${requiredTools.length} MCP tools covered.`);

package/scripts/verify-final.js

@@ -0,0 +1,162 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs';
+
+const requiredFiles = [
+  'README.md',
+  'LICENSE',
+  'SKILL.md',
+  'skill.json',
+  'package.json',
+  'contracts/crawleo-endpoints.json',
+  'contracts/crawleo-endpoints.md',
+  'contracts/coverage-checklist.md',
+  'contracts/final-assembly-report.md',
+  'examples/README.md',
+  'examples/offline-fake-fetch.js',
+  'examples/live-usage-template.js',
+  'src/index.js',
+  'src/client.js',
+  'src/contract.js',
+  'src/endpoints.js',
+  'src/errors.js',
+  'test/client.test.js',
+  'test/endpoints.test.js',
+  'test/error-fixtures.test.js',
+  'test/errors.test.js',
+  'test/live.test.js',
+  'test/scaffold.test.js',
+  'test/wrapper-fixtures.test.js',
+  'scripts/verify-contracts.js',
+  'scripts/verify-final.js',
+  'scripts/verify-scaffold.js'
+];
+
+const requiredEndpoints = ['/search', '/google-search', '/google-maps', '/crawl', '/headful-browser'];
+const requiredTools = ['search_web', 'google_search', 'google_maps', 'crawl_web', 'headful_browser'];
+const requiredWrappers = ['client.search', 'client.googleSearch', 'client.googleMaps', 'client.crawl', 'client.headfulBrowser'];
+const requiredScripts = ['test', 'test:live', 'verify:contracts', 'verify:examples', 'verify:scaffold', 'verify:final'];
+const deliverableFilesForBranding = [
+  'README.md',
+  'SKILL.md',
+  'skill.json',
+  'package.json',
+  'contracts/crawleo-endpoints.md',
+  'contracts/coverage-checklist.md',
+  'contracts/final-assembly-report.md',
+  'examples/README.md',
+  'examples/offline-fake-fetch.js',
+  'examples/live-usage-template.js',
+  'src/index.js',
+  'src/client.js',
+  'src/contract.js',
+  'src/endpoints.js',
+  'src/errors.js'
+];
+const disallowedBrandTerms = ['Firecrawl', 'firecrawl', 'Apify', 'apify', 'Tavily', 'tavily', 'SerpAPI', 'serpapi', 'Browserbase', 'browserbase'];
+
+const failures = [];
+
+function check(condition, message) {
+  if (!condition) failures.push(message);
+}
+
+function readText(path) {
+  return fs.readFileSync(path, 'utf8');
+}
+
+for (const file of requiredFiles) {
+  check(fs.existsSync(file), `${file} is missing`);
+  if (fs.existsSync(file)) check(fs.statSync(file).size > 0, `${file} is empty`);
+}
+
+let packageJson = {};
+let skillJson = {};
+let contract = {};
+try {
+  packageJson = JSON.parse(readText('package.json'));
+} catch (error) {
+  failures.push(`package.json is invalid JSON: ${error.message}`);
+}
+try {
+  skillJson = JSON.parse(readText('skill.json'));
+} catch (error) {
+  failures.push(`skill.json is invalid JSON: ${error.message}`);
+}
+try {
+  contract = JSON.parse(readText('contracts/crawleo-endpoints.json'));
+} catch (error) {
+  failures.push(`contracts/crawleo-endpoints.json is invalid JSON: ${error.message}`);
+}
+
+const textFiles = Object.fromEntries(
+  requiredFiles.filter((file) => fs.existsSync(file)).map((file) => [file, readText(file)])
+);
+const combined = Object.values(textFiles).join('\n');
+
+check(packageJson.name === 'openclaw-crawleo-skill', 'package name must be openclaw-crawleo-skill');
+check(packageJson.type === 'module', 'package type must be module');
+check(packageJson.private === false, 'package must be publishable with private=false');
+check(packageJson.license === 'MIT', 'package license must be MIT');
+check(Array.isArray(packageJson.files) && packageJson.files.includes('LICENSE'), 'package files must include LICENSE');
+check(Array.isArray(packageJson.files) && packageJson.files.includes('scripts/'), 'package files must include scripts/ for verifier scripts');
+check(skillJson.name === 'crawleo', 'skill.json name must be crawleo');
+check(skillJson.brand === 'Crawleo', 'skill.json brand must be Crawleo');
+check(skillJson.contract === './contracts/crawleo-endpoints.json', 'skill.json must point to contract JSON');
+check(skillJson.instructions === './SKILL.md', 'skill.json must point to SKILL.md');
+
+for (const scriptName of requiredScripts) {
+  check(Boolean(packageJson.scripts?.[scriptName]), `package.json missing ${scriptName} script`);
+}
+
+const contractEndpoints = Array.isArray(contract.endpoints) ? contract.endpoints : [];
+const contractPaths = contractEndpoints.map((endpoint) => endpoint.path);
+const contractTools = contractEndpoints.map((endpoint) => endpoint.mcp_tool).filter(Boolean);
+const mcpTools = Array.isArray(contract.mcp?.tools) ? contract.mcp.tools.map((tool) => tool.name) : [];
+
+for (const endpoint of requiredEndpoints) {
+  check(contractPaths.filter((path) => path === endpoint).length === 1, `contract must contain exactly one ${endpoint}`);
+  for (const file of ['README.md', 'SKILL.md', 'contracts/crawleo-endpoints.md', 'contracts/coverage-checklist.md', 'contracts/final-assembly-report.md', 'examples/offline-fake-fetch.js']) {
+    check(textFiles[file]?.includes(endpoint), `${file} must mention ${endpoint}`);
+  }
+}
+
+for (const tool of requiredTools) {
+  check(contractTools.includes(tool) || mcpTools.includes(tool), `contract must include MCP tool ${tool}`);
+  for (const file of ['README.md', 'SKILL.md', 'contracts/crawleo-endpoints.md', 'contracts/coverage-checklist.md', 'contracts/final-assembly-report.md', 'skill.json']) {
+    check(textFiles[file]?.includes(tool), `${file} must mention ${tool}`);
+  }
+}
+
+for (const wrapper of requiredWrappers) {
+  for (const file of ['README.md', 'contracts/coverage-checklist.md', 'test/wrapper-fixtures.test.js']) {
+    check(textFiles[file]?.includes(wrapper), `${file} must mention ${wrapper}`);
+  }
+}
+
+for (const file of ['README.md', 'SKILL.md', 'contracts/coverage-checklist.md', 'contracts/final-assembly-report.md', 'test/live.test.js']) {
+  check(textFiles[file]?.includes('CRAWLEO_ENABLE_LIVE_TESTS'), `${file} must document or enforce CRAWLEO_ENABLE_LIVE_TESTS`);
+  check(textFiles[file]?.includes('CRAWLEO_API_KEY'), `${file} must document or enforce CRAWLEO_API_KEY`);
+}
+
+check(textFiles['README.md']?.includes('contracts/final-assembly-report.md'), 'README.md must point to final assembly report');
+check(textFiles['README.md']?.includes('npm run test:live'), 'README.md must document npm run test:live');
+check(textFiles['SKILL.md']?.includes('npm run test:live'), 'SKILL.md must document npm run test:live');
+check(textFiles['contracts/coverage-checklist.md']?.includes('npm run test:live'), 'coverage checklist must document npm run test:live');
+check(combined.includes('not specified in Crawleo docs'), 'deliverables must preserve the Crawleo ambiguity phrase');
+check(combined.includes('https://api.crawleo.dev/mcp'), 'deliverables must mention the optional Crawleo MCP endpoint');
+
+for (const file of deliverableFilesForBranding) {
+  const text = textFiles[file] || '';
+  for (const term of disallowedBrandTerms) {
+    check(!text.includes(term), `${file} contains non-Crawleo brand/reference ${term}`);
+  }
+}
+
+if (failures.length > 0) {
+  console.error('Crawleo final assembly verification failed:');
+  for (const failure of failures) console.error(`- ${failure}`);
+  process.exit(1);
+}
+
+console.log(`Crawleo final assembly verification passed: ${requiredFiles.length} files, ${requiredEndpoints.length} endpoints, ${requiredTools.length} MCP tools, ${requiredWrappers.length} wrapper methods, ${requiredScripts.length} scripts.`);

package/scripts/verify-scaffold.js

@@ -0,0 +1,166 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs';
+
+const requiredFiles = [
+  'package.json',
+  'README.md',
+  'SKILL.md',
+  'skill.json',
+  'src/index.js',
+  'src/client.js',
+  'src/contract.js',
+  'src/endpoints.js',
+  'src/errors.js',
+  'test/scaffold.test.js',
+  'test/client.test.js',
+  'test/endpoints.test.js',
+  'test/errors.test.js',
+  'test/error-fixtures.test.js',
+  'test/live.test.js',
+  'test/wrapper-fixtures.test.js',
+  'examples/README.md',
+  'examples/offline-fake-fetch.js',
+  'examples/live-usage-template.js',
+  'contracts/crawleo-endpoints.json',
+  'contracts/crawleo-endpoints.md',
+  'contracts/coverage-checklist.md',
+  'scripts/verify-contracts.js',
+  'scripts/verify-scaffold.js'
+];
+
+const requiredEndpoints = ['/search', '/google-search', '/google-maps', '/crawl', '/headful-browser'];
+const requiredTools = ['search_web', 'google_search', 'google_maps', 'crawl_web', 'headful_browser'];
+const requiredExports = [
+  'createCrawleoClient',
+  'requestCrawleo',
+  'buildCrawleoUrl',
+  'CrawleoError',
+  'CRAWLEO_ERROR_CODES',
+  'search',
+  'googleSearch',
+  'googleMaps',
+  'crawl',
+  'headfulBrowser'
+];
+const requiredWrapperMentions = ['client.search', 'client.googleSearch', 'client.googleMaps', 'client.crawl', 'client.headfulBrowser'];
+
+function fail(message) {
+  console.error(`FAIL: ${message}`);
+  process.exitCode = 1;
+}
+
+function assert(condition, message) {
+  if (!condition) fail(message);
+}
+
+for (const file of requiredFiles) {
+  assert(fs.existsSync(file), `${file} is missing`);
+  if (fs.existsSync(file)) {
+    assert(fs.statSync(file).size > 0, `${file} is empty`);
+  }
+}
+
+let packageJson = {};
+let skillJson = {};
+let contract = {};
+
+try {
+  packageJson = JSON.parse(fs.readFileSync('package.json', 'utf8'));
+} catch (error) {
+  fail(`package.json is invalid JSON: ${error.message}`);
+}
+
+try {
+  skillJson = JSON.parse(fs.readFileSync('skill.json', 'utf8'));
+} catch (error) {
+  fail(`skill.json is invalid JSON: ${error.message}`);
+}
+
+try {
+  contract = JSON.parse(fs.readFileSync('contracts/crawleo-endpoints.json', 'utf8'));
+} catch (error) {
+  fail(`contracts/crawleo-endpoints.json is invalid JSON: ${error.message}`);
+}
+
+assert(packageJson.name === 'openclaw-crawleo-skill', 'package name must be openclaw-crawleo-skill');
+assert(packageJson.type === 'module', 'package must use ESM modules');
+assert(packageJson.scripts && packageJson.scripts.test === 'node --test', 'package must expose node --test script');
+assert(packageJson.scripts && packageJson.scripts['test:live'] === 'node --test test/live.test.js', 'package must expose test:live script');
+assert(packageJson.scripts && packageJson.scripts['verify:contracts'] === 'node scripts/verify-contracts.js', 'package must expose verify:contracts script');
+assert(packageJson.scripts && packageJson.scripts['verify:examples'] === 'node examples/offline-fake-fetch.js && node examples/live-usage-template.js', 'package must expose verify:examples script');
+assert(packageJson.scripts && packageJson.scripts['verify:scaffold'] === 'node scripts/verify-scaffold.js', 'package must expose verify:scaffold script');
+
+assert(skillJson.contract === './contracts/crawleo-endpoints.json', 'skill.json must point at the contract inventory');
+assert(skillJson.instructions === './SKILL.md', 'skill.json must point at SKILL.md');
+assert(skillJson.entrypoint === './src/index.js', 'skill.json must point at src/index.js');
+
+const readme = fs.readFileSync('README.md', 'utf8');
+const skillText = fs.readFileSync('SKILL.md', 'utf8');
+const coverageText = fs.readFileSync('contracts/coverage-checklist.md', 'utf8');
+const sourceText = fs.readFileSync('src/index.js', 'utf8');
+const contractText = JSON.stringify(contract);
+const skillJsonText = JSON.stringify(skillJson);
+
+for (const endpoint of requiredEndpoints) {
+  assert(readme.includes(endpoint), `README.md must mention ${endpoint}`);
+  assert(skillText.includes(endpoint), `SKILL.md must mention ${endpoint}`);
+  assert(coverageText.includes(endpoint), `coverage checklist must mention ${endpoint}`);
+  assert(sourceText.includes(endpoint), `src/index.js must mention ${endpoint}`);
+  assert(contractText.includes(endpoint), `contract must mention ${endpoint}`);
+  assert(skillJsonText.includes(endpoint), `skill.json must mention ${endpoint}`);
+}
+
+for (const tool of requiredTools) {
+  assert(readme.includes(tool), `README.md must mention ${tool}`);
+  assert(skillText.includes(tool), `SKILL.md must mention ${tool}`);
+  assert(coverageText.includes(tool), `coverage checklist must mention ${tool}`);
+  assert(sourceText.includes(tool), `src/index.js must mention ${tool}`);
+  assert(contractText.includes(tool), `contract must mention ${tool}`);
+  assert(skillJsonText.includes(tool), `skill.json must mention ${tool}`);
+}
+
+assert(readme.includes('CRAWLEO_API_KEY'), 'README.md must document CRAWLEO_API_KEY');
+assert(readme.includes('CRAWLEO_ENABLE_LIVE_TESTS'), 'README.md must document CRAWLEO_ENABLE_LIVE_TESTS');
+assert(readme.includes('npm run test:live'), 'README.md must document test:live');
+assert(skillText.includes('CRAWLEO_ENABLE_LIVE_TESTS'), 'SKILL.md must document CRAWLEO_ENABLE_LIVE_TESTS');
+assert(skillText.includes('npm run test:live'), 'SKILL.md must document test:live');
+assert(coverageText.includes('npm run test:live'), 'coverage checklist must document test:live');
+assert(readme.includes('offline'), 'README.md must document offline verification posture');
+assert(readme.includes('createCrawleoClient'), 'README.md must document createCrawleoClient');
+assert(readme.includes('client.search'), 'README.md must document runtime wrapper methods');
+assert(readme.includes('contracts/crawleo-endpoints.json'), 'README.md must point to contract JSON');
+assert(readme.includes('contracts/coverage-checklist.md'), 'README.md must point to coverage checklist');
+assert(skillText.includes('contracts/coverage-checklist.md'), 'SKILL.md must point to coverage checklist');
+assert(readme.includes('https://api.crawleo.dev/mcp'), 'README.md must mention optional Crawleo MCP endpoint');
+assert(skillText.includes('not specified in Crawleo docs'), 'SKILL.md must include ambiguity policy');
+assert(skillText.includes('createCrawleoClient'), 'SKILL.md must document the client factory');
+
+let publicApi = {};
+try {
+  publicApi = await import(new URL('../src/index.js', import.meta.url));
+} catch (error) {
+  fail(`src/index.js could not be imported: ${error.message}`);
+}
+
+for (const exportName of requiredExports) {
+  assert(typeof publicApi[exportName] !== 'undefined', `src/index.js must export ${exportName}`);
+}
+
+for (const wrapperName of ['search', 'googleSearch', 'googleMaps', 'crawl', 'headfulBrowser']) {
+  assert(typeof publicApi[wrapperName] === 'function', `${wrapperName} export must be a function`);
+}
+
+assert(typeof publicApi.createCrawleoClient === 'function', 'createCrawleoClient export must be a function');
+
+for (const wrapperMention of requiredWrapperMentions) {
+  assert(readme.includes(wrapperMention), `README.md must mention ${wrapperMention}`);
+  assert(coverageText.includes(wrapperMention), `coverage checklist must mention ${wrapperMention}`);
+}
+
+if (process.exitCode) {
+  console.error('Crawleo scaffold verification failed.');
+  process.exit(process.exitCode);
+}
+
+console.log(`Crawleo scaffold verification passed: ${requiredFiles.length} files, ${requiredEndpoints.length} endpoints, ${requiredTools.length} MCP tools, ${requiredExports.length} public exports.`);

package/skill.json

@@ -0,0 +1,47 @@
+{
+  "name": "crawleo",
+  "displayName": "Crawleo OpenClaw Skill",
+  "version": "0.1.0",
+  "description": "OpenClaw skill package for Crawleo web search, Google Search, Google Maps, crawling, and headful browser crawling.",
+  "brand": "Crawleo",
+  "entrypoint": "./src/index.js",
+  "instructions": "./SKILL.md",
+  "contract": "./contracts/crawleo-endpoints.json",
+  "environment": [
+    {
+      "name": "CRAWLEO_API_KEY",
+      "requiredForLiveCalls": true,
+      "secret": true,
+      "description": "Crawleo API key sent with the x-api-key header. Never log or echo the value."
+    }
+  ],
+  "capabilities": {
+    "restEndpoints": [
+      { "path": "/search", "name": "Bing Search API", "mcpTool": "search_web" },
+      { "path": "/google-search", "name": "Google Search API", "mcpTool": "google_search" },
+      { "path": "/google-maps", "name": "Google Maps API", "mcpTool": "google_maps" },
+      { "path": "/crawl", "name": "Crawler API", "mcpTool": "crawl_web" },
+      { "path": "/headful-browser", "name": "Headful Browser API", "mcpTool": "headful_browser" }
+    ],
+    "mcpTools": [
+      "search_web",
+      "google_search",
+      "google_maps",
+      "crawl_web",
+      "headful_browser"
+    ]
+  },
+  "verification": {
+    "offlineByDefault": true,
+    "defaultCommands": [
+      "npm test",
+      "npm run verify:contracts",
+      "npm run verify:scaffold"
+    ],
+    "liveCallsRequire": [
+      "CRAWLEO_API_KEY",
+      "explicit live-test enablement"
+    ]
+  },
+  "status": "scaffold-only; REST wrappers are implemented in a later slice"
+}