ton-mesh-harness 0.13.0

package/dist/utils/http.d.ts

@@ -0,0 +1,25 @@
+export interface HttpResponse<T = unknown> {
+    statusCode: number;
+    headers: Record<string, string | string[] | undefined>;
+    body: T;
+}
+export interface HttpOptions {
+    headers?: Record<string, string>;
+    timeout?: number;
+    /**
+     * Cap the response body size to defend against a buggy or malicious
+     * server returning unbounded data. Defaults to 8 MiB, which is far
+     * above any expected TONAPI / Toncenter response (typical: 1-20 KB).
+     * Codex pre-GA self-audit class — resource-exhaustion defence.
+     */
+    maxBodyBytes?: number;
+}
+/**
+ * Perform an HTTPS GET request and parse JSON response.
+ *
+ * @param url - The URL to request
+ * @param options - Optional headers and timeout
+ * @returns Parsed JSON response
+ * @throws {Error} On HTTP errors or invalid JSON
+ */
+export declare function httpsGet<T = unknown>(url: string, options?: HttpOptions): Promise<T>;

package/dist/utils/tunnel-config.d.ts

@@ -0,0 +1,20 @@
+export interface ResolvedTunnel {
+    /** Absolute path after `~` expansion. */
+    absPath: string;
+    /** Best-effort count of intermediate nodes in the pool. */
+    nodeCount: number;
+}
+/** `~` and `~/foo` expansion — Node's `path.resolve()` does NOT do this. */
+export declare function expandTilde(p: string): string;
+export type TunnelConfigErrorReason = 'not_found' | 'unparseable' | 'empty_pool';
+export declare class TunnelConfigError extends Error {
+    readonly reason: TunnelConfigErrorReason;
+    readonly absPath: string;
+    constructor(reason: TunnelConfigErrorReason, absPath: string, message: string);
+}
+/**
+ * Resolve, validate, and summarise a tunnel-config file. Throws
+ * `TunnelConfigError` on every failure mode — callers map to their own
+ * error class (CLI: plain Error / SDK: SdkError(ERR_INVALID_INPUT)).
+ */
+export declare function resolveTunnelConfig(rawPath: string): ResolvedTunnel;

package/dist/version.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Single source of truth for the kit's version string. Imported by
+ * `src/cli.ts` and `src/mcp.ts`; previously each file hardcoded its
+ * own copy and they drifted (rc2 → rc5 sync was missed twice).
+ *
+ * MUST match `package.json#version` exactly. The `scripts/cli-smoke.cjs`
+ * CI step validates the published binary surfaces a semver-shaped
+ * string, so a forgotten bump here triggers a build-time failure even
+ * if `package.json` is correct.
+ *
+ * NO `console.*` IN THIS FILE — lint-enforced.
+ */
+export declare const MESH_HARNESS_VERSION = "0.13.0";

package/dist/wallet/FSStorage.d.ts

@@ -0,0 +1,12 @@
+import type { Storage } from './Storage';
+export declare class FSStorage implements Storage {
+    private readonly path;
+    constructor(path: string);
+    private mutationChain;
+    private serialize;
+    private readObject;
+    private writeObject;
+    setItem(key: string, value: string): Promise<void>;
+    getItem(key: string): Promise<string | null>;
+    removeItem(key: string): Promise<void>;
+}

package/dist/wallet/SendProvider.d.ts

@@ -0,0 +1,17 @@
+import type { Address, Cell, StateInit } from '@ton/core';
+export interface SendProvider {
+    connect(): Promise<void>;
+    sendTransaction(address: Address, amount: bigint, payload?: Cell, stateInit?: StateInit): Promise<unknown>;
+    sendTransactionMulti(messages: Array<{
+        address: Address;
+        amount: bigint;
+        payload?: Cell;
+        stateInit?: StateInit;
+    }>): Promise<unknown>;
+    address(): Address | undefined;
+    /**
+     * Stop the bridge HTTP listener so the Node event loop can drain. Does
+     * NOT unpair the wallet (the next run still finds the session on disk).
+     */
+    dispose(): void;
+}

package/dist/wallet/Storage.d.ts

