one-code-extension 0.4.1 → 0.5.0

package/extensions/mcp/oauth/flow.ts

@@ -10,10 +10,11 @@
  */
 
 import type { HttpServer } from "../config.ts";
-import { beginInteractiveAuth, type Connection, connect } from "../client.ts";
+import { beginInteractiveAuth, type Connection, connect, finishInteractiveAuth } from "../client.ts";
 import { openBrowser } from "./browser.ts";
 import { startCallbackServer } from "./callback.ts";
 import { McpOAuthProvider } from "./provider.ts";
+import type { OAuthServer } from "./store.ts";
 
 export interface AuthenticateOptions {
 	server: HttpServer;
@@ -25,8 +26,8 @@ export interface AuthenticateOptions {
 }
 
 /** A provider for a silent (non-interactive) connect using already-stored tokens. */
-export function silentProvider(serverName: string, home?: string, env?: NodeJS.ProcessEnv): McpOAuthProvider {
-	return new McpOAuthProvider({ serverName, home, env });
+export function silentProvider(server: OAuthServer, home?: string, env?: NodeJS.ProcessEnv): McpOAuthProvider {
+	return new McpOAuthProvider({ server, home, env });
 }
 
 export async function authenticate(options: AuthenticateOptions): Promise<Connection> {
@@ -34,14 +35,17 @@ export async function authenticate(options: AuthenticateOptions): Promise<Connec
 	const callback = await startCallbackServer();
 	try {
 		const provider = new McpOAuthProvider({
-			serverName: server.name,
+			server,
 			redirectUrl: callback.redirectUrl,
 			openAuthorization: (url) => {
-				const opened = openBrowser(url.toString());
-				onPrompt?.(
-					opened
-						? `Opened your browser to authorize "${server.name}". If it didn't open, visit:\n${url}`
-						: `Open this URL to authorize "${server.name}":\n${url}`,
+				// A refused URL throws here, before any launch; the prompt waits
+				// for the opener to report whether it started.
+				void openBrowser(url.toString()).then((opened) =>
+					onPrompt?.(
+						opened
+							? `Opened your browser to authorize "${server.name}". If it didn't open, visit:\n${url}`
+							: `Open this URL to authorize "${server.name}":\n${url}`,
+					),
 				);
 			},
 			home,
@@ -51,17 +55,21 @@ export async function authenticate(options: AuthenticateOptions): Promise<Connec
 		const started = await beginInteractiveAuth(server, provider);
 		if ("connection" in started) return started.connection; // valid tokens already present
 
-		const { code, state } = await callback.waitForCode(timeoutMs);
-		// Login-CSRF guard (RFC 8252 §8.9): the redirect must echo the state this
-		// provider issued, or an attacker-planted code could bind their account.
-		const expected = provider.expectedState();
-		if (expected !== undefined && state !== expected) {
-			throw new Error(`authorization response state mismatch for "${server.name}" — the redirect did not come from this authorization request`);
+		try {
+			const { code, state } = await callback.waitForCode(timeoutMs);
+			// Login-CSRF guard (RFC 8252 §8.9): the redirect must echo the state this
+			// provider issued, or an attacker-planted code could bind their account.
+			const expected = provider.expectedState();
+			if (expected !== undefined && state !== expected) {
+				throw new Error(`authorization response state mismatch for "${server.name}" — the redirect did not come from this authorization request`);
+			}
+			await finishInteractiveAuth(started.transport, code);
+		} finally {
+			await started.transport.close().catch(() => {});
 		}
-		await started.transport.finishAuth(code);
 
 		// Reconnect fresh: the provider now has stored tokens, so this is silent.
-		return await connect(server, silentProvider(server.name, home, env));
+		return await connect(server, silentProvider(server, home, env));
 	} finally {
 		callback.close();
 	}

package/extensions/mcp/oauth/provider.ts

@@ -20,10 +20,13 @@ import type {
 } from "@modelcontextprotocol/sdk/shared/auth.js";
 import { randomBytes } from "node:crypto";
 import type { OAuthClientProvider, OAuthDiscoveryState } from "@modelcontextprotocol/sdk/client/auth.js";
-import { readAuth, type StoredAuth, writeAuth } from "./store.ts";
+import { type OAuthServer, readAuth, type StoredAuth, writeAuth } from "./store.ts";
+
+export class McpAuthenticationRequiredError extends Error {}
 
 export interface McpOAuthProviderOptions {
-	serverName: string;
+	/** The server the credentials are bound to (name, URL and headers). */
+	server: OAuthServer;
 	/** Loopback redirect_uri; required for an interactive flow, omitted for silent reconnect. */
 	redirectUrl?: string;
 	/** Sends the user to the authorization URL (opens a browser). Interactive flows only. */
@@ -33,7 +36,7 @@ export interface McpOAuthProviderOptions {
 }
 
 export class McpOAuthProvider implements OAuthClientProvider {
-	private readonly serverName: string;
+	private readonly server: OAuthServer;
 	private readonly _redirectUrl?: string;
 	private readonly openAuthorization?: (url: URL) => void;
 	private readonly home?: string;
@@ -47,7 +50,7 @@ export class McpOAuthProvider implements OAuthClientProvider {
 	private issuedState?: string;
 
 	constructor(options: McpOAuthProviderOptions) {
-		this.serverName = options.serverName;
+		this.server = options.server;
 		this._redirectUrl = options.redirectUrl;
 		this.openAuthorization = options.openAuthorization;
 		this.home = options.home;
@@ -55,17 +58,20 @@ export class McpOAuthProvider implements OAuthClientProvider {
 	}
 
 	private load(): StoredAuth {
-		return (this.cache ??= readAuth(this.serverName, this.home, this.env));
+		return (this.cache ??= readAuth(this.server, this.home, this.env));
 	}
 
 	/** Merge a patch into the cached store and persist it. */
 	private save(patch: Partial<StoredAuth>): void {
 		this.cache = { ...this.load(), ...patch };
-		writeAuth(this.serverName, this.cache, this.home, this.env);
+		writeAuth(this.server, this.cache, this.home, this.env);
 	}
 
 	get redirectUrl(): string | URL | undefined {
-		return this._redirectUrl;
+		// The SDK uses an absent redirect URI to select a non-interactive grant,
+		// which skips refresh tokens. Silent reconnects still use the registered
+		// authorization-code client; only opening a browser is disallowed.
+		return this._redirectUrl ?? this.load().clientMetadata?.redirect_uris[0];
 	}
 
 	get clientMetadata(): OAuthClientMetadata {
@@ -113,7 +119,7 @@ export class McpOAuthProvider implements OAuthClientProvider {
 
 	redirectToAuthorization(authorizationUrl: URL): void {
 		if (!this.openAuthorization) {
-			throw new Error(`MCP server "${this.serverName}" needs authentication; run /mcp and choose Authenticate.`);
+			throw new McpAuthenticationRequiredError(`MCP server "${this.server.name}" needs authentication; run /mcp and choose Authenticate.`);
 		}
 		this.openAuthorization(authorizationUrl);
 	}

package/extensions/mcp/oauth/store.ts

@@ -10,8 +10,16 @@
  *
  * Kept in ~/.onecode (never ~/.claude) like all One Code state, and separate
  * from settings.json because tokens are secrets, not configuration.
+ *
+ * A record belongs to a server, not a name: the file is keyed by the name
+ * plus a sha256 of the server's URL and headers, and records the URL it was
+ * issued for. Until 2026-09-27 it was keyed by name alone, so a project
+ * `.mcp.json` server named like an authenticated user server received that
+ * server's bearer token at its own URL. A record whose URL differs is never
+ * offered, so a server whose URL or headers change signs in again.
  */
 
+import { createHash } from "node:crypto";
 import { mkdirSync, chmodSync } from "node:fs";
 import os from "node:os";
 import { join } from "node:path";
@@ -20,7 +28,16 @@ import type { OAuthDiscoveryState } from "@modelcontextprotocol/sdk/client/auth.
 import { readJsonFile, writeJsonAtomic } from "../../lib/atomic-write.ts";
 import { oneCodeStateDir } from "../../lib/paths.ts";
 
+/** The part of an http server's config its credentials are bound to. */
+export interface OAuthServer {
+	name: string;
+	url: string;
+	headers?: Record<string, string>;
+}
+
 export interface StoredAuth {
+	/** The server URL the record was issued for; a record for another URL is never read. */
+	serverUrl?: string;
 	clientInformation?: OAuthClientInformationFull;
 	clientMetadata?: OAuthClientMetadata;
 	tokens?: OAuthTokens;
@@ -33,27 +50,28 @@ export interface StoredAuth {
  * stem plus a short hash of the raw name, so two names that sanitize alike
  * (e.g. "a/b" and "a_b") still get distinct files.
  */
-function slug(serverName: string): string {
-	let hash = 5381;
-	for (let i = 0; i < serverName.length; i++) hash = ((hash << 5) + hash + serverName.charCodeAt(i)) >>> 0;
-	const safe = serverName.replace(/[^A-Za-z0-9._-]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 48);
-	return `${safe || "server"}-${hash.toString(16).padStart(8, "0")}.json`;
+function slug(server: OAuthServer): string {
+	const headers = Object.entries(server.headers ?? {}).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
+	const hash = createHash("sha256").update(JSON.stringify({ name: server.name, type: "http", url: server.url, headers })).digest("hex").slice(0, 16);
+	const safe = server.name.replace(/[^A-Za-z0-9._-]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 48);
+	return `${safe || "server"}-${hash}.json`;
 }
 
 export function authStoreDir(home: string = os.homedir(), env: NodeJS.ProcessEnv = process.env): string {
 	return join(oneCodeStateDir(env, home), "mcp-auth");
 }
 
-function authFilePath(serverName: string, home: string, env: NodeJS.ProcessEnv): string {
-	return join(authStoreDir(home, env), slug(serverName));
+function authFilePath(server: OAuthServer, home: string, env: NodeJS.ProcessEnv): string {
+	return join(authStoreDir(home, env), slug(server));
 }
 
-export function readAuth(serverName: string, home: string = os.homedir(), env: NodeJS.ProcessEnv = process.env): StoredAuth {
-	return readJsonFile<StoredAuth>(authFilePath(serverName, home, env)) ?? {};
+export function readAuth(server: OAuthServer, home: string = os.homedir(), env: NodeJS.ProcessEnv = process.env): StoredAuth {
+	const stored = readJsonFile<StoredAuth>(authFilePath(server, home, env));
+	return stored && stored.serverUrl === server.url ? stored : {};
 }
 
 export function writeAuth(
-	serverName: string,
+	server: OAuthServer,
 	auth: StoredAuth,
 	home: string = os.homedir(),
 	env: NodeJS.ProcessEnv = process.env,
@@ -67,20 +85,20 @@ export function writeAuth(
 	} catch {
 		// Not fatal (a filesystem without modes); the file mode below still applies where it can.
 	}
-	writeJsonAtomic(authFilePath(serverName, home, env), auth, { mode: 0o600 });
+	writeJsonAtomic(authFilePath(server, home, env), { ...auth, serverUrl: server.url }, { mode: 0o600 });
 }
 
 /** Merge a partial update into the stored record. */
 export function updateAuth(
-	serverName: string,
+	server: OAuthServer,
 	patch: Partial<StoredAuth>,
 	home: string = os.homedir(),
 	env: NodeJS.ProcessEnv = process.env,
 ): void {
-	writeAuth(serverName, { ...readAuth(serverName, home, env), ...patch }, home, env);
+	writeAuth(server, { ...readAuth(server, home, env), ...patch }, home, env);
 }
 
-/** True when a usable (non-empty) access token is stored. */
-export function hasStoredTokens(serverName: string, home: string = os.homedir(), env: NodeJS.ProcessEnv = process.env): boolean {
-	return Boolean(readAuth(serverName, home, env).tokens?.access_token);
+/** True when a usable (non-empty) access token is stored for this server. */
+export function hasStoredTokens(server: OAuthServer, home: string = os.homedir(), env: NodeJS.ProcessEnv = process.env): boolean {
+	return Boolean(readAuth(server, home, env).tokens?.access_token);
 }

package/extensions/mcp/panel/keys.ts

@@ -1,5 +1,6 @@
 /**
- * Raw-byte key decoding for the /mcp panel (pure).
+ * Key decoding for the /mcp panel (pure), named through `lib/key-input.ts`
+ * so every terminal encoding of a key decodes alike.
  *
  * The panel is a two-level menu (server list → server detail with a numbered
  * action list), navigated with the arrows and Enter, Esc to go back/close. A
@@ -7,28 +8,28 @@
  * other printable input is ignored.
  */
 
+import { keyId } from "../../lib/key-input.ts";
+
 export type McpKey =
 	| { kind: "up" | "down" | "enter" | "back" | "close" }
 	| { kind: "digit"; value: number };
 
 export function decodeMcpKey(data: string): McpKey | undefined {
-	switch (data) {
-		case "\x1b[A":
-		case "\x1bOA":
+	const id = keyId(data);
+	switch (id) {
+		case "up":
 			return { kind: "up" };
-		case "\x1b[B":
-		case "\x1bOB":
+		case "down":
 			return { kind: "down" };
-		case "\r":
-		case "\n":
+		case "enter":
 			return { kind: "enter" };
-		case "\x1b":
+		case "escape":
 			return { kind: "back" };
-		case "\x03": // ctrl+c
+		case "ctrl+c":
 			return { kind: "close" };
 		default:
 			break;
 	}
-	if (data.length === 1 && data >= "1" && data <= "9") return { kind: "digit", value: Number(data) };
+	if (id && id.length === 1 && id >= "1" && id <= "9") return { kind: "digit", value: Number(id) };
 	return undefined;
 }

package/extensions/mcp/panel/render.ts

@@ -8,7 +8,7 @@
  * Only width-1 glyphs are used so cutPlainText's code-point count stays exact.
  */
 
-import { cutPlainText, padPlainText, panelTopRule, type RenderBlock as Block, windowBlocks } from "../../lib/tui-render.ts";
+import { cutPlainText, hintLines, padPlainText, panelTopRule, type RenderBlock as Block, windowBlocks } from "../../lib/tui-render.ts";
 import { actionsFor, type McpEntry, statusText } from "./model.ts";
 import { clampMcpCursor, detailEntry, type McpPanelState } from "./state.ts";
 
@@ -106,19 +106,23 @@ export function renderMcpPanel(input: McpRenderInput, paint: McpPaint): string[]
 	clampMcpCursor(state, entries);
 
 	const out: string[] = [panelTopRule(paint.fg, width)];
-	let footer: string;
+	// Hints wrap at their separators (hintLines); the list budget counts the rows.
+	const wrapFooter = (text: string) => hintLines(text, width - 1, " ");
+	let footer: string[];
 
 	if (state.detail) {
 		out.push("");
 		const detail = detailLines(input, paint);
 		out.push(...detail.lines);
-		footer = detail.footer;
+		footer = wrapFooter(detail.footer);
 	} else {
 		out.push(` ${paint.bold("Manage MCP servers")}`);
 		const count = `${entries.length} server${entries.length === 1 ? "" : "s"}${input.settled ? "" : " · connecting…"}`;
 		out.push(paint.fg("dim", cutPlainText(` ${count}`, width - 1)));
 
-		const footerReserve = 3 + input.notices.length + 1;
+		footer = wrapFooter("↑/↓ to navigate · Enter to confirm · Esc to cancel");
+		const noticeLines = input.notices.reduce((sum, notice) => sum + notice.split("\n").length, 0);
+		const footerReserve = 2 + footer.length + noticeLines + 1;
 		const budget = Math.max(1, height - out.length - footerReserve);
 		if (entries.length === 0) {
 			out.push("", paint.fg("dim", "  No MCP servers configured. Add them to .mcp.json or ~/.claude.json."));
@@ -129,13 +133,12 @@ export function renderMcpPanel(input: McpRenderInput, paint: McpPaint): string[]
 		}
 		out.push("");
 		out.push(paint.fg("dim", cutPlainText("  Servers are configured in .mcp.json or ~/.claude.json.", width - 1)));
-		footer = "↑/↓ to navigate · Enter to confirm · Esc to cancel";
 	}
 
 	for (const notice of input.notices) {
 		for (const line of notice.split("\n")) out.push(paint.fg("warning", cutPlainText(`  ${line}`, width - 1)));
 	}
 	out.push("");
-	out.push(paint.fg("dim", cutPlainText(` ${footer}`, width - 1)));
+	for (const line of footer) out.push(paint.fg("dim", line));
 	return out;
 }

package/extensions/mcp/schema.ts

@@ -7,6 +7,7 @@
  * anything exotic degrades to a permissive object that passes arguments through.
  */
 
+import { crc32 } from "node:zlib";
 import { type TSchema, Type } from "typebox";
 
 /**
@@ -67,9 +68,8 @@ function descriptionOptions(schema: JsonSchema): Record<string, unknown> {
 
 function convertLeaf(schema: JsonSchema): TSchema | undefined {
 	const options = descriptionOptions(schema);
-	const type = Array.isArray(schema.type) ? schema.type.find((t) => t !== "null") : schema.type;
 
-	switch (type) {
+	switch (schema.type) {
 		case "string":
 			return Type.String(options);
 		case "number":
@@ -78,10 +78,10 @@ function convertLeaf(schema: JsonSchema): TSchema | undefined {
 			return Type.Integer(options);
 		case "boolean":
 			return Type.Boolean(options);
+		case "null":
+			return Type.Null(options);
 		case "array":
 			return Type.Array(schema.items ? jsonSchemaToTypeBox(schema.items) : Type.Unknown(), options);
-		case "object":
-			return jsonSchemaToTypeBox(schema);
 		default:
 			return undefined;
 	}
@@ -108,7 +108,17 @@ export function jsonSchemaToTypeBox(schema: JsonSchema | undefined): TSchema {
 		return Type.Unknown();
 	}
 
-	if (schema.properties || schema.type === "object") {
+	if (Array.isArray(schema.type) && schema.type.length > 0) {
+		if (schema.type.length === 1) return jsonSchemaToTypeBox({ ...schema, type: schema.type[0] });
+		// TypeBox emits anyOf, which pi's provider converters understand. Keep
+		// the description on the union, not on each of its generated branches.
+		return Type.Union(
+			schema.type.map((type) => jsonSchemaToTypeBox({ ...schema, type, description: undefined })),
+			options,
+		);
+	}
+
+	if (schema.type === "object" || (schema.type === undefined && schema.properties)) {
 		const required = new Set(Array.isArray(schema.required) ? schema.required : []);
 		const properties: Record<string, TSchema> = {};
 		for (const [key, value] of Object.entries(schema.properties ?? {})) {
@@ -176,6 +186,12 @@ const MAX_IMAGE_BYTES = 5 * 1024 * 1024;
  * on every later one, since the block stays in the history. So the bytes are
  * checked against a small magic-number allow-list here and `mimeType` is
  * derived from them, never trusted; a block that fails becomes a text note.
+ * A valid signature is not enough: a PNG signature followed by garbage passed
+ * the sniff and still poisoned the session. So the container is walked to its
+ * end too (`wholeImageProblem`): PNG chunks with their CRCs from IHDR to IEND,
+ * JPEG segments to the scan and the end-of-image marker, the GIF trailer, the
+ * WebP RIFF length. It is not a pixel decode, so a crafted image with a valid
+ * container can still fail at the provider; a corrupt or truncated one cannot.
  */
 /** Base64 length that decodes to just over the byte ceiling (4 base64 chars per 3 bytes). */
 const MAX_IMAGE_BASE64_LENGTH = Math.ceil((MAX_IMAGE_BYTES * 4) / 3);
@@ -197,9 +213,92 @@ export function validateImageData(
 	if (head.length === 0) return { ok: false, reason: "empty after base64 decode", bytes: 0 };
 	const mime = sniffImageMime(head);
 	if (!mime) return { ok: false, reason: `unrecognised image format (claimed ${claimedMime ?? "none"})`, bytes: approxBytes };
+	const bytes = Buffer.from(data, "base64");
+	const problem = wholeImageProblem(bytes, mime);
+	if (problem) return { ok: false, reason: problem, bytes: bytes.length };
 	return { ok: true, mimeType: mime };
 }
 
+const PNG_SIGNATURE = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+
+/** A JPEG end-of-image marker. */
+const JPEG_EOI = Buffer.from([0xff, 0xd9]);
+
+/** The end of `buf` with trailing zero padding dropped (some encoders pad after the end marker). */
+function paddedEnd(buf: Buffer): number {
+	let end = buf.length;
+	while (end > 0 && buf[end - 1] === 0x00) end--;
+	return end;
+}
+
+/** Why the image's container is not whole, or undefined when it is. Pure. */
+export function wholeImageProblem(buf: Buffer, mime: string): string | undefined {
+	if (mime === "image/png") {
+		if (buf.length < 8 || !buf.subarray(0, 8).equals(PNG_SIGNATURE)) return "corrupt PNG signature";
+		let offset = 8;
+		let first = true;
+		let sawData = false;
+		for (;;) {
+			if (offset + 12 > buf.length) return "truncated PNG (no IEND chunk)";
+			const length = buf.readUInt32BE(offset);
+			const type = buf.toString("latin1", offset + 4, offset + 8);
+			if (offset + 12 + length > buf.length) return `truncated PNG (the ${type} chunk runs past the data)`;
+			if (crc32(buf.subarray(offset + 4, offset + 8 + length)) !== buf.readUInt32BE(offset + 8 + length)) return `corrupt PNG (bad ${type} chunk checksum)`;
+			if (first) {
+				if (type !== "IHDR" || length !== 13) return "corrupt PNG (IHDR is not the first chunk)";
+				if (buf.readUInt32BE(offset + 8) === 0 || buf.readUInt32BE(offset + 12) === 0) return "corrupt PNG (zero width or height)";
+				first = false;
+			}
+			if (type === "IDAT") sawData = true;
+			offset += 12 + length;
+			if (type === "IEND") return sawData ? undefined : "corrupt PNG (no image data)";
+		}
+	}
+	if (mime === "image/jpeg") {
+		let offset = 2;
+		for (;;) {
+			if (offset + 2 > buf.length) return "truncated JPEG (no image scan)";
+			if (buf[offset] !== 0xff) return "corrupt JPEG (bad segment marker)";
+			const marker = buf[offset + 1];
+			if (marker === 0xff) {
+				offset++; // fill byte
+				continue;
+			}
+			if (marker === 0xda) break; // start of scan: entropy-coded data follows
+			if (marker === 0xd9) return "corrupt JPEG (ends before its image scan)";
+			if (marker === 0x01 || (marker >= 0xd0 && marker <= 0xd7)) {
+				offset += 2;
+				continue;
+			}
+			if (offset + 4 > buf.length) return "truncated JPEG";
+			const length = buf.readUInt16BE(offset + 2);
+			if (length < 2 || offset + 2 + length > buf.length) return "truncated JPEG (a segment runs past the data)";
+			offset += 2 + length;
+		}
+		// The EOI marker anywhere after the scan: scan data escapes every 0xFF, and
+		// bytes after EOI (a vendor trailer, a Motion Photo payload) are allowed.
+		return buf.indexOf(JPEG_EOI, offset + 2) !== -1 ? undefined : "truncated JPEG (no end-of-image marker)";
+	}
+	if (mime === "image/gif") {
+		const header = buf.toString("latin1", 0, 6);
+		if (header !== "GIF87a" && header !== "GIF89a") return "corrupt GIF header";
+		if (buf.length < 14) return "truncated GIF";
+		if (buf.readUInt16LE(6) === 0 || buf.readUInt16LE(8) === 0) return "corrupt GIF (zero width or height)";
+		const end = paddedEnd(buf);
+		return buf[end - 1] === 0x3b ? undefined : "truncated GIF (no trailer)";
+	}
+	if (mime === "image/webp") {
+		if (buf.length < 20) return "truncated WebP";
+		const riffEnd = buf.readUInt32LE(4) + 8;
+		if (riffEnd > buf.length) return "truncated WebP (shorter than its RIFF length)";
+		const chunk = buf.toString("latin1", 12, 16);
+		if (chunk !== "VP8 " && chunk !== "VP8L" && chunk !== "VP8X") return "corrupt WebP (no image chunk)";
+		if (20 + buf.readUInt32LE(16) > riffEnd) return "truncated WebP (its image chunk runs past the data)";
+		return undefined;
+	}
+	return `unsupported image type ${mime}`;
+}
+
 /** Magic-number sniff for the formats Anthropic accepts. Returns undefined for anything else. */
 function sniffImageMime(buf: Buffer): string | undefined {
 	if (buf.length >= 8 && buf[0] === 0x89 && buf[1] === 0x50 && buf[2] === 0x4e && buf[3] === 0x47) return "image/png";