@zythum02/fello-server 0.1.42 → 0.1.45

package/out/scripts/mcp-toolbox/server.mjs

@@ -0,0 +1,482 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import * as http from "http";
+const base64EncodeRequestSchema = z.object({
+  text: z.string().describe("The text string to encode into Base64.")
+});
+const base64EncodeRespondSchema = z.object({
+  result: z.string()
+});
+const base64DecodeRequestSchema = z.object({
+  base64: z.string().describe("The Base64-encoded string to decode back into text.")
+});
+const base64DecodeRespondSchema = z.object({
+  result: z.string()
+});
+const urlEncodeRequestSchema = z.object({
+  text: z.string().describe("The text string to URL-encode.")
+});
+const urlEncodeRespondSchema = z.object({
+  result: z.string()
+});
+const urlDecodeRequestSchema = z.object({
+  text: z.string().describe("The URL-encoded string to decode.")
+});
+const urlDecodeRespondSchema = z.object({
+  result: z.string()
+});
+const hashRequestSchema = z.object({
+  text: z.string().describe("The text to hash."),
+  algorithm: z.enum(["md5", "sha1", "sha256"]).default("sha256").describe("Hash algorithm: md5, sha1, or sha256. Default: sha256.")
+});
+const hashRespondSchema = z.object({
+  result: z.string()
+});
+const timeRequestSchema = z.object({
+  format: z.enum(["iso", "timestamp"]).default("iso").describe(
+    "Output format: 'iso' for ISO 8601 string, 'timestamp' for Unix timestamp in seconds."
+  )
+});
+const timeRespondSchema = z.object({
+  result: z.union([z.string(), z.number()])
+});
+const uuidRequestSchema = z.object({});
+const uuidRespondSchema = z.object({
+  result: z.string()
+});
+const shortIdRequestSchema = z.object({
+  length: z.number().int().min(4).max(32).default(8).describe("Length of the short ID (4-32). Default: 8.")
+});
+const shortIdRespondSchema = z.object({
+  result: z.string()
+});
+const randomRequestSchema = z.object({
+  length: z.number().int().min(1).max(256).default(16).describe("Length of the random string (1-256). Default: 16."),
+  charset: z.enum(["alphanumeric", "alpha", "numeric", "hex"]).default("alphanumeric").describe("Character set: alphanumeric, alpha, numeric, or hex. Default: alphanumeric.")
+});
+const randomRespondSchema = z.object({
+  result: z.string()
+});
+const randIntRequestSchema = z.object({
+  min: z.number().int().describe("Minimum value (inclusive)."),
+  max: z.number().int().describe("Maximum value (inclusive).")
+});
+const randIntRespondSchema = z.object({
+  result: z.number().int()
+});
+const choiceRequestSchema = z.object({
+  items: z.array(z.string()).min(1).describe("Array of items to choose from.")
+});
+const choiceRespondSchema = z.object({
+  result: z.string()
+});
+const shuffleRequestSchema = z.object({
+  items: z.array(z.string()).min(1).describe("Array of items to shuffle.")
+});
+const shuffleRespondSchema = z.object({
+  result: z.array(z.string())
+});
+const imageMetadataRequestSchema = z.object({
+  path: z.string().describe("Absolute or project-relative path to the image file.")
+});
+const imageMetadataRespondSchema = z.object({
+  result: z.object({
+    width: z.number().optional(),
+    height: z.number().optional(),
+    format: z.string().optional(),
+    space: z.string().optional(),
+    channels: z.number().optional(),
+    depth: z.string().optional(),
+    density: z.number().optional(),
+    hasAlpha: z.boolean().optional(),
+    size: z.number().optional()
+  })
+});
+const imageThumbnailRequestSchema = z.object({
+  path: z.string().describe("Absolute or project-relative path to the source image."),
+  width: z.number().int().min(1).max(1024).default(200).describe("Thumbnail width in pixels (1-1024). Default: 200."),
+  output: z.string().optional().describe("Output path. If omitted, saves alongside source with '.thumb{width}' suffix.")
+});
+const imageThumbnailRespondSchema = z.object({
+  result: z.object({
+    output: z.string(),
+    metadata: imageMetadataRespondSchema.shape.result
+  })
+});
+const imageResizeRequestSchema = z.object({
+  path: z.string().describe("Absolute or project-relative path to the source image."),
+  width: z.number().int().min(1).optional().describe("Target width in pixels."),
+  height: z.number().int().min(1).optional().describe("Target height in pixels."),
+  fit: z.enum(["cover", "contain", "fill", "inside", "outside"]).default("inside").describe("How to fit the image: cover, contain, fill, inside, outside. Default: inside."),
+  output: z.string().optional().describe("Output path. If omitted, saves alongside source with '.{width}x{height}' suffix.")
+});
+const imageResizeRespondSchema = z.object({
+  result: z.object({
+    output: z.string(),
+    metadata: imageMetadataRespondSchema.shape.result
+  })
+});
+const imageConvertRequestSchema = z.object({
+  path: z.string().describe("Absolute or project-relative path to the source image."),
+  format: z.enum(["jpeg", "png", "webp", "avif", "tiff"]).describe("Target image format."),
+  quality: z.number().int().min(1).max(100).optional().describe("Quality for lossy formats (1-100). Applies to jpeg, webp, avif."),
+  output: z.string().optional().describe("Output path. If omitted, saves alongside source with new extension.")
+});
+const imageConvertRespondSchema = z.object({
+  result: z.object({
+    output: z.string(),
+    metadata: imageMetadataRespondSchema.shape.result
+  })
+});
+function getArg(name) {
+  const idx = process.argv.indexOf(`--${name}`);
+  return idx !== -1 ? process.argv[idx + 1] : void 0;
+}
+const socketPath = getArg("socket-path");
+const projectDir = getArg("project-dir");
+if (!socketPath) {
+  console.error("[mcp-toolbox] Missing required argument: --socket-path");
+  process.exit(1);
+}
+if (!projectDir) {
+  console.error("[mcp-toolbox] Missing required argument: --project-dir");
+  process.exit(1);
+}
+const server = new McpServer({
+  name: "Toolbox",
+  version: "1.0.0",
+  description: "Built-in utility tools: base64, URL encode/decode, hash, time, UUID, random, etc."
+});
+server.registerTool(
+  "base64_encode",
+  {
+    description: "Encode a text string into Base64 format. Supports UTF-8 text.",
+    inputSchema: base64EncodeRequestSchema
+  },
+  async (input) => {
+    try {
+      const res = base64EncodeRespondSchema.parse(
+        await postToSocket("/toolbox/base64-encode", { text: input.text })
+      );
+      return { content: [{ type: "text", text: res.result }] };
+    } catch (err) {
+      return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+server.registerTool(
+  "base64_decode",
+  {
+    description: "Decode a Base64-encoded string back into UTF-8 text.",
+    inputSchema: base64DecodeRequestSchema
+  },
+  async (input) => {
+    try {
+      const res = base64DecodeRespondSchema.parse(
+        await postToSocket("/toolbox/base64-decode", { base64: input.base64 })
+      );
+      return { content: [{ type: "text", text: res.result }] };
+    } catch (err) {
+      return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+server.registerTool(
+  "url_encode",
+  {
+    description: "URL-encode a text string (percent-encoding).",
+    inputSchema: urlEncodeRequestSchema
+  },
+  async (input) => {
+    try {
+      const res = urlEncodeRespondSchema.parse(
+        await postToSocket("/toolbox/url-encode", { text: input.text })
+      );
+      return { content: [{ type: "text", text: res.result }] };
+    } catch (err) {
+      return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+server.registerTool(
+  "url_decode",
+  {
+    description: "Decode a URL-encoded (percent-encoded) string back into text.",
+    inputSchema: urlDecodeRequestSchema
+  },
+  async (input) => {
+    try {
+      const res = urlDecodeRespondSchema.parse(
+        await postToSocket("/toolbox/url-decode", { text: input.text })
+      );
+      return { content: [{ type: "text", text: res.result }] };
+    } catch (err) {
+      return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+server.registerTool(
+  "hash",
+  {
+    description: "Compute a hash (MD5, SHA1, or SHA256) of a text string. Returns hex digest.",
+    inputSchema: hashRequestSchema
+  },
+  async (input) => {
+    try {
+      const res = hashRespondSchema.parse(
+        await postToSocket("/toolbox/hash", {
+          text: input.text,
+          algorithm: input.algorithm
+        })
+      );
+      return { content: [{ type: "text", text: res.result }] };
+    } catch (err) {
+      return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+server.registerTool(
+  "time",
+  {
+    description: "Get the current time. Returns either an ISO 8601 string or a Unix timestamp in seconds.",
+    inputSchema: timeRequestSchema
+  },
+  async (input) => {
+    try {
+      const res = timeRespondSchema.parse(
+        await postToSocket("/toolbox/time", { format: input.format })
+      );
+      return { content: [{ type: "text", text: String(res.result) }] };
+    } catch (err) {
+      return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+server.registerTool(
+  "uuid",
+  {
+    description: "Generate a random UUID v4.",
+    inputSchema: uuidRequestSchema
+  },
+  async () => {
+    try {
+      const res = uuidRespondSchema.parse(await postToSocket("/toolbox/uuid", {}));
+      return { content: [{ type: "text", text: res.result }] };
+    } catch (err) {
+      return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+server.registerTool(
+  "short_id",
+  {
+    description: "Generate a short random alphanumeric ID.",
+    inputSchema: shortIdRequestSchema
+  },
+  async (input) => {
+    try {
+      const res = shortIdRespondSchema.parse(
+        await postToSocket("/toolbox/short-id", { length: input.length })
+      );
+      return { content: [{ type: "text", text: res.result }] };
+    } catch (err) {
+      return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+server.registerTool(
+  "random",
+  {
+    description: "Generate a random string with specified length and character set.",
+    inputSchema: randomRequestSchema
+  },
+  async (input) => {
+    try {
+      const res = randomRespondSchema.parse(
+        await postToSocket("/toolbox/random", {
+          length: input.length,
+          charset: input.charset
+        })
+      );
+      return { content: [{ type: "text", text: res.result }] };
+    } catch (err) {
+      return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+server.registerTool(
+  "rand_int",
+  {
+    description: "Generate a random integer between min and max (inclusive).",
+    inputSchema: randIntRequestSchema
+  },
+  async (input) => {
+    try {
+      const res = randIntRespondSchema.parse(
+        await postToSocket("/toolbox/rand-int", { min: input.min, max: input.max })
+      );
+      return { content: [{ type: "text", text: String(res.result) }] };
+    } catch (err) {
+      return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+server.registerTool(
+  "choice",
+  {
+    description: "Pick a random item from an array.",
+    inputSchema: choiceRequestSchema
+  },
+  async (input) => {
+    try {
+      const res = choiceRespondSchema.parse(
+        await postToSocket("/toolbox/choice", { items: input.items })
+      );
+      return { content: [{ type: "text", text: res.result }] };
+    } catch (err) {
+      return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+server.registerTool(
+  "shuffle",
+  {
+    description: "Shuffle an array randomly (Fisher-Yates).",
+    inputSchema: shuffleRequestSchema
+  },
+  async (input) => {
+    try {
+      const res = shuffleRespondSchema.parse(
+        await postToSocket("/toolbox/shuffle", { items: input.items })
+      );
+      return { content: [{ type: "text", text: JSON.stringify(res.result) }] };
+    } catch (err) {
+      return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+server.registerTool(
+  "image_metadata",
+  {
+    description: "Read image metadata (width, height, format, color space, channels, etc.) from a file.",
+    inputSchema: imageMetadataRequestSchema
+  },
+  async (input) => {
+    try {
+      const res = imageMetadataRespondSchema.parse(
+        await postToSocket("/toolbox/image-metadata", { path: input.path })
+      );
+      return { content: [{ type: "text", text: JSON.stringify(res.result, null, 2) }] };
+    } catch (err) {
+      return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+server.registerTool(
+  "image_thumbnail",
+  {
+    description: "Generate a thumbnail from an image. Returns the output file path and new image metadata.",
+    inputSchema: imageThumbnailRequestSchema
+  },
+  async (input) => {
+    try {
+      const res = imageThumbnailRespondSchema.parse(
+        await postToSocket("/toolbox/image-thumbnail", {
+          path: input.path,
+          width: input.width,
+          output: input.output
+        })
+      );
+      return { content: [{ type: "text", text: JSON.stringify(res.result, null, 2) }] };
+    } catch (err) {
+      return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+server.registerTool(
+  "image_resize",
+  {
+    description: "Resize an image to specified dimensions. Returns the output file path and new image metadata.",
+    inputSchema: imageResizeRequestSchema
+  },
+  async (input) => {
+    try {
+      const res = imageResizeRespondSchema.parse(
+        await postToSocket("/toolbox/image-resize", {
+          path: input.path,
+          width: input.width,
+          height: input.height,
+          fit: input.fit,
+          output: input.output
+        })
+      );
+      return { content: [{ type: "text", text: JSON.stringify(res.result, null, 2) }] };
+    } catch (err) {
+      return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+server.registerTool(
+  "image_convert",
+  {
+    description: "Convert an image to a different format (jpeg, png, webp, avif, tiff). Returns the output file path and new image metadata.",
+    inputSchema: imageConvertRequestSchema
+  },
+  async (input) => {
+    try {
+      const res = imageConvertRespondSchema.parse(
+        await postToSocket("/toolbox/image-convert", {
+          path: input.path,
+          format: input.format,
+          quality: input.quality,
+          output: input.output
+        })
+      );
+      return { content: [{ type: "text", text: JSON.stringify(res.result, null, 2) }] };
+    } catch (err) {
+      return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+function postToSocket(path, body) {
+  return new Promise((resolve, reject) => {
+    const data = JSON.stringify(body);
+    const options = {
+      socketPath,
+      path,
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Content-Length": Buffer.byteLength(data)
+      }
+    };
+    const req = http.request(options, (res) => {
+      const chunks = [];
+      res.on("data", (chunk) => chunks.push(chunk));
+      res.on("end", () => {
+        const raw = Buffer.concat(chunks).toString("utf8");
+        try {
+          const parsed = JSON.parse(raw);
+          if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+            resolve(parsed);
+          } else {
+            reject(new Error(parsed.error || `HTTP ${res.statusCode}: ${raw}`));
+          }
+        } catch {
+          reject(new Error(`Invalid response (${res.statusCode}): ${raw}`));
+        }
+      });
+    });
+    req.on("error", (err) => {
+      reject(new Error(`Socket request failed: ${err.message}`));
+    });
+    req.write(data);
+    req.end();
+  });
+}
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+main().catch(console.error);

package/out/scripts/worker-file-outline/worker.mjs

@@ -232,6 +232,7 @@ async function parse(req) {
   if (!tree) throw new Error("Failed to parse");
   let result = [];
   const typeSet = new Set(req.symbols.flatMap((s) => s.types));
+  const symbolScanBoundaryTypes = new Set(req.symbolScanBoundaryTypes || []);
   const detailLabels = req.statementDetail ? new Set(req.statementDetail.labels || DEFAULT_DETAIL_LABELS) : null;
   const cursor = tree.walk();
   try {
@@ -289,6 +290,10 @@ async function parse(req) {
           }
         }
       }
+      if (descend && symbolScanBoundaryTypes.has(t)) {
+        descend = false;
+        continue;
+      }
       if (descend && cursor.gotoFirstChild()) continue;
       if (cursor.gotoNextSibling()) {
         descend = true;