@@ -0,0 +1,5 @@
+export interface Storage {
+    setItem(key: string, value: string): Promise<void>;
+    getItem(key: string): Promise<string | null>;
+    removeItem(key: string): Promise<void>;
+}

package/dist/wallet/TonConnectProvider.d.ts

@@ -0,0 +1,48 @@
+import { type SendTransactionResponse } from '@tonconnect/sdk';
+import { Address, Cell, type StateInit } from '@ton/core';
+import type { SendProvider } from './SendProvider';
+import type { Storage } from './Storage';
+import type { WalletUI } from './ui';
+export type WalletNetwork = 'mainnet' | 'testnet';
+/** @internal */
+export declare function _enterQuiet_FOR_TEST(): void;
+/** @internal */
+export declare function _leaveQuiet_FOR_TEST(): void;
+export declare class TonConnectProvider implements SendProvider {
+    private readonly connector;
+    private readonly ui;
+    private readonly network;
+    constructor(storage: Storage, ui: WalletUI, network: WalletNetwork, manifestUrl: string);
+    /**
+     * @param onConnectUrl — optional callback fired with the freshly-generated
+     * TonConnect connect URL just before we await the wallet pairing. Used by
+     * the SDK's `deploy()` generator to emit `awaiting_signature` with
+     * `signing_url` set. CLI callers can ignore — the URL is also printed via
+     * the QR code in `connectWallet()`.
+     */
+    connect(onConnectUrl?: (url: string) => void): Promise<void>;
+    address(): Address | undefined;
+    /**
+     * Stop the @tonconnect/sdk bridge HTTP listener (server-sent events) so
+     * the Node event loop drains and the CLI can exit after a `--no-watch`
+     * deploy. We pause rather than disconnect so the on-disk session stays
+     * paired — `connect()` next run finds it via `restoreConnection()`.
+     * Caller responsibility: invoke from a `finally` block after the last
+     * sendTransaction[Multi] call.
+     */
+    dispose(): void;
+    private connectWallet;
+    sendTransaction(address: Address, amount: bigint, payload?: Cell, stateInit?: StateInit): Promise<SendTransactionResponse>;
+    /**
+     * Send a TonConnect transaction with multiple messages bundled into a single
+     * sign request. Tonkeeper supports up to 4 messages per tx (TonConnect spec
+     * §sendTransaction). Used by --domain when both a `storage` and `site` DNS
+     * record are written in one user-prompt.
+     */
+    sendTransactionMulti(messages: Array<{
+        address: Address;
+        amount: bigint;
+        payload?: Cell;
+        stateInit?: StateInit;
+    }>): Promise<SendTransactionResponse>;
+}

package/dist/wallet/constants.d.ts

@@ -0,0 +1,12 @@
+export declare const TONCONNECT_MANIFEST_URL = "https://raw.githubusercontent.com/Masashi-Ono0611/ton-mesh-harness/main/tonconnect/manifest.json";
+export declare function getTonConnectStoragePath(): string;
+/** Sign-request validity window: 5 minutes (chain-enforced cap). */
+export declare const SIGN_WINDOW_SECONDS: number;
+/**
+ * Build the `validUntil` Unix-epoch-second timestamp for a wallet sign
+ * request (TonConnect SDK + walletkit both use this convention).
+ * Used by `TonConnectProvider.sendTransactionMulti` and
+ * `agenticSignAndSend` so the same 5-minute window applies regardless
+ * of signing path.
+ */
+export declare function signRequestValidUntilSeconds(): number;

package/dist/wallet/ui.d.ts

@@ -0,0 +1,13 @@
+export interface WalletUI {
+    choose<T>(message: string, options: T[], display: (t: T) => string): Promise<T>;
+    input(message: string): Promise<string>;
+    write(message: string): void;
+    setActionPrompt(message: string): void;
+    clearActionPrompt(): void;
+}
+export interface WalletUIOptions {
+    interactive: boolean;
+    defaultPick?: number;
+    preferByName?: string;
+}
+export declare function createWalletUI(opts: WalletUIOptions): WalletUI;

package/package.json

