highwire-mcp 0.10.0 → 0.11.1

package/ideas/starter/src/highwire.ts

@@ -0,0 +1,44 @@
+import { execFile } from "node:child_process";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// Highwire's command line, for the agent's own code: every command runs for this project's wallet, inside its policy.
+
+// The project's .env, if there is one (SOLANA_RPC_URL, say): every command the agent runs inherits it.
+const ENV_FILE = fileURLToPath(new URL("../.env", import.meta.url));
+if (existsSync(ENV_FILE)) process.loadEnvFile(ENV_FILE);
+
+export const HOME = process.env.HIGHWIRE_HOME || join(homedir(), ".highwire", "{{slug}}");
+const CLI = fileURLToPath(new URL("../node_modules/highwire-mcp/dist/cli.js", import.meta.url));
+
+export interface Result {
+  ok: boolean;
+  /** The command's output: its JSON when it was asked for (`--json`), otherwise its text. */
+  out: string;
+  err: string;
+}
+
+/** Runs `highwire <args>`. Never throws for a refusal: `ok` is false and `err` says why. */
+export function highwire(args: string[]): Promise<Result> {
+  const wallet = join(HOME, "wallet.json");
+  const env = { ...process.env, HIGHWIRE_HOME: HOME, ...(existsSync(wallet) ? { HIGHWIRE_KEYPAIR_PATH: wallet } : {}) };
+  return new Promise((resolve) => {
+    execFile(process.execPath, [CLI, ...args], { env, maxBuffer: 10 * 1024 * 1024 }, (error, stdout, stderr) => {
+      resolve({ ok: !error, out: stdout.trim(), err: stderr.trim() });
+    });
+  });
+}
+
+/** Runs a command that takes `--json` and parses its result. */
+export async function highwireJson<T = Record<string, unknown>>(args: string[]): Promise<{ ok: boolean; body: T | null; err: string }> {
+  const r = await highwire([...args, "--json"]);
+  let body: T | null = null;
+  try {
+    body = JSON.parse(r.out) as T;
+  } catch {
+    body = null;
+  }
+  return { ok: r.ok, body, err: r.err };
+}

package/ideas/starter/src/start.ts

@@ -0,0 +1,40 @@
+import { spawn, type ChildProcess } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { HOME } from "./highwire.ts";
+
+// `npm start`: the whole agent, in one process. It runs Highwire's order runner, which fills the standing orders
+// (fee claims, buybacks, limit buys, stop-losses), and the agent's own loop, `src/agent.ts --loop`. If either stops,
+// both stop, so `npm run service` (or any process manager) restarts them together. The policy decides what's real:
+// while it's a dry run everything is simulated, and once the user sets "live": true the same process acts, with a
+// dry run's timed orders running straight away. Nothing here writes the policy.
+
+const ROOT = fileURLToPath(new URL("..", import.meta.url));
+const POLICY = join(HOME, "policy.json");
+const log = (s: string) => console.log(`${new Date().toISOString().slice(0, 19)}Z  ${s}`);
+
+if (!existsSync(join(HOME, "wallet.json")) || !existsSync(POLICY)) {
+  log(`No wallet or policy in ${HOME} yet: run \`npm run setup\` first.`);
+  process.exit(1);
+}
+let live = false;
+try {
+  live = (JSON.parse(readFileSync(POLICY, "utf8")) as { live?: boolean }).live === true;
+} catch {
+  // Highwire's own commands say what's wrong with the policy.
+}
+log(live ? "The policy is live: orders fill and the agent acts." : `The policy is a dry run: everything is simulated until you set "live": true in ${POLICY}.`);
+if (!process.env.SOLANA_RPC_URL) log("Using Solana's public RPC, which rate-limits busy agents. Put SOLANA_RPC_URL in .env for a steadier one.");
+
+const children: ChildProcess[] = [
+  spawn(process.execPath, [join(ROOT, "scripts/highwire.mjs"), "orders", "run"], { cwd: ROOT, stdio: "inherit" }),
+  spawn(join(ROOT, "node_modules/.bin/tsx"), [join(ROOT, "src/agent.ts"), "--loop"], { cwd: ROOT, stdio: "inherit" }),
+];
+for (const c of children) {
+  c.on("exit", (code) => {
+    for (const other of children) if (other !== c && other.exitCode === null) other.kill("SIGTERM");
+    process.exitCode = code ?? 1;
+  });
+}
+for (const s of ["SIGINT", "SIGTERM"] as const) process.on(s, () => children.forEach((c) => c.kill(s)));

