@tempad-dev/mcp 0.1.0 → 0.2.0

package/dist/hub.js

@@ -1,13 +1,60 @@
 // src/hub.ts
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { nanoid as nanoid2 } from "nanoid";
-import { existsSync, rmSync, chmodSync } from "node:fs";
-import { createServer } from "node:net";
+import { nanoid as nanoid3 } from "nanoid";
+import { existsSync as existsSync3, rmSync as rmSync2, chmodSync, readFileSync as readFileSync2, statSync as statSync3 } from "node:fs";
+import { createServer as createServer2 } from "node:net";
 import { WebSocketServer } from "ws";
 
-// src/request.ts
+// ../mcp/shared/constants.ts
+var MCP_PORT_CANDIDATES = [6220, 7431, 8127];
+var MCP_MAX_PAYLOAD_BYTES = 4 * 1024 * 1024;
+var MCP_TOOL_TIMEOUT_MS = 15e3;
+var MCP_AUTO_ACTIVATE_GRACE_MS = 1500;
+var MCP_MAX_ASSET_BYTES = 8 * 1024 * 1024;
+var MCP_ASSET_RESOURCE_NAME = "tempad-assets";
+var MCP_ASSET_URI_PREFIX = "asset://tempad/";
+var MCP_ASSET_URI_TEMPLATE = `${MCP_ASSET_URI_PREFIX}{hash}`;
+var MCP_HASH_PATTERN = /^[a-f0-9]{64}$/i;
+
+// src/asset-http-server.ts
 import { nanoid } from "nanoid";