@@ -0,0 +1,105 @@
+{
+  "name": "ton-mesh-harness",
+  "version": "0.13.0",
+  "description": "TON Mesh Harness — one-command CLI + MCP server to deploy a static site to .ton (TON Storage + .ton DNS + ADNL), self-host first, agent-callable. CLI, MCP server (4 tools), and a programmable SDK on one deploy contract.",
+  "main": "./dist/sdk.js",
+  "types": "./dist/sdk.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/sdk.d.ts",
+      "default": "./dist/sdk.js"
+    },
+    "./sdk": {
+      "types": "./dist/sdk.d.ts",
+      "default": "./dist/sdk.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "ton-mesh-harness": "dist/cli.js",
+    "ton-mesh-harness-mcp": "dist/mcp.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
+  ],
+  "scripts": {
+    "build": "bun run scripts/build.ts && bun run build:types",
+    "build:types": "tsc -p tsconfig.build.json",
+    "dev": "bun run scripts/build.ts --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint src/sdk",
+    "typecheck": "tsc --noEmit",
+    "smoke": "node scripts/cli-smoke.cjs && node scripts/mcp-smoke.cjs && node scripts/mcp-http-smoke.cjs && node scripts/sdk-smoke.cjs",
+    "smoke:full": "bun run smoke && node scripts/tarball-smoke.cjs",
+    "verify": "bun run lint && bun run typecheck && bun run test && bun run build && bun run smoke",
+    "pack:dry": "npm pack --dry-run"
+  },
+  "files": [
+    "dist",
+    "templates",
+    "skills"
+  ],
+  "keywords": [
+    "ton",
+    "ton-storage",
+    "ton-dns",
+    "dot-ton",
+    "adnl",
+    "blockchain",
+    "deploy",
+    "static-site",
+    "website",
+    "storage",
+    "decentralized-web",
+    "censorship-resistant",
+    "mcp",
+    "mcp-server",
+    "agent-skill",
+    "claude-skill",
+    "tonconnect",
+    "agentic-wallet"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@ton/ton": "^15.4.0",
+    "@ton/walletkit": "^0.0.12-alpha.3",
+    "@tonconnect/sdk": "^3.4.1",
+    "chalk": "^4.1.2",
+    "chokidar": "^4.0.3",
+    "commander": "^12.1.0",
+    "ora": "^5.4.1",
+    "qrcode-terminal": "^0.12.0",
+    "zod": "^3.25.76"
+  },
+  "overrides": {
+    "axios": ">=1.16.0",
+    "form-data": ">=4.0.6",
+    "hono": ">=4.12.25",
+    "ws": ">=8.21.0"
+  },
+  "peerDependencies": {
+    "@ton/mcp": "^0.1.15-alpha.15"
+  },
+  "peerDependenciesMeta": {
+    "@ton/mcp": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@ton/mcp": "^0.1.15-alpha.15",
+    "@types/node": "^25.5.0",
+    "@types/qrcode-terminal": "^0.12.2",
+    "eslint": "^9.39.4",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.59.2",
+    "vitest": "^2.1.9",
+    "zod-to-json-schema": "^3.25.2"
+  }
+}

package/skills/mesh-deploy.md

