@fil-b/foc-storage-mcp 0.1.9 → 0.2.0

package/README.md

@@ -45,11 +45,24 @@ After installation, update `PRIVATE_KEY` in your config. [Learn more](https://cu
 
 ### Claude Code
 
-```bash
-claude mcp add foc-storage -- npx -y @fil-b/foc-storage-mcp
+Add to `.mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "foc-storage": {
+      "command": "npx",
+      "args": ["-y", "@fil-b/foc-storage-mcp"],
+      "env": {
+        "PRIVATE_KEY": "your_private_key_here",
+        "FILECOIN_NETWORK": "calibration"
+      }
+    }
+  }
+}
 ```
 
-Edit `.mcp.json` to add `PRIVATE_KEY`. [Learn more](https://docs.claude.com/en/docs/claude-code/mcp)
+[Learn more](https://docs.claude.com/en/docs/claude-code/mcp)
 
 ### Claude Desktop
 
@@ -188,17 +201,6 @@ Ask naturally in Claude, Cursor, or any MCP client:
 
 ## Troubleshooting
 
-**"Unexpected token 'with'" or import syntax error:**
-
-1. Verify Node.js >= 20.10.0: `node --version`
-2. Clear npx cache:
-   - Command: `npx clear-npx-cache`
-   - Windows: Delete `%LOCALAPPDATA%\npm-cache\_npx`
-   - Linux/Mac: Delete `~/.npm/_npx`
-3. Force fresh install: `npx --yes @fil-b/foc-storage-mcp@latest`
-4. Restart your IDE
-5. If issue persists, check IDE is using correct Node version
-
 **Server not found:** Verify `npx --version`, check JSON syntax, restart IDE
 
 **"PRIVATE_KEY is required":** Add to `env` section, must start with `0x`

package/dist/{mcp-server.js → stdio.js}

@@ -1,17 +1,437 @@
 #!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/.pnpm/dotenv@17.2.3/node_modules/dotenv/package.json
+var require_package = __commonJS({
+  "node_modules/.pnpm/dotenv@17.2.3/node_modules/dotenv/package.json"(exports, module) {
+    module.exports = {
+      name: "dotenv",
+      version: "17.2.3",
+      description: "Loads environment variables from .env file",
+      main: "lib/main.js",
+      types: "lib/main.d.ts",
+      exports: {
+        ".": {
+          types: "./lib/main.d.ts",
+          require: "./lib/main.js",
+          default: "./lib/main.js"
+        },
+        "./config": "./config.js",
+        "./config.js": "./config.js",
+        "./lib/env-options": "./lib/env-options.js",
+        "./lib/env-options.js": "./lib/env-options.js",
+        "./lib/cli-options": "./lib/cli-options.js",
+        "./lib/cli-options.js": "./lib/cli-options.js",
+        "./package.json": "./package.json"
+      },
+      scripts: {
+        "dts-check": "tsc --project tests/types/tsconfig.json",
+        lint: "standard",
+        pretest: "npm run lint && npm run dts-check",
+        test: "tap run tests/**/*.js --allow-empty-coverage --disable-coverage --timeout=60000",
+        "test:coverage": "tap run tests/**/*.js --show-full-coverage --timeout=60000 --coverage-report=text --coverage-report=lcov",
+        prerelease: "npm test",
+        release: "standard-version"
+      },
+      repository: {
+        type: "git",
+        url: "git://github.com/motdotla/dotenv.git"
+      },
+      homepage: "https://github.com/motdotla/dotenv#readme",
+      funding: "https://dotenvx.com",
+      keywords: [
+        "dotenv",
+        "env",
+        ".env",
+        "environment",
+        "variables",
+        "config",
+        "settings"
+      ],
+      readmeFilename: "README.md",
+      license: "BSD-2-Clause",
+      devDependencies: {
+        "@types/node": "^18.11.3",
+        decache: "^4.6.2",
+        sinon: "^14.0.1",
+        standard: "^17.0.0",
+        "standard-version": "^9.5.0",
+        tap: "^19.2.0",
+        typescript: "^4.8.4"
+      },
+      engines: {
+        node: ">=12"
+      },
+      browser: {
+        fs: false
+      }
+    };
+  }
+});
 
-// src/mcp-server.ts
-import { config as config2 } from "dotenv";
+// node_modules/.pnpm/dotenv@17.2.3/node_modules/dotenv/lib/main.js
+var require_main = __commonJS({
+  "node_modules/.pnpm/dotenv@17.2.3/node_modules/dotenv/lib/main.js"(exports, module) {
+    "use strict";
+    var fs3 = __require("fs");
+    var path = __require("path");
+    var os = __require("os");
+    var crypto = __require("crypto");
+    var packageJson = require_package();
+    var version = packageJson.version;
+    var TIPS = [
+      "\u{1F510} encrypt with Dotenvx: https://dotenvx.com",
+      "\u{1F510} prevent committing .env to code: https://dotenvx.com/precommit",
+      "\u{1F510} prevent building .env in docker: https://dotenvx.com/prebuild",
+      "\u{1F4E1} add observability to secrets: https://dotenvx.com/ops",
+      "\u{1F465} sync secrets across teammates & machines: https://dotenvx.com/ops",
+      "\u{1F5C2}\uFE0F backup and recover secrets: https://dotenvx.com/ops",
+      "\u2705 audit secrets and track compliance: https://dotenvx.com/ops",
+      "\u{1F504} add secrets lifecycle management: https://dotenvx.com/ops",
+      "\u{1F511} add access controls to secrets: https://dotenvx.com/ops",
+      "\u{1F6E0}\uFE0F  run anywhere with `dotenvx run -- yourcommand`",
+      "\u2699\uFE0F  specify custom .env file path with { path: '/custom/path/.env' }",
+      "\u2699\uFE0F  enable debug logging with { debug: true }",
+      "\u2699\uFE0F  override existing env vars with { override: true }",
+      "\u2699\uFE0F  suppress all logs with { quiet: true }",
+      "\u2699\uFE0F  write to custom object with { processEnv: myObject }",
+      "\u2699\uFE0F  load multiple .env files with { path: ['.env.local', '.env'] }"
+    ];
+    function _getRandomTip() {
+      return TIPS[Math.floor(Math.random() * TIPS.length)];
+    }
+    function parseBoolean(value) {
+      if (typeof value === "string") {
+        return !["false", "0", "no", "off", ""].includes(value.toLowerCase());
+      }
+      return Boolean(value);
+    }
+    function supportsAnsi() {
+      return process.stdout.isTTY;
+    }
+    function dim(text) {
+      return supportsAnsi() ? `\x1B[2m${text}\x1B[0m` : text;
+    }
+    var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
+    function parse(src) {
+      const obj = {};
+      let lines = src.toString();
+      lines = lines.replace(/\r\n?/mg, "\n");
+      let match;
+      while ((match = LINE.exec(lines)) != null) {
+        const key = match[1];
+        let value = match[2] || "";
+        value = value.trim();
+        const maybeQuote = value[0];
+        value = value.replace(/^(['"`])([\s\S]*)\1$/mg, "$2");
+        if (maybeQuote === '"') {
+          value = value.replace(/\\n/g, "\n");
+          value = value.replace(/\\r/g, "\r");
+        }
+        obj[key] = value;
+      }
+      return obj;
+    }
+    function _parseVault(options) {
+      options = options || {};
+      const vaultPath = _vaultPath(options);
+      options.path = vaultPath;
+      const result = DotenvModule.configDotenv(options);
+      if (!result.parsed) {
+        const err = new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
+        err.code = "MISSING_DATA";
+        throw err;
+      }
+      const keys = _dotenvKey(options).split(",");
+      const length = keys.length;
+      let decrypted;
+      for (let i = 0; i < length; i++) {
+        try {
+          const key = keys[i].trim();
+          const attrs = _instructions(result, key);
+          decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
+          break;
+        } catch (error) {
+          if (i + 1 >= length) {
+            throw error;
+          }
+        }
+      }
+      return DotenvModule.parse(decrypted);
+    }
+    function _warn(message) {
+      console.error(`[dotenv@${version}][WARN] ${message}`);
+    }
+    function _debug(message) {
+      console.log(`[dotenv@${version}][DEBUG] ${message}`);
+    }
+    function _log(message) {
+      console.log(`[dotenv@${version}] ${message}`);
+    }
+    function _dotenvKey(options) {
+      if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) {
+        return options.DOTENV_KEY;
+      }
+      if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) {
+        return process.env.DOTENV_KEY;
+      }
+      return "";
+    }
+    function _instructions(result, dotenvKey) {
+      let uri;
+      try {
+        uri = new URL(dotenvKey);
+      } catch (error) {
+        if (error.code === "ERR_INVALID_URL") {
+          const err = new Error("INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development");
+          err.code = "INVALID_DOTENV_KEY";
+          throw err;
+        }
+        throw error;
+      }
+      const key = uri.password;
+      if (!key) {
+        const err = new Error("INVALID_DOTENV_KEY: Missing key part");
+        err.code = "INVALID_DOTENV_KEY";
+        throw err;
+      }
+      const environment = uri.searchParams.get("environment");
+      if (!environment) {
+        const err = new Error("INVALID_DOTENV_KEY: Missing environment part");
+        err.code = "INVALID_DOTENV_KEY";
+        throw err;
+      }
+      const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`;
+      const ciphertext = result.parsed[environmentKey];
+      if (!ciphertext) {
+        const err = new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`);
+        err.code = "NOT_FOUND_DOTENV_ENVIRONMENT";
+        throw err;
+      }
+      return { ciphertext, key };
+    }
+    function _vaultPath(options) {
+      let possibleVaultPath = null;
+      if (options && options.path && options.path.length > 0) {
+        if (Array.isArray(options.path)) {
+          for (const filepath of options.path) {
+            if (fs3.existsSync(filepath)) {
+              possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
+            }
+          }
+        } else {
+          possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
+        }
+      } else {
+        possibleVaultPath = path.resolve(process.cwd(), ".env.vault");
+      }
+      if (fs3.existsSync(possibleVaultPath)) {
+        return possibleVaultPath;
+      }
+      return null;
+    }
+    function _resolveHome(envPath) {
+      return envPath[0] === "~" ? path.join(os.homedir(), envPath.slice(1)) : envPath;
+    }
+    function _configVault(options) {
+      const debug = parseBoolean(process.env.DOTENV_CONFIG_DEBUG || options && options.debug);
+      const quiet = parseBoolean(process.env.DOTENV_CONFIG_QUIET || options && options.quiet);
+      if (debug || !quiet) {
+        _log("Loading env from encrypted .env.vault");
+      }
+      const parsed = DotenvModule._parseVault(options);
+      let processEnv = process.env;
+      if (options && options.processEnv != null) {
+        processEnv = options.processEnv;
+      }
+      DotenvModule.populate(processEnv, parsed, options);
+      return { parsed };
+    }
+    function configDotenv(options) {
+      const dotenvPath = path.resolve(process.cwd(), ".env");
+      let encoding = "utf8";
+      let processEnv = process.env;
+      if (options && options.processEnv != null) {
+        processEnv = options.processEnv;
+      }
+      let debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || options && options.debug);
+      let quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || options && options.quiet);
+      if (options && options.encoding) {
+        encoding = options.encoding;
+      } else {
+        if (debug) {
+          _debug("No encoding is specified. UTF-8 is used by default");
+        }
+      }
+      let optionPaths = [dotenvPath];
+      if (options && options.path) {
+        if (!Array.isArray(options.path)) {
+          optionPaths = [_resolveHome(options.path)];
+        } else {
+          optionPaths = [];
+          for (const filepath of options.path) {
+            optionPaths.push(_resolveHome(filepath));
+          }
+        }
+      }
+      let lastError;
+      const parsedAll = {};
+      for (const path2 of optionPaths) {
+        try {
+          const parsed = DotenvModule.parse(fs3.readFileSync(path2, { encoding }));
+          DotenvModule.populate(parsedAll, parsed, options);
+        } catch (e) {
+          if (debug) {
+            _debug(`Failed to load ${path2} ${e.message}`);
+          }
+          lastError = e;
+        }
+      }
+      const populated = DotenvModule.populate(processEnv, parsedAll, options);
+      debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || debug);
+      quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || quiet);
+      if (debug || !quiet) {
+        const keysCount = Object.keys(populated).length;
+        const shortPaths = [];
+        for (const filePath of optionPaths) {
+          try {
+            const relative = path.relative(process.cwd(), filePath);
+            shortPaths.push(relative);
+          } catch (e) {
+            if (debug) {
+              _debug(`Failed to load ${filePath} ${e.message}`);
+            }
+            lastError = e;
+          }
+        }
+        _log(`injecting env (${keysCount}) from ${shortPaths.join(",")} ${dim(`-- tip: ${_getRandomTip()}`)}`);
+      }
+      if (lastError) {
+        return { parsed: parsedAll, error: lastError };
+      } else {
+        return { parsed: parsedAll };
+      }
+    }
+    function config2(options) {
+      if (_dotenvKey(options).length === 0) {
+        return DotenvModule.configDotenv(options);
+      }
+      const vaultPath = _vaultPath(options);
+      if (!vaultPath) {
+        _warn(`You set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}. Did you forget to build it?`);
+        return DotenvModule.configDotenv(options);
+      }
+      return DotenvModule._configVault(options);
+    }
+    function decrypt(encrypted, keyStr) {
+      const key = Buffer.from(keyStr.slice(-64), "hex");
+      let ciphertext = Buffer.from(encrypted, "base64");
+      const nonce = ciphertext.subarray(0, 12);
+      const authTag = ciphertext.subarray(-16);
+      ciphertext = ciphertext.subarray(12, -16);
+      try {
+        const aesgcm = crypto.createDecipheriv("aes-256-gcm", key, nonce);
+        aesgcm.setAuthTag(authTag);
+        return `${aesgcm.update(ciphertext)}${aesgcm.final()}`;
+      } catch (error) {
+        const isRange = error instanceof RangeError;
+        const invalidKeyLength = error.message === "Invalid key length";
+        const decryptionFailed = error.message === "Unsupported state or unable to authenticate data";
+        if (isRange || invalidKeyLength) {
+          const err = new Error("INVALID_DOTENV_KEY: It must be 64 characters long (or more)");
+          err.code = "INVALID_DOTENV_KEY";
+          throw err;
+        } else if (decryptionFailed) {
+          const err = new Error("DECRYPTION_FAILED: Please check your DOTENV_KEY");
+          err.code = "DECRYPTION_FAILED";
+          throw err;
+        } else {
+          throw error;
+        }
+      }
+    }
+    function populate(processEnv, parsed, options = {}) {
+      const debug = Boolean(options && options.debug);
+      const override = Boolean(options && options.override);
+      const populated = {};
+      if (typeof parsed !== "object") {
+        const err = new Error("OBJECT_REQUIRED: Please check the processEnv argument being passed to populate");
+        err.code = "OBJECT_REQUIRED";
+        throw err;
+      }
+      for (const key of Object.keys(parsed)) {
+        if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
+          if (override === true) {
+            processEnv[key] = parsed[key];
+            populated[key] = parsed[key];
+          }
+          if (debug) {
+            if (override === true) {
+              _debug(`"${key}" is already defined and WAS overwritten`);
+            } else {
+              _debug(`"${key}" is already defined and was NOT overwritten`);
+            }
+          }
+        } else {
+          processEnv[key] = parsed[key];
+          populated[key] = parsed[key];
+        }
+      }
+      return populated;
+    }
+    var DotenvModule = {
+      configDotenv,
+      _configVault,
+      _parseVault,
+      config: config2,
+      decrypt,
+      parse,
+      populate
+    };
+    module.exports.configDotenv = DotenvModule.configDotenv;
+    module.exports._configVault = DotenvModule._configVault;
+    module.exports._parseVault = DotenvModule._parseVault;
+    module.exports.config = DotenvModule.config;
+    module.exports.decrypt = DotenvModule.decrypt;
+    module.exports.parse = DotenvModule.parse;
+    module.exports.populate = DotenvModule.populate;
+    module.exports = DotenvModule;
+  }
+});
 
