@vellumai/assistant 0.3.4 → 0.3.6

package/src/config/bundled-skills/google-oauth-setup/SKILL.md

@@ -0,0 +1,183 @@
+---
+name: "Google OAuth Setup"
+description: "Set up Google Cloud OAuth credentials for Gmail and Calendar using browser automation"
+user-invocable: true
+includes: ["browser", "public-ingress"]
+metadata: {"vellum": {"emoji": "\ud83d\udd11"}}
+---
+
+You are helping your user set up Google Cloud OAuth credentials so Gmail and Google Calendar integrations can connect. You will automate the entire GCP setup via the browser while the user watches via screencast. The user's only manual action is signing in to their Google account — everything else is fully automated.
+
+## Client Check
+
+If the user is on Telegram (or any non-macOS client without browser automation):
+
+> "Gmail setup requires browser automation, which is available on the macOS app. Please open the Vellum app on your Mac and ask me to connect Gmail there — I'll handle the rest automatically."
+
+Stop here. Do not attempt a manual walkthrough.
+
+## Prerequisites
+
+Before starting, check that `ingress.publicBaseUrl` is configured (`INGRESS_PUBLIC_BASE_URL` env var or workspace config). If it is not set, load and execute the **public-ingress** skill first (`skill_load` with `skill: "public-ingress"`) to set up an ngrok tunnel and persist the public URL. The OAuth redirect URI depends on this value.
+
+## Step 1: Single Upfront Confirmation
+
+Use `ui_show` with `surface_type: "confirmation"` and this message:
+
+> **Set up Google Cloud for Gmail & Calendar**
+>
+> Here's what will happen:
+> 1. **A browser opens** — you sign in to your Google account
+> 2. **I automate everything** — project creation, APIs, OAuth config, credentials
+> 3. **You enter credentials** from a downloaded file (secure prompt — I never see them)
+> 4. **You authorize Vellum** with one click
+>
+> The whole thing takes 2-3 minutes. Ready?
+
+If the user declines, acknowledge and stop. No further confirmations are needed after this point.
+
+## Step 2: Open Google Cloud Console
+
+Use `browser_navigate` to go to `https://console.cloud.google.com/`.
+
+Take a `browser_screenshot` and `browser_snapshot` to check the page state:
+- **If a sign-in page appears:** Tell the user: "Please sign in to your Google account in the browser preview panel (or the Chrome window that just opened)." Then **auto-detect sign-in completion** by polling `browser_snapshot` every 5-10 seconds. Check if the current URL has moved away from `accounts.google.com` to `console.cloud.google.com`. Do NOT ask the user to "let me know when you're done" — detect it automatically. Once sign-in is detected, tell the user: "Signed in! Starting the automated setup now..."
+- **If already signed in** (URL is already `console.cloud.google.com`): Tell the user: "Already signed in — starting setup now..." and continue immediately.
+- **If a CAPTCHA appears:** The browser automation's built-in handoff will handle this. If it persists, tell the user: "There's a CAPTCHA in the browser — please complete it and I'll continue automatically."
+- **If the console dashboard loads:** Continue to Step 3.
+
+## Step 3: Create or Select a Project
+
+Tell the user: "Creating Google Cloud project 'Vellum Assistant'..."
+
+Navigate to `https://console.cloud.google.com/projectcreate`.
+
+Take a `browser_snapshot`. Fill in the project name:
+- Use `browser_type` to set the project name to "Vellum Assistant"
+- Use `browser_click` to submit the "Create" button
+
+Wait a few seconds, take a `browser_screenshot` and `browser_snapshot` to confirm. If the project already exists, navigate to its dashboard. Note the project ID for subsequent steps.
+
+Tell the user: "Project created!"
+
+## Step 4: Enable Gmail and Calendar APIs
+
+Tell the user: "Enabling Gmail and Calendar APIs..."
+
+Navigate to `https://console.cloud.google.com/apis/library/gmail.googleapis.com?project=PROJECT_ID` (substitute actual project ID).
+
+Take a `browser_snapshot`:
+- If already enabled (shows "API enabled" or "Manage" button): skip.
+- If not: click the "Enable" button and wait.
+
+Then navigate to `https://console.cloud.google.com/apis/library/calendar-json.googleapis.com?project=PROJECT_ID`.
+
+Same check — enable if needed.
+
+Take a `browser_screenshot` to show result. Tell the user: "APIs enabled!"
+
+## Step 5: Configure OAuth Consent Screen
+
+Tell the user: "Configuring OAuth consent screen — this is the longest step, but it's fully automated..."
+
+Navigate to `https://console.cloud.google.com/apis/credentials/consent?project=PROJECT_ID`.
+
+Take a `browser_snapshot`:
+- If consent screen is already configured: skip to Step 6.
+- If user type selection appears: select "External" and click "Create".
+
+Fill in the consent screen form:
+1. **App name:** "Vellum Assistant"
+2. **User support email:** Select the user's email from the dropdown
+3. **Developer contact email:** Type the user's email address
+4. Leave other fields as defaults
+
+Navigate through the wizard pages:
+- App information page: Fill fields, click "Save and Continue"
+- Scopes page: Click "Add or Remove Scopes", search for and select:
+  - `https://www.googleapis.com/auth/gmail.readonly`
+  - `https://www.googleapis.com/auth/gmail.modify`
+  - `https://www.googleapis.com/auth/gmail.send`
+  - `https://www.googleapis.com/auth/calendar.readonly`
+  - `https://www.googleapis.com/auth/calendar.events`
+  - `https://www.googleapis.com/auth/userinfo.email`
+  - Click "Update" then "Save and Continue"
+- Test users page: Add the user's email as a test user, click "Save and Continue"
+- Summary page: Click "Back to Dashboard"
+
+Tell the user: "Consent screen configured!"
+
+## Step 6: Create OAuth Credentials
+
+Tell the user: "Creating OAuth credentials..."
+
+Navigate to `https://console.cloud.google.com/apis/credentials?project=PROJECT_ID`.
+
+Click "+ Create Credentials" then select "OAuth client ID".
+
+Take a `browser_snapshot` and fill in:
+1. **Application type:** Select "Web application"
+2. **Name:** "Vellum Assistant"
+3. **Authorized redirect URIs:** Click "Add URI" and enter `${ingress.publicBaseUrl}/webhooks/oauth/callback`
+
+Click "Create".
+
+## Step 7: Download Credentials JSON
+
+Tell the user: "Almost done — downloading credentials..."
+
+After the credentials dialog appears, click the "Download JSON" button (it may say "DOWNLOAD JSON" or show a download icon).
+
+Use `browser_wait_for_download` to wait for the file to download.
+
+Tell the user: "Credentials downloaded!"
+
+## Step 8: Secure Credential Entry
+
+Tell the user: "I've downloaded the credentials file. Please open it and enter the values below. I won't see what you type — these go directly to secure storage."
+
+```
+credential_store prompt:
+  service: "integration:gmail"
+  field: "client_id"
+  label: "Google OAuth Client ID"
+  description: "Open the downloaded JSON file and copy the client_id value"
+  placeholder: "123456789.apps.googleusercontent.com"
+```
+
+```
+credential_store prompt:
+  service: "integration:gmail"
+  field: "client_secret"
+  label: "Google OAuth Client Secret"
+  description: "Copy the client_secret value from the same JSON file"
+  placeholder: "GOCSPX-..."
+```
+
+## Step 9: OAuth2 Authorization
+
+Tell the user: "Opening Google sign-in so you can authorize Vellum. Just click 'Allow' on the consent page."
+
+Use `credential_store` with:
+
+```
+action: "oauth2_connect"
+service: "integration:gmail"
+```
+
+This auto-reads client_id/client_secret from the secure store and auto-fills auth_url, token_url, scopes, and extra_params from well-known config.
+
+**If the user sees a "This app isn't verified" warning:** Tell them this is normal for apps in testing mode. Click "Advanced" then "Go to Vellum Assistant (unsafe)" to proceed.
+
+## Step 10: Done!
+
+"**Gmail and Calendar are connected!** You can now read, search, and send emails, plus view and manage your calendar. Try asking me to check your inbox or show your upcoming events!"
+
+## Error Handling
+
+- **Page load failures:** Retry navigation once. If it still fails, tell the user and ask them to check their internet connection.
+- **Permission errors in GCP:** The user may need billing enabled or organization-level permissions. Explain clearly and ask them to resolve it.
+- **Consent screen already configured:** Don't overwrite — skip to credential creation.
+- **Element not found:** Take a fresh `browser_snapshot` to re-assess. GCP UI may have changed. Tell the user what you're looking for if stuck.
+- **OAuth flow timeout or failure:** Offer to retry. The credentials are already stored, so reconnecting only requires re-running the authorization flow.
+- **Any unexpected state:** Take a `browser_screenshot` and `browser_snapshot`, describe what you see, and ask the user for guidance.