@@ -0,0 +1,283 @@
+---
+name: mesh-deploy
+description: Deploy a static site to .ton (TON Storage + .ton DNS) with one tool call. Censorship-resistant, no server, no CDN, no domain registrar.
+---
+
+# Mesh Deploy — TON Storage + .ton DNS in one tool call
+
+## When to use
+
+Use this skill when the user wants to publish a static site (built `dist/`,
+`build/`, `out/`, or `public/` directory) to TON's digital-resistance stack
+so the site:
+
+- Cannot be taken down by hosting providers / domain registrars
+- Survives geo-blocks
+- Resolves at `<name>.ton` via TON DNS
+- Is content-addressed (a bag id; the URL is the hash)
+
+Trigger phrases (verbatim or paraphrased):
+- "deploy this to .ton"
+- "publish censorship-resistant"
+- "TON Storage deploy"
+- "host my site on TON"
+- "I want a .ton domain pointing at this"
+
+Skip this skill when:
+- The site is a server-rendered app — TON Sites serve static content only
+- The user wants a `.eth` domain or IPFS-only — different stack
+- The deploy target is a private network (corporate intranet) — overkill
+
+## Prerequisites
+
+Run `mesh_check_env` BEFORE `mesh_deploy` to surface fixable
+problems early. Required:
+
+- **Node ≥ 18** (the kit declares `engines.node: ">=18"`)
+- **A built directory** (`dist/`, `build/`, `out/`, or `public/`)
+- **UDP port 17555 free** (the tonutils-storage daemon binds here; TON
+  Browser.app conflicts — quit it before deploying)
+- **TONAPI mainnet reachable** (the kit verifies the bag via TONAPI;
+  blocked behind a corporate proxy → tell the user to whitelist
+  `tonapi.io`)
+- **Disk free ≥ 100 MB** for the daemon binary cache at `~/.ton-mesh/bin/`
+- **One of two signing paths** (see "Signing modes" below)
+
+If the user wants a `.ton` DNS record (most do — that's the human-readable
+URL), they additionally need:
+- **The `.ton` domain owned** by their TonConnect wallet (≈ 1 TON one-time
+  to mint)
+- **≈ 0.02 TON** for the DNS write transaction gas
+
+## Signing modes
+
+The kit supports two orthogonal signing paths via the `wallet` input:
+
+### Path 1 — TonConnect (human-signed, default)
+```json
+{ "wallet": { "kind": "tonconnect", "connector": "Tonkeeper" } }
+```
+- The agent surfaces a `signing_url` via the `awaiting_signature` progress
+  event. The HUMAN opens it in their wallet app and approves.
+- Use this when there's a human in the loop.
+- Connector substring matches the TonConnect manifest name —
+  `"Tonkeeper"`, `"MyTonWallet"`, etc.
+
+### Path 2 — Agentic (autonomous, no human)
+```json
+{ "wallet": { "kind": "agentic" } }
+```
+- The kit reads `~/.config/ton/config.json` (or `$TON_CONFIG_PATH`) — the
+  same file `@ton/mcp` writes via `agentic_start_root_wallet_setup`.
+- Signing is fully autonomous — no human approval prompt.
+- Use this when the agent operates without a user (CI, autonomous
+  agents, scheduled deploys).
+- Set up the wallet once via:
+  ```bash
+  npx -y @ton/mcp@alpha agentic_start_root_wallet_setup
+  ```
+  Or load `@ton/mcp` as a peer MCP server and call its agentic
+  wallet management tools.
+
+The signing modes are filesystem-level compose with `@ton/mcp`; there is
+no inter-MCP RPC handoff.
+
+## Steps
+
+### 1. Pre-flight check
+```jsonc
+// MCP call
+{
+  "name": "mesh_check_env",
+  "arguments": { "source_dir": "./dist" }
+}
+```
+Returns a `CheckEnvResult`. If `ready: false`, the `blocking` array has
+items with `code`, `message`, and `fix_hint`. Surface each `fix_hint` to
+the user; don't proceed to deploy until `ready: true`.
+
+### 2. Deploy
+
+TonConnect path (human-signed):
+
+```jsonc
+// MCP call (rc5+)
+{
+  "name": "mesh_deploy",
+  "arguments": {
+    "source_dir": "./dist",
+    "domain": "myprotocol.ton",
+    "wallet": { "kind": "tonconnect", "connector": "Tonkeeper" }
+  }
+}
+```
+
+Agentic path (autonomous — reads `~/.config/ton/config.json`):
+
+```jsonc
+{
+  "name": "mesh_deploy",
+  "arguments": {
+    "source_dir": "./dist",
+    "domain": "myprotocol.ton",
+    "wallet": { "kind": "agentic", "wallet_label": "main-mainnet" }
+  }
+}
+```
+
+#### What rc5 MCP does end-to-end
+
+From rc3+ the MCP server completes the **entire flow** — bag upload
+AND .ton DNS write — for both wallet paths. `notifications/progress`
+events fire in this order:
+
+1. `env_check` — preparing tonutils-storage
+2. `daemon_starting` — spawning the storage daemon
+3. `bag_creating` — uploading the build dir
+4. `bag_uploaded` — bag is on disk in the daemon
+5. `awaiting_signature` — TonConnect: `data.signing_url` is a tonkeeper://
+   deeplink, surface to the user. Agentic: `signing_url: null`, signing
+   proceeds locally and instantly.
+6. `dns_signing` — broadcast accepted by Toncenter (TonConnect: signed
+   message BOC in `data`; agentic: normalized message hash in `data`)
+7. `dns_confirmed` — DNS record propagated via TONAPI
+8. `verifying` — informational; TONAPI propagation IS the verification
+
+Then the terminal `done` event with `DeployResult.dns_tx_hash` carrying
+the **real on-chain tx hash** resolved via Toncenter v3
+`transactionsByMessage` (rc4+), or `null` with a `next_actions` fallback
+hint if Toncenter's index hadn't caught up by the 3s grace deadline.
+
+### 3. After deploy
+- Tell the user the bag id (it's the content hash). Do NOT hand them
+  `https://ton.run/<bag_id>` — public gateways serve `.ton` domains, not raw
+  bag ids, so that URL 404s. A browser URL only exists once a `.ton` domain
+  points at the bag and a reachable node seeds it.
+- If `dns_tx_hash` is non-null, surface a tonviewer link:
+  `https://tonviewer.com/transaction/<hash without 0x>`.
+- If they passed `domain`, tell them `<domain>.ton` will resolve within
+  a few minutes after the DNS tx confirms (the `dns_confirmed` event
+  already implies TONAPI propagation succeeded).
+- Suggest `--watch` mode (CLI) or a follow-up call if they expect the
+  build dir to change. **MCP rejects `keep_alive: true`** — use the CLI
+  if you need long-running watch.
+
+## Common mistakes
+
+- **UDP port 17555 collision with TON Browser.app.** Quit the app before
+  deploying. `mesh_check_env` flags this as a blocker.
+- **TONAPI unreachable in corporate networks.** Bag verification fails.
+  Whitelist `tonapi.io` or skip verification with `skip_verify: true`.
+- **Forgetting that mainnet provider economy is dormant.** Do NOT suggest
+  `--provider` — the kit disabled it in v0.6 and v0.9 reserve will revisit.
+- **Treating `--watch` as 24-hour hosting.** The daemon must keep running
+  for the bag to stay seedable. Suggest the user either keep their machine
+  on or contract a tunnel-rental (v0.9 reserve).
+- **Empty `.ton` domain resolution.** The bag is created instantly but
+  TONAPI lags ~minutes; tell the user to wait if `.ton` returns nothing
+  immediately.
+
+## Examples
+
+### Minimal deploy (no DNS — just upload the bag)
+```jsonc
+{
+  "name": "mesh_deploy",
+  "arguments": { "source_dir": "./dist" }
+}
+```
+
+### Deploy with custom domain (default TonConnect)
+```jsonc
+{
+  "name": "mesh_deploy",
+  "arguments": {
+    "source_dir": "./dist",
+    "domain": "myprotocol.ton",
+    "description": "MyProtocol v1.2.0 release build"
+  }
+}
+```
+
+### Agentic deploy (no human)
+```jsonc
+{
+  "name": "mesh_deploy",
+  "arguments": {
+    "source_dir": "./dist",
+    "domain": "ci-bot.ton",
+    "wallet": { "kind": "agentic", "wallet_label": "ci" }
+  }
+}
+```
+
+### With tunnel client (NAT traversal, v0.9 reserve)
+```jsonc
+{
+  "name": "mesh_deploy",
+  "arguments": {
+    "source_dir": "./dist",
+    "domain": "from-behind-nat.ton",
+    "tunnel_config": "/Users/me/.ton-tunnel/nodes-pool.json"
+  }
+}
+```
+
+## Tool surface
+
+- `mesh_check_env({ source_dir? })` → `CheckEnvResult`
+- `mesh_deploy({ source_dir, domain?, wallet?, ... })` → `DeployResult`
+- `mesh_status({ bag_id, domain?, testnet? })` → `StatusResult` (one-shot propagation snapshot)
+- `mesh_site_record({ domain, site_adnl, testnet? })` → `SiteRecordResult` (Tonkeeper deeplink that sets only the `site` record; never broadcasts)
+
+Full input/output schemas: see the `tools/list` response or
+[`docs/v0.8/mcp-core-requirements.md`](https://github.com/Masashi-Ono0611/ton-mesh-harness/blob/main/docs/v0.8/mcp-core-requirements.md)
+§F2.
+
+## Install
+
+```bash
+# Per-call (recommended for agents)
+npx -y --package ton-mesh-harness ton-mesh-harness-mcp
+
+# Or pin globally
+npm install -g ton-mesh-harness
+```
+
+Add to your MCP client config:
+```jsonc
+{
+  "mcpServers": {
+    "ton-mesh-harness": {
+      "command": "npx",
+      "args": ["-y", "--package", "ton-mesh-harness", "ton-mesh-harness-mcp"]
+    }
+  }
+}
+```
+
+For agentic-wallet flows, also load `@ton/mcp@alpha` so the kit can share
+the wallet config:
+```jsonc
+{
+  "mcpServers": {
+    "ton-mesh-harness": {
+      "command": "npx",
+      "args": ["-y", "--package", "ton-mesh-harness", "ton-mesh-harness-mcp"]
+    },
+    "ton": {
+      "command": "npx",
+      "args": ["-y", "@ton/mcp@alpha"]
+    }
+  }
+}
+```
+
+## Source
+
+- GitHub: https://github.com/Masashi-Ono0611/ton-mesh-harness
+- License: MIT
+- v0.8.0-rc1 first published 2026-05-10
+- Status: rc5 — full end-to-end (bag upload + .ton DNS write via either
+  TonConnect or agentic signing path). v0.8.0 GA pending V3 (E2E
+  acceptance) + V4 (red-team) per the open Epic.

package/templates/.well-known/mcp.json

@@ -0,0 +1,44 @@
+{
+  "_note_schema": "This is an experimental shape — there is no published JSON Schema at https://modelcontextprotocol.io/.well-known/ at the time of writing. Treat the file as a kit-specific self-description until/unless a standard MCP well-known schema lands. If a standard does land, add a $schema reference and update consumers.",
+  "_note_template": "This file is a TEMPLATE. Users who self-host the kit's dashboard at <domain>.ton can copy it into their build dir's .well-known/ so an agent visiting their site can discover the kit that published it (the 'View Source + Redeploy' axis from concept update 2026-05-10 Codex C proposal). The kit does NOT auto-write this file — copying is opt-in.",
+  "name": "ton-mesh-harness-mcp",
+  "version": "0.13.0",
+  "description": "Deploy a static site to .ton (TON Storage + .ton DNS, end-to-end). Censorship-resistant, no server, no CDN, no domain registrar. Agent-callable via MCP. Supports human-signed (TonConnect) and autonomous (agentic, reads ~/.config/ton/config.json shared with @ton/mcp) signing modes. Real on-chain dns_tx_hash via Toncenter v3 lookup.",
+  "homepage": "https://github.com/Masashi-Ono0611/ton-mesh-harness",
+  "install": {
+    "command": "npx",
+    "args": ["-y", "--package", "ton-mesh-harness", "ton-mesh-harness-mcp"]
+  },
+  "tools": [
+    {
+      "name": "mesh_check_env",
+      "summary": "Pre-flight readiness probe — call BEFORE mesh_deploy."
+    },
+    {
+      "name": "mesh_deploy",
+      "summary": "Deploy a static site to .ton (bag upload + DNS write, end-to-end) via TonConnect or agentic signing."
+    },
+    {
+      "name": "mesh_status",
+      "summary": "One-shot bag propagation + DNS resolution snapshot for a deployed site."
+    },
+    {
+      "name": "mesh_site_record",
+      "summary": "Build a Tonkeeper deeplink that sets only the site (ADNL) DNS record."
+    }
+  ],
+  "compose": {
+    "peer_mcp_servers": [
+      {
+        "name": "@ton/mcp",
+        "purpose": "agentic wallet management (autonomous signing). The kit reads ~/.config/ton/config.json — the same file @ton/mcp manages.",
+        "install": {
+          "command": "npx",
+          "args": ["-y", "@ton/mcp@alpha"]
+        }
+      }
+    ]
+  },
+  "skill_md": "https://github.com/Masashi-Ono0611/ton-mesh-harness/blob/main/skills/mesh-deploy.md",
+  "license": "MIT"
+}