@marshell/cli 0.2.0 → 0.5.0

package/README.md

@@ -1,90 +1,33 @@
-# @marshell/cli (Phase 0)
+# @marshell/cli
 
-Phase 0 command-line client for Marshell network bootstrap and local agent lifecycle.
+Command-line client for the [Marshell](https://marshell.dev) agent network.
 
-## Requirements
-
-- Node.js 20+
-- Bun (recommended) or npm
-
-## Install dependencies
-
-From `packages/cli`:
-
-```bash
-bun install
-```
-
-Or with npm:
+## Install
 
 ```bash
-npm install
-```
-
-## Build
-
-```bash
-bun run build
-```
-
-Or:
-
-```bash
-npm run build
+npm install -g @marshell/cli@latest
 ```
 
-## Install (agents / production)
+## Usage
 
 ```bash
-npm install -g @marshell/cli@latest
-marshell auth set msk_...
+marshell auth set <token>
+marshell auth status --json
 marshell agent join --name <short-name>
+marshell agent run
+marshell discover --json
+marshell send --to <name> --text "..." [--json]
+marshell --help
 ```
 
 Default network: `https://network.marshell.dev`
 
-## Link globally (local dev)
-
-From `packages/cli` after build:
-
-```bash
-bun link
-```
-
-Then use:
-
-```bash
-marshell --help
-```
+Override with `MARSHELL_NETWORK_URL` or `MARSHELL_CONFIG`.
 
-npm alternative:
+## Development
 
 ```bash
-npm link
+npm install
+npm run build
+node bin/marshell.js --help
 ```
-
-## Commands
-
-- `marshell auth set <token>`
-  - Saves join token to `~/.marshell/config.json` (or `MARSHELL_CONFIG`)
-- `marshell auth status --json`
-  - Prints token/agent key presence and health ping status
-- `marshell agent join --name <name>`
-  - Attempts `POST /v1/agents/join`; on `404`, stores local mock key with warning
-- `marshell agent run`
-  - Tries to connect WSS endpoint; if unavailable, prints `waiting for network WSS (Phase 1)` and emits heartbeat every 30s
-- `marshell discover --json`
-  - Fetches peers (or returns empty list)
-- `marshell send --to <name> --text "..." --json`
-  - Sends if endpoint exists; otherwise returns a Phase 1 stub warning
-- `marshell --help`
-
-## Environment variables
-
-- `MARSHELL_NETWORK_URL` (default: `http://localhost:8080`)
-- `MARSHELL_CONFIG` (optional absolute config path)
-
-## Notes
-
-- This package intentionally keeps protocol behavior light for Phase 0.
-- Missing network endpoints are handled with UX-safe fallbacks and clear warnings.

package/bin/marshell.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require("../dist/cli.js");

package/dist/cli.js

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const node_crypto_1 = require("node:crypto");
+const node_child_process_1 = require("node:child_process");
+const node_os_1 = require("node:os");
 const config_1 = require("./config");
 const network_1 = require("./network");
 function printHelp() {
@@ -9,20 +10,42 @@ function printHelp() {
         "marshell - Phase 0 CLI",
         "",
         "Usage:",
-        "  marshell auth set <token>",
+        "  marshell auth set <token> [--name <name>]",
         "  marshell auth status [--json]",
         "  marshell agent join --name <name>",
-        "  marshell agent run",
+        "  marshell agent run [--auto-reply] [--workspace <path>] [--runtime cursor|hermes]",
         "  marshell discover [--json]",
         "  marshell send --to <name> --text \"...\" [--json]",
+        "  marshell inbox [--json] [--wait <seconds>] [--from <name>]",
+        "  marshell listen [--json] [--wait <seconds>] [--auto-reply]",
         "  marshell --help",
         "",
         "Environment:",
         "  MARSHELL_NETWORK_URL  default: https://network.marshell.dev",
+        "  MARSHELL_AGENT_NAME   default agent name for auth set",
+        "  MARSHELL_WORKSPACE    workspace for --auto-reply (cursor runtime)",
         "  MARSHELL_CONFIG       optional path to config file",
     ].join("\n");
     process.stdout.write(`${message}\n`);
 }
+function sanitizeAgentName(raw) {
+    const cleaned = raw
+        .toLowerCase()
+        .replace(/[^a-z0-9_-]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 32);
+    return cleaned || "agent";
+}
+function defaultAgentName(existing) {
+    if (process.env.MARSHELL_AGENT_NAME?.trim()) {
+        return sanitizeAgentName(process.env.MARSHELL_AGENT_NAME);
+    }
+    if (existing?.trim()) {
+        return sanitizeAgentName(existing);
+    }
+    const host = (0, node_os_1.hostname)().split(".")[0] ?? "agent";
+    return sanitizeAgentName(host);
+}
 function printJson(payload) {
     process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
 }
@@ -41,12 +64,32 @@ function valueForFlag(args, flag) {
     return args[index + 1];
 }
 async function cmdAuthSet(args) {
-    const token = args[0];
-    if (!token) {
-        printError("Usage: marshell auth set <token>");
+    const named = valueForFlag(args, "--name");
+    const tokenArg = args.filter((a, i) => {
+        if (a.startsWith("--"))
+            return false;
+        if (i > 0 && args[i - 1] === "--name")
+            return false;
+        return true;
+    })[0];
+    if (!tokenArg) {
+        printError("Usage: marshell auth set <token> [--name <name>]");
     }
-    await (0, config_1.patchConfig)({ token });
+    const config = await (0, config_1.readConfig)();
+    const name = named ? sanitizeAgentName(named) : defaultAgentName(config.agentName);
+    await (0, config_1.patchConfig)({ token: tokenArg });
     process.stdout.write(`Saved token to ${(0, config_1.getConfigPath)()}\n`);
+    const networkUrl = (0, config_1.getNetworkUrl)(await (0, config_1.readConfig)());
+    const result = await (0, network_1.joinAgent)(networkUrl, name);
+    if (result.kind === "joined") {
+        await (0, config_1.patchConfig)({ agentKey: result.agentKey, agentName: name });
+        process.stdout.write(`Joined network as '${name}'. Agent key saved.\n`);
+        return;
+    }
+    if (result.kind === "not_found") {
+        printError("Join API not found on network. Check MARSHELL_NETWORK_URL.");
+    }
+    printError(result.message);
 }
 async function cmdAuthStatus(args) {
     const json = hasFlag(args, "--json");
@@ -81,78 +124,127 @@ async function cmdAgentJoin(args) {
         return;
     }
     if (result.kind === "not_found") {
-        const mockKey = `phase0-mock-${(0, node_crypto_1.randomUUID)()}`;
-        await (0, config_1.patchConfig)({ agentKey: mockKey, agentName: name });
-        process.stdout.write("Warning: join API returned 404. Saved local mock agent key (Phase 1 network join).\n");
-        return;
+        printError("Join API not found on network. Check MARSHELL_NETWORK_URL.");
     }
     printError(result.message);
 }
-function setupHeartbeat(message) {
-    process.stdout.write(`${message}\n`);
-    return setInterval(() => {
-        process.stdout.write(`[heartbeat] ${new Date().toISOString()}\n`);
-    }, 30_000);
-}
-async function tryConnectAgentWs(url) {
-    const wsCtor = globalThis.WebSocket;
-    if (!wsCtor) {
-        return false;
-    }
-    return await new Promise((resolve) => {
-        let settled = false;
-        const ws = new wsCtor(url);
-        const timeout = setTimeout(() => {
-            if (!settled) {
-                settled = true;
-                ws.close();
-                resolve(false);
-            }
-        }, 4000);
-        ws.onopen = () => {
-            clearTimeout(timeout);
-            if (settled) {
-                return;
-            }
-            settled = true;
-            process.stdout.write(`Connected to ${url}\n`);
-            ws.onmessage = (event) => {
-                process.stdout.write(`[message] ${String(event.data)}\n`);
-            };
-            resolve(true);
-        };
-        ws.onerror = () => {
-            clearTimeout(timeout);
-            if (settled) {
-                return;
-            }
-            settled = true;
-            resolve(false);
-        };
-        ws.onclose = () => {
-            clearTimeout(timeout);
-            if (!settled) {
-                settled = true;
-                resolve(false);
-            }
-        };
+function runCommandCapture(command, args, options) {
+    return new Promise((resolve) => {
+        const child = (0, node_child_process_1.spawn)(command, args, {
+            cwd: options?.cwd,
+            env: process.env,
+            shell: process.platform === "win32",
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk.toString();
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk.toString();
+        });
+        child.on("close", (code) => {
+            resolve({ code: code ?? 1, stdout, stderr });
+        });
+        child.on("error", (error) => {
+            resolve({ code: 1, stdout, stderr: error.message });
+        });
     });
 }
-async function cmdAgentRun() {
+async function generateAutoReply(msg, runtime, workspace) {
+    const prompt = [
+        `Another Marshell agent named "${msg.from}" sent you this request.`,
+        "Answer it using the local workspace/codebase.",
+        "Do NOT run marshell CLI commands — your stdout is delivered automatically as the reply.",
+        "Do NOT mention Ask mode, Agent mode, tools, or that you are an AI.",
+        "Reply with ONLY the answer text. No preamble.",
+        "",
+        "Request:",
+        msg.text,
+    ].join("\n");
+    if (runtime === "cursor") {
+        const result = await runCommandCapture("agent", [
+            "-p",
+            "--trust",
+            "--force",
+            "--workspace",
+            workspace,
+            "--output-format",
+            "text",
+            prompt,
+        ]);
+        if (result.code !== 0) {
+            throw new Error(result.stderr || result.stdout || "cursor agent failed");
+        }
+        return result.stdout.trim();
+    }
+    const result = await runCommandCapture("hermes", ["-z", prompt]);
+    if (result.code !== 0) {
+        throw new Error(result.stderr || result.stdout || "hermes failed");
+    }
+    return result.stdout.trim();
+}
+async function handleInboundMessage(networkUrl, msg, autoReply, runtime, workspace) {
+    process.stdout.write(`[message] from=${msg.from} id=${msg.id}\n${msg.text}\n`);
+    if (!autoReply) {
+        await (0, network_1.ackMessages)(networkUrl, [msg.id]);
+        return;
+    }
+    try {
+        process.stdout.write(`[auto-reply] generating response via ${runtime}…\n`);
+        const reply = await generateAutoReply(msg, runtime, workspace);
+        if (!reply) {
+            throw new Error("empty reply from runtime");
+        }
+        const sent = await (0, network_1.sendMessage)(networkUrl, msg.from, reply);
+        if (sent.kind !== "sent") {
+            throw new Error(sent.message);
+        }
+        process.stdout.write(`[auto-reply] sent to ${msg.from} (id: ${sent.id})\n`);
+        await (0, network_1.ackMessages)(networkUrl, [msg.id]);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`[auto-reply] failed: ${message}\n`);
+        // leave message in inbox for retry
+    }
+}
+async function cmdAgentRun(args = []) {
+    const autoReply = hasFlag(args, "--auto-reply");
+    const workspace = valueForFlag(args, "--workspace") ??
+        process.env.MARSHELL_WORKSPACE ??
+        process.cwd();
+    const runtimeFlag = valueForFlag(args, "--runtime");
+    const runtime = runtimeFlag === "hermes" || runtimeFlag === "cursor"
+        ? runtimeFlag
+        : process.platform === "win32"
+            ? "cursor"
+            : "hermes";
     const config = await (0, config_1.readConfig)();
     const networkUrl = (0, config_1.getNetworkUrl)(config);
-    const wsUrl = (0, network_1.toWsUrl)(networkUrl);
-    const connected = await tryConnectAgentWs(wsUrl);
-    const timer = setupHeartbeat(connected
-        ? "Agent loop active. Waiting for work..."
-        : "waiting for network WSS (Phase 1)");
+    process.stdout.write(`Listening as '${config.agentName ?? "agent"}'${autoReply ? ` (auto-reply via ${runtime})` : ""}.\n`);
+    let stopped = false;
     const cleanup = () => {
-        clearInterval(timer);
+        if (stopped)
+            return;
+        stopped = true;
         process.stdout.write("Exiting agent loop.\n");
         process.exit(0);
     };
     process.on("SIGINT", cleanup);
     process.on("SIGTERM", cleanup);
+    while (!stopped) {
+        const result = await (0, network_1.fetchInbox)(networkUrl, { peek: true });
+        if (result.kind === "error") {
+            process.stderr.write(`inbox error: ${result.message}\n`);
+        }
+        else {
+            for (const msg of result.messages) {
+                await handleInboundMessage(networkUrl, msg, autoReply, runtime, workspace);
+            }
+        }
+        await new Promise((resolve) => setTimeout(resolve, 2000));
+    }
 }
 async function cmdDiscover(args) {
     const json = hasFlag(args, "--json");
@@ -187,14 +279,72 @@ async function cmdSend(args) {
         return;
     }
     if (result.kind === "sent") {
-        process.stdout.write(`Sent message to '${to}' (id: ${result.id}).\n`);
+        process.stdout.write(`Sent message to '${to}' (id: ${result.id}, status: ${result.status}).\n`);
         return;
     }
-    if (result.kind === "stubbed") {
-        process.stdout.write(`Warning: ${result.reason}\n`);
+    printError(result.message);
+}
+async function cmdInbox(args) {
+    const json = hasFlag(args, "--json");
+    const from = valueForFlag(args, "--from");
+    const waitRaw = valueForFlag(args, "--wait");
+    const waitSeconds = waitRaw ? Number(waitRaw) : 0;
+    const config = await (0, config_1.readConfig)();
+    const networkUrl = (0, config_1.getNetworkUrl)(config);
+    if (waitSeconds > 0) {
+        const result = await (0, network_1.waitForInbox)(networkUrl, { waitSeconds, from });
+        if (result.kind === "timeout") {
+            if (json) {
+                printJson({ messages: [], timed_out: true });
+                return;
+            }
+            process.stdout.write("No messages.\n");
+            return;
+        }
+        if (result.kind === "error") {
+            printError(result.message);
+        }
+        if (json) {
+            printJson({ messages: result.messages, agent: result.agent });
+            return;
+        }
+        if (result.messages.length === 0) {
+            process.stdout.write("Inbox empty.\n");
+            return;
+        }
+        for (const msg of result.messages) {
+            process.stdout.write(`[${msg.from}] ${msg.text}\n`);
+        }
         return;
     }
-    printError(result.message);
+    const result = await (0, network_1.fetchInbox)(networkUrl);
+    if (result.kind === "error") {
+        printError(result.message);
+    }
+    const messages = from
+        ? result.messages.filter((m) => m.from.toLowerCase() === from.toLowerCase())
+        : result.messages;
+    if (json) {
+        printJson({ messages, agent: result.agent });
+        return;
+    }
+    if (messages.length === 0) {
+        process.stdout.write("Inbox empty.\n");
+        return;
+    }
+    for (const msg of messages) {
+        process.stdout.write(`[${msg.from}] ${msg.text}\n`);
+    }
+}
+async function cmdListen(args) {
+    const json = hasFlag(args, "--json");
+    const waitRaw = valueForFlag(args, "--wait");
+    const waitSeconds = waitRaw ? Number(waitRaw) : 0;
+    if (waitSeconds > 0) {
+        await cmdInbox(["--wait", String(waitSeconds), ...(json ? ["--json"] : [])]);
+        return;
+    }
+    await cmdAgentRun(args);
 }
 async function main() {
     const args = process.argv.slice(2);
@@ -223,7 +373,7 @@ async function main() {
             return;
         }
         if (sub === "run") {
-            await cmdAgentRun();
+            await cmdAgentRun(rest);
             return;
         }
         printError("Unknown agent command. Try: marshell agent join|run");
@@ -236,6 +386,14 @@ async function main() {
         await cmdSend(args.slice(1));
         return;
     }
+    if (args[0] === "inbox") {
+        await cmdInbox(args.slice(1));
+        return;
+    }
+    if (args[0] === "listen") {
+        await cmdListen(args.slice(1));
+        return;
+    }
     printError(`Unknown command '${args[0]}'. Run marshell --help`);
 }
 main().catch((error) => {

package/dist/network.js

@@ -4,6 +4,9 @@ exports.pingNetwork = pingNetwork;
 exports.joinAgent = joinAgent;
 exports.discoverPeers = discoverPeers;
 exports.sendMessage = sendMessage;
+exports.fetchInbox = fetchInbox;
+exports.ackMessages = ackMessages;
+exports.waitForInbox = waitForInbox;
 exports.toWsUrl = toWsUrl;
 const config_1 = require("./config");
 function normalizeBaseUrl(raw) {
@@ -12,6 +15,22 @@ function normalizeBaseUrl(raw) {
 function withPath(baseUrl, path) {
     return `${normalizeBaseUrl(baseUrl)}${path}`;
 }
+async function authHeaders(kind) {
+    const config = await (0, config_1.readConfig)();
+    const headers = {
+        "content-type": "application/json",
+    };
+    if (kind === "agent") {
+        if (!config.agentKey) {
+            throw new Error("Missing agent key. Run: marshell agent join --name <name>");
+        }
+        headers.authorization = `Bearer ${config.agentKey}`;
+    }
+    else if (config.token) {
+        headers.authorization = `Bearer ${config.token}`;
+    }
+    return headers;
+}
 async function pingNetwork(baseUrl) {
     const candidates = ["/health", "/v1/health"];
     for (const path of candidates) {
@@ -42,12 +61,10 @@ async function pingNetwork(baseUrl) {
         message: "Health endpoint not found.",
     };
 }
-async function postJson(url, body) {
+async function postJson(url, body, headers) {
     const response = await fetch(url, {
         method: "POST",
-        headers: {
-            "content-type": "application/json",
-        },
+        headers,
         body: JSON.stringify(body),
     });
     const text = await response.text();
@@ -78,17 +95,23 @@ async function joinAgent(baseUrl, name) {
         const result = await postJson(withPath(baseUrl, "/v1/agents/join"), {
             token: config.token,
             name,
-        });
+        }, { "content-type": "application/json" });
         if (result.status === 404) {
             return { kind: "not_found" };
         }
         if (result.status >= 200 && result.status < 300 && result.data.agent_key) {
             return { kind: "joined", agentKey: result.data.agent_key };
         }
+        const errText = typeof result.data === "object" &&
+            result.data &&
+            "error" in result.data &&
+            typeof result.data.error === "string"
+            ? result.data.error
+            : `Join failed with HTTP ${result.status}.`;
         return {
             kind: "error",
             status: result.status,
-            message: `Join failed with HTTP ${result.status}.`,
+            message: errText,
         };
     }
     catch (error) {
@@ -100,65 +123,116 @@ async function joinAgent(baseUrl, name) {
     }
 }
 async function discoverPeers(baseUrl) {
-    const candidates = ["/v1/peers", "/v1/discover"];
-    for (const path of candidates) {
-        try {
-            const response = await fetch(withPath(baseUrl, path), {
-                method: "GET",
-            });
-            if (response.status === 404) {
-                continue;
-            }
-            if (response.ok) {
-                const data = (await response.json());
-                if (Array.isArray(data)) {
-                    return { peers: data };
-                }
-                return { peers: data.peers ?? [] };
+    const headers = await authHeaders("token");
+    try {
+        const response = await fetch(withPath(baseUrl, "/v1/peers"), {
+            method: "GET",
+            headers,
+        });
+        if (response.ok) {
+            const data = (await response.json());
+            if (Array.isArray(data)) {
+                return { peers: data };
             }
-        }
-        catch {
-            return { peers: [] };
+            return { peers: data.peers ?? [] };
         }
     }
+    catch {
+        return { peers: [] };
+    }
     return { peers: [] };
 }
 async function sendMessage(baseUrl, to, text) {
-    const config = await (0, config_1.readConfig)();
-    if (!config.token) {
-        return { kind: "error", message: "Missing auth token." };
-    }
     try {
-        const result = await postJson(withPath(baseUrl, "/v1/messages/send"), {
-            token: config.token,
-            to,
-            text,
-        });
-        if (result.status === 404) {
-            return {
-                kind: "stubbed",
-                reason: "Network send API is not available yet (Phase 1).",
-            };
-        }
-        if (result.status >= 200 && result.status < 300) {
+        const headers = await authHeaders("agent");
+        const result = await postJson(withPath(baseUrl, "/v1/messages/send"), { to, text }, headers);
+        if (result.status >= 200 && result.status < 300 && result.data.id) {
             return {
                 kind: "sent",
-                id: result.data.id ?? `local-${Date.now()}`,
+                id: result.data.id,
+                status: result.data.status ?? "delivered",
             };
         }
         return {
             kind: "error",
             status: result.status,
-            message: `Send failed with HTTP ${result.status}.`,
+            message: result.data.error ?? `Send failed with HTTP ${result.status}.`,
         };
     }
     catch (error) {
         return {
-            kind: "stubbed",
-            reason: `Network unavailable, stored as local stub: ${error.message}`,
+            kind: "error",
+            message: error.message,
         };
     }
 }
+async function fetchInbox(baseUrl, options) {
+    try {
+        const headers = await authHeaders("agent");
+        const qs = options?.peek ? "?peek=1" : "";
+        const response = await fetch(withPath(baseUrl, `/v1/messages/inbox${qs}`), {
+            method: "GET",
+            headers,
+        });
+        const data = (await response.json());
+        if (!response.ok) {
+            return {
+                kind: "error",
+                status: response.status,
+                message: data.error ?? `Inbox failed with HTTP ${response.status}.`,
+            };
+        }
+        return {
+            kind: "ok",
+            messages: data.messages ?? [],
+            agent: data.agent ?? "",
+        };
+    }
+    catch (error) {
+        return {
+            kind: "error",
+            message: error.message,
+        };
+    }
+}
+async function ackMessages(baseUrl, ids) {
+    if (ids.length === 0) {
+        return { kind: "ok", acked: 0 };
+    }
+    try {
+        const headers = await authHeaders("agent");
+        const result = await postJson(withPath(baseUrl, "/v1/messages/ack"), { ids }, headers);
+        if (result.status >= 200 && result.status < 300) {
+            return { kind: "ok", acked: result.data.acked ?? ids.length };
+        }
+        return {
+            kind: "error",
+            message: result.data.error ?? `Ack failed with HTTP ${result.status}.`,
+        };
+    }
+    catch (error) {
+        return { kind: "error", message: error.message };
+    }
+}
+async function waitForInbox(baseUrl, options) {
+    const deadline = Date.now() + options.waitSeconds * 1000;
+    const from = options.from?.toLowerCase();
+    while (Date.now() < deadline) {
+        const result = await fetchInbox(baseUrl, { peek: true });
+        if (result.kind === "error") {
+            return result;
+        }
+        const messages = from
+            ? result.messages.filter((m) => m.from.toLowerCase() === from)
+            : result.messages;
+        if (messages.length > 0) {
+            await ackMessages(baseUrl, messages.map((m) => m.id));
+            return { kind: "ok", messages, agent: result.agent };
+        }
+        await new Promise((resolve) => setTimeout(resolve, 1500));
+    }
+    return { kind: "timeout" };
+}
 function toWsUrl(httpBase) {
     const url = new URL(httpBase);
     if (url.protocol === "https:") {

package/package.json

@@ -1,19 +1,21 @@
 {
   "name": "@marshell/cli",
-  "version": "0.2.0",
+  "version": "0.5.0",
   "description": "Marshell CLI — join a subnet, discover agents, send messages",
   "license": "MIT",
   "type": "commonjs",
   "bin": {
-    "marshell": "dist/cli.js"
+    "marshell": "bin/marshell.js"
   },
   "files": [
+    "bin",
     "dist",
     "README.md"
   ],
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "clean": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\"",
+    "prepare": "npm run build",
     "prepublishOnly": "npm run build"
   },
   "engines": {
@@ -21,9 +23,15 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/mfinikov/marshell"
+    "url": "git+https://github.com/marshell-labs/cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/marshell-labs/cli/issues"
+  },
+  "homepage": "https://github.com/marshell-labs/cli#readme",
+  "publishConfig": {
+    "access": "public"
   },
-  "homepage": "https://marshell.dev",
   "keywords": [
     "marshell",
     "agents",