-// src/mastra/index.ts
-import { Mastra } from "@mastra/core/mastra";
-import { PinoLogger } from "@mastra/loggers";
-import { LibSQLStore } from "@mastra/libsql";
+// src/mastra/stdio.ts
 import { MCPServer } from "@mastra/mcp";
 
-// src/mastra/agents/foc-storage-agent.ts
-import { Agent } from "@mastra/core/agent";
-
 // src/mastra/tools/dataset-tools.ts
 import { createTool } from "@mastra/core";
 
@@ -19,10 +439,10 @@ import { createTool } from "@mastra/core";
 import { z as z2 } from "zod";
 
 // src/config/index.ts
+var import_dotenv = __toESM(require_main(), 1);
 import { calibration, mainnet } from "@filoz/synapse-core/chains";
-import { config } from "dotenv";
 import { z } from "zod";
-config();
+(0, import_dotenv.config)();
 var EnvSchema = z.object({
   PRIVATE_KEY: z.string().min(1, "PRIVATE_KEY is required"),
   FILECOIN_NETWORK: z.enum(["mainnet", "calibration"]).default("calibration"),
@@ -1565,219 +1985,6 @@ var focStorageTools = {
 };
 var focStorageToolsArray = Object.values(focStorageTools);
 
-// src/mastra/workflows/e2e-file-upload.ts
-import { createStep, createWorkflow } from "@mastra/core/workflows";
-import { z as z4 } from "zod";
-var e2eFileUploadInputSchema = z4.object({
-  filePath: z4.string().describe("Absolute path to the file to upload"),
-  datasetId: z4.string().optional().describe("Existing dataset ID to use"),
-  withCDN: z4.boolean().optional().describe("Enable CDN for faster retrieval").default(false),
-  persistenceDays: z4.number().optional().describe("Storage duration in days (default: 180)").default(env.PERSISTENCE_PERIOD_DAYS),
-  notificationThresholdDays: z4.number().optional().describe("Notification threshold in days (default: 10)").default(env.RUNOUT_NOTIFICATION_THRESHOLD_DAYS),
-  fileMetadata: z4.record(z4.string(), z4.string()).optional().describe("Metadata for the file (max 4 key-value pairs)")
-});
-var checkBalanceStep = createStep({
-  id: "checkBalance",
-  description: "Check current FIL/USDFC balances and storage metrics",
-  inputSchema: e2eFileUploadInputSchema,
-  outputSchema: z4.object({
-    balances: z4.any(),
-    needsPayment: z4.boolean(),
-    depositNeeded: z4.number()
-  }),
-  execute: async ({ inputData, runtimeContext }) => {
-    console.log("\u{1F4CA} STEP 1: Checking balances and storage metrics...");
-    const fileInfo = await validateFilePath(inputData.filePath);
-    const expectedStorageBytes = fileInfo.size;
-    const { getBalances: getBalances2 } = focStorageTools;
-    const result = await getBalances2.execute({
-      context: { storageCapacityBytes: expectedStorageBytes, persistencePeriodDays: inputData.persistenceDays, notificationThresholdDays: inputData.notificationThresholdDays },
-      runtimeContext
-    });
-    if (result.success === false) {
-      throw new Error(`Balance check failed: ${result.error || "Unknown error"}`);
-    }
-    if (!result.checkStorageBalanceResult) {
-      throw new Error(`Balance check returned invalid structure`);
-    }
-    return {
-      balances: result.checkStorageBalanceResult,
-      needsPayment: !result.checkStorageBalanceResult.isRateSufficient || !result.checkStorageBalanceResult.isLockupSufficient || Number(result.checkStorageBalanceResult.depositNeeded) > 0,
-      depositNeeded: Number(result.checkStorageBalanceResult.depositNeeded) || 0
-    };
-  }
-});
-var processPaymentStep = createStep({
-  id: "processPayment",
-  description: "Deposit USDFC if insufficient balance detected",
-  inputSchema: z4.object({
-    balances: z4.any(),
-    needsPayment: z4.boolean(),
-    depositNeeded: z4.number()
-  }),
-  outputSchema: z4.object({
-    skipped: z4.boolean(),
-    txHash: z4.string().optional(),
-    depositAmount: z4.string().optional(),
-    message: z4.string().optional()
-  }),
-  execute: async ({ getStepResult, getInitData, runtimeContext }) => {
-    const balanceInfo = getStepResult("checkBalance");
-    const initData = getInitData();
-    const persistenceDays = initData.persistenceDays || 180;
-    if (!balanceInfo.needsPayment) {
-      console.log("\u2705 STEP 2: Balance and allowances are sufficient, skipping payment");
-      return {
-        skipped: true,
-        message: "Payment not needed - balance and allowances sufficient"
-      };
-    }
-    console.log("\u{1F4B0} STEP 2: Processing payment and/or setting allowances...");
-    if (balanceInfo.depositNeeded > 0) {
-      console.log(`   Deposit needed: ${fromBaseUnits(balanceInfo.depositNeeded, 18)} USDFC`);
-    } else {
-      console.log(`   Deposit sufficient, but allowances need to be set`);
-    }
-    console.log(`   Persistence period: ${persistenceDays} days`);
-    const { processPayment: processPayment2 } = focStorageTools;
-    const result = await processPayment2.execute({
-      context: {
-        depositAmount: Number(balanceInfo.depositNeeded)
-      },
-      runtimeContext
-    });
-    if (result.success === false || result.error) {
-      throw new Error(`Payment failed: ${result.error || "Unknown error"}`);
-    }
-    console.log(`\u2705 Payment/allowances processed successfully`);
-    if (result.txHash) {
-      console.log(`   TX Hash: ${result.txHash}`);
-    }
-    if (result.depositAmount) {
-      console.log(`   Deposit Amount: ${result.depositAmount}`);
-    }
-    if (result.message) {
-      console.log(`   ${result.message}`);
-    }
-    return {
-      skipped: false,
-      txHash: result.txHash ?? void 0,
-      depositAmount: result.depositAmount ?? void 0,
-      message: result.message ?? "Payment processed"
-    };
-  }
-});
-var uploadFileStep = createStep({
-  id: "uploadFile",
-  description: "Upload file to Filecoin storage",
-  inputSchema: z4.object({
-    skipped: z4.boolean(),
-    txHash: z4.string().optional(),
-    depositAmount: z4.string().optional(),
-    message: z4.string().optional()
-  }),
-  outputSchema: z4.object({
-    pieceCid: z4.string(),
-    txHash: z4.string().optional(),
-    fileName: z4.string(),
-    fileSize: z4.number(),
-    progressLog: z4.array(z4.string()).optional()
-  }),
-  execute: async ({ getInitData, runtimeContext }) => {
-    const initData = getInitData();
-    console.log("\u{1F4E4} STEP 3: Uploading file to Filecoin...");
-    console.log(`   File: ${initData.filePath}`);
-    const { uploadFile: uploadFile2 } = focStorageTools;
-    const result = await uploadFile2.execute({
-      context: {
-        filePath: initData.filePath,
-        datasetId: initData.datasetId,
-        withCDN: initData.withCDN || false,
-        autoPayment: false,
-        // Already handled in step 2
-        metadata: initData.fileMetadata
-      },
-      runtimeContext
-    });
-    if (result.success === false || result.error) {
-      throw new Error(`File upload failed: ${result.error || "Unknown error"}`);
-    }
-    console.log(`\u2705 File uploaded successfully`);
-    console.log(`   Piece CID: ${result.pieceCid}`);
-    console.log(`   File Name: ${result.fileName}`);
-    console.log(`   File Size: ${result.fileSize} bytes`);
-    return {
-      pieceCid: result.pieceCid,
-      txHash: result.txHash,
-      fileName: result.fileName,
-      fileSize: result.fileSize,
-      progressLog: result.progressLog
-    };
-  }
-});
-var summaryStep = createStep({
-  id: "summary",
-  description: "Generate final summary of the upload process",
-  inputSchema: z4.object({
-    pieceCid: z4.string(),
-    txHash: z4.string().optional(),
-    fileName: z4.string(),
-    fileSize: z4.number(),
-    progressLog: z4.array(z4.string()).optional()
-  }),
-  outputSchema: z4.object({
-    success: z4.boolean(),
-    summary: z4.object({
-      balance: z4.any(),
-      payment: z4.any(),
-      upload: z4.any()
-    })
-  }),
-  execute: async ({ getStepResult }) => {
-    const balanceInfo = getStepResult("checkBalance");
-    const paymentInfo = getStepResult("processPayment");
-    const uploadInfo = getStepResult("uploadFile");
-    console.log("\n\u{1F389} ============================================");
-    console.log("   E2E FILE UPLOAD COMPLETED SUCCESSFULLY");
-    console.log("============================================");
-    console.log(`\u{1F4CA} Initial Balance: ${balanceInfo.balances.accountStatusMessage}`);
-    if (!paymentInfo.skipped) {
-      console.log(`\u{1F4B0} Payment Processed: ${paymentInfo.depositAmount} USDFC`);
-      console.log(`   TX: ${paymentInfo.txHash}`);
-    } else {
-      console.log(`\u{1F4B0} Payment: Not needed (sufficient balance)`);
-    }
-    console.log(`\u{1F4E4} File Uploaded: ${uploadInfo.fileName}`);
-    console.log(`   Size: ${uploadInfo.fileSize} bytes`);
-    console.log(`   Piece CID: ${uploadInfo.pieceCid}`);
-    if (uploadInfo.txHash) {
-      console.log(`   TX: ${uploadInfo.txHash}`);
-    }
-    console.log("============================================\n");
-    return {
-      success: true,
-      summary: {
-        balance: balanceInfo.balances,
-        payment: paymentInfo,
-        upload: uploadInfo
-      }
-    };
-  }
-});
-var e2eFileUploadWorkflow = createWorkflow({
-  id: "e2eFileUpload",
-  description: "Upload a file to Filecoin storage",
-  inputSchema: e2eFileUploadInputSchema,
-  outputSchema: z4.object({
-    success: z4.boolean(),
-    summary: z4.object({
-      balance: z4.any(),
-      payment: z4.any(),
-      upload: z4.any()
-    })
-  })
-}).then(checkBalanceStep).then(processPaymentStep).then(uploadFileStep).then(summaryStep).commit();
-
 // src/mastra/resources/instructions.ts
 var instructions = `You are an AI agent specialized in managing decentralized file storage operations on the Filecoin network using the FOC-Synapse SDK. Your role is to help users store, retrieve, and manage files on Filecoin in a simple, efficient manner.
 
@@ -2011,18 +2218,6 @@ ERROR RESPONSES:
 
 Remember: Your goal is to make decentralized storage as simple as traditional cloud storage, while educating users about the benefits of Filecoin's decentralized approach.`;
 
-// src/mastra/agents/foc-storage-agent.ts
-var focStorageAgent = new Agent({
-  name: "FOCStorageAgent",
-  description: "AI agent for managing decentralized file storage on Filecoin via FOC-Synapse SDK. Handles file uploads, dataset management, balance checking, and storage operations.",
-  instructions,
-  model: "openai/gpt-5-mini",
-  tools: focStorageTools,
-  workflows: {
-    e2eFileUpload: e2eFileUploadWorkflow
-  }
-});
-
 // src/mastra/resources/index.ts
 var myResources = [
   { uri: "file://instructions", name: "Instructions", mimeType: "application/markdown" }
@@ -2049,10 +2244,10 @@ var focStorageResources = {
   resourceTemplates: async () => myResourceTemplates
 };
 
-// src/mastra/index.ts
-var mcpServer = new MCPServer({
+// src/mastra/stdio.ts
+var server = new MCPServer({
   name: "FOC Storage MCP",
-  version: "0.1.9",
+  version: "0.2.0",
   description: "Professional-grade MCP server for decentralized file storage on Filecoin Onchain Cloud. Powered by the FOC-Synapse SDK, this server provides AI agents with seamless access to Filecoin's distributed storage network. Upload files with automatic payment handling, organize content in datasets, monitor storage balances, and manage providers - all through intuitive MCP tools. Supports both standard storage and CDN-enabled fast retrieval. Perfect for building AI applications that need persistent, censorship-resistant storage.",
   tools: focStorageTools,
   repository: {
@@ -2065,46 +2260,7 @@ var mcpServer = new MCPServer({
   packageCanonical: "npm",
   resources: focStorageResources
 });
-var mastra = new Mastra({
-  agents: {
-    focStorageAgent
-  },
-  workflows: {
-    e2eFileUpload: e2eFileUploadWorkflow
-  },
-  mcpServers: {
-    focStorageServer: mcpServer
-  },
-  storage: new LibSQLStore({
-    url: ":memory:"
-  }),
-  logger: new PinoLogger({
-    name: "Mastra",
-    level: "silent"
-  }),
-  bundler: {
-    externals: ["@filoz/synapse-sdk"]
-  }
-});
-
-// src/mcp-server.ts
-config2();
-async function startMCPServer() {
-  try {
-    await mcpServer.startStdio();
-  } catch (error) {
-    console.error("Error starting MCP server:", error);
-    process.exit(1);
-  }
-}
-process.on("SIGINT", async () => {
-  console.error("Shutting down MCP server...");
-  await mcpServer.close();
-  process.exit(0);
-});
-process.on("SIGTERM", async () => {
-  console.error("Shutting down MCP server...");
-  await mcpServer.close();
-  process.exit(0);
+server.startStdio().catch((error) => {
+  console.error("Error running MCP server:", error);
+  process.exit(1);
 });
-startMCPServer();

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@fil-b/foc-storage-mcp",
-  "version": "0.1.9",
+  "version": "0.2.0",
   "main": "dist/mcp-server.js",
-  "bin": "./dist/mcp-server.js",
+  "bin": "dist/stdio.js",
   "scripts": {
+    "build:mcp": "tsup src/mastra/stdio.ts --format esm --no-splitting --dts && chmod +x dist/stdio.js",
     "dev": "mastra dev",
     "build": "mastra build",
     "start": "mastra start",
     "mcp": "tsx src/mcp-server.ts",
-    "start:mcp": "tsx src/mcp-server.ts",
-    "build:mcp": "tsup"
+    "start:mcp": "tsx src/mcp-server.ts"
   },
   "keywords": [
     "filecoin",