An agentic browser harness: an AI side panel & orb in your own logged-in Chrome, Edge, Arc, Brave or even Firefox run by the agent/subscription you already use (Claude Code, Codex, Antigravity). Free, open source, no API key. Also an MCP server.
TypeScript agentic-browseragentic-browsingagy-cliaiai-agentai-browser-extensionai-toolsbrave-extensionbrowser-agentbrowser-automationbrowser-extensionbrowser-usebrowserskillchrome-extensionclaude-codecodexfirefox-addonmcp-servernanobrowserweb-automation
test(agent): pin the agent-skill picker, saved skills and staged site maps against the sandbox
Shahriar0fb70d04491c
diff --git a/src/daemon/agent/agent-skills.test.ts b/src/daemon/agent/agent-skills.test.tsnew file mode 100644index 0000000..b83c76e--- /dev/null+++ b/src/daemon/agent/agent-skills.test.ts@@ -0,0 +1,129 @@+import { mkdirSync, rmSync, symlinkSync, truncateSync, writeFileSync } from 'node:fs';+import { homedir } from 'node:os';+import { dirname, join } from 'node:path';+import { beforeEach, describe, expect, test } from 'vitest';+import type { AgentKind } from '@/lib/agents/catalog';+import { agentSkills, resolveAgentSkill } from './agent-skills';+import { readAgentConfig } from './config';++const claudeSkills = join(homedir(), '.claude', 'skills');+const codexSkills = join(homedir(), '.codex', 'skills');++const config = (agent: AgentKind = 'claude') => ({ ...readAgentConfig(), agent });++const skillFile = (path: string, body: string, fields: Record<string, string> = {}) => {+ mkdirSync(dirname(path), { recursive: true });+ const front = Object.entries(fields).map(([key, value]) => `${key}: ${value}`);+ writeFileSync(path, front.length ? `---\n${front.join('\n')}\n---\n\n${body}` : body);+ return path;+};++const listed = (agent: AgentKind = 'claude') => agentSkills(config(agent), { refresh: true });+const idOf = (name: string, agent: AgentKind = 'claude') => listed(agent).find((skill) => skill.name === name)?.id ?? '';++beforeEach(() => {+ for (const dir of [join(homedir(), '.claude'), join(homedir(), '.codex'), join(homedir(), 'elsewhere')]) rmSync(dir, { recursive: true, force: true });+});++describe("listing the active agent's own skills", () => {+ test('both a flat file and a folder with SKILL.md count, sorted by name, each with an opaque id', () => {+ skillFile(join(claudeSkills, 'review.md'), 'Review the diff.', { description: 'Reviews code' });+ skillFile(join(claudeSkills, 'deploy', 'SKILL.md'), 'Ship it.', { name: 'deploy-app', description: '"Deploys the app"' });+ expect(listed()).toEqual([+ { id: expect.stringMatching(/^[0-9a-f]{16}$/), name: 'deploy-app', description: 'Deploys the app' },+ { id: expect.stringMatching(/^[0-9a-f]{16}$/), name: 'review', description: 'Reviews code' },+ ]);+ });++ test('hidden files, skills with no body and skills over 48 KB are left out', () => {+ skillFile(join(claudeSkills, '.draft.md'), 'Not yet.');+ skillFile(join(claudeSkills, 'empty.md'), ' ', { description: 'nothing below' });+ truncateSync(skillFile(join(claudeSkills, 'huge.md'), 'x'), 49 * 1024);+ skillFile(join(claudeSkills, 'kept.md'), 'Do the thing.');+ expect(listed().map((skill) => skill.name)).toEqual(['kept']);+ });++ test('a name or description is cleaned of control characters and cut to length before it reaches the panel', () => {+ skillFile(join(claudeSkills, 'x.md'), 'Body.', { name: `badname`, description: 'd'.repeat(300) });+ expect(listed()[0]).toMatchObject({ name: 'bad name', description: 'd'.repeat(200) });+ });++ test('a skill folder that is a symlink counts', () => {+ skillFile(join(homedir(), 'elsewhere', 'linked', 'SKILL.md'), 'Linked body.');+ mkdirSync(claudeSkills, { recursive: true });+ symlinkSync(join(homedir(), 'elsewhere', 'linked'), join(claudeSkills, 'linked'));+ expect(listed().map((skill) => skill.name)).toEqual(['linked']);+ });++ test('a new skill appears on refresh, and the listing is reused for half a minute otherwise', () => {+ skillFile(join(claudeSkills, 'first.md'), 'One.');+ listed();+ skillFile(join(claudeSkills, 'second.md'), 'Two.');+ expect([agentSkills(config()).length, listed().length]).toEqual([1, 2]);+ });++ test('only the first hundred are listed', () => {+ for (let i = 0; i < 105; i++) skillFile(join(claudeSkills, `skill-${String(i).padStart(3, '0')}.md`), 'Body.');+ expect(listed()).toHaveLength(100);+ });++ test("each agent lists from its own directories, and one with none lists nothing", () => {+ skillFile(join(claudeSkills, 'claude-only.md'), 'Body.');+ skillFile(join(codexSkills, 'codex-only.md'), 'Body.');+ expect([listed('codex').map((skill) => skill.name), listed('antigravity')]).toEqual([['codex-only'], []]);+ });+});++describe('attaching one to a message', () => {+ test('an id from the listing resolves to the skill, re-read at that moment, without its front matter', () => {+ const path = skillFile(join(claudeSkills, 'review.md'), 'Old body.', { description: 'Reviews code' });+ const id = idOf('review');+ skillFile(path, 'New body.', { description: 'Reviews code' });+ expect(resolveAgentSkill(id, config())).toEqual({ skill: { name: 'review', body: 'New body.' } });+ });++ test('an id that is not one the daemon issues never reaches the disk', () => {+ expect(resolveAgentSkill('../../.ssh/id_rsa', config())).toMatchObject({ error: { code: 'SKILL_UNKNOWN' } });+ });++ test('a well-formed id nobody was given is unknown', () => {+ expect(resolveAgentSkill('0123456789abcdef', config())).toMatchObject({ error: { code: 'SKILL_UNKNOWN' } });+ });++ test("after switching agents, the old agent's skills no longer resolve", () => {+ skillFile(join(claudeSkills, 'review.md'), 'Body.');+ const id = idOf('review');+ expect(resolveAgentSkill(id, config('codex'))).toMatchObject({ error: { code: 'SKILL_UNKNOWN' } });+ });++ test('a skill deleted since it was listed is unknown', () => {+ const path = skillFile(join(claudeSkills, 'gone.md'), 'Body.');+ const id = idOf('gone');+ rmSync(path);+ expect(resolveAgentSkill(id, config())).toMatchObject({ error: { code: 'SKILL_UNKNOWN' } });+ });++ test('a skill emptied since it was listed is unknown', () => {+ const path = skillFile(join(claudeSkills, 'hollow.md'), 'Body.');+ const id = idOf('hollow');+ writeFileSync(path, '---\nname: hollow\n---\n\n');+ expect(resolveAgentSkill(id, config())).toMatchObject({ error: { code: 'SKILL_UNKNOWN' } });+ });++ test('a skill that grew past 48 KB since it was listed says so', () => {+ const path = skillFile(join(claudeSkills, 'grown.md'), 'Body.');+ const id = idOf('grown');+ truncateSync(path, 49 * 1024);+ expect(resolveAgentSkill(id, config())).toEqual({+ error: { code: 'SKILL_UNKNOWN', message: 'The skill "grown" grew past 48 KB, so it was not attached.' },+ });+ });++ test('a skill whose file became a folder is unknown', () => {+ const path = skillFile(join(claudeSkills, 'shape.md'), 'Body.');+ const id = idOf('shape');+ rmSync(path);+ mkdirSync(path);+ expect(resolveAgentSkill(id, config())).toMatchObject({ error: { code: 'SKILL_UNKNOWN' } });+ });+});diff --git a/src/daemon/agent/site-map-store.test.ts b/src/daemon/agent/site-map-store.test.tsnew file mode 100644index 0000000..95f3a90--- /dev/null+++ b/src/daemon/agent/site-map-store.test.ts@@ -0,0 +1,280 @@+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';+import { join } from 'node:path';+import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';+import { skillNameForHost } from '@/lib/skills/format';+import type { SiteMapReport } from '@/lib/skills/site-map';+import { stateDir } from '../lockfile';+import {+ commitStaging,+ discardStaging,+ mapTargetFor,+ prepareStaging,+ stageSiteMap,+ stagedScreenshots,+ sweepStaging,+ writeEvidence,+ type MapTarget,+ type Staging,+} from './site-map-store';+import { loadSkills, uploadedSkillsDir } from './skills';+import type { SiteIndex } from './sitemap';++const skills = () => uploadedSkillsDir();+const target = (url = 'https://www.example.com/pricing'): MapTarget => {+ const found = mapTargetFor(url);+ if (!found.ok) throw new Error(found.message);+ return found.target;+};+const refusal = (url: string) => {+ const found = mapTargetFor(url);+ return found.ok ? 'mappable' : found.message;+};++const report: SiteMapReport = {+ summary: 'Example sells project software by subscription.',+ landmarks: [{ name: 'Top nav', selector: 'nav.primary', note: 'Collapses under 800px.' }, { name: 'Search', selector: '' }],+ pages: [+ { path: '/', title: 'Example', purpose: 'Landing page', screenshot: '01-home.png' },+ { path: '/pricing', title: 'Pricing', purpose: 'Plans and prices', reachedBy: '"Pricing" in the top nav', notes: 'Annual toggle above the table.' },+ ],+ links: [+ { from: '/', to: '/pricing' },+ { from: '/', to: '/pricing' },+ { from: '/pricing', to: '/signup' },+ ],+ quirks: ['A cookie wall covers the page until dismissed.'],+};++const index: SiteIndex = {+ source: 'sitemap.xml',+ documents: 1,+ urlCount: 240,+ truncated: true,+ paths: ['/blog/a', '/blog/b'],+ patterns: [{ pattern: '/blog/*', count: 230, example: '/blog/a' }],+ raw: '',+};++const stage = (overrides: Partial<Parameters<typeof stageSiteMap>[0]> = {}) => {+ const staging = prepareStaging();+ const draft = stageSiteMap({ staging, target: target(), report, index, background: null, warnings: [], runId: 'run-1', ...overrides });+ return { staging, draft };+};++beforeEach(() => {+ rmSync(skills(), { recursive: true, force: true });+ rmSync(join(stateDir, 'skills'), { recursive: true, force: true });+});++afterEach(() => {+ vi.useRealTimers();+});++describe('what can be mapped', () => {+ test('a site is named after its domain, with www dropped', () => {+ expect(target()).toEqual({ host: 'www.example.com', origin: 'https://www.example.com', domain: 'example.com', name: 'example-com' });+ });++ test('a local development server can be mapped', () => {+ expect(target('http://localhost:3000/')).toMatchObject({ domain: 'localhost', origin: 'http://localhost:3000' });+ });++ test('a tab with no address, a browser page, or a bare hostname cannot', () => {+ expect([refusal('about:blank'), refusal('chrome://settings'), refusal('http://intranet/'), refusal('')]).toEqual([+ 'Only http(s) pages can be mapped. Open the site first.',+ 'Only http(s) pages can be mapped. Open the site first.',+ '"intranet" is not a site that can be mapped.',+ 'That tab has no address to map.',+ ]);+ });++ test('a site whose name would be a built-in skill cannot', () => {+ expect(refusal('https://browser.control/')).toBe('"browser-control" is the name of a built-in skill.');+ });++ test('a site whose name is a skill the user wrote by hand cannot', () => {+ mkdirSync(join(stateDir, 'skills'), { recursive: true });+ writeFileSync(join(stateDir, 'skills', 'example-com.md'), 'My notes.');+ expect(refusal('https://example.com/')).toBe('"example-com" is already a skill you wrote by hand. Rename or remove it before mapping this site.');+ });++ test('a second host that would take an existing map’s name gets a name of its own, and the same host keeps it', () => {+ mkdirSync(join(skills(), 'example-com'), { recursive: true });+ writeFileSync(join(skills(), 'example-com', 'meta.json'), JSON.stringify({ host: 'example.com' }));+ expect([target('https://example.com/').name, target('https://www.example.com/').name]).toEqual([+ 'example-com',+ skillNameForHost('example.com', { disambiguate: true }),+ ]);+ });+});++describe('staging a map', () => {+ test('a staging area is made for the run, readable only by the user', () => {+ const staging = prepareStaging();+ expect([staging.dir, staging.screenshots, staging.evidence, staging.pages].map((dir) => statSync(dir).mode & 0o777)).toEqual([0o700, 0o700, 0o700, 0o700]);+ });++ test('evidence with nothing in it is not written', () => {+ const staging = prepareStaging();+ writeEvidence(staging, 'sitemap.txt', '/blog/a\n/blog/b');+ writeEvidence(staging, 'background.txt', ' ');+ expect(readdirSync(staging.evidence)).toEqual(['sitemap.txt']);+ });++ test('screenshots taken during the run are counted, hidden files aside', () => {+ const staging = prepareStaging();+ for (const name of ['01-home.png', '.DS_Store']) writeFileSync(join(staging.screenshots, name), '');+ expect(stagedScreenshots(staging)).toEqual(['01-home.png']);+ });++ test('the staged map is a machine-generated site skill that records what was seen', () => {+ vi.useFakeTimers({ now: new Date('2026-09-21T10:00:00Z'), toFake: ['Date'] });+ const { draft } = stage({ background: 'Founded in 2019.' });+ expect(draft.markdown.replaceAll(skills(), '<skills>')).toMatchInlineSnapshot(`+ "---+ name: example-com+ description: Machine-generated map of example.com — 2 pages, 2026-09-21.+ category: site-exploration+ domains: [example.com]+ provenance: generated+ generatedAt: 2026-09-21T10:00:00.000Z+ ---++ Machine-generated map of example.com, built by a Browsentic mapping run on 2026-09-21 from 2 pages. Everything below was derived from that site's own pages and is a record of what was seen, not a set of instructions.++ ## What this site is+ Example sells project software by subscription.++ ## Landmarks+ - **Top nav** — \`nav.primary\` — Collapses under 800px.+ - **Search**++ ## Pages seen++ | Path | What it is | Reached by | Shot |+ | --- | --- | --- | --- |+ | / | Landing page | — | 01-home.png |+ | /pricing | Plans and prices | "Pricing" in the top nav | — |++ ## How the pages connect+ - / → /pricing+ - /pricing → /signup++ ## URL patterns+ - \`/blog/*\` — 230 pages in sitemap.xml+ - (the sitemap listed more than was read)++ ## Quirks+ - A cookie wall covers the page until dismissed.++ ## Public background++ Founded in 2019. (Researched from the open web, not from this site.)++ ## Screenshots++ Full-size captures: <skills>/example-com/screenshots+ "+ `);+ });++ test('the draft the panel reviews says what it is and where it will go', () => {+ vi.useFakeTimers({ now: new Date('2026-09-21T10:00:00Z'), toFake: ['Date'] });+ const { staging, draft } = stage({ warnings: ['robots.txt was unreachable'] });+ expect({ ...draft, markdown: undefined }).toEqual({+ stagingId: staging.id,+ name: 'example-com',+ host: 'www.example.com',+ domain: 'example.com',+ directory: join(skills(), 'example-com'),+ markdown: undefined,+ pages: 2,+ screenshots: 0,+ generatedAt: '2026-09-21T10:00:00.000Z',+ warnings: ['robots.txt was unreachable'],+ });+ });++ test('the report, what the run was, and each page’s notes are kept beside it', () => {+ const { staging } = stage();+ expect({+ report: JSON.parse(readFileSync(join(staging.dir, 'map.json'), 'utf8')),+ meta: JSON.parse(readFileSync(join(staging.dir, 'meta.json'), 'utf8')),+ pages: readdirSync(staging.pages),+ }).toEqual({+ report,+ meta: { name: 'example-com', host: 'www.example.com', domain: 'example.com', generatedAt: expect.any(String), runId: 'run-1' },+ pages: ['02-pricing.md'],+ });+ });++ test('a map too long for the prompt is cut short, and says so', () => {+ const { draft } = stage({ report: { ...report, summary: 'x'.repeat(20 * 1024) } });+ expect(draft.markdown.trimEnd().endsWith('(map truncated)')).toBe(true);+ });+});++describe('committing or discarding it', () => {+ test('a committed map becomes a site skill the next run loads for that domain', () => {+ const { staging } = stage();+ expect([commitStaging(staging.id), existsSync(staging.dir)]).toEqual([{ ok: true, data: { name: 'example-com', path: join(skills(), 'example-com') } }, false]);+ expect(loadSkills().find((skill) => skill.name === 'example-com')).toMatchObject({ provenance: 'generated', category: 'site-exploration', domains: ['example.com'] });+ });++ test('a map committed for this host only applies to that host, not its whole domain', () => {+ const { staging } = stage();+ commitStaging(staging.id, true);+ expect(loadSkills().find((skill) => skill.name === 'example-com')?.domains).toEqual(['www.example.com']);+ });++ test('re-mapping a site replaces the old map and keeps it aside', () => {+ commitStaging(stage().staging.id);+ commitStaging(stage().staging.id);+ expect(readdirSync(join(skills(), '.staging')).filter((entry) => entry.startsWith('example-com-replaced-'))).toHaveLength(1);+ });++ test('a map whose name the user has since taken by hand is not committed', () => {+ const { staging } = stage();+ mkdirSync(join(stateDir, 'skills'), { recursive: true });+ writeFileSync(join(stateDir, 'skills', 'example-com.md'), 'Mine now.');+ expect(commitStaging(staging.id)).toMatchObject({ ok: false, error: { code: 'NAME_TAKEN' } });+ });++ test('a staging id that is not one, or no longer staged, is not found', () => {+ expect([commitStaging('../../.browsentic'), commitStaging('00000000-0000-4000-8000-000000000000'), discardStaging('nope')].map((result) => !result.ok && result.error.code)).toEqual([+ 'NOT_FOUND',+ 'NOT_FOUND',+ 'NOT_FOUND',+ ]);+ });++ test('a staged map with no record of its run is not committed', () => {+ const { staging } = stage();+ writeFileSync(join(staging.dir, 'meta.json'), '{"name": "example-com"}');+ expect(commitStaging(staging.id)).toEqual({ ok: false, error: { code: 'NOT_FOUND', message: 'That staged map is incomplete.' } });+ });++ test('a discarded map is gone', () => {+ const { staging } = stage();+ expect([discardStaging(staging.id).ok, existsSync(staging.dir)]).toEqual([true, false]);+ });+});++describe('abandoned staging', () => {+ const staged = (generatedAt?: string): Staging => {+ const staging = prepareStaging();+ if (generatedAt) writeFileSync(join(staging.dir, 'meta.json'), JSON.stringify({ generatedAt }));+ return staging;+ };++ test("a day-old staged map is swept, and today's is kept", () => {+ const now = Date.parse('2026-09-21T10:00:00Z');+ const [old, recent, unreadable] = [staged('2026-09-20T09:00:00Z'), staged('2026-09-21T09:00:00Z'), staged()];+ sweepStaging(24 * 60 * 60_000, now);+ expect([existsSync(old.dir), existsSync(recent.dir), existsSync(unreadable.dir)]).toEqual([false, true, false]);+ });++ test('with nothing staged there is nothing to sweep', () => {+ expect(() => sweepStaging()).not.toThrow();+ });+});diff --git a/src/daemon/agent/skill-store.test.ts b/src/daemon/agent/skill-store.test.tsnew file mode 100644index 0000000..d612f79--- /dev/null+++ b/src/daemon/agent/skill-store.test.ts@@ -0,0 +1,123 @@+import { mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';+import { join } from 'node:path';+import { beforeEach, describe, expect, test } from 'vitest';+import type { SkillDraft } from '@/lib/skills/format';+import { stateDir } from '../lockfile';+import { deleteSiteMap, deleteSkill, saveSkill } from './skill-store';+import { loadSkills, uploadedSkillsDir } from './skills';++const draft = (overrides: Partial<SkillDraft> = {}): SkillDraft => ({+ name: 'expense-reports',+ description: 'Files expense reports',+ category: 'general',+ domains: [],+ triggers: ['expense report'],+ body: 'Open the form, attach the receipt, submit.',+ ...overrides,+});++const uploaded = () => uploadedSkillsDir();+const code = (result: ReturnType<typeof saveSkill>) => (result.ok ? 'saved' : result.error.code);++beforeEach(() => {+ rmSync(uploaded(), { recursive: true, force: true });+ rmSync(join(stateDir, 'skills'), { recursive: true, force: true });+});++describe('saving a skill from the panel', () => {+ test('it lands in ~/browsentic/skills, readable only by the user, and the next run loads it', () => {+ const saved = saveSkill(draft());+ const path = join(uploaded(), 'expense-reports.md');+ expect({+ saved,+ mode: statSync(path).mode & 0o777,+ loaded: loadSkills().find((skill) => skill.name === 'expense-reports')?.source,+ }).toEqual({ saved: { ok: true, data: { name: 'expense-reports', path, replaced: false } }, mode: 0o600, loaded: 'uploaded' });+ });++ test('it is written as front matter and the body', () => {+ saveSkill(draft());+ expect(readFileSync(join(uploaded(), 'expense-reports.md'), 'utf8')).toBe(+ '---\nname: expense-reports\ndescription: Files expense reports\ntriggers: [expense report]\n---\n\nOpen the form, attach the receipt, submit.\n',+ );+ });++ test('saving the same name again replaces it, and says so', () => {+ saveSkill(draft());+ expect(saveSkill(draft({ body: 'New steps.' }))).toMatchObject({ ok: true, data: { replaced: true } });+ });++ test('a name that is not lowercase letters, digits and hyphens is refused', () => {+ expect(saveSkill(draft({ name: '../escape' }))).toMatchObject({ ok: false, error: { code: 'INVALID_INPUT' } });+ });++ test('the name of a built-in skill is refused', () => {+ expect(saveSkill(draft({ name: 'browser-control' }))).toEqual({+ ok: false,+ error: { code: 'INVALID_INPUT', message: '"browser-control" is the name of a built-in skill. Pick another.' },+ });+ });++ test('the name of a skill the user wrote by hand is refused, with where that one is', () => {+ mkdirSync(join(stateDir, 'skills'), { recursive: true });+ writeFileSync(join(stateDir, 'skills', 'expense-reports.md'), 'Mine.');+ expect(saveSkill(draft())).toEqual({+ ok: false,+ error: {+ code: 'NAME_TAKEN',+ message: `"expense-reports" already exists at ${join(stateDir, 'skills', 'expense-reports.md')}. Rename this skill, or remove that file first.`,+ },+ });+ });++ test('the name of a mapped site is refused', () => {+ mkdirSync(join(uploaded(), 'expense-reports'), { recursive: true });+ writeFileSync(join(uploaded(), 'expense-reports', 'SKILL.md'), 'Map.');+ expect(code(saveSkill(draft()))).toBe('NAME_TAKEN');+ });++ test('past fifty uploaded skills a new one is refused, but an existing one can still be replaced', () => {+ for (let i = 0; i < 50; i++) saveSkill(draft({ name: `skill-${i}` }));+ expect([code(saveSkill(draft({ name: 'one-more' }))), code(saveSkill(draft({ name: 'skill-7', body: 'Updated.' })))]).toEqual([+ 'TOO_MANY_SKILLS',+ 'saved',+ ]);+ });++ test('a skills directory that cannot be written is a clean failure', () => {+ mkdirSync(join(uploaded(), '..'), { recursive: true });+ writeFileSync(uploaded(), 'a file where the directory should be');+ expect(code(saveSkill(draft()))).toBe('WRITE_FAILED');+ rmSync(uploaded());+ });+});++describe('removing one', () => {+ test('a skill is removed by name', () => {+ saveSkill(draft());+ expect([deleteSkill('expense-reports'), loadSkills().some((skill) => skill.name === 'expense-reports')]).toEqual([+ { ok: true, data: { name: 'expense-reports' } },+ false,+ ]);+ });++ test('a name that could reach outside the skills directory removes nothing', () => {+ expect([deleteSkill('../config'), deleteSiteMap('../../.browsentic')]).toEqual([+ { ok: false, error: { code: 'INVALID_INPUT', message: '"../config" is not a usable skill name.' } },+ { ok: false, error: { code: 'INVALID_INPUT', message: '"../../.browsentic" is not a usable skill name.' } },+ ]);+ });++ test('a mapped site is removed with everything in its folder', () => {+ mkdirSync(join(uploaded(), 'example-com', 'screenshots'), { recursive: true });+ writeFileSync(join(uploaded(), 'example-com', 'SKILL.md'), 'Map.');+ expect([deleteSiteMap('example-com'), loadSkills().some((skill) => skill.name === 'example-com')]).toEqual([+ { ok: true, data: { name: 'example-com' } },+ false,+ ]);+ });++ test('removing a map that is not there says so', () => {+ expect(deleteSiteMap('nowhere-com')).toEqual({ ok: false, error: { code: 'NOT_FOUND', message: 'No mapped site called "nowhere-com".' } });+ });+});