Skip to content

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.

feat(icons): redesign the mark as browser, voice, and link

Shahriarf23833b4a322
diff --git a/scripts/generate-icons.mjs b/scripts/generate-icons.mjs
index 1baf8f1..ecbb03f 100644
--- a/scripts/generate-icons.mjs
+++ b/scripts/generate-icons.mjs
@@ -1,5 +1,9 @@
-// Generates placeholder extension icons (violet gradient + white sound bars)
-// as raw PNGs with no image dependencies. Run: npm run icons
+// Generates the extension icons as raw PNGs with no image dependencies. Run: yarn icons
+//
+// The mark is the product in three parts: the tile itself is the *browser* (a lighter chrome
+// strip across the top with tab dots), the waveform below it is *voice*, and the two
+// interlocking rings threaded through the waveform are the *link*. Detail is dropped as the
+// canvas shrinks — see DETAIL below — because a 16px toolbar icon cannot hold three glyphs.
import { deflateSync } from 'node:zlib';
import { mkdirSync, writeFileSync } from 'node:fs';
import { dirname, join } from 'node:path';
@@ -58,11 +62,42 @@ const clamp = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
const lerp = (a, b, t) => a + (b - a) * t;
const VIOLET = [139, 92, 246];
const INDIGO = [79, 70, 229];
-const BARS = [
- { x: 0.3, h: 0.28 },
- { x: 0.5, h: 0.5 },
- { x: 0.7, h: 0.28 },
+
+// Every measurement is a fraction of the icon's edge, so one layout drives all five sizes.
+const CORNER = 0.22;
+const STRIP_H = 0.26; // browser chrome: a lighter band across the top of the tile
+const DOTS = { y: 0.135, r: 0.036, x: [0.135, 0.225, 0.315] };
+const CENTER_Y = 0.62; // middle of the content area below the strip
+// `half` is half the bar's total height, caps included.
+const BARS_FULL = [
+ { x: 0.215, half: 0.07 },
+ { x: 0.3, half: 0.14 },
+ { x: 0.7, half: 0.14 },
+ { x: 0.785, half: 0.07 },
+];
+const BARS_PLAIN = [
+ { x: 0.32, half: 0.1 },
+ { x: 0.5, half: 0.19 },
+ { x: 0.68, half: 0.1 },
];
+// Two rings on the 45° diagonal — the orientation every link glyph uses. Side by side they
+// read as the letters "CO" instead; tilting them is what makes the pair say "chain". `off`
+// is each centre's distance from the middle along that diagonal, at 0.79×r so the strokes
+// cross: closer and the holes merge, further and it is two loose circles.
+const CHAIN = { off: 0.059, r: 0.075, halfW: 0.021 };
+
+// Below 48px the rings close up into a blob and the dots land on half a pixel, so both drop
+// out and the waveform widens to carry the icon alone. 16px keeps only the strip and bars.
+function detailFor(size) {
+ return { rings: size >= 48, dots: size >= 32, barHalfW: size >= 48 ? 0.026 : 0.06 };
+}
+
+// At 16 and 32 a bar is one or two pixels wide, and a fractional centre splits it across two
+// columns at half coverage each — the bar washes out into the gradient instead of reading as
+// white. Snapping edges to the pixel grid is what keeps the toolbar icon crisp; the larger
+// sizes have the resolution to anti-alias smoothly and are left alone.
+const snapEdge = (v, on) => (on ? Math.round(v) : v);
+const snapMid = (v, on) => (on ? Math.floor(v) + 0.5 : v);
function distToVSegment(px, py, x, y1, y2) {
const cy = clamp(py, y1, y2);
@@ -70,8 +105,23 @@ function distToVSegment(px, py, x, y1, y2) {
}
function makePixelFn(size) {
- const corner = size * 0.22;
- const barHalfW = size * 0.055;
+ const { rings, dots, barHalfW: barHalfWFrac } = detailFor(size);
+ const snap = !rings;
+ const corner = size * CORNER;
+ const barHalfW = snap ? Math.max(1, Math.round(size * barHalfWFrac)) : size * barHalfWFrac;
+ const bars = rings ? BARS_FULL : BARS_PLAIN;
+ const cy = snapEdge(size * CENTER_Y, snap);
+ const stripY = snapEdge(size * STRIP_H, snap);
+ const ringR = size * CHAIN.r;
+ const ringHalfW = size * CHAIN.halfW;
+ // The break that makes one ring read as passing behind the other; never below a pixel.
+ const ringGap = Math.max(1, size * 0.014);
+ const ringOff = (size * CHAIN.off) / Math.SQRT2; // 45°, so the same offset on both axes
+ const backX = size * 0.5 - ringOff;
+ const backY = cy + ringOff;
+ const frontX = size * 0.5 + ringOff;
+ const frontY = cy - ringOff;
+
return (ix, iy) => {
const x = ix + 0.5;
const y = iy + 0.5;
@@ -86,15 +136,44 @@ function makePixelFn(size) {
let g = lerp(VIOLET[1], INDIGO[1], t);
let b = lerp(VIOLET[2], INDIGO[2], t);
- let barCov = 0;
- for (const bar of BARS) {
- const halfH = Math.max((bar.h * size) / 2 - barHalfW, 0);
- const d = distToVSegment(x, y, bar.x * size, size / 2 - halfH, size / 2 + halfH);
- barCov = Math.max(barCov, clamp(barHalfW + 0.5 - d, 0, 1));
+ // Browser: the chrome strip, then the tab dots once they have pixels to land on.
+ let white = 0.18 * clamp(stripY + 0.5 - y, 0, 1);
+ if (dots) {
+ const dotR = snap ? Math.max(1, Math.round(DOTS.r * size)) : DOTS.r * size;
+ const dotY = snapMid(DOTS.y * size, snap);
+ for (const dotX of DOTS.x) {
+ const d = Math.hypot(x - snapMid(dotX * size, snap), y - dotY);
+ white = Math.max(white, 0.75 * clamp(dotR + 0.5 - d, 0, 1));
+ }
}
- r = lerp(r, 255, barCov);
- g = lerp(g, 255, barCov);
- b = lerp(b, 255, barCov);
+
+ // Voice: the waveform.
+ let ink = 0;
+ for (const bar of bars) {
+ const halfH = Math.max(snapEdge(bar.half * size, snap) - barHalfW, 0);
+ const d = distToVSegment(x, y, snapEdge(bar.x * size, snap), cy - halfH, cy + halfH);
+ ink = Math.max(ink, clamp(barHalfW + 0.5 - d, 0, 1));
+ }
+
+ // Link: two rings threaded through the waveform. The back one is hidden by the whole
+ // front disc, not just where the strokes cross — clip only at the stroke and its far arc
+ // still shows through the front ring's hole, which reads as a smudge rather than a chain.
+ if (rings) {
+ const toFront = Math.hypot(x - frontX, y - frontY);
+ const back = Math.abs(Math.hypot(x - backX, y - backY) - ringR);
+ const front = Math.abs(toFront - ringR);
+ const occluded = clamp(toFront - (ringR + ringHalfW + ringGap) + 0.5, 0, 1);
+ ink = Math.max(
+ ink,
+ clamp(ringHalfW + 0.5 - back, 0, 1) * occluded,
+ clamp(ringHalfW + 0.5 - front, 0, 1),
+ );
+ }
+
+ white = Math.max(white, ink);
+ r = lerp(r, 255, white);
+ g = lerp(g, 255, white);
+ b = lerp(b, 255, white);
return [Math.round(r), Math.round(g), Math.round(b), Math.round(bg * 255)];
};