codetrellis 0.0.0-stage → 0.3.0

package/src/backend/mcp/tools/mobile-tools.js

@@ -0,0 +1,118 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mobile_tools_exports = {};
+__export(mobile_tools_exports, {
+  register: () => register
+});
+module.exports = __toCommonJS(mobile_tools_exports);
+var import_zod = require("zod");
+var import_helpers = require("../helpers");
+var import_mobile_rpc_service = require("../../services/mobile-rpc-service");
+const VIEW_ROUTES = {
+  home: "/(tabs)",
+  plans: "/(tabs)/plans",
+  graph: "/(tabs)/graph",
+  terminals: "/(tabs)/terminals",
+  activity: "/(tabs)/activity"
+};
+function register(server, deps) {
+  server.registerTool(
+    "mobile_navigate",
+    {
+      description: "Drive a connected phone (CodeTrellis mobile companion) to a view. Use to walk a teammate through something on their device. Provide a `view` (home/plans/graph/terminals/activity), or a `plan_uid` to open a plan, or an `item_uid` (+ plan_uid) to open a plan item. `route` overrides everything with a raw Expo Router path. Requires a paired phone to be connected.",
+      inputSchema: {
+        view: import_zod.z.enum(["home", "plans", "graph", "terminals", "activity"]).optional().describe("A top-level mobile view to switch to."),
+        plan_uid: import_zod.z.string().optional().describe("Open this plan on the phone."),
+        item_uid: import_zod.z.string().optional().describe("Open this plan item on the phone (pair with plan_uid)."),
+        route: import_zod.z.string().optional().describe('Raw Expo Router path, e.g. "/graph" or "/plan-detail?uid=\u2026".')
+      }
+    },
+    async ({ view, plan_uid, item_uid, route }) => {
+      if (!(0, import_mobile_rpc_service.mobileConnected)()) {
+        return { content: [{ type: "text", text: "No mobile device is connected. Pair + connect a phone first." }], isError: true };
+      }
+      if (!route && item_uid) {
+        const item = deps.planItemService.getItem(item_uid);
+        if (!item) return { content: [{ type: "text", text: `Item not found: ${item_uid}` }], isError: true };
+        if (!plan_uid) plan_uid = item.planUid;
+      }
+      if (!route && plan_uid && !deps.planService.getPlan(plan_uid)) {
+        return { content: [{ type: "text", text: `Plan not found: ${plan_uid}` }], isError: true };
+      }
+      let target = route;
+      if (!target && item_uid) {
+        target = `/item-detail?uid=${encodeURIComponent(item_uid)}${plan_uid ? `&planUid=${encodeURIComponent(plan_uid)}` : ""}`;
+      }
+      if (!target && plan_uid) target = `/plan-detail?uid=${encodeURIComponent(plan_uid)}`;
+      if (!target && view) target = VIEW_ROUTES[view];
+      if (!target) {
+        return { content: [{ type: "text", text: "Provide a view, plan_uid, item_uid, or route." }], isError: true };
+      }
+      const reached = (0, import_mobile_rpc_service.navigateMobile)(target);
+      return { content: [{ type: "text", text: `Navigated ${reached} phone(s) to ${target}` }] };
+    }
+  );
+  server.registerTool(
+    "mobile_screenshot",
+    {
+      description: "Capture a screenshot of a connected phone (CodeTrellis mobile companion) and return it as a PNG. Use to see what the user sees on their device \u2014 e.g. after mobile_navigate, to confirm a walkthrough step. Requires a connected phone.",
+      inputSchema: {}
+    },
+    async () => {
+      if (!(0, import_mobile_rpc_service.mobileConnected)()) {
+        return { content: [{ type: "text", text: "No mobile device is connected." }], isError: true };
+      }
+      try {
+        const img = await (0, import_mobile_rpc_service.requestMobileScreenshot)();
+        if (!img.data) {
+          return { content: [{ type: "text", text: "The phone returned an empty image (screenshot support may not be built into this dev client yet)." }], isError: true };
+        }
+        return { content: [{ type: "image", data: img.data, mimeType: img.mime || "image/png" }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: err instanceof Error ? err.message : String(err) }], isError: true };
+      }
+    }
+  );
+  server.registerTool(
+    "mobile_present",
+    {
+      description: "Show a narration card on a connected phone (and the desktop). Use to guide a teammate through a mobile walkthrough. Supports basic markdown.",
+      inputSchema: {
+        text: import_zod.z.string().describe("Card body \u2014 supports **bold**, `code`, links."),
+        tone: import_zod.z.enum(["neutral", "success", "warning", "question"]).optional().default("neutral")
+      }
+    },
+    async ({ text, tone }, extra) => {
+      const { author } = (0, import_helpers.authorFromExtra)(deps, extra);
+      const card = deps.presenceService.postCard({
+        text,
+        speak: false,
+        requireAck: false,
+        tone,
+        linkTo: null,
+        agentId: author
+      });
+      const n = deps.broadcast("presence-card", { card });
+      return (0, import_helpers.resultWithMeta)({ card_id: card.id, mobile: (0, import_mobile_rpc_service.mobileConnected)() }, n);
+    }
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  register
+});

