@vtxmacro/cli 0.1.0

package/bin/vtx-mcp.js

@@ -0,0 +1,1109 @@
+#!/usr/bin/env node
+
+// lib/agent-core/client.ts
+import { randomUUID } from "node:crypto";
+
+// lib/agent-core/types.ts
+var AgentClientError = class extends Error {
+  constructor(payload) {
+    super(payload.message);
+    this.name = "AgentClientError";
+    this.status = payload.status;
+    this.code = payload.code;
+    this.detail = payload.detail;
+  }
+};
+
+// lib/agent-core/client.ts
+var SECRET_RESPONSE_FIELDS = /* @__PURE__ */ new Set([
+  "hyperliquid_signing_key",
+  "local_ai_api_key",
+  "openai_compatible_api_key",
+  "openai_api_key",
+  "anthropic_api_key",
+  "gemini_api_key",
+  "grok_api_key",
+  "groq_api_key",
+  "openrouter_api_key",
+  "venice_api_key",
+  "deepseek_api_key",
+  "mistral_api_key",
+  "together_api_key",
+  "fireworks_api_key",
+  "cerebras_api_key",
+  "moonshot_api_key",
+  "alibaba_cloud_model_studio_api_key",
+  "amazon_bedrock_api_key",
+  "lightning_api_key"
+]);
+function normalizeApiUrl(value) {
+  const parsed = String(value || "").trim();
+  if (!parsed) {
+    throw new Error("VTX API URL is required");
+  }
+  return parsed.replace(/\/+$/, "");
+}
+async function parseError(response, fallback) {
+  let detail = null;
+  try {
+    detail = await response.json();
+  } catch {
+    detail = null;
+  }
+  const rawDetail = detail && typeof detail === "object" && "detail" in detail ? detail.detail : detail;
+  const message = typeof rawDetail === "string" ? rawDetail : fallback;
+  const code = rawDetail && typeof rawDetail === "object" && "code" in rawDetail ? String(rawDetail.code || "") : void 0;
+  return new AgentClientError({
+    status: response.status,
+    code,
+    message,
+    detail: rawDetail
+  });
+}
+function redactSecretResponse(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => redactSecretResponse(item));
+  }
+  if (!value || typeof value !== "object") {
+    return value;
+  }
+  const redacted = {};
+  for (const [key, nested] of Object.entries(value)) {
+    if (SECRET_RESPONSE_FIELDS.has(key)) {
+      redacted[key] = nested ? "[redacted]" : null;
+      continue;
+    }
+    redacted[key] = redactSecretResponse(nested);
+  }
+  return redacted;
+}
+var VtxAgentClient = class _VtxAgentClient {
+  constructor(config) {
+    this.apiUrl = normalizeApiUrl(config.apiUrl);
+    this.token = String(config.token || "").trim() || null;
+    this.activeProfileId = config.activeProfileId ?? null;
+    this.fetchImpl = config.fetchImpl ?? fetch;
+  }
+  async request(path, options = {}) {
+    const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+    const headers = {
+      Accept: "application/json"
+    };
+    if (this.token) {
+      headers.Authorization = `Bearer ${this.token}`;
+    }
+    const profileId = options.profileId ?? this.activeProfileId;
+    if (profileId != null) {
+      headers["x-profile-id"] = String(profileId);
+    }
+    if (options.idempotencyKey) {
+      headers["x-idempotency-key"] = options.idempotencyKey;
+    }
+    if (options.headers) {
+      for (const [key, value] of Object.entries(options.headers)) {
+        if (value) {
+          headers[key] = value;
+        }
+      }
+    }
+    let body;
+    if (options.body !== void 0) {
+      headers["Content-Type"] = "application/json";
+      body = JSON.stringify(options.body);
+    }
+    const response = await this.fetchImpl(`${this.apiUrl}${normalizedPath}`, {
+      method: options.method ?? "GET",
+      headers,
+      body
+    });
+    if (!response.ok) {
+      throw await parseError(response, `VTX API request failed: ${response.status}`);
+    }
+    if (response.status === 204) {
+      return void 0;
+    }
+    return await response.json();
+  }
+  whoami() {
+    return this.request("/auth/agent-tokens/whoami");
+  }
+  listTokens() {
+    return this.request("/auth/agent-tokens");
+  }
+  createToken(payload) {
+    return this.request("/auth/agent-tokens", { method: "POST", body: payload });
+  }
+  startBrowserLogin(payload) {
+    return this.request("/auth/agent-tokens/login/start", {
+      method: "POST",
+      body: payload
+    });
+  }
+  pollBrowserLogin(loginCode) {
+    return this.request("/auth/agent-tokens/login/poll", {
+      method: "POST",
+      body: { login_code: loginCode }
+    });
+  }
+  revokeToken(tokenId, reason = "cli_revoked") {
+    return this.request(`/auth/agent-tokens/${tokenId}`, {
+      method: "DELETE",
+      body: { reason }
+    });
+  }
+  listProfiles() {
+    return this.request("/auth/me/profiles");
+  }
+  createProfile(profileId) {
+    return this.request("/auth/me/profiles", {
+      method: "POST",
+      profileId
+    });
+  }
+  updateProfile(profileId, payload) {
+    return this.request("/auth/me", {
+      method: "PATCH",
+      profileId,
+      body: payload
+    });
+  }
+  deleteProfile(profileId) {
+    return this.request(`/auth/me/profiles/${profileId}`, {
+      method: "DELETE"
+    });
+  }
+  setProfileExecutionMode(profileId, executionMode) {
+    return this.request("/preferences", {
+      method: "PUT",
+      profileId,
+      body: { preferences: { execution_mode: executionMode } }
+    });
+  }
+  updatePreferences(profileId, preferences) {
+    return this.request("/preferences", {
+      method: "PUT",
+      profileId,
+      body: { preferences }
+    });
+  }
+  getBillingStatus() {
+    return this.request("/billing/balance");
+  }
+  getBillingPrices(profileId) {
+    return this.request("/billing/prices", { profileId });
+  }
+  getRuntimeStatus(profileId) {
+    return this.request("/trading/ai/status", { profileId });
+  }
+  getRuntimeEvents(profileId, options = {}) {
+    const params = new URLSearchParams();
+    if (options.limit !== void 0) {
+      params.set("limit", String(options.limit));
+    }
+    if (options.eventType) {
+      params.set("event_type", options.eventType);
+    }
+    if (options.clientEventType) {
+      params.set("client_event_type", options.clientEventType);
+    }
+    const query = params.toString();
+    return this.request(`/trading/ai/runtime/events${query ? `?${query}` : ""}`, { profileId });
+  }
+  getRuntimeBootstrap(profileId, leaseToken) {
+    return this.request("/trading/ai/runtime/bootstrap", {
+      profileId,
+      headers: { "x-client-runtime-lease": leaseToken }
+    });
+  }
+  getRuntimeSecrets(profileId, leaseToken, options = {}) {
+    const params = new URLSearchParams();
+    if (options.activeProvider) {
+      params.set("active_provider", options.activeProvider);
+    }
+    if (typeof options.includeAllProviderKeys === "boolean") {
+      params.set("include_all_provider_keys", String(options.includeAllProviderKeys));
+    }
+    const query = params.toString();
+    return this.request(`/auth/me/client-runtime-secrets${query ? `?${query}` : ""}`, {
+      profileId,
+      headers: { "x-client-runtime-lease": leaseToken }
+    });
+  }
+  getRuntimePromptContractMetadata(profileId, payload, leaseToken) {
+    return this.request("/trading/ai/runtime/prompt-contract/metadata", {
+      method: "POST",
+      profileId,
+      headers: { "x-client-runtime-lease": leaseToken },
+      body: payload
+    });
+  }
+  getRuntimePromptContractDerivedContext(profileId, payload, leaseToken) {
+    return this.request("/trading/ai/runtime/prompt-contract/derived-context", {
+      method: "POST",
+      profileId,
+      headers: { "x-client-runtime-lease": leaseToken },
+      body: payload
+    });
+  }
+  getRuntimePrompt(profileId, payload, leaseToken) {
+    return this.request("/trading/ai/runtime/prompt", {
+      method: "POST",
+      profileId,
+      headers: { "x-client-runtime-lease": leaseToken },
+      body: payload
+    });
+  }
+  getLlmConfig(profileId) {
+    return this.request("/llm/config", { profileId });
+  }
+  heartbeatRuntime(profileId, payload, leaseToken) {
+    return this.request("/trading/ai/runtime/heartbeat", {
+      method: "POST",
+      profileId,
+      headers: { "x-client-runtime-lease": leaseToken },
+      body: payload
+    });
+  }
+  reportRuntimeDecision(profileId, payload, leaseToken) {
+    return this.request("/trading/ai/runtime/decision", {
+      method: "POST",
+      profileId,
+      idempotencyKey: randomUUID(),
+      headers: { "x-client-runtime-lease": leaseToken },
+      body: payload
+    });
+  }
+  reportRuntimeTradeSync(profileId, payload, leaseToken) {
+    return this.request("/trading/ai/runtime/trade-sync", {
+      method: "POST",
+      profileId,
+      idempotencyKey: randomUUID(),
+      headers: { "x-client-runtime-lease": leaseToken },
+      body: payload
+    });
+  }
+  reportRuntimeError(profileId, payload, leaseToken) {
+    return this.request("/trading/ai/runtime/error", {
+      method: "POST",
+      profileId,
+      idempotencyKey: randomUUID(),
+      headers: { "x-client-runtime-lease": leaseToken },
+      body: payload
+    });
+  }
+  getTradeHistory(profileId) {
+    return this.request("/trading/ai/history", { profileId });
+  }
+  placeMarketOrder(profileId, payload) {
+    return this.request("/trading/market-order", {
+      method: "POST",
+      profileId,
+      idempotencyKey: randomUUID(),
+      body: payload
+    });
+  }
+  placeLimitOrder(profileId, payload) {
+    return this.request("/trading/limit-order", {
+      method: "POST",
+      profileId,
+      idempotencyKey: randomUUID(),
+      body: payload
+    });
+  }
+  cancelOrder(profileId, payload) {
+    return this.request("/trading/cancel-order", {
+      method: "POST",
+      profileId,
+      idempotencyKey: randomUUID(),
+      body: payload
+    });
+  }
+  getSecretStatus(profileId) {
+    return this.request("/auth/me", { profileId });
+  }
+  async setRuntimeSecret(profileId, fieldName, value) {
+    const response = await this.request("/auth/me/client-runtime-secrets", {
+      method: "PUT",
+      profileId,
+      body: { [fieldName]: value }
+    });
+    return redactSecretResponse(response);
+  }
+  startBot(profileId, payload = {}) {
+    return this.request("/trading/ai/start", {
+      method: "POST",
+      profileId,
+      idempotencyKey: randomUUID(),
+      body: payload
+    });
+  }
+  stopBot(profileId) {
+    return this.request("/trading/ai/stop", {
+      method: "POST",
+      profileId,
+      idempotencyKey: randomUUID(),
+      body: {}
+    });
+  }
+  startAssistant(profileId) {
+    return this.request("/trading/ai/assistant/start", {
+      method: "POST",
+      profileId,
+      idempotencyKey: randomUUID(),
+      body: {}
+    });
+  }
+  stopAssistant(profileId) {
+    return this.request("/trading/ai/assistant/stop", {
+      method: "POST",
+      profileId,
+      idempotencyKey: randomUUID(),
+      body: {}
+    });
+  }
+  startRuntime(profileId, payload) {
+    return this.request("/trading/ai/runtime/session/start", {
+      method: "POST",
+      profileId,
+      idempotencyKey: randomUUID(),
+      body: payload
+    });
+  }
+  stopRuntime(profileId, payload, leaseToken) {
+    const headersLease = String(leaseToken || "").trim();
+    const previousFetch = this.fetchImpl;
+    if (!headersLease) {
+      return this.request("/trading/ai/runtime/session/stop", {
+        method: "POST",
+        profileId,
+        idempotencyKey: randomUUID(),
+        body: payload
+      });
+    }
+    const withLeaseFetch = async (input, init) => {
+      const headers = new Headers(init?.headers);
+      headers.set("x-client-runtime-lease", headersLease);
+      return previousFetch(input, { ...init, headers });
+    };
+    return new _VtxAgentClient({
+      apiUrl: this.apiUrl,
+      token: this.token,
+      activeProfileId: this.activeProfileId,
+      fetchImpl: withLeaseFetch
+    }).request("/trading/ai/runtime/session/stop", {
+      method: "POST",
+      profileId,
+      idempotencyKey: randomUUID(),
+      body: payload
+    });
+  }
+};
+function createAgentClient(config) {
+  return new VtxAgentClient(config);
+}
+
+// lib/agent-core/config.ts
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+function defaultBaseDir() {
+  return join(homedir(), ".vtx");
+}
+function resolveAgentCliConfig(env = process.env) {
+  const baseDir = String(env.VTX_HOME || "").trim() || defaultBaseDir();
+  const rawProfile = String(env.VTX_PROFILE_ID || "").trim();
+  const parsedProfile = rawProfile ? Number(rawProfile) : NaN;
+  return {
+    apiUrl: String(env.VTX_API_URL || "http://localhost:8000").replace(/\/+$/, ""),
+    tokenPath: String(env.VTX_TOKEN_PATH || "").trim() || join(baseDir, "token.json"),
+    statePath: String(env.VTX_RUNTIME_STATE_PATH || "").trim() || join(baseDir, "runtime-state.json"),
+    runtimeDeviceId: String(env.VTX_RUNTIME_DEVICE_ID || "").trim() || null,
+    activeProfileId: Number.isFinite(parsedProfile) && parsedProfile > 0 ? parsedProfile : null,
+    outputJson: String(env.VTX_OUTPUT || "").trim().toLowerCase() === "json"
+  };
+}
+async function readStoredAgentAuth(path) {
+  try {
+    const raw = await readFile(path, "utf8");
+    if (!raw.trim()) {
+      throw new Error(`VTX token file is empty at ${path}. Run "vtx auth login" or remove the file and retry.`);
+    }
+    const parsed = JSON.parse(raw);
+    const token = String(parsed.token || "").trim();
+    return token ? { token } : null;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    if (error instanceof SyntaxError) {
+      throw new Error(`VTX token file is not valid JSON at ${path}. Run "vtx auth login" or remove the file and retry.`);
+    }
+    throw error;
+  }
+}
+
+// lib/runtime/hyperliquid-market-symbol.ts
+var configuredCaseSensitiveSymbols = [];
+var canonicalBaseSymbol = (base) => {
+  const trimmed = base.trim();
+  if (!trimmed) return "";
+  const upper = trimmed.toUpperCase();
+  for (const candidate of configuredCaseSensitiveSymbols) {
+    if (candidate.toUpperCase() === upper) {
+      return candidate;
+    }
+  }
+  return upper;
+};
+var normalizeHyperliquidMarketSymbol = (value) => {
+  const raw = String(value ?? "").trim();
+  if (!raw) return "";
+  if (!raw.includes(":")) return canonicalBaseSymbol(raw);
+  const [dex, ...rest] = raw.split(":");
+  const base = rest.join(":").trim();
+  const normalizedDex = dex.trim().toLowerCase();
+  if (!normalizedDex || !base) return "";
+  return `${normalizedDex}:${canonicalBaseSymbol(base)}`;
+};
+
+// lib/agent-mcp/server.ts
+var VTX_MCP_TOOLS = [
+  {
+    name: "vtx_whoami",
+    description: "Inspect the authenticated VTX user and agent-token scopes.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "vtx_profiles_list",
+    description: "List profiles owned by the authenticated VTX user.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "vtx_profiles_create",
+    description: "Create a profile for the authenticated VTX user. Requires profile:write scope.",
+    inputSchema: {
+      type: "object",
+      properties: { sourceProfileId: { type: "number" } }
+    }
+  },
+  {
+    name: "vtx_profiles_update",
+    description: "Update the selected profile handle for the authenticated VTX user. Requires profile:write scope.",
+    inputSchema: {
+      type: "object",
+      required: ["profileId", "name"],
+      properties: { profileId: { type: "number" }, name: { type: "string" } }
+    }
+  },
+  {
+    name: "vtx_profiles_delete",
+    description: "Delete a profile owned by the authenticated VTX user. Requires profile:write scope.",
+    inputSchema: {
+      type: "object",
+      required: ["profileId"],
+      properties: { profileId: { type: "number" } }
+    }
+  },
+  {
+    name: "vtx_profiles_set_mode",
+    description: "Set a profile execution mode. Client Mode runs locally with no VTX platform fee; Server Mode uses normal VTX infrastructure and fees.",
+    inputSchema: {
+      type: "object",
+      required: ["profileId", "mode"],
+      properties: { profileId: { type: "number" }, mode: { type: "string", enum: ["client", "server"] } }
+    }
+  },
+  {
+    name: "vtx_bots_start",
+    description: "Start the Server Mode AI Trader for a profile through the normal backend path. Requires bot:control scope and normal Server Mode billing/caps.",
+    inputSchema: {
+      type: "object",
+      required: ["profileId"],
+      properties: {
+        profileId: { type: "number" },
+        symbol: { type: "string" },
+        timeframe: { type: "string" },
+        size: { type: "string" },
+        leverage: { type: "number" },
+        interval: { type: "number" }
+      }
+    }
+  },
+  {
+    name: "vtx_bots_configure",
+    description: "Configure AI Trader profile preferences through the normal preferences API before starting a bot. Requires profile:write scope.",
+    inputSchema: {
+      type: "object",
+      required: ["profileId"],
+      properties: {
+        profileId: { type: "number" },
+        symbol: { type: "string" },
+        timeframe: { type: "string" },
+        size: { type: "string" },
+        leverage: { type: "number" },
+        interval: { type: "number" }
+      }
+    }
+  },
+  {
+    name: "vtx_bots_stop",
+    description: "Stop the Server Mode AI Trader for a profile through the normal backend path. Requires bot:control scope.",
+    inputSchema: {
+      type: "object",
+      required: ["profileId"],
+      properties: { profileId: { type: "number" } }
+    }
+  },
+  {
+    name: "vtx_bots_status",
+    description: "Read bot/runtime status for a profile.",
+    inputSchema: {
+      type: "object",
+      required: ["profileId"],
+      properties: { profileId: { type: "number" } }
+    }
+  },
+  {
+    name: "vtx_bots_logs",
+    description: "Read AI Trader decision history/logs for a profile without executing trades.",
+    inputSchema: {
+      type: "object",
+      required: ["profileId"],
+      properties: { profileId: { type: "number" } }
+    }
+  },
+  {
+    name: "vtx_runtime_status",
+    description: "Read Client Mode runtime status for a profile. Client Mode has no VTX platform fee; Server Mode bots use normal fees.",
+    inputSchema: {
+      type: "object",
+      required: ["profileId"],
+      properties: { profileId: { type: "number" } }
+    }
+  },
+  {
+    name: "vtx_runtime_events",
+    description: "Read Client Mode runtime events for a profile. This is status/history visibility and does not execute local runtime work.",
+    inputSchema: {
+      type: "object",
+      required: ["profileId"],
+      properties: {
+        profileId: { type: "number" },
+        limit: { type: "number" },
+        eventType: { type: "string" },
+        clientEventType: { type: "string" }
+      }
+    }
+  },
+  {
+    name: "vtx_trade_market_order",
+    description: "Submit a market order for a profile through the normal Trade page backend path. Requires trading:execute scope and uses the same risk checks, rate limits, and idempotency behavior as a user-submitted order.",
+    inputSchema: {
+      type: "object",
+      required: ["profileId", "symbol", "side", "size"],
+      properties: {
+        profileId: { type: "number" },
+        symbol: { type: "string" },
+        side: { type: "string", enum: ["buy", "sell"] },
+        size: { type: "number" },
+        slippage: { type: "number" },
+        estimatedPrice: { type: "number" },
+        estimatedPriceTimestampMs: { type: "number" }
+      }
+    }
+  },
+  {
+    name: "vtx_trade_limit_order",
+    description: "Submit a limit order for a profile through the normal Trade page backend path. Requires trading:execute scope and uses the same risk checks, rate limits, and idempotency behavior as a user-submitted order.",
+    inputSchema: {
+      type: "object",
+      required: ["profileId", "symbol", "side", "size", "limitPrice"],
+      properties: {
+        profileId: { type: "number" },
+        symbol: { type: "string" },
+        side: { type: "string", enum: ["buy", "sell"] },
+        size: { type: "number" },
+        limitPrice: { type: "number" },
+        reduceOnly: { type: "boolean" }
+      }
+    }
+  },
+  {
+    name: "vtx_trade_cancel_order",
+    description: "Cancel an open order for a profile through the normal Trade page backend path. Requires trading:execute scope.",
+    inputSchema: {
+      type: "object",
+      required: ["profileId", "symbol", "oid"],
+      properties: {
+        profileId: { type: "number" },
+        symbol: { type: "string" },
+        oid: { type: "number" }
+      }
+    }
+  },
+  {
+    name: "vtx_tokens_list",
+    description: "List agent tokens without returning raw token values.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "vtx_billing_status",
+    description: "Read VTX billing balance for the authenticated user.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "vtx_billing_prices",
+    description: "Read VTX pricing visibility, including Server Mode trader call fee and model pricing metadata.",
+    inputSchema: {
+      type: "object",
+      properties: { profileId: { type: "number" } }
+    }
+  },
+  {
+    name: "vtx_ai_config",
+    description: "Read the shared AI/runtime configuration contract used by the web app, CLI, MCP, and Client Mode runtime.",
+    inputSchema: {
+      type: "object",
+      properties: { profileId: { type: "number" } }
+    }
+  },
+  {
+    name: "vtx_secrets_status",
+    description: "Read secret readiness and masked previews for a profile. Raw stored secret values are not returned.",
+    inputSchema: {
+      type: "object",
+      required: ["profileId"],
+      properties: { profileId: { type: "number" } }
+    }
+  },
+  {
+    name: "vtx_secrets_set",
+    description: "Write or rotate one runtime secret for a profile. The response redacts raw secret values.",
+    inputSchema: {
+      type: "object",
+      required: ["profileId", "field", "value"],
+      properties: {
+        profileId: { type: "number" },
+        field: { type: "string" },
+        value: { type: "string" }
+      }
+    }
+  }
+];
+var WRITABLE_SECRET_FIELDS = /* @__PURE__ */ new Set([
+  "hyperliquid_signing_key",
+  "local_ai_api_key",
+  "openai_compatible_api_key",
+  "openai_api_key",
+  "anthropic_api_key",
+  "gemini_api_key",
+  "grok_api_key",
+  "groq_api_key",
+  "openrouter_api_key",
+  "venice_api_key",
+  "deepseek_api_key",
+  "mistral_api_key",
+  "together_api_key",
+  "fireworks_api_key",
+  "cerebras_api_key",
+  "moonshot_api_key",
+  "alibaba_cloud_model_studio_api_key",
+  "lightning_api_key"
+]);
+function requirePositiveNumber(input, key) {
+  const value = Number(input[key]);
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new Error(`${key} must be a positive number`);
+  }
+  return value;
+}
+function optionalPositiveNumber(input, key) {
+  if (input[key] === void 0 || input[key] === null || input[key] === "") {
+    return void 0;
+  }
+  return requirePositiveNumber(input, key);
+}
+function optionalString(input, key) {
+  const value = String(input[key] || "").trim();
+  return value || null;
+}
+function botStartPayload(input) {
+  const payload = {};
+  for (const key of ["symbol", "timeframe", "size"]) {
+    const value = optionalString(input, key);
+    if (value) {
+      payload[key] = value;
+    }
+  }
+  const leverage = optionalPositiveNumber(input, "leverage");
+  if (leverage !== void 0) {
+    payload.leverage = leverage;
+  }
+  const interval = optionalPositiveNumber(input, "interval");
+  if (interval !== void 0) {
+    payload.interval = interval;
+  }
+  return payload;
+}
+function botConfigurePreferences(input) {
+  const preferences = {};
+  const trade = {};
+  const symbol = optionalString(input, "symbol");
+  if (symbol) {
+    const normalizedSymbol = normalizeHyperliquidMarketSymbol(symbol);
+    preferences.trading_symbols = [normalizedSymbol];
+    trade.tradingSymbol = normalizedSymbol;
+  }
+  const timeframe = optionalString(input, "timeframe");
+  if (timeframe) {
+    preferences.trading_timeframes = [timeframe.trim()];
+    trade.chartInterval = timeframe.trim();
+  }
+  const size = optionalString(input, "size");
+  if (size) {
+    preferences.ai_trade_amount = Number(size);
+    trade.orderSizeUSDC = size;
+  }
+  const leverage = optionalPositiveNumber(input, "leverage");
+  if (leverage !== void 0) {
+    trade.leverage = leverage;
+  }
+  const interval = optionalPositiveNumber(input, "interval");
+  if (interval !== void 0) {
+    preferences.trading_interval = interval;
+  }
+  if (Object.keys(trade).length > 0) {
+    preferences.trade = trade;
+  }
+  if (Object.keys(preferences).length === 0) {
+    throw new Error("At least one bot configuration field is required");
+  }
+  return preferences;
+}
+function requireOrderSide(input) {
+  const side = optionalString(input, "side");
+  if (side !== "buy" && side !== "sell") {
+    throw new Error("side must be buy or sell");
+  }
+  return side;
+}
+function requireSymbol(input) {
+  const symbol = optionalString(input, "symbol");
+  if (!symbol) {
+    throw new Error("symbol is required");
+  }
+  return normalizeHyperliquidMarketSymbol(symbol);
+}
+function marketOrderPayload(input) {
+  const payload = {
+    symbol: requireSymbol(input),
+    side: requireOrderSide(input),
+    size: requirePositiveNumber(input, "size")
+  };
+  const slippage = optionalPositiveNumber(input, "slippage");
+  if (slippage !== void 0) {
+    payload.slippage = slippage;
+  }
+  const estimatedPrice = optionalPositiveNumber(input, "estimatedPrice");
+  if (estimatedPrice !== void 0) {
+    payload.estimated_price = estimatedPrice;
+  }
+  const estimatedPriceTimestampMs = optionalPositiveNumber(input, "estimatedPriceTimestampMs");
+  if (estimatedPriceTimestampMs !== void 0) {
+    payload.estimated_price_timestamp_ms = estimatedPriceTimestampMs;
+  }
+  return payload;
+}
+function limitOrderPayload(input) {
+  return {
+    symbol: requireSymbol(input),
+    side: requireOrderSide(input),
+    size: requirePositiveNumber(input, "size"),
+    limit_price: requirePositiveNumber(input, "limitPrice"),
+    reduce_only: Boolean(input.reduceOnly)
+  };
+}
+function cancelOrderPayload(input) {
+  return {
+    symbol: requireSymbol(input),
+    oid: requirePositiveNumber(input, "oid")
+  };
+}
+function requireSecretField(input) {
+  const field = optionalString(input, "field");
+  if (!field || !WRITABLE_SECRET_FIELDS.has(field)) {
+    throw new Error(`Unsupported secret field: ${field || "(none)"}`);
+  }
+  return field;
+}
+async function createDefaultMcpClient(env = process.env) {
+  const config = resolveAgentCliConfig(env);
+  const auth = await readStoredAgentAuth(config.tokenPath);
+  return createAgentClient({
+    apiUrl: config.apiUrl,
+    token: auth?.token,
+    activeProfileId: config.activeProfileId
+  });
+}
+async function callVtxMcpTool(client, name, input = {}) {
+  if (name === "vtx_whoami") {
+    return client.whoami();
+  }
+  if (name === "vtx_profiles_list") {
+    return client.listProfiles();
+  }
+  if (name === "vtx_profiles_create") {
+    const sourceProfileId = optionalPositiveNumber(input, "sourceProfileId") ?? null;
+    return client.createProfile(sourceProfileId);
+  }
+  if (name === "vtx_profiles_update") {
+    const profileId = requirePositiveNumber(input, "profileId");
+    const username = optionalString(input, "name");
+    if (!username) {
+      throw new Error("name is required");
+    }
+    return client.updateProfile(profileId, { username });
+  }
+  if (name === "vtx_profiles_delete") {
+    return client.deleteProfile(requirePositiveNumber(input, "profileId"));
+  }
+  if (name === "vtx_profiles_set_mode") {
+    const profileId = requirePositiveNumber(input, "profileId");
+    const mode = optionalString(input, "mode");
+    if (mode !== "client" && mode !== "server") {
+      throw new Error("mode must be client or server");
+    }
+    return client.setProfileExecutionMode(profileId, mode);
+  }
+  if (name === "vtx_tokens_list") {
+    return client.listTokens();
+  }
+  if (name === "vtx_bots_start") {
+    return client.startBot(requirePositiveNumber(input, "profileId"), botStartPayload(input));
+  }
+  if (name === "vtx_bots_configure") {
+    return client.updatePreferences(requirePositiveNumber(input, "profileId"), botConfigurePreferences(input));
+  }
+  if (name === "vtx_bots_stop") {
+    return client.stopBot(requirePositiveNumber(input, "profileId"));
+  }
+  if (name === "vtx_bots_status") {
+    return client.getRuntimeStatus(requirePositiveNumber(input, "profileId"));
+  }
+  if (name === "vtx_bots_logs") {
+    return client.getTradeHistory(requirePositiveNumber(input, "profileId"));
+  }
+  if (name === "vtx_runtime_status") {
+    return client.getRuntimeStatus(requirePositiveNumber(input, "profileId"));
+  }
+  if (name === "vtx_runtime_events") {
+    return client.getRuntimeEvents(requirePositiveNumber(input, "profileId"), {
+      limit: optionalPositiveNumber(input, "limit"),
+      eventType: optionalString(input, "eventType"),
+      clientEventType: optionalString(input, "clientEventType")
+    });
+  }
+  if (name === "vtx_trade_market_order") {
+    return client.placeMarketOrder(requirePositiveNumber(input, "profileId"), marketOrderPayload(input));
+  }
+  if (name === "vtx_trade_limit_order") {
+    return client.placeLimitOrder(requirePositiveNumber(input, "profileId"), limitOrderPayload(input));
+  }
+  if (name === "vtx_trade_cancel_order") {
+    return client.cancelOrder(requirePositiveNumber(input, "profileId"), cancelOrderPayload(input));
+  }
+  if (name === "vtx_billing_status") {
+    return client.getBillingStatus();
+  }
+  if (name === "vtx_billing_prices") {
+    return client.getBillingPrices(optionalPositiveNumber(input, "profileId") ?? null);
+  }
+  if (name === "vtx_ai_config") {
+    return client.getLlmConfig(optionalPositiveNumber(input, "profileId") ?? null);
+  }
+  if (name === "vtx_secrets_status") {
+    return client.getSecretStatus(requirePositiveNumber(input, "profileId"));
+  }
+  if (name === "vtx_secrets_set") {
+    const value = optionalString(input, "value");
+    if (value === null) {
+      throw new Error("value is required");
+    }
+    return client.setRuntimeSecret(requirePositiveNumber(input, "profileId"), requireSecretField(input), value);
+  }
+  throw new Error(`Unknown VTX MCP tool: ${name}`);
+}
+
+// lib/agent-mcp/stdio.ts
+var MCP_PROTOCOL_VERSION = "2024-11-05";
+function jsonRpcResult(id, result) {
+  return { jsonrpc: "2.0", id, result };
+}
+function jsonRpcError(id, code, message, data) {
+  return { jsonrpc: "2.0", id, error: { code, message, data } };
+}
+function requestId(request) {
+  return request.id === void 0 ? null : request.id;
+}
+function isNotification(request) {
+  return request.id === void 0;
+}
+function stringifyToolResult(result) {
+  if (typeof result === "string") {
+    return result;
+  }
+  return JSON.stringify(result, null, 2);
+}
+async function handleMcpJsonRpcRequest(request, clientFactory = createDefaultMcpClient) {
+  const id = requestId(request);
+  const method = String(request.method || "").trim();
+  if (!method) {
+    return jsonRpcError(id, -32600, "Invalid JSON-RPC request.");
+  }
+  if (method === "initialize") {
+    return jsonRpcResult(id, {
+      protocolVersion: MCP_PROTOCOL_VERSION,
+      capabilities: {
+        tools: {}
+      },
+      serverInfo: {
+        name: "vtx-macro",
+        version: "0.1.0"
+      }
+    });
+  }
+  if (method === "notifications/initialized") {
+    return null;
+  }
+  if (method === "ping") {
+    return jsonRpcResult(id, {});
+  }
+  if (method === "tools/list") {
+    return jsonRpcResult(id, { tools: VTX_MCP_TOOLS });
+  }
+  if (method === "tools/call") {
+    const params = request.params || {};
+    const name = String(params.name || "").trim();
+    const args = params.arguments && typeof params.arguments === "object" ? params.arguments : {};
+    if (!name) {
+      return jsonRpcError(id, -32602, "Tool name is required.");
+    }
+    try {
+      const client = await clientFactory();
+      const result = await callVtxMcpTool(client, name, args);
+      return jsonRpcResult(id, {
+        content: [
+          {
+            type: "text",
+            text: stringifyToolResult(result)
+          }
+        ],
+        isError: false
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "VTX MCP tool failed.";
+      return jsonRpcResult(id, {
+        content: [
+          {
+            type: "text",
+            text: message
+          }
+        ],
+        isError: true
+      });
+    }
+  }
+  if (isNotification(request)) {
+    return null;
+  }
+  return jsonRpcError(id, -32601, `Unsupported MCP method: ${method}`);
+}
+function encodeMcpFrame(message) {
+  const body = JSON.stringify(message);
+  return Buffer.from(`Content-Length: ${Buffer.byteLength(body, "utf8")}\r
+\r
+${body}`, "utf8");
+}
+function encodeMcpLine(message) {
+  return Buffer.from(`${JSON.stringify(message)}
+`, "utf8");
+}
+function encodeMcpResponse(message, format) {
+  return format === "json-line" ? encodeMcpLine(message) : encodeMcpFrame(message);
+}
+function parseJsonLineFrame(buffer, newlineEnd) {
+  const line = buffer.subarray(0, newlineEnd).toString("utf8").trim();
+  if (!line) {
+    return {
+      message: null,
+      remaining: buffer.subarray(newlineEnd + 1),
+      format: "json-line"
+    };
+  }
+  if (!line.startsWith("{") && !line.startsWith("[")) {
+    return null;
+  }
+  return {
+    message: JSON.parse(line),
+    remaining: buffer.subarray(newlineEnd + 1),
+    format: "json-line"
+  };
+}
+function extractFrame(buffer) {
+  const headerEnd = buffer.indexOf("\r\n\r\n");
+  const delimiterLength = 4;
+  const normalizedHeaderEnd = headerEnd >= 0 ? headerEnd : buffer.indexOf("\n\n");
+  const normalizedDelimiterLength = headerEnd >= 0 ? delimiterLength : 2;
+  if (normalizedHeaderEnd < 0) {
+    const newlineEnd = buffer.indexOf("\n");
+    if (newlineEnd < 0) {
+      return null;
+    }
+    return parseJsonLineFrame(buffer, newlineEnd);
+  }
+  const headers = buffer.subarray(0, normalizedHeaderEnd).toString("utf8");
+  const lengthLine = headers.split(/\r?\n/).find((line) => /^content-length:/i.test(line));
+  if (!lengthLine) {
+    const newlineEnd = buffer.indexOf("\n");
+    if (newlineEnd >= 0 && normalizedHeaderEnd > newlineEnd) {
+      return parseJsonLineFrame(buffer, newlineEnd);
+    }
+    return null;
+  }
+  const rawLength = lengthLine.split(":")[1]?.trim();
+  const contentLength = Number(rawLength);
+  if (!Number.isInteger(contentLength) || contentLength < 0) {
+    throw new Error("MCP frame has invalid Content-Length header.");
+  }
+  const bodyStart = normalizedHeaderEnd + normalizedDelimiterLength;
+  const bodyEnd = bodyStart + contentLength;
+  if (buffer.length < bodyEnd) {
+    return null;
+  }
+  const body = buffer.subarray(bodyStart, bodyEnd).toString("utf8");
+  return {
+    message: JSON.parse(body),
+    remaining: buffer.subarray(bodyEnd),
+    format: "content-length"
+  };
+}
+async function runVtxMcpStdioServer(input = process.stdin, output = process.stdout, clientFactory = createDefaultMcpClient) {
+  let buffer = Buffer.alloc(0);
+  for await (const chunk of input) {
+    buffer = Buffer.concat([buffer, Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk))]);
+    let frame = extractFrame(buffer);
+    while (frame) {
+      buffer = frame.remaining;
+      if (frame.message) {
+        const response = await handleMcpJsonRpcRequest(frame.message, clientFactory);
+        if (response) {
+          output.write(encodeMcpResponse(response, frame.format));
+        }
+      }
+      frame = extractFrame(buffer);
+    }
+  }
+}
+
+// bin/vtx-mcp.ts
+await runVtxMcpStdioServer();