+import { createHash } from "node:crypto";
+import {
+  createReadStream,
+  createWriteStream,
+  existsSync,
+  renameSync,
+  statSync,
+  unlinkSync
+} from "node:fs";
+import { createServer } from "node:http";
+import { join as join2 } from "node:path";
+import { URL } from "node:url";
+
+// src/config.ts
+function parsePositiveInt(envValue, fallback) {
+  const parsed = envValue ? Number.parseInt(envValue, 10) : Number.NaN;
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+function resolveToolTimeoutMs() {
+  return parsePositiveInt(process.env.TEMPAD_MCP_TOOL_TIMEOUT, MCP_TOOL_TIMEOUT_MS);
+}
+function resolveAutoActivateGraceMs() {
+  return parsePositiveInt(process.env.TEMPAD_MCP_AUTO_ACTIVATE_GRACE, MCP_AUTO_ACTIVATE_GRACE_MS);
+}
+function resolveMaxAssetSizeBytes() {
+  return parsePositiveInt(process.env.TEMPAD_MCP_MAX_ASSET_BYTES, MCP_MAX_ASSET_BYTES);
+}
+function getMcpServerConfig() {
+  return {
+    wsPortCandidates: [...MCP_PORT_CANDIDATES],
+    toolTimeoutMs: resolveToolTimeoutMs(),
+    maxPayloadBytes: MCP_MAX_PAYLOAD_BYTES,
+    autoActivateGraceMs: resolveAutoActivateGraceMs(),
+    maxAssetSizeBytes: resolveMaxAssetSizeBytes()
+  };
+}
 
 // src/shared.ts
 import { closeSync, mkdirSync, openSync } from "node:fs";
@@ -25,10 +72,16 @@ function resolveLogDir() {
   if (process.env.TEMPAD_MCP_LOG_DIR) return process.env.TEMPAD_MCP_LOG_DIR;
   return join(tmpdir(), "tempad-dev", "log");
 }
+function resolveAssetDir() {
+  if (process.env.TEMPAD_MCP_ASSET_DIR) return process.env.TEMPAD_MCP_ASSET_DIR;
+  return join(tmpdir(), "tempad-dev", "assets");
+}
 var RUNTIME_DIR = resolveRuntimeDir();
 var LOG_DIR = resolveLogDir();
+var ASSET_DIR = resolveAssetDir();
 ensureDir(RUNTIME_DIR);
 ensureDir(LOG_DIR);
+ensureDir(ASSET_DIR);
 function ensureFile(filePath) {
   const fd = openSync(filePath, "a");
   closeSync(fd);
@@ -54,10 +107,447 @@ var log = pino(
 );
 var SOCK_PATH = process.platform === "win32" ? "\\\\.\\pipe\\tempad-mcp" : join(RUNTIME_DIR, "mcp.sock");
 
+// src/asset-http-server.ts
+var LOOPBACK_HOST = "127.0.0.1";
+var { maxAssetSizeBytes } = getMcpServerConfig();
+function createAssetHttpServer(store) {
+  const server = createServer(handleRequest);
+  let port2 = null;
+  async function start() {
+    if (port2 !== null) return;
+    await new Promise((resolve2, reject2) => {
+      const onError = (error) => {
+        server.off("listening", onListening);
+        reject2(error);
+      };
+      const onListening = () => {
+        server.off("error", onError);
+        const address = server.address();
+        if (address && typeof address === "object") {
+          port2 = address.port;
+          resolve2();
+        } else {
+          reject2(new Error("Failed to determine HTTP server port."));
+        }
+      };
+      server.once("error", onError);
+      server.once("listening", onListening);
+      server.listen(0, LOOPBACK_HOST);
+    });
+    log.info({ port: port2 }, "Asset HTTP server ready.");
+  }
+  function stop() {
+    if (port2 === null) return;
+    server.close();
+    port2 = null;
+  }
+  function getBaseUrl() {
+    if (port2 === null) throw new Error("Asset HTTP server is not running.");
+    return `http://${LOOPBACK_HOST}:${port2}`;
+  }
+  function handleRequest(req, res) {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type, X-Asset-Width, X-Asset-Height");
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    if (!req.url) {
+      res.writeHead(400);
+      res.end("Missing URL");
+      return;
+    }
+    const url = new URL(req.url, getBaseUrl());
+    const segments = url.pathname.split("/").filter(Boolean);
+    if (segments.length !== 2 || segments[0] !== "assets") {
+      res.writeHead(404);
+      res.end("Not Found");
+      return;
+    }
+    const hash = segments[1];
+    if (req.method === "POST") {
+      handleUpload(req, res, hash);
+      return;
+    }
+    if (req.method === "GET") {
+      handleDownload(req, res, hash);
+      return;
+    }
+    res.writeHead(405);
+    res.end("Method Not Allowed");
+  }
+  function handleDownload(req, res, hash) {
+    const record = store.get(hash);
+    if (!record) {
+      res.writeHead(404);
+      res.end("Not Found");
+      return;
+    }
+    let stat;
+    try {
+      stat = statSync(record.filePath);
+    } catch (error) {
+      const err = error;
+      if (err.code === "ENOENT") {
+        store.remove(hash, { removeFile: false });
+        res.writeHead(404);
+        res.end("Not Found");
+      } else {
+        log.error({ error, hash }, "Failed to stat asset file.");
+        res.writeHead(500);
+        res.end("Internal Server Error");
+      }
+      return;
+    }
+    res.writeHead(200, {
+      "Content-Type": record.mimeType,
+      "Content-Length": stat.size.toString(),
+      "Cache-Control": "public, max-age=31536000, immutable"
+    });
+    const stream = createReadStream(record.filePath);
+    stream.on("error", (error) => {
+      log.warn({ error, hash }, "Failed to stream asset file.");
+      if (!res.headersSent) {
+        res.writeHead(500);
+      }
+      res.end("Internal Server Error");
+    });
+    stream.on("open", () => {
+      store.touch(hash);
+    });
+    stream.pipe(res);
+  }
+  function handleUpload(req, res, hash) {
+    if (!MCP_HASH_PATTERN.test(hash)) {
+      res.writeHead(400);
+      res.end("Invalid Hash Format");
+      return;
+    }
+    const mimeType = req.headers["content-type"] || "application/octet-stream";
+    const filePath = join2(ASSET_DIR, hash);
+    const width = parseInt(req.headers["x-asset-width"], 10);
+    const height = parseInt(req.headers["x-asset-height"], 10);
+    const metadata = !isNaN(width) && !isNaN(height) && width > 0 && height > 0 ? { width, height } : void 0;
+    if (store.has(hash) && existsSync(filePath)) {
+      req.resume();
+      const existing = store.get(hash);
+      let changed = false;
+      if (metadata) {
+        existing.metadata = metadata;
+        changed = true;
+      }
+      if (existing.mimeType !== mimeType) {
+        existing.mimeType = mimeType;
+        changed = true;
+      }
+      if (changed) {
+        store.upsert(existing);
+      }
+      store.touch(hash);
+      res.writeHead(200);
+      res.end("OK");
+      return;
+    }
+    const tmpPath = `${filePath}.tmp.${nanoid()}`;
+    const writeStream = createWriteStream(tmpPath);
+    const hasher = createHash("sha256");
+    let size = 0;
+    let aborted = false;
+    const cleanup = () => {
+      if (existsSync(tmpPath)) {
+        try {
+          unlinkSync(tmpPath);
+        } catch (e) {
+          log.warn({ error: e, tmpPath }, "Failed to cleanup temp file.");
+        }
+      }
+    };
+    req.on("data", (chunk) => {
+      if (aborted) return;
+      size += chunk.length;
+      if (size > maxAssetSizeBytes) {
+        aborted = true;
+        req.destroy();
+        writeStream.destroy();
+        cleanup();
+        res.writeHead(413);
+        res.end("Payload Too Large");
+        return;
+      }
+      hasher.update(chunk);
+    });
+    req.pipe(writeStream);
+    req.on("aborted", () => {
+      aborted = true;
+      writeStream.destroy();
+      cleanup();
+    });
+    req.on("error", (err) => {
+      log.warn({ err, hash }, "Upload request error.");
+      aborted = true;
+      writeStream.destroy();
+      cleanup();
+    });
+    req.on("close", () => {
+      if (!res.writableEnded && !aborted) {
+        log.warn({ hash }, "Upload request closed prematurely.");
+        aborted = true;
+        writeStream.destroy();
+        cleanup();
+      }
+    });
+    writeStream.on("error", (error) => {
+      if (aborted) return;
+      log.error({ error, hash }, "Failed to write uploaded asset.");
+      cleanup();
+      res.writeHead(500);
+      res.end("Internal Server Error");
+    });
+    writeStream.on("finish", () => {
+      if (aborted) return;
+      const computedHash = hasher.digest("hex");
+      if (computedHash !== hash) {
+        cleanup();
+        res.writeHead(400);
+        res.end("Hash Mismatch");
+        return;
+      }
+      try {
+        renameSync(tmpPath, filePath);
+      } catch (error) {
+        log.error({ error, hash }, "Failed to rename temp file to asset.");
+        cleanup();
+        res.writeHead(500);
+        res.end("Internal Server Error");
+        return;
+      }
+      store.upsert({
+        hash,
+        filePath,
+        mimeType,
+        size,
+        metadata
+      });
+      log.info({ hash, size }, "Stored uploaded asset via HTTP.");
+      res.writeHead(201);
+      res.end("Created");
+    });
+  }
+  return {
+    start,
+    stop,
+    getBaseUrl
+  };
+}
+
+// src/asset-store.ts
+import { existsSync as existsSync2, readFileSync, rmSync, writeFileSync, readdirSync, statSync as statSync2 } from "node:fs";
+import { join as join3 } from "node:path";
+var INDEX_FILENAME = "assets.json";
+var DEFAULT_INDEX_PATH = join3(ASSET_DIR, INDEX_FILENAME);
+function readIndex(indexPath) {
+  if (!existsSync2(indexPath)) return [];
+  try {
+    const raw = readFileSync(indexPath, "utf8").trim();
+    if (!raw) return [];
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch (error) {
+    log.warn({ error, indexPath }, "Failed to read asset catalog; starting fresh.");
+    return [];
+  }
+}
+function writeIndex(indexPath, values) {
+  const payload = JSON.stringify(values, null, 2);
+  writeFileSync(indexPath, payload, "utf8");
+}
+function createAssetStore(options = {}) {
+  ensureDir(ASSET_DIR);
+  const indexPath = options.indexPath ?? DEFAULT_INDEX_PATH;
+  ensureFile(indexPath);
+  const records = /* @__PURE__ */ new Map();
+  let persistTimer = null;
+  function loadExisting() {
+    const list2 = readIndex(indexPath);
+    for (const record of list2) {
+      if (record?.hash && record?.filePath) {
+        records.set(record.hash, record);
+      }
+    }
+  }
+  function persist() {
+    if (persistTimer) return;
+    persistTimer = setTimeout(() => {
+      persistTimer = null;
+      writeIndex(indexPath, [...records.values()]);
+    }, 5e3);
+    if (typeof persistTimer.unref === "function") {
+      persistTimer.unref();
+    }
+  }
+  function flush() {
+    if (persistTimer) {
+      clearTimeout(persistTimer);
+      persistTimer = null;
+    }
+    writeIndex(indexPath, [...records.values()]);
+  }
+  function list() {
+    return [...records.values()];
+  }
+  function has(hash) {
+    return records.has(hash);
+  }
+  function get(hash) {
+    return records.get(hash);
+  }
+  function getMany(hashes) {
+    return hashes.map((hash) => records.get(hash)).filter((record) => !!record);
+  }
+  function upsert(input) {
+    const now = Date.now();
+    const record = {
+      ...input,
+      uploadedAt: input.uploadedAt ?? now,
+      lastAccess: input.lastAccess ?? now
+    };
+    records.set(record.hash, record);
+    persist();
+    return record;
+  }
+  function touch(hash) {
+    const existing = records.get(hash);
+    if (!existing) return void 0;
+    existing.lastAccess = Date.now();
+    persist();
+    return existing;
+  }
+  function remove(hash, { removeFile = true } = {}) {
+    const record = records.get(hash);
+    if (!record) return;
+    records.delete(hash);
+    persist();
+    if (removeFile) {
+      try {
+        rmSync(record.filePath, { force: true });
+      } catch (error) {
+        log.warn({ hash, error }, "Failed to remove asset file on delete.");
+      }
+    }
+  }
+  function reconcile() {
+    let changed = false;
+    for (const [hash, record] of records) {
+      if (!existsSync2(record.filePath)) {
+        records.delete(hash);
+        changed = true;
+      }
+    }
+    try {
+      const files = readdirSync(ASSET_DIR);
+      const now = Date.now();
+      for (const file of files) {
+        if (file === INDEX_FILENAME) continue;
+        if (file.includes(".tmp.")) {
+          try {
+            const filePath = join3(ASSET_DIR, file);
+            const stat = statSync2(filePath);
+            if (now - stat.mtimeMs > 3600 * 1e3) {
+              rmSync(filePath, { force: true });
+              log.info({ file }, "Cleaned up stale temp file.");
+            }
+          } catch {
+          }
+          continue;
+        }
+        if (!/^[a-f0-9]{64}$/i.test(file)) continue;
+        if (!records.has(file)) {
+          const filePath = join3(ASSET_DIR, file);
+          try {
+            const stat = statSync2(filePath);
+            records.set(file, {
+              hash: file,
+              filePath,
+              mimeType: "application/octet-stream",
+              size: stat.size,
+              uploadedAt: stat.birthtimeMs,
+              lastAccess: stat.atimeMs
+            });
+            changed = true;
+            log.info({ hash: file }, "Recovered orphan asset file.");
+          } catch (e) {
+            log.warn({ error: e, file }, "Failed to stat orphan file.");
+          }
+        }
+      }
+    } catch (error) {
+      log.warn({ error }, "Failed to scan asset directory for orphans.");
+    }
+    if (changed) flush();
+  }
+  loadExisting();
+  reconcile();
+  return {
+    list,
+    has,
+    get,
+    getMany,
+    upsert,
+    touch,
+    remove,
+    reconcile,
+    flush
+  };
+}
+
+// src/protocol.ts
+import { z } from "zod";
+var RegisteredMessageSchema = z.object({
+  type: z.literal("registered"),
+  id: z.string()
+});
+var StateMessageSchema = z.object({
+  type: z.literal("state"),
+  activeId: z.string().nullable(),
+  count: z.number().nonnegative(),
+  port: z.number().positive(),
+  assetServerUrl: z.string().url()
+});
+var ToolCallPayloadSchema = z.object({
+  name: z.string(),
+  args: z.unknown()
+});
+var ToolCallMessageSchema = z.object({
+  type: z.literal("toolCall"),
+  id: z.string(),
+  payload: ToolCallPayloadSchema
+});
+var MessageToExtensionSchema = z.discriminatedUnion("type", [
+  RegisteredMessageSchema,
+  StateMessageSchema,
+  ToolCallMessageSchema
+]);
+var ActivateMessageSchema = z.object({
+  type: z.literal("activate")
+});
+var ToolResultMessageSchema = z.object({
+  type: z.literal("toolResult"),
+  id: z.string(),
+  payload: z.unknown().optional(),
+  error: z.unknown().optional()
+});
+var MessageFromExtensionSchema = z.discriminatedUnion("type", [
+  ActivateMessageSchema,
+  ToolResultMessageSchema
+]);
+
 // src/request.ts
+import { nanoid as nanoid2 } from "nanoid";
 var pendingCalls = /* @__PURE__ */ new Map();
 function register(extensionId, timeout) {
-  const requestId = nanoid();
+  const requestId = nanoid2();
   const promise = new Promise((resolve2, reject2) => {
     const timer = setTimeout(() => {
       pendingCalls.delete(requestId);
@@ -75,8 +565,9 @@ function register(extensionId, timeout) {
 function resolve(requestId, payload) {
   const call = pendingCalls.get(requestId);
   if (call) {
-    clearTimeout(call.timer);
-    call.resolve(payload);
+    const { timer, resolve: finish } = call;
+    clearTimeout(timer);
+    finish(payload);
     pendingCalls.delete(requestId);
   } else {
     log.warn({ reqId: requestId }, "Received result for unknown/timed-out call.");
@@ -85,8 +576,9 @@ function resolve(requestId, payload) {
 function reject(requestId, error) {
   const call = pendingCalls.get(requestId);
   if (call) {
-    clearTimeout(call.timer);
-    call.reject(error);
+    const { timer, reject: fail } = call;
+    clearTimeout(timer);
+    fail(error);
     pendingCalls.delete(requestId);
   } else {
     log.warn({ reqId: requestId }, "Received error for unknown/timed-out call.");
@@ -94,9 +586,10 @@ function reject(requestId, error) {
 }
 function cleanupForExtension(extensionId) {
   for (const [reqId, call] of pendingCalls.entries()) {
-    if (call.extensionId === extensionId) {
-      clearTimeout(call.timer);
-      call.reject(new Error("Extension disconnected before providing a result."));
+    const { timer, reject: fail, extensionId: extId } = call;
+    if (extId === extensionId) {
+      clearTimeout(timer);
+      fail(new Error("Extension disconnected before providing a result."));
       pendingCalls.delete(reqId);
       log.warn({ reqId, extId: extensionId }, "Rejected pending call from disconnected extension.");
     }
@@ -104,82 +597,236 @@ function cleanupForExtension(extensionId) {
 }
 function cleanupAll() {
   pendingCalls.forEach((call, reqId) => {
-    clearTimeout(call.timer);
-    call.reject(new Error("Hub is shutting down."));
+    const { timer, reject: fail } = call;
+    clearTimeout(timer);
+    fail(new Error("Hub is shutting down."));
     log.debug({ reqId }, "Rejected pending tool call due to shutdown.");
   });
   pendingCalls.clear();
 }
 
 // src/tools.ts
-import { z } from "zod";
-var GetCodeParametersSchema = z.object({
-  output: z.enum(["css", "js"]).optional().default("css")
-});
-var TOOLS = [
-  {
-    name: "get_code",
-    description: "Returns generated code for the currently selected node.",
-    parameters: GetCodeParametersSchema
-  }
-];
-
-// src/protocol.ts
 import { z as z2 } from "zod";
-var RegisteredMessageSchema = z2.object({
-  type: z2.literal("registered"),
-  id: z2.string()
+var GetCodeParametersSchema = z2.object({
+  nodeId: z2.string().optional(),
+  preferredLang: z2.enum(["jsx", "vue"]).optional(),
+  resolveTokens: z2.boolean().optional()
 });
-var StateMessageSchema = z2.object({
-  type: z2.literal("state"),
-  activeId: z2.string().nullable(),
-  count: z2.number().nonnegative(),
-  port: z2.number().positive()
+var GetTokenDefsParametersSchema = z2.object({
+  nodeId: z2.string().optional()
 });
-var ToolCallPayloadSchema = z2.object({
-  name: z2.string(),
-  args: z2.unknown()
+var AssetDescriptorSchema = z2.object({
+  hash: z2.string().min(1),
+  url: z2.string().url(),
+  mimeType: z2.string().min(1),
+  size: z2.number().int().nonnegative(),
+  resourceUri: z2.string().regex(/^asset:\/\/tempad\/[a-f0-9]{64}$/i),
+  width: z2.number().int().positive().optional(),
+  height: z2.number().int().positive().optional()
 });
-var ToolCallMessageSchema = z2.object({
-  type: z2.literal("toolCall"),
-  id: z2.string(),
-  payload: ToolCallPayloadSchema
+var GetScreenshotParametersSchema = z2.object({
+  nodeId: z2.string().optional()
 });
-var MessageToExtensionSchema = z2.discriminatedUnion("type", [
-  RegisteredMessageSchema,
-  StateMessageSchema,
-  ToolCallMessageSchema
-]);
-var ActivateMessageSchema = z2.object({
-  type: z2.literal("activate")
+var GetStructureParametersSchema = z2.object({
+  nodeId: z2.string().optional(),
+  options: z2.object({
+    depth: z2.number().int().positive().optional()
+  }).optional()
 });
-var ToolResultMessageSchema = z2.object({
-  type: z2.literal("toolResult"),
-  id: z2.string(),
-  payload: z2.unknown().optional(),
-  error: z2.unknown().optional()
+var GetAssetsParametersSchema = z2.object({
+  hashes: z2.array(z2.string().regex(MCP_HASH_PATTERN)).min(1)
 });
-var MessageFromExtensionSchema = z2.discriminatedUnion("type", [
-  ActivateMessageSchema,
-  ToolResultMessageSchema
-]);
+var GetAssetsResultSchema = z2.object({
+  assets: z2.array(AssetDescriptorSchema),
+  missing: z2.array(z2.string().min(1))
+});
+var TOOLS = [
+  {
+    name: "get_code",
+    description: "High fidelity code snapshot for the current selection or provided node ids.",
+    parameters: GetCodeParametersSchema
+  },
+  {
+    name: "get_token_defs",
+    description: "Token definitions referenced by the current selection or provided node ids.",
+    parameters: GetTokenDefsParametersSchema
+  },
+  {
+    name: "get_screenshot",
+    description: "Rendered screenshot for the requested node.",
+    parameters: GetScreenshotParametersSchema
+  },
+  {
+    name: "get_structure",
+    description: "Structural outline of the current selection or provided node ids.",
+    parameters: GetStructureParametersSchema
+  }
+];
 
 // src/hub.ts
-function parsePositiveInt(env, fallback) {
-  const parsed = env ? Number.parseInt(env, 10) : Number.NaN;
-  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
-}
-var WS_PORT_CANDIDATES = [6220, 7431, 8127];
-var TOOL_CALL_TIMEOUT = parsePositiveInt(process.env.TEMPAD_MCP_TOOL_TIMEOUT, 15e3);
-var MAX_PAYLOAD_SIZE = 4 * 1024 * 1024;
 var SHUTDOWN_TIMEOUT = 2e3;
-var AUTO_ACTIVATE_GRACE_MS = parsePositiveInt(process.env.TEMPAD_MCP_AUTO_ACTIVATE_GRACE, 1500);
+var { wsPortCandidates, toolTimeoutMs, maxPayloadBytes, autoActivateGraceMs } = getMcpServerConfig();
 var extensions = [];
 var consumerCount = 0;
 var autoActivateTimer = null;
 var selectedWsPort = 0;
 var mcp = new McpServer({ name: "tempad-dev-mcp", version: "0.1.0" });
-for (const tool of TOOLS) {
+var assetStore = createAssetStore();
+var assetHttpServer = createAssetHttpServer(assetStore);
+await assetHttpServer.start();
+registerAssetResources();
+function registerAssetResources() {
+  const template = new ResourceTemplate(MCP_ASSET_URI_TEMPLATE, {
+    list: async () => ({
+      resources: assetStore.list().filter((record) => existsSync3(record.filePath)).map((record) => ({
+        uri: buildAssetResourceUri(record.hash),
+        name: formatAssetResourceName(record.hash),
+        description: `${record.mimeType} (${formatBytes(record.size)})`,
+        mimeType: record.mimeType
+      }))
+    })
+  });
+  mcp.registerResource(
+    MCP_ASSET_RESOURCE_NAME,
+    template,
+    {
+      description: "Binary assets captured by the TemPad Dev hub."
+    },
+    async (_uri, variables) => {
+      const hash = typeof variables.hash === "string" ? variables.hash : "";
+      return readAssetResource(hash);
+    }
+  );
+}
+async function readAssetResource(hash) {
+  if (!hash) {
+    throw new Error("Missing asset hash in resource URI.");
+  }
+  const record = assetStore.get(hash);
+  if (!record) {
+    throw new Error(`Asset ${hash} not found.`);
+  }
+  if (!existsSync3(record.filePath)) {
+    assetStore.remove(hash, { removeFile: false });
+    throw new Error(`Asset ${hash} file is missing.`);
+  }
+  const stat = statSync3(record.filePath);
+  const estimatedSize = Math.ceil(stat.size / 3) * 4;
+  if (estimatedSize > maxPayloadBytes) {
+    throw new Error(
+      `Asset ${hash} is too large (${formatBytes(stat.size)}, encoded: ${formatBytes(estimatedSize)}) to read via MCP protocol. Use HTTP download.`
+    );
+  }
+  assetStore.touch(hash);
+  const buffer = readFileSync2(record.filePath);
+  const resourceUri = buildAssetResourceUri(hash);
+  if (isTextualMime(record.mimeType)) {
+    return {
+      contents: [
+        {
+          uri: resourceUri,
+          mimeType: record.mimeType,
+          text: buffer.toString("utf8")
+        }
+      ]
+    };
+  }
+  return {
+    contents: [
+      {
+        uri: resourceUri,
+        mimeType: record.mimeType,
+        blob: buffer.toString("base64")
+      }
+    ]
+  };
+}
+function isTextualMime(mimeType) {
+  return mimeType === "image/svg+xml" || mimeType.startsWith("text/");
+}
+function buildAssetResourceUri(hash) {
+  return `${MCP_ASSET_URI_PREFIX}${hash}`;
+}
+function formatAssetResourceName(hash) {
+  return `asset:${hash.slice(0, 8)}`;
+}
+function buildAssetDescriptor(record) {
+  return {
+    hash: record.hash,
+    url: `${assetHttpServer.getBaseUrl()}/assets/${record.hash}`,
+    mimeType: record.mimeType,
+    size: record.size,
+    resourceUri: buildAssetResourceUri(record.hash),
+    width: record.metadata?.width,
+    height: record.metadata?.height
+  };
+}
+function createAssetResourceLinkBlock(asset) {
+  return {
+    type: "resource_link",
+    name: formatAssetResourceName(asset.hash),
+    uri: asset.resourceUri,
+    mimeType: asset.mimeType,
+    description: `${describeAsset(asset)} - Download: ${asset.url}`
+  };
+}
+function describeAsset(asset) {
+  return `${asset.mimeType} (${formatBytes(asset.size)})`;
+}
+function registerHubTools() {
+  for (const tool of TOOLS) {
+    registerExtensionTool(tool);
+  }
+  mcp.registerTool(
+    "get_assets",
+    {
+      description: "Resolve uploaded asset hashes to downloadable URLs and resource URIs for resources/read calls.",
+      inputSchema: GetAssetsParametersSchema,
+      outputSchema: GetAssetsResultSchema
+    },
+    async (args) => {
+      const { hashes } = GetAssetsParametersSchema.parse(args);
+      if (hashes.length > 100) {
+        throw new Error("Too many hashes requested. Limit is 100.");
+      }
+      const unique = Array.from(new Set(hashes));
+      const records = assetStore.getMany(unique).filter((record) => {
+        if (existsSync3(record.filePath)) return true;
+        assetStore.remove(record.hash, { removeFile: false });
+        return false;
+      });
+      const found = new Set(records.map((record) => record.hash));
+      const payload = GetAssetsResultSchema.parse({
+        assets: records.map((record) => buildAssetDescriptor(record)),
+        missing: unique.filter((hash) => !found.has(hash))
+      });
+      const summary = [];
+      summary.push(
+        payload.assets.length ? `Resolved ${payload.assets.length} asset${payload.assets.length === 1 ? "" : "s"}.` : "No assets were resolved for the requested hashes."
+      );
+      if (payload.missing.length) {
+        summary.push(`Missing: ${payload.missing.join(", ")}`);
+      }
+      summary.push(
+        "Use resources/read with each resourceUri or fetch the fallback URL to download bytes."
+      );
+      const content = [
+        {
+          type: "text",
+          text: summary.join("\n")
+        },
+        ...payload.assets.map((asset) => createAssetResourceLinkBlock(asset))
+      ];
+      return {
+        content,
+        structuredContent: payload
+      };
+    }
+  );
+}
+registerHubTools();
+log.info({ tools: TOOLS.map((t) => t.name) }, "Registered tools.");
+function registerExtensionTool(tool) {
   const schema = tool.parameters;
   mcp.registerTool(
     tool.name,
@@ -191,7 +838,7 @@ for (const tool of TOOLS) {
       const parsedArgs = schema.parse(args);
       const activeExt = extensions.find((e) => e.active);
       if (!activeExt) throw new Error("No active TemPad Dev extension available.");
-      const { promise, requestId } = register(activeExt.id, TOOL_CALL_TIMEOUT);
+      const { promise, requestId } = register(activeExt.id, toolTimeoutMs);
       const message = {
         type: "toolCall",
         id: requestId,
@@ -202,13 +849,103 @@ for (const tool of TOOLS) {
       };
       activeExt.ws.send(JSON.stringify(message));
       log.info({ tool: tool.name, req: requestId, extId: activeExt.id }, "Forwarded tool call.");
-      const unknownPayload = await promise;
-      const textContent = typeof unknownPayload === "string" ? unknownPayload : JSON.stringify(unknownPayload, null, 2);
-      return { content: [{ type: "text", text: textContent }] };
+      const payload = await promise;
+      return createToolResponse(tool.name, payload);
     }
   );
 }
-log.info({ tools: TOOLS.map((t) => t.name) }, "Registered tools.");
+function createToolResponse(toolName, payload) {
+  if (toolName === "get_screenshot") {
+    try {
+      return createScreenshotToolResponse(payload);
+    } catch (error) {
+      log.warn({ error }, "Failed to format get_screenshot result; returning raw payload.");
+      return coercePayloadToToolResponse(payload);
+    }
+  }
+  if (toolName === "get_code") {
+    try {
+      return createCodeToolResponse(payload);
+    } catch (error) {
+      log.warn({ error }, "Failed to format get_code result; returning raw payload.");
+      return coercePayloadToToolResponse(payload);
+    }
+  }
+  return coercePayloadToToolResponse(payload);
+}
+function coercePayloadToToolResponse(payload) {
+  if (payload && typeof payload === "object" && Array.isArray(payload.content)) {
+    return payload;
+  }
+  return {
+    content: [
+      {
+        type: "text",
+        text: typeof payload === "string" ? payload : JSON.stringify(payload, null, 2)
+      }
+    ]
+  };
+}
+function createCodeToolResponse(payload) {
+  if (!isCodeResult(payload)) {
+    throw new Error("Invalid get_code payload received from extension.");
+  }
+  const normalized = normalizeCodeResult(payload);
+  const summary = [];
+  const codeSize = Buffer.byteLength(normalized.code, "utf8");
+  summary.push(`Generated ${normalized.lang.toUpperCase()} snippet (${formatBytes(codeSize)}).`);
+  if (normalized.message) {
+    summary.push(normalized.message);
+  }
+  summary.push(
+    normalized.assets.length ? `Assets attached: ${normalized.assets.length}. Fetch bytes via resources/read using resourceUri or call get_assets.` : "No binary assets were attached to this response."
+  );
+  if (normalized.usedTokens?.length) {
+    summary.push(`Token references included: ${normalized.usedTokens.length}.`);
+  }
+  summary.push("Read structuredContent for the full code string and asset metadata.");
+  return {
+    content: [
+      {
+        type: "text",
+        text: summary.join("\n")
+      }
+    ],
+    structuredContent: normalized
+  };
+}
+function isCodeResult(payload) {
+  if (typeof payload !== "object" || !payload) return false;
+  const candidate = payload;
+  return typeof candidate.code === "string" && typeof candidate.lang === "string" && Array.isArray(candidate.assets);
+}
+function normalizeCodeResult(result) {
+  const updatedAssets = result.assets.map((asset) => enrichAssetDescriptor(asset));
+  const rewrittenCode = rewriteCodeAssetUrls(result.code, updatedAssets);
+  return {
+    ...result,
+    code: rewrittenCode,
+    assets: updatedAssets
+  };
+}
+function rewriteCodeAssetUrls(code, assets) {
+  let updatedCode = code;
+  for (const asset of assets) {
+    const uriPattern = new RegExp(escapeRegExp(asset.resourceUri), "g");
+    updatedCode = updatedCode.replace(uriPattern, asset.url);
+  }
+  return updatedCode;
+}
+function enrichAssetDescriptor(asset) {
+  const record = assetStore.get(asset.hash);
+  if (!record) {
+    return asset;
+  }
+  return buildAssetDescriptor(record);
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 function getActiveId() {
   return extensions.find((e) => e.active)?.id ?? null;
 }
@@ -236,7 +973,15 @@ function scheduleAutoActivate() {
       log.info({ id: target.id }, "Auto-activated sole extension after grace period.");
       broadcastState();
     }
-  }, AUTO_ACTIVATE_GRACE_MS);
+  }, autoActivateGraceMs);
+}
+function unrefTimer(timer) {
+  if (typeof timer === "object" && timer !== null) {
+    const handle = timer;
+    if (typeof handle.unref === "function") {
+      handle.unref();
+    }
+  }
 }
 function broadcastState() {
   const activeId = getActiveId();
@@ -244,13 +989,64 @@ function broadcastState() {
     type: "state",
     activeId,
     count: extensions.length,
-    port: selectedWsPort
+    port: selectedWsPort,
+    assetServerUrl: assetHttpServer.getBaseUrl()
   };
   extensions.forEach((ext) => ext.ws.send(JSON.stringify(message)));
   log.debug({ activeId, count: extensions.length }, "Broadcasted state.");
 }
+function rawDataToBuffer(raw) {
+  if (typeof raw === "string") return Buffer.from(raw);
+  if (Buffer.isBuffer(raw)) return raw;
+  if (raw instanceof ArrayBuffer) return Buffer.from(raw);
+  return Buffer.concat(raw);
+}
+function createScreenshotToolResponse(payload) {
+  if (!isScreenshotResult(payload)) {
+    throw new Error("Invalid get_screenshot payload received from extension.");
+  }
+  const descriptionBlock = {
+    type: "text",
+    text: describeScreenshot(payload)
+  };
+  return {
+    content: [
+      descriptionBlock,
+      {
+        type: "text",
+        text: `![Screenshot](${payload.asset.url})`
+      },
+      createResourceLinkBlock(payload.asset, payload)
+    ],
+    structuredContent: payload
+  };
+}
+function createResourceLinkBlock(asset, result) {
+  return {
+    type: "resource_link",
+    name: "Screenshot",
+    uri: asset.resourceUri,
+    mimeType: asset.mimeType,
+    description: `Screenshot ${result.width}x${result.height} @${result.scale}x - Download: ${asset.url}`
+  };
+}
+function describeScreenshot(result) {
+  return `Screenshot ${result.width}x${result.height} @${result.scale}x (${formatBytes(result.bytes)})`;
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function isScreenshotResult(payload) {
+  if (typeof payload !== "object" || !payload) return false;
+  const candidate = payload;
+  return typeof candidate.asset === "object" && candidate.asset !== null && typeof candidate.width === "number" && typeof candidate.height === "number" && typeof candidate.scale === "number" && typeof candidate.bytes === "number" && typeof candidate.format === "string";
+}
 function shutdown() {
   log.info("Hub is shutting down...");
+  assetStore.flush();
+  assetHttpServer.stop();
   netServer.close(() => log.info("Net server closed."));
   wss?.close(() => log.info("WebSocket server closed."));
   cleanupAll();
@@ -258,19 +1054,19 @@ function shutdown() {
     log.warn("Shutdown timed out. Forcing exit.");
     process.exit(1);
   }, SHUTDOWN_TIMEOUT);
-  timer.unref();
+  unrefTimer(timer);
 }
 try {
   ensureDir(RUNTIME_DIR);
-  if (process.platform !== "win32" && existsSync(SOCK_PATH)) {
+  if (process.platform !== "win32" && existsSync3(SOCK_PATH)) {
     log.warn({ sock: SOCK_PATH }, "Removing stale socket file.");
-    rmSync(SOCK_PATH);
+    rmSync2(SOCK_PATH);
   }
 } catch (error) {
   log.error({ err: error }, "Failed to initialize runtime environment.");
   process.exit(1);
 }
-var netServer = createServer((sock) => {
+var netServer = createServer2((sock) => {
   consumerCount++;
   log.info(`Consumer connected. Total: ${consumerCount}`);
   const transport = new StdioServerTransport(sock, sock);
@@ -307,11 +1103,11 @@ netServer.listen(SOCK_PATH, () => {
   log.info({ sock: SOCK_PATH }, "Hub socket ready.");
 });
 async function startWebSocketServer() {
-  for (const candidate of WS_PORT_CANDIDATES) {
+  for (const candidate of wsPortCandidates) {
     const server = new WebSocketServer({
       host: "127.0.0.1",
       port: candidate,
-      maxPayload: MAX_PAYLOAD_SIZE
+      maxPayload: maxPayloadBytes
     });
     try {
       await new Promise((resolve2, reject2) => {
@@ -339,7 +1135,7 @@ async function startWebSocketServer() {
     }
   }
   log.error(
-    { candidates: WS_PORT_CANDIDATES },
+    { candidates: wsPortCandidates },
     "Unable to start WebSocket server on any candidate port."
   );
   process.exit(1);
@@ -351,22 +1147,19 @@ wss.on("error", (err) => {
   process.exit(1);
 });
 wss.on("connection", (ws) => {
-  const ext = { id: nanoid2(), ws, active: false };
+  const ext = { id: nanoid3(), ws, active: false };
   extensions.push(ext);
   log.info({ id: ext.id }, `Extension connected. Total: ${extensions.length}`);
   const message = { type: "registered", id: ext.id };
   ws.send(JSON.stringify(message));
   broadcastState();
   scheduleAutoActivate();
-  ws.on("message", (raw) => {
-    let messageBuffer;
-    if (Buffer.isBuffer(raw)) {
-      messageBuffer = raw;
-    } else if (raw instanceof ArrayBuffer) {
-      messageBuffer = Buffer.from(raw);
-    } else {
-      messageBuffer = Buffer.concat(raw);
+  ws.on("message", (raw, isBinary) => {
+    if (isBinary) {
+      log.warn({ extId: ext.id }, "Unexpected binary message received.");
+      return;
     }
+    const messageBuffer = rawDataToBuffer(raw);
     let parsedJson;
     try {
       parsedJson = JSON.parse(messageBuffer.toString("utf-8"));