package/src/backend/mcp/tools/peer-tools.js

@@ -0,0 +1,330 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var peer_tools_exports = {};
+__export(peer_tools_exports, {
+  registerPeerTools: () => registerPeerTools
+});
+module.exports = __toCommonJS(peer_tools_exports);
+var _lazy_______services_peer_connection_service = __toESM(require("../../services/peer-connection-service"));
+var import_zod = require("zod");
+var import_helpers = require("../helpers");
+function registerPeerTools(server, deps) {
+  server.tool(
+    "get_peer_status",
+    "Get the status of the peer connection manager: discovery state, paired device count, connected peer count, whether pairing is active.",
+    {},
+    async () => {
+      try {
+        const peerService = _lazy_______services_peer_connection_service;
+        const status = peerService.getPeerManagerStatus();
+        return {
+          content: [{ type: "text", text: JSON.stringify(status) }]
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: String(err) }) }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "list_discovered_peers",
+    "List CodeTrellis instances discovered on the local network via mDNS. These are nearby devices that could be paired.",
+    {},
+    async () => {
+      try {
+        const peerService = _lazy_______services_peer_connection_service;
+        const peers = peerService.getDiscoveredDevices();
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              count: peers.length,
+              peers
+            })
+          }]
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: String(err) }) }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "list_paired_devices",
+    "List all devices that have completed the QR-code pairing handshake. Paired devices can auto-reconnect.",
+    {},
+    async () => {
+      try {
+        const peerService = _lazy_______services_peer_connection_service;
+        const devices = peerService.getDevices();
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              count: devices.length,
+              devices: devices.map((d) => ({
+                fingerprint: d.fingerprint,
+                alias: d.alias,
+                deviceType: d.deviceType,
+                pairedAt: d.pairedAt,
+                lastConnected: d.lastConnected
+              }))
+            })
+          }]
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: String(err) }) }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "list_peer_connections",
+    "List active WebRTC connections to paired devices. Shows connection state, latency, and open data channels.",
+    {},
+    async () => {
+      try {
+        const peerService = _lazy_______services_peer_connection_service;
+        const connections = peerService.getConnections();
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              count: connections.length,
+              connections
+            })
+          }]
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: String(err) }) }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "unpair_device",
+    "Remove a paired device. Disconnects the WebRTC connection and deletes the stored pairing. The device will need to re-pair via QR code to connect again.",
+    {
+      fingerprint: import_zod.z.string().describe("DTLS fingerprint of the device to unpair")
+    },
+    async ({ fingerprint }) => {
+      try {
+        const peerService = _lazy_______services_peer_connection_service;
+        const removed = await peerService.unpairDevice(fingerprint);
+        return {
+          ...removed ? {} : { isError: true },
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              removed,
+              message: removed ? `Device ${fingerprint.slice(0, 12)}\u2026 unpaired` : `No device found with fingerprint ${fingerprint.slice(0, 12)}\u2026`
+            })
+          }]
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: String(err) }) }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "get_remote_state",
+    "Get the workspace state snapshot from a connected peer. Shows their plans, agent sessions, channel events, and audio status. If no fingerprint is given, returns state from all connected peers.",
+    {
+      fingerprint: import_zod.z.string().optional().describe("DTLS fingerprint of a specific peer. Omit for all peers.")
+    },
+    async ({ fingerprint }) => {
+      try {
+        const peerService = _lazy_______services_peer_connection_service;
+        if (fingerprint) {
+          const state = peerService.getRemoteState(fingerprint);
+          if (!state) {
+            return { content: [{ type: "text", text: JSON.stringify({ error: "No state from this peer \u2014 not connected or no snapshot received yet." }) }], isError: true };
+          }
+          return { content: [{ type: "text", text: JSON.stringify(state) }] };
+        }
+        const allStates = peerService.getAllRemoteStates();
+        const result = {};
+        for (const [fp, state] of allStates) {
+          result[fp] = state;
+        }
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({ peerCount: allStates.size, states: result })
+          }]
+        };
+      } catch (err) {
+        return { content: [{ type: "text", text: JSON.stringify({ error: String(err) }) }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "list_remote_terminals",
+    "List terminals running on connected peers. Remote terminals can be viewed and controlled from this machine. Each terminal shows the peer it belongs to, the agent preset, title, and whether it is alive.",
+    {
+      fingerprint: import_zod.z.string().optional().describe("Filter to a specific peer. Omit for all peers.")
+    },
+    async ({ fingerprint }) => {
+      try {
+        const peerService = _lazy_______services_peer_connection_service;
+        const terminals = fingerprint ? peerService.getRemoteTerminalsForPeer(fingerprint) : peerService.getRemoteTerminals();
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              count: terminals.length,
+              terminals: terminals.map((t) => ({
+                id: t.id,
+                preset: t.preset,
+                title: t.title,
+                cwd: t.cwd,
+                alive: t.alive,
+                peerFingerprint: t.peerFingerprint
+              }))
+            })
+          }]
+        };
+      } catch (err) {
+        return { content: [{ type: "text", text: JSON.stringify({ error: String(err) }) }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "write_remote_terminal",
+    "Send input to a terminal running on a connected peer. Use this to type commands into remote terminals. Append \\n to execute the command.",
+    {
+      fingerprint: import_zod.z.string().describe("DTLS fingerprint of the peer that owns the terminal."),
+      terminal_id: import_zod.z.string().describe("ID of the remote terminal."),
+      data: import_zod.z.string().describe("The text to send to the terminal. Include \\n to press Enter.")
+    },
+    async ({ fingerprint, terminal_id, data }) => {
+      try {
+        const peerService = _lazy_______services_peer_connection_service;
+        const sent = peerService.writeRemoteTerminal(fingerprint, terminal_id, data);
+        return {
+          ...sent ? {} : { isError: true },
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              sent,
+              message: sent ? `Sent ${data.length} chars to remote terminal ${terminal_id}` : "Failed \u2014 terminal not found or peer not connected"
+            })
+          }]
+        };
+      } catch (err) {
+        return { content: [{ type: "text", text: JSON.stringify({ error: String(err) }) }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "get_remote_audio",
+    "Get audio capture status from connected peers. Shows which peers are capturing audio and how much is buffered. When a peer is capturing with shareAudio enabled, their audio is automatically fed into this instance's audio buffer.",
+    {},
+    async () => {
+      try {
+        const peerService = _lazy_______services_peer_connection_service;
+        const statuses = peerService.getRemoteAudioStatuses();
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              count: statuses.length,
+              peers: statuses
+            })
+          }]
+        };
+      } catch (err) {
+        return { content: [{ type: "text", text: JSON.stringify({ error: String(err) }) }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "list_remote_input_requests",
+    "List pending user-input requests from agents running on connected peers. These are prompts that remote agents have sent via await_user_input \u2014 you can respond from this machine to unblock them.",
+    {},
+    async () => {
+      try {
+        const peerService = _lazy_______services_peer_connection_service;
+        const requests = peerService.getPendingInputRequests();
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              count: requests.length,
+              requests
+            })
+          }]
+        };
+      } catch (err) {
+        return { content: [{ type: "text", text: JSON.stringify({ error: String(err) }) }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "respond_remote_input",
+    "Respond to a pending user-input request from a remote agent. The response is sent to the peer where the agent is running, unblocking the agent. First response wins \u2014 if the local user already answered, this is a no-op. The question was put to a person: your answer reaches the asker marked as yours (your agent type), not as theirs.",
+    {
+      request_id: import_zod.z.string().describe("ID of the input request to respond to."),
+      response: import_zod.z.string().describe("The response text to send back to the remote agent.")
+    },
+    async ({ request_id, response }, extra) => {
+      try {
+        const peerService = _lazy_______services_peer_connection_service;
+        const { author, authorType } = (0, import_helpers.authorFromExtra)(deps, extra);
+        const sent = peerService.respondToInputRequest(request_id, response, { actor: author, actorType: authorType, channel: "mcp" });
+        return {
+          ...sent ? {} : { isError: true },
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              sent,
+              message: sent ? "Response sent to remote agent" : "Request not found or already answered"
+            })
+          }]
+        };
+      } catch (err) {
+        return { content: [{ type: "text", text: JSON.stringify({ error: String(err) }) }], isError: true };
+      }
+    }
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  registerPeerTools
+});