agentcash 0.2.3

package/dist/esm/chunk-WW65CMHP.js

@@ -0,0 +1,826 @@
+import {
+  isVerbose
+} from "./chunk-J3LUL7DB.js";
+import {
+  init_esm_shims
+} from "./chunk-A2KI7TKE.js";
+
+// src/shared/log.ts
+init_esm_shims();
+
+// src/shared/neverthrow/fs/index.ts
+init_esm_shims();
+import { readFile, writeFile, appendFile, chmod } from "fs/promises";
+
+// ../../internal/neverthrow/dist/index.js
+init_esm_shims();
+
+// ../../../node_modules/.pnpm/neverthrow@8.2.0/node_modules/neverthrow/dist/index.es.js
+init_esm_shims();
+var defaultErrorConfig = {
+  withStackTrace: false
+};
+var createNeverThrowError = (message, result, config = defaultErrorConfig) => {
+  const data = result.isOk() ? { type: "Ok", value: result.value } : { type: "Err", value: result.error };
+  const maybeStack = config.withStackTrace ? new Error().stack : void 0;
+  return {
+    data,
+    message,
+    stack: maybeStack
+  };
+};
+function __awaiter(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function(resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function(resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+}
+function __values(o) {
+  var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+  if (m) return m.call(o);
+  if (o && typeof o.length === "number") return {
+    next: function() {
+      if (o && i >= o.length) o = void 0;
+      return { value: o && o[i++], done: !o };
+    }
+  };
+  throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function __await(v) {
+  return this instanceof __await ? (this.v = v, this) : new __await(v);
+}
+function __asyncGenerator(thisArg, _arguments, generator) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var g = generator.apply(thisArg, _arguments || []), i, q = [];
+  return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function() {
+    return this;
+  }, i;
+  function awaitReturn(f) {
+    return function(v) {
+      return Promise.resolve(v).then(f, reject);
+    };
+  }
+  function verb(n, f) {
+    if (g[n]) {
+      i[n] = function(v) {
+        return new Promise(function(a, b) {
+          q.push([n, v, a, b]) > 1 || resume(n, v);
+        });
+      };
+      if (f) i[n] = f(i[n]);
+    }
+  }
+  function resume(n, v) {
+    try {
+      step(g[n](v));
+    } catch (e) {
+      settle(q[0][3], e);
+    }
+  }
+  function step(r) {
+    r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
+  }
+  function fulfill(value) {
+    resume("next", value);
+  }
+  function reject(value) {
+    resume("throw", value);
+  }
+  function settle(f, v) {
+    if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]);
+  }
+}
+function __asyncDelegator(o) {
+  var i, p;
+  return i = {}, verb("next"), verb("throw", function(e) {
+    throw e;
+  }), verb("return"), i[Symbol.iterator] = function() {
+    return this;
+  }, i;
+  function verb(n, f) {
+    i[n] = o[n] ? function(v) {
+      return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v;
+    } : f;
+  }
+}
+function __asyncValues(o) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var m = o[Symbol.asyncIterator], i;
+  return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
+    return this;
+  }, i);
+  function verb(n) {
+    i[n] = o[n] && function(v) {
+      return new Promise(function(resolve, reject) {
+        v = o[n](v), settle(resolve, reject, v.done, v.value);
+      });
+    };
+  }
+  function settle(resolve, reject, d, v) {
+    Promise.resolve(v).then(function(v2) {
+      resolve({ value: v2, done: d });
+    }, reject);
+  }
+}
+var ResultAsync = class _ResultAsync {
+  constructor(res) {
+    this._promise = res;
+  }
+  static fromSafePromise(promise) {
+    const newPromise = promise.then((value) => new Ok(value));
+    return new _ResultAsync(newPromise);
+  }
+  static fromPromise(promise, errorFn) {
+    const newPromise = promise.then((value) => new Ok(value)).catch((e) => new Err(errorFn(e)));
+    return new _ResultAsync(newPromise);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromThrowable(fn, errorFn) {
+    return (...args) => {
+      return new _ResultAsync((() => __awaiter(this, void 0, void 0, function* () {
+        try {
+          return new Ok(yield fn(...args));
+        } catch (error) {
+          return new Err(errorFn ? errorFn(error) : error);
+        }
+      }))());
+    };
+  }
+  static combine(asyncResultList) {
+    return combineResultAsyncList(asyncResultList);
+  }
+  static combineWithAllErrors(asyncResultList) {
+    return combineResultAsyncListWithAllErrors(asyncResultList);
+  }
+  map(f) {
+    return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+      if (res.isErr()) {
+        return new Err(res.error);
+      }
+      return new Ok(yield f(res.value));
+    })));
+  }
+  andThrough(f) {
+    return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+      if (res.isErr()) {
+        return new Err(res.error);
+      }
+      const newRes = yield f(res.value);
+      if (newRes.isErr()) {
+        return new Err(newRes.error);
+      }
+      return new Ok(res.value);
+    })));
+  }
+  andTee(f) {
+    return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+      if (res.isErr()) {
+        return new Err(res.error);
+      }
+      try {
+        yield f(res.value);
+      } catch (e) {
+      }
+      return new Ok(res.value);
+    })));
+  }
+  orTee(f) {
+    return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+      if (res.isOk()) {
+        return new Ok(res.value);
+      }
+      try {
+        yield f(res.error);
+      } catch (e) {
+      }
+      return new Err(res.error);
+    })));
+  }
+  mapErr(f) {
+    return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+      if (res.isOk()) {
+        return new Ok(res.value);
+      }
+      return new Err(yield f(res.error));
+    })));
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  andThen(f) {
+    return new _ResultAsync(this._promise.then((res) => {
+      if (res.isErr()) {
+        return new Err(res.error);
+      }
+      const newValue = f(res.value);
+      return newValue instanceof _ResultAsync ? newValue._promise : newValue;
+    }));
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  orElse(f) {
+    return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+      if (res.isErr()) {
+        return f(res.error);
+      }
+      return new Ok(res.value);
+    })));
+  }
+  match(ok3, _err) {
+    return this._promise.then((res) => res.match(ok3, _err));
+  }
+  unwrapOr(t) {
+    return this._promise.then((res) => res.unwrapOr(t));
+  }
+  /**
+   * @deprecated will be removed in 9.0.0.
+   *
+   * You can use `safeTry` without this method.
+   * @example
+   * ```typescript
+   * safeTry(async function* () {
+   *   const okValue = yield* yourResult
+   * })
+   * ```
+   * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.
+   */
+  safeUnwrap() {
+    return __asyncGenerator(this, arguments, function* safeUnwrap_1() {
+      return yield __await(yield __await(yield* __asyncDelegator(__asyncValues(yield __await(this._promise.then((res) => res.safeUnwrap()))))));
+    });
+  }
+  // Makes ResultAsync implement PromiseLike<Result>
+  then(successCallback, failureCallback) {
+    return this._promise.then(successCallback, failureCallback);
+  }
+  [Symbol.asyncIterator]() {
+    return __asyncGenerator(this, arguments, function* _a() {
+      const result = yield __await(this._promise);
+      if (result.isErr()) {
+        yield yield __await(errAsync(result.error));
+      }
+      return yield __await(result.value);
+    });
+  }
+};
+function errAsync(err3) {
+  return new ResultAsync(Promise.resolve(new Err(err3)));
+}
+var fromPromise = ResultAsync.fromPromise;
+var fromSafePromise = ResultAsync.fromSafePromise;
+var fromAsyncThrowable = ResultAsync.fromThrowable;
+var combineResultList = (resultList) => {
+  let acc = ok([]);
+  for (const result of resultList) {
+    if (result.isErr()) {
+      acc = err(result.error);
+      break;
+    } else {
+      acc.map((list) => list.push(result.value));
+    }
+  }
+  return acc;
+};
+var combineResultAsyncList = (asyncResultList) => ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(combineResultList);
+var combineResultListWithAllErrors = (resultList) => {
+  let acc = ok([]);
+  for (const result of resultList) {
+    if (result.isErr() && acc.isErr()) {
+      acc.error.push(result.error);
+    } else if (result.isErr() && acc.isOk()) {
+      acc = err([result.error]);
+    } else if (result.isOk() && acc.isOk()) {
+      acc.value.push(result.value);
+    }
+  }
+  return acc;
+};
+var combineResultAsyncListWithAllErrors = (asyncResultList) => ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(combineResultListWithAllErrors);
+var Result;
+(function(Result2) {
+  function fromThrowable2(fn, errorFn) {
+    return (...args) => {
+      try {
+        const result = fn(...args);
+        return ok(result);
+      } catch (e) {
+        return err(errorFn ? errorFn(e) : e);
+      }
+    };
+  }
+  Result2.fromThrowable = fromThrowable2;
+  function combine(resultList) {
+    return combineResultList(resultList);
+  }
+  Result2.combine = combine;
+  function combineWithAllErrors(resultList) {
+    return combineResultListWithAllErrors(resultList);
+  }
+  Result2.combineWithAllErrors = combineWithAllErrors;
+})(Result || (Result = {}));
+function ok(value) {
+  return new Ok(value);
+}
+function err(err3) {
+  return new Err(err3);
+}
+var Ok = class {
+  constructor(value) {
+    this.value = value;
+  }
+  isOk() {
+    return true;
+  }
+  isErr() {
+    return !this.isOk();
+  }
+  map(f) {
+    return ok(f(this.value));
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  mapErr(_f) {
+    return ok(this.value);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  andThen(f) {
+    return f(this.value);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  andThrough(f) {
+    return f(this.value).map((_value) => this.value);
+  }
+  andTee(f) {
+    try {
+      f(this.value);
+    } catch (e) {
+    }
+    return ok(this.value);
+  }
+  orTee(_f) {
+    return ok(this.value);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  orElse(_f) {
+    return ok(this.value);
+  }
+  asyncAndThen(f) {
+    return f(this.value);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  asyncAndThrough(f) {
+    return f(this.value).map(() => this.value);
+  }
+  asyncMap(f) {
+    return ResultAsync.fromSafePromise(f(this.value));
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  unwrapOr(_v) {
+    return this.value;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  match(ok3, _err) {
+    return ok3(this.value);
+  }
+  safeUnwrap() {
+    const value = this.value;
+    return (function* () {
+      return value;
+    })();
+  }
+  _unsafeUnwrap(_) {
+    return this.value;
+  }
+  _unsafeUnwrapErr(config) {
+    throw createNeverThrowError("Called `_unsafeUnwrapErr` on an Ok", this, config);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-this-alias, require-yield
+  *[Symbol.iterator]() {
+    return this.value;
+  }
+};
+var Err = class {
+  constructor(error) {
+    this.error = error;
+  }
+  isOk() {
+    return false;
+  }
+  isErr() {
+    return !this.isOk();
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  map(_f) {
+    return err(this.error);
+  }
+  mapErr(f) {
+    return err(f(this.error));
+  }
+  andThrough(_f) {
+    return err(this.error);
+  }
+  andTee(_f) {
+    return err(this.error);
+  }
+  orTee(f) {
+    try {
+      f(this.error);
+    } catch (e) {
+    }
+    return err(this.error);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  andThen(_f) {
+    return err(this.error);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  orElse(f) {
+    return f(this.error);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  asyncAndThen(_f) {
+    return errAsync(this.error);
+  }
+  asyncAndThrough(_f) {
+    return errAsync(this.error);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  asyncMap(_f) {
+    return errAsync(this.error);
+  }
+  unwrapOr(v) {
+    return v;
+  }
+  match(_ok, err3) {
+    return err3(this.error);
+  }
+  safeUnwrap() {
+    const error = this.error;
+    return (function* () {
+      yield err(error);
+      throw new Error("Do not use this generator out of `safeTry`");
+    })();
+  }
+  _unsafeUnwrap(config) {
+    throw createNeverThrowError("Called `_unsafeUnwrap` on an Err", this, config);
+  }
+  _unsafeUnwrapErr(_) {
+    return this.error;
+  }
+  *[Symbol.iterator]() {
+    const self = this;
+    yield self;
+    return self;
+  }
+};
+var fromThrowable = Result.fromThrowable;
+
+// ../../internal/neverthrow/dist/index.js
+function resultFromPromise(type2, surface, promise, error) {
+  return ResultAsync.fromPromise(promise, (e) => ({
+    ...error(e),
+    type: type2,
+    surface
+  }));
+}
+function resultFromThrowable(type2, surface, fn, error) {
+  return Result.fromThrowable(fn, (e) => ({
+    ...error(e),
+    type: type2,
+    surface
+  }))();
+}
+function ok2(data) {
+  return ok(data);
+}
+function err2(type2, surface, error) {
+  return err({
+    ...error,
+    type: type2,
+    surface
+  });
+}
+
+// src/shared/neverthrow/fs/index.ts
+var errorType = "fs";
+var fsErr = (surface, error) => err2(errorType, surface, error);
+var fsResultFromPromise = (surface, promise, error) => resultFromPromise(errorType, surface, promise, error);
+var safeReadFile = (surface, path) => fsResultFromPromise(surface, readFile(path, "utf-8"), () => ({
+  cause: "file_not_readable",
+  message: "Failed to read file"
+}));
+var safeWriteFile = (surface, path, data) => fsResultFromPromise(surface, writeFile(path, data), () => ({
+  cause: "file_not_writable",
+  message: "Failed to write file"
+}));
+var safeAppendFile = (surface, path, data) => fsResultFromPromise(surface, appendFile(path, data), () => ({
+  cause: "file_not_writable",
+  message: "Failed to append file"
+}));
+var safeChmod = (surface, path, mode) => fsResultFromPromise(surface, chmod(path, mode), () => ({
+  cause: "file_not_chmodable",
+  message: "Failed to chmod file"
+}));
+
+// src/shared/fs.ts
+init_esm_shims();
+import { join } from "path";
+import { homedir } from "os";
+import * as fs from "fs";
+var BASE_DIRECTORY = join(homedir(), ".agentcash");
+if (!fs.existsSync(BASE_DIRECTORY)) {
+  fs.mkdirSync(BASE_DIRECTORY, { recursive: true });
+}
+var configFile = (name) => {
+  if (!fs.existsSync(BASE_DIRECTORY)) {
+    fs.mkdirSync(BASE_DIRECTORY, { recursive: true });
+  }
+  const filePath = join(BASE_DIRECTORY, name);
+  return filePath;
+};
+
+// src/shared/log.ts
+var LOG_FILE = configFile("mcp.log");
+function format(args) {
+  return args.map(
+    (a) => typeof a === "object" && a !== null ? JSON.stringify(a) : String(a)
+  ).join(" ");
+}
+function write(level, msg, args) {
+  const formatted = args.length ? `${msg} ${format(args)}` : msg;
+  const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] [${level}] ${formatted}
+`;
+  safeAppendFile("log", LOG_FILE, line);
+  if (isVerbose()) {
+    console.error(`[agentcash] ${formatted}`);
+  }
+}
+var log = {
+  info: (msg, ...args) => write("INFO", msg, args),
+  error: (msg, ...args) => write("ERROR", msg, args),
+  debug: (msg, ...args) => isVerbose() && write("DEBUG", msg, args),
+  path: LOG_FILE
+};
+
+// src/shared/networks.ts
+init_esm_shims();
+import {
+  base,
+  baseSepolia,
+  mainnet,
+  sepolia,
+  optimism,
+  arbitrum,
+  polygon
+} from "viem/chains";
+var CHAIN_CONFIGS = {
+  "eip155:8453": {
+    chain: base,
+    caip2: "eip155:8453",
+    v1Name: "base",
+    usdcAddress: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
+  },
+  "eip155:84532": {
+    chain: baseSepolia,
+    caip2: "eip155:84532",
+    v1Name: "base-sepolia",
+    usdcAddress: "0x036CbD53842c5426634e7929541eC2318f3dCF7e"
+  },
+  "eip155:1": {
+    chain: mainnet,
+    caip2: "eip155:1",
+    v1Name: "ethereum",
+    usdcAddress: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"
+  },
+  "eip155:11155111": {
+    chain: sepolia,
+    caip2: "eip155:11155111",
+    v1Name: "ethereum-sepolia",
+    usdcAddress: "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238"
+  },
+  "eip155:10": {
+    chain: optimism,
+    caip2: "eip155:10",
+    v1Name: "optimism",
+    usdcAddress: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85"
+  },
+  "eip155:42161": {
+    chain: arbitrum,
+    caip2: "eip155:42161",
+    v1Name: "arbitrum",
+    usdcAddress: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831"
+  },
+  "eip155:137": {
+    chain: polygon,
+    caip2: "eip155:137",
+    v1Name: "polygon",
+    usdcAddress: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359"
+  }
+};
+var V1_TO_CAIP2 = {
+  base: "eip155:8453",
+  "base-sepolia": "eip155:84532",
+  ethereum: "eip155:1",
+  "ethereum-sepolia": "eip155:11155111",
+  optimism: "eip155:10",
+  arbitrum: "eip155:42161",
+  polygon: "eip155:137"
+};
+var DEFAULT_NETWORK = "eip155:8453";
+function toCaip2(network) {
+  if (network.startsWith("eip155:")) return network;
+  return V1_TO_CAIP2[network.toLowerCase()] ?? network;
+}
+function getChainConfig(network) {
+  return CHAIN_CONFIGS[toCaip2(network)];
+}
+function getChainName(network) {
+  return getChainConfig(network)?.chain.name ?? network;
+}
+
+// src/shared/neverthrow/parse/index.ts
+init_esm_shims();
+import z from "zod";
+var type = "json";
+var parseErr = (surface, error) => err2(type, surface, error);
+var safeParse = (surface, schema, value) => {
+  const parseResult = schema.safeParse(value);
+  if (!parseResult.success) {
+    return parseErr(surface, {
+      cause: "invalid_data",
+      message: JSON.stringify(z.treeifyError(parseResult.error), null, 2),
+      error: parseResult.error
+    });
+  }
+  return ok2(parseResult.data);
+};
+
+// src/shared/neverthrow/fetch/index.ts
+init_esm_shims();
+import contentType from "content-type";
+var IMAGE_TYPES = /* @__PURE__ */ new Set([
+  "image/png",
+  "image/jpeg",
+  "image/gif",
+  "image/webp",
+  "image/svg+xml",
+  "image/tiff",
+  "image/bmp",
+  "image/ico"
+]);
+var errorType2 = "fetch";
+var fetchErr = (surface, error) => err2(errorType2, surface, error);
+var fetchOk = (value) => ok2(value);
+var fetchHttpErr = (surface, response) => fetchErr(surface, {
+  cause: "http",
+  statusCode: response.status,
+  message: response.statusText,
+  response
+});
+var safeFetch = (surface, request) => {
+  return resultFromPromise(
+    errorType2,
+    surface,
+    fetch(request),
+    (error) => ({
+      cause: "network",
+      message: error instanceof Error ? error.message : "Network error"
+    })
+  );
+};
+var safeFetchJson = (surface, request, schema) => {
+  return safeFetch(surface, request).andThen((response) => {
+    if (!response.ok) {
+      return fetchHttpErr(surface, response);
+    }
+    return resultFromPromise(errorType2, surface, response.json(), () => ({
+      cause: "parse",
+      message: "Could not parse JSON from response",
+      statusCode: response.status,
+      contentType: response.headers.get("content-type") ?? "Not specified"
+    }));
+  }).andThen((data) => safeParse(surface, schema, data));
+};
+var safeParseResponse = (surface, response) => {
+  return resultFromPromise(
+    errorType2,
+    surface,
+    (async () => {
+      const header = response.headers.get("content-type");
+      const { type: mimeType } = header ? contentType.parse(header) : { type: "application/octet-stream" };
+      switch (mimeType) {
+        case "application/json":
+          return {
+            type: "json",
+            data: await response.json()
+          };
+        case "application/pdf":
+          return {
+            type: "pdf",
+            mimeType,
+            data: await response.arrayBuffer()
+          };
+        case "application/octet-stream":
+          return {
+            type: "octet-stream",
+            mimeType,
+            data: await response.arrayBuffer()
+          };
+        case "multipart/form-data":
+          return { type: "formData", data: await response.formData() };
+      }
+      if (IMAGE_TYPES.has(mimeType)) {
+        return {
+          type: "image",
+          mimeType,
+          data: await response.arrayBuffer()
+        };
+      }
+      if (mimeType.startsWith("audio/")) {
+        return {
+          type: "audio",
+          mimeType,
+          data: await response.arrayBuffer()
+        };
+      }
+      if (mimeType.startsWith("video/")) {
+        return {
+          type: "video",
+          mimeType,
+          data: await response.arrayBuffer()
+        };
+      }
+      if (mimeType.startsWith("text/")) {
+        return { type: "text", data: await response.text() };
+      }
+      throw new Error(`Unsupported content type: ${header}`);
+    })(),
+    (e) => ({
+      cause: "parse",
+      message: e instanceof Error ? e.message : "Could not parse response",
+      statusCode: response.status,
+      contentType: response.headers.get("content-type") ?? "Not specified"
+    })
+  );
+};
+var isFetchError = (error) => {
+  return error.type === errorType2;
+};
+
+// src/shared/utils.ts
+init_esm_shims();
+import open from "open";
+var getBaseUrl = (dev) => {
+  return dev ? "http://localhost:3000" : "https://x402scan.com";
+};
+var getDepositLink = (address, flags) => {
+  return `${getBaseUrl(flags.dev)}/mcp/deposit/${address}`;
+};
+var openDepositLink = async (address, flags) => {
+  const depositLink = getDepositLink(address, flags);
+  await open(depositLink);
+};
+
+export {
+  DEFAULT_NETWORK,
+  getChainName,
+  resultFromPromise,
+  resultFromThrowable,
+  ok2 as ok,
+  err2 as err,
+  safeParse,
+  fetchErr,
+  fetchOk,
+  fetchHttpErr,
+  safeFetch,
+  safeFetchJson,
+  safeParseResponse,
+  isFetchError,
+  fsErr,
+  safeReadFile,
+  safeWriteFile,
+  safeChmod,
+  configFile,
+  log,
+  getBaseUrl,
+  getDepositLink,
+  openDepositLink
+};
+//# sourceMappingURL=chunk-WW65CMHP.js.map