package/ideas/starter/src/tools.ts

@@ -0,0 +1,43 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { HOME } from "./highwire.ts";
+
+// Every Highwire tool, from code: the same MCP server a coding agent uses, started for this project's wallet. Execute
+// tools (execute_trade, execute_claim, post_comment …) still pass the policy, and are dry runs until it's live.
+
+const CLI = fileURLToPath(new URL("../node_modules/highwire-mcp/dist/cli.js", import.meta.url));
+
+export interface ToolResult<T> {
+  ok: boolean;
+  /** The tool's JSON. On failure: `{error, code, next_step}`. */
+  body: T;
+}
+
+export class Highwire {
+  private constructor(private readonly client: Client) {}
+
+  static async connect(): Promise<Highwire> {
+    const wallet = join(HOME, "wallet.json");
+    const env: Record<string, string> = {};
+    for (const [k, v] of Object.entries(process.env)) if (v !== undefined) env[k] = v;
+    env.HIGHWIRE_HOME = HOME;
+    if (existsSync(wallet)) env.HIGHWIRE_KEYPAIR_PATH = wallet;
+    const client = new Client({ name: "{{slug}}", version: "0" });
+    await client.connect(new StdioClientTransport({ command: process.execPath, args: [CLI], env, stderr: "ignore" }));
+    return new Highwire(client);
+  }
+
+  /** Calls one tool. A refusal or error comes back with `ok: false`, never as a throw. */
+  async call<T = Record<string, unknown>>(name: string, args: Record<string, unknown> = {}): Promise<ToolResult<T>> {
+    const res = await this.client.callTool({ name, arguments: args });
+    const text = (res.content as Array<{ type: string; text?: string }>)[0]?.text ?? "{}";
+    return { ok: !res.isError, body: JSON.parse(text) as T };
+  }
+
+  close(): Promise<void> {
+    return this.client.close();
+  }
+}

package/ideas/starter/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "types": ["node"],
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "allowImportingTsExtensions": true,
+    "noEmit": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "highwire-mcp",
-  "version": "0.10.0",
+  "version": "0.11.1",
   "description": "Highwire: the MCP server that lets AI agents use higher.fun, the open-source Solana launchpad",
   "type": "module",
   "license": "MIT",
@@ -17,11 +17,17 @@
       "highwire-source": "./src/index.ts",
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
+    },
+    "./ideas": {
+      "highwire-source": "./src/ideas.ts",
+      "types": "./dist/ideas.d.ts",
+      "default": "./dist/ideas.js"
     }
   },
   "files": [
     "dist",
     "skills",
+    "ideas",
     "README.md",
     "LICENSE"
   ],
@@ -35,13 +41,14 @@
     "test": "tsx --conditions=highwire-source --test test/*.test.ts",
     "smoke": "tsx --conditions=highwire-source scripts/smoke.ts",
     "simulate": "tsx --conditions=highwire-source scripts/simulate.ts",
-    "prepack": "npm run build && cp ../../LICENSE .",
+    "prepack": "npm run build && cp ../../LICENSE . && rm -rf ideas && cp -R ../../ideas ideas",
+    "postpack": "rm -rf ideas",
     "rehearse": "tsx --conditions=highwire-source scripts/rehearse.ts"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.32.1",
-    "highwire-agent": "0.10.0",
-    "highwire-core": "0.10.0",
+    "highwire-agent": "0.11.1",
+    "highwire-core": "0.11.1",
     "zod": "4.6.7"
   },
   "mcpName": "fun.highwire/highwire"