package/src/config/bundled-skills/influencer/SKILL.md

@@ -0,0 +1,144 @@
+---
+name: "Influencer Research"
+description: "Research influencers on Instagram, TikTok, and X/Twitter using the Chrome extension relay"
+user-invocable: true
+metadata: {"vellum": {"emoji": "🔍"}}
+---
+
+You can research and discover influencers across Instagram, TikTok, and X/Twitter using the `vellum influencer` CLI.
+
+## CLI Setup
+
+**IMPORTANT: Always use `host_bash` (not `bash`) for all `vellum influencer` commands.** The influencer CLI needs host access for the Chrome extension relay and the `vellum` binary, neither of which are available inside the sandbox.
+
+`vellum influencer` is a built-in subcommand of the Vellum assistant CLI. If `vellum` is not found, prepend `PATH="$HOME/.local/bin:$PATH"` to the command.
+
+## Prerequisites
+
+- The Chrome extension relay must be connected (user should have the Vellum extension loaded in Chrome)
+- The user must be **logged in** on each platform they want to search (Instagram, TikTok, X) in their Chrome browser
+- The extension MUST have the `debugger` permission (required to bypass CSP on Instagram and other Meta sites)
+- If the relay is not connected, tell the user: "Please open Chrome, click the Vellum extension icon, and click Connect — then I'll retry."
+
+## Platform-Specific Architecture
+
+### Instagram
+Instagram's search at `/explore/search/keyword/?q=...` shows a **grid of posts**, NOT profiles. The discovery flow is:
+1. Search by keyword → extract post links (`/p/` and `/reel/`)
+2. Visit each post → find the author username from page links
+3. Deduplicate usernames
+4. Visit each unique profile → scrape stats from `meta[name="description"]` (most reliable source, format: "49K Followers, 463 Following, 551 Posts - Display Name (@user)")
+5. Filter and rank by criteria
+
+**CSP Note:** Instagram blocks `eval()`, `new Function()`, inline scripts, and blob URLs via strict CSP. The extension uses `chrome.debugger` API (CDP Runtime.evaluate) as a fallback, which bypasses all CSP restrictions.
+
+### TikTok
+TikTok has a dedicated user search at `/search/user?q=...`. Each result card produces a predictable text pattern in `innerText`:
+```
+DisplayName
+username
+77.9K
+Followers
+·
+1.5M
+Likes
+Follow
+```
+We parse this pattern directly (DOM class selectors are obfuscated and unreliable on TikTok). After extracting usernames and follower counts, we visit each profile for bios.
+
+### X/Twitter
+X has a people search at `/search?q=...&f=user` with `[data-testid="UserCell"]` components containing username, display name, bio, and verified status.
+
+## Typical Flow
+
+When the user asks to find or research influencers:
+
+1. **Understand the criteria.** Ask about:
+   - **Niche/topic** — what kind of influencers? (fitness, beauty, tech, food, etc.)
+   - **Platforms** — Instagram, TikTok, X/Twitter, or all three?
+   - **Follower range** — micro (1K-10K), mid-tier (10K-100K), macro (100K-1M), mega (1M+)?
+   - **Verified only?** — do they need the blue checkmark?
+   - Don't over-ask. If the user says "find me fitness influencers on Instagram", that's enough to start.
+
+2. **Search** — run `vellum influencer search "<query>" --platforms <platforms> [options] --json`
+
+3. **Present results** — show a clean summary of each influencer found:
+   - Username and display name
+   - Platform
+   - Follower count
+   - Bio snippet
+   - Verified status
+   - Content themes detected
+   - Profile URL
+
+4. **Deep dive** (if needed) — run `vellum influencer profile <username> --platform <platform> --json` to get detailed data on a specific influencer.
+
+5. **Compare** (if needed) — run `vellum influencer compare instagram:user1 twitter:user2 tiktok:user3 --json` to compare influencers side by side.
+
+## Follower Range Shortcuts
+
+When the user describes influencer tiers, map to these ranges:
+- **Nano**: `--min-followers 1000 --max-followers 10000`
+- **Micro**: `--min-followers 10000 --max-followers 100000`
+- **Mid-tier**: `--min-followers 100000 --max-followers 500000`
+- **Macro**: `--min-followers 500000 --max-followers 1000000`
+- **Mega**: `--min-followers 1000000`
+
+Human-friendly numbers are supported: `10k`, `100k`, `1m`, etc.
+
+## Command Reference
+
+```
+vellum influencer search "<query>" [options] --json
+  --platforms <list>       Comma-separated: instagram,tiktok,twitter (default: all three)
+  --min-followers <n>      Minimum follower count (e.g. 10k, 100000)
+  --max-followers <n>      Maximum follower count (e.g. 1m, 500k)
+  --limit <n>              Max results per platform (default: 10)
+  --verified               Only return verified accounts
+
+vellum influencer profile <username> --platform <platform> --json
+  --platform <platform>    instagram, tiktok, or twitter (default: instagram)
+
+vellum influencer compare <platform:username ...> --json
+  Arguments are space-separated platform:username pairs
+  e.g. instagram:nike twitter:nike tiktok:nike
+```
+
+## Important Behavior
+
+- **Use `--json` flag** on all commands for reliable parsing.
+- **Always use `host_bash`** for these commands, never `bash`.
+- **Be patient with results.** The tool navigates actual browser tabs, so each platform search takes 10-30 seconds. Warn the user it may take a moment.
+- **Rate limiting.** Don't hammer the platforms. The tool has built-in delays, but avoid running many searches in rapid succession.
+- **Present results nicely.** Use tables or formatted lists. Group by platform. Highlight standout profiles.
+- **Offer next steps.** After showing results, ask if they want to:
+  - Get more details on specific profiles
+  - Compare top picks side by side
+  - Search with different criteria
+  - Export the results
+- **Handle errors gracefully.** If a platform fails (e.g. not logged in), show results from the platforms that worked and mention which one failed.
+- **Do NOT use the browser skill.** All influencer research goes through the CLI, not browser automation.
+
+## Example Interactions
+
+**User**: "Find me fitness influencers on Instagram and TikTok"
+
+1. `vellum influencer search "fitness coach workout" --platforms instagram,tiktok --limit 10 --json`
+2. Present results grouped by platform with follower counts and bios
+3. "I found 8 fitness influencers on Instagram and 6 on TikTok. Want me to dig deeper into any of these profiles?"
+
+**User**: "I need micro-influencers in the beauty niche, verified only"
+
+1. `vellum influencer search "beauty makeup skincare" --platforms instagram,tiktok,twitter --min-followers 10k --max-followers 100k --verified --limit 10 --json`
+2. Present filtered results
+3. Offer to compare top picks
+
+**User**: "Compare @username1 on Instagram with @username2 on TikTok"
+
+1. `vellum influencer compare instagram:username1 tiktok:username2 --json`
+2. Present side-by-side comparison with followers, engagement, bio, themes
+
+**User**: "Tell me more about @specificuser on Instagram"
+
+1. `vellum influencer profile specificuser --platform instagram --json`
+2. Show full profile details including bio, follower/following counts, verified status, content themes

package/src/config/bundled-skills/knowledge-graph/SKILL.md

@@ -0,0 +1,15 @@
+# Knowledge Graph
+
+Query the entity knowledge graph to explore relationships between people, projects, tools, and other entities tracked in memory.
+
+## When to use
+
+- When the user asks about relationships between entities ("what tools does project X use?", "who works on project Y?")
+- When the user wants to explore connected entities across the knowledge graph
+- When automatic memory recall doesn't surface the right relationship-based information
+
+## Capabilities
+
+- **Neighbors**: Find entities directly connected to seed entities (optionally filtered by relation and entity type)
+- **Typed traversal**: Multi-step traversal with type constraints at each step (e.g., "me -> works_on -> projects -> uses -> tools")
+- **Intersection**: Find entities reachable from ALL given seeds (e.g., "projects both Alice and Bob work on")

package/src/config/bundled-skills/knowledge-graph/TOOLS.json

@@ -0,0 +1,56 @@
+{
+  "version": 1,
+  "tools": [
+    {
+      "name": "knowledge_graph_query",
+      "description": "Query the entity knowledge graph to find related entities and their associated memory items. Supports three query types: 'neighbors' (direct connections), 'typed_traversal' (multi-step with type filters), and 'intersection' (entities reachable from ALL seeds).",
+      "category": "memory",
+      "risk": "low",
+      "input_schema": {
+        "type": "object",
+        "properties": {
+          "query_type": {
+            "type": "string",
+            "enum": ["neighbors", "typed_traversal", "intersection"],
+            "description": "Type of graph query to execute"
+          },
+          "seeds": {
+            "type": "array",
+            "items": { "type": "string" },
+            "description": "Entity names or aliases to use as starting points"
+          },
+          "steps": {
+            "type": "array",
+            "items": {
+              "type": "object",
+              "properties": {
+                "relation_types": {
+                  "type": "array",
+                  "items": { "type": "string" },
+                  "description": "Relation types to follow (e.g., 'uses', 'works_on', 'depends_on')"
+                },
+                "entity_types": {
+                  "type": "array",
+                  "items": { "type": "string" },
+                  "description": "Entity types to include (e.g., 'person', 'project', 'tool')"
+                }
+              }
+            },
+            "description": "Traversal steps for typed_traversal and intersection queries. Each step defines type filters for one hop."
+          },
+          "max_results": {
+            "type": "number",
+            "description": "Maximum number of entities to return (default: 20)"
+          },
+          "include_items": {
+            "type": "boolean",
+            "description": "Include associated memory items for each found entity (default: true)"
+          }
+        },
+        "required": ["query_type", "seeds"]
+      },
+      "executor": "tools/graph-query.ts",
+      "execution_target": "host"
+    }
+  ]
+}

package/src/config/bundled-skills/knowledge-graph/tools/graph-query.ts

@@ -0,0 +1,185 @@
+import { initializeDb, getDb } from '../../../../memory/db.js';
+import { findMatchedEntities, findNeighborEntities, getEntityLinkedItemCandidates, collectTypedNeighbors } from '../../../../memory/search/entity.js';
+import { memoryEntities } from '../../../../memory/schema.js';
+import { inArray } from 'drizzle-orm';
+import type { TraversalStep } from '../../../../memory/search/types.js';
+import type { EntityRelationType, EntityType } from '../../../../memory/entity-extractor.js';
+import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
+
+interface GraphQueryInput {
+  query_type: 'neighbors' | 'typed_traversal' | 'intersection';
+  seeds: string[];
+  steps?: Array<{
+    relation_types?: string[];
+    entity_types?: string[];
+  }>;
+  max_results?: number;
+  include_items?: boolean;
+}
+
+interface EntityResult {
+  id: string;
+  name: string;
+  type: string;
+  aliases: string[];
+  items?: Array<{ subject: string; statement: string }>;
+}
+
+export async function run(
+  input: Record<string, unknown>,
+  _context: ToolContext,
+): Promise<ToolExecutionResult> {
+  const params = input as unknown as GraphQueryInput;
+
+  initializeDb();
+
+  const maxResults = params.max_results ?? 20;
+  const includeItems = params.include_items ?? true;
+
+  // Resolve seed entity names to IDs
+  const seedEntityIds: string[] = [];
+  const resolvedSeeds: Array<{ name: string; id: string }> = [];
+  for (const seedName of params.seeds) {
+    const matched = findMatchedEntities(seedName, 5);
+    if (matched.length > 0) {
+      seedEntityIds.push(matched[0].id);
+      resolvedSeeds.push({ name: seedName, id: matched[0].id });
+    }
+  }
+
+  if (seedEntityIds.length === 0) {
+    return {
+      content: JSON.stringify({
+        error: 'No matching entities found for the provided seed names',
+        seeds: params.seeds,
+      }),
+      isError: true,
+    };
+  }
+
+  // For intersection queries, all seeds must resolve — dropping any seed silently
+  // changes semantics from "reachable from ALL seeds" to "reachable from resolved seeds"
+  if (params.query_type === 'intersection' && seedEntityIds.length < params.seeds.length) {
+    const unresolvedSeeds = params.seeds.filter(
+      name => !resolvedSeeds.some(s => s.name === name),
+    );
+    return {
+      content: JSON.stringify({
+        error: 'Some seed entities could not be resolved. Intersection requires all seeds to match.',
+        unresolved_seeds: unresolvedSeeds,
+        resolved_seeds: resolvedSeeds,
+      }),
+      isError: true,
+    };
+  }
+
+  let resultEntityIds: string[];
+
+  switch (params.query_type) {
+    case 'neighbors': {
+      const steps = params.steps?.[0];
+      const result = findNeighborEntities(seedEntityIds, {
+        maxEdges: 40,
+        maxNeighborEntities: maxResults,
+        maxDepth: 1,
+        relationTypes: steps?.relation_types as EntityRelationType[] | undefined,
+        entityTypes: steps?.entity_types as EntityType[] | undefined,
+      });
+      resultEntityIds = result.neighborEntityIds;
+      break;
+    }
+
+    case 'typed_traversal': {
+      const traversalSteps: TraversalStep[] = (params.steps ?? []).map(s => ({
+        relationTypes: s.relation_types as EntityRelationType[] | undefined,
+        entityTypes: s.entity_types as EntityType[] | undefined,
+      }));
+      resultEntityIds = collectTypedNeighbors(seedEntityIds, traversalSteps, {
+        maxResultsPerStep: maxResults,
+        maxEdgesPerStep: 40,
+      });
+      break;
+    }
+
+    case 'intersection': {
+      // Run typed traversal from each seed independently, then intersect
+      const traversalSteps: TraversalStep[] = (params.steps ?? []).map(s => ({
+        relationTypes: s.relation_types as EntityRelationType[] | undefined,
+        entityTypes: s.entity_types as EntityType[] | undefined,
+      }));
+
+      const resultSets: Set<string>[] = [];
+      for (const seedId of seedEntityIds) {
+        const result = collectTypedNeighbors([seedId], traversalSteps, {
+          maxResultsPerStep: maxResults,
+          maxEdgesPerStep: 40,
+        });
+        resultSets.push(new Set(result));
+      }
+
+      if (resultSets.length === 0) {
+        resultEntityIds = [];
+      } else {
+        // Intersect all sets
+        const intersection = [...resultSets[0]].filter(id =>
+          resultSets.every(set => set.has(id))
+        );
+        resultEntityIds = intersection;
+      }
+      break;
+    }
+
+    default:
+      return {
+        content: JSON.stringify({ error: `Unknown query_type: ${params.query_type}` }),
+        isError: true,
+      };
+  }
+
+  // Look up entity details
+  const db = getDb();
+  const entities: EntityResult[] = [];
+
+  if (resultEntityIds.length > 0) {
+    const entityRows = db
+      .select()
+      .from(memoryEntities)
+      .where(inArray(memoryEntities.id, resultEntityIds.slice(0, maxResults)))
+      .all();
+
+    for (const row of entityRows) {
+      const entity: EntityResult = {
+        id: row.id,
+        name: row.name,
+        type: row.type,
+        aliases: row.aliases ? JSON.parse(row.aliases) as string[] : [],
+      };
+
+      if (includeItems) {
+        const candidates = getEntityLinkedItemCandidates([row.id], {
+          source: 'entity_direct',
+          scopeIds: _context.memoryScopeId ? [_context.memoryScopeId] : undefined,
+        });
+        entity.items = candidates.slice(0, 5).map(c => {
+          const parts = c.text.split(': ');
+          return {
+            subject: parts[0] ?? '',
+            statement: parts.slice(1).join(': ') || c.text,
+          };
+        });
+      }
+
+      entities.push(entity);
+    }
+  }
+
+  return {
+    content: JSON.stringify({
+      query_type: params.query_type,
+      resolved_seeds: resolvedSeeds,
+      result_count: entities.length,
+      entities,
+    }, null, 2),
+    isError: false,
+  };
+}

package/src/config/bundled-skills/macos-automation/icon.svg

@@ -0,0 +1,12 @@
+<svg viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg">
+<rect x="2" y="2" width="12" height="11" fill="#e8e8e8" stroke="#333" stroke-width="1"/>
+<rect x="3" y="3" width="10" height="9" fill="#f5f5f5"/>
+<circle cx="8" cy="7" r="2" fill="#0071e3"/>
+<rect x="5" y="5" width="1" height="1" fill="#333"/>
+<rect x="10" y="5" width="1" height="1" fill="#333"/>
+<rect x="5" y="9" width="1" height="1" fill="#333"/>
+<rect x="10" y="9" width="1" height="1" fill="#333"/>
+<path d="M 8 4 L 8 6 M 6 7 L 8 7 M 8 8 L 8 10 M 8 7 L 10 7" stroke="#0071e3" stroke-width="1" fill="none"/>
+<rect x="3" y="13" width="10" height="1" fill="#333"/>
+<rect x="4" y="14" width="8" height="1" fill="#0071e3"/>
+</svg>