@zetaloop/chappie 0.5.0 → 1.1.0

package/.codex-plugin/plugin.json

@@ -0,0 +1,13 @@
+{
+	"name": "chappie",
+	"description": "Connect ChatGPT and local agents across devices",
+	"mcpServers": {
+		"chappie": {
+			"command": "node",
+			"args": ["dist/cli.js", "codex"],
+			"env_vars": ["CODEX_HOME"],
+			"cwd": "."
+		}
+	},
+	"version": "1.1.0"
+}

package/README.md

@@ -1,56 +1,53 @@
 # Chappie
 
-Use ChatGPT to work through [Pi](https://github.com/earendil-works/pi): edit local files, run commands, call Pi extensions, exchange files and images, and move between sessions on one or more devices.
+Use ChatGPT to work through Pi, Oh My Pi, OpenCode, or Codex: edit projects, run commands, and exchange files and images. Agent sessions can also work with each other, on the same computer or across devices.
 
 ## Setup
 
-Install the Pi package:
+Install Chappie in each participating agent:
+
+| Agent                                             | Install                                          |
+| ------------------------------------------------- | ------------------------------------------------ |
+| [Pi](https://github.com/earendil-works/pi)        | `pi install npm:@zetaloop/chappie`               |
+| [Oh My Pi](https://github.com/can1357/oh-my-pi)   | `omp plugin install @zetaloop/chappie`           |
+| [OpenCode](https://github.com/anomalyco/opencode) | `opencode plugin add @zetaloop/chappie`          |
+| [Codex](https://github.com/openai/codex)          | [Plugin and provider setup](docs/setup.md#codex) |
+
+The broker connects these sessions to ChatGPT and to each other. Install it on one device:
 
 ```sh
-pi install npm:@zetaloop/chappie
+pnpm add -g @zetaloop/chappie@1
 ```
 
-Run Chappie as the MCP server managed by [otunnel](https://github.com/zetaloop/otunnel):
+## With ChatGPT
+
+Run the broker through [otunnel](https://github.com/zetaloop/otunnel) with this MCP configuration:
 
 ```yaml
 mcp:
   commands:
     - channel: main
-      command: pi --chappie
-```
-
-Add the tunnel as a developer-mode app in ChatGPT, then start Pi in a project:
-
-```sh
-pi --provider chappie --model chatgpt
+      command: chappie
 ```
 
-Call `init` from ChatGPT to connect the conversation to Pi. A conversation can resume an existing task with its Pi session ID, while `sessions` can find connected sessions by device, directory, or name.
-
-## Usage
-
-Chappie exposes common coding tools directly and every active Pi tool through `tools` and `call`. `chat` sends an assistant message to Pi, Pi input accompanies later tool results, and `transfer` moves files between ChatGPT and Pi or between connected devices. `history` reads recent Pi messages and activity with timestamps. `ask` can present a persistent question in ChatGPT when webpage questions are enabled.
+Add the tunnel as a developer-mode app in ChatGPT. Open a project in the agent with its Chappie model selected, then tell ChatGPT which project or session to use and what to do:
 
-See the [tool guide](docs/tools.md) for session selection, history, Pi tools, webpage questions, and file transfer.
+> Use \@Chappie to review the recent changes in the website project.
 
-## Configuration
+Tool activity and assistant messages appear in the agent's interface. Messages entered there reach ChatGPT with later tool results. Attach files in ChatGPT for the agent to use, or ask for generated files to be sent back.
 
-`chappie.json` in Pi's agent directory configures Chappie.
+To continue from another chat or branch, ask ChatGPT to reconnect to the same agent session.
 
-A broker can accept Pi sessions from other devices on the local network:
+## Between agents
 
-```json
-{ "listen": true }
-```
+An agent using its usual model can work through another agent session. For example, an assistant on macOS can run a build in a Windows session and retrieve the output files.
 
-Remote Pi sessions connect through the broker device's mDNS name:
+Start `chappie` in a terminal, or use the broker already running through otunnel. On the controlling agent's device, enable local tools in `~/.chappie/config.json`:
 
 ```json
-{ "connect": "<broker>.local" }
+{ "localTools": true }
 ```
 
-The default port is `24274`. Set `listen` to a port number or append `:port` to `connect` to use another one. Only the broker device runs otunnel; local and remote sessions appear in the same session list.
-
-Set `ask` to `false` to disable webpage questions.
+Use the usual model in the controlling session and the Chappie model in the target session. Ask the controlling assistant to find that session and work on its project.
 
-Closely spaced initializations from the same ChatGPT conversation receive guidance to observe the ongoing work through `history` and explain its results. See [participation](docs/tools.md#participation).
+See [setup and configuration](docs/setup.md) for device connections and agent-specific settings, and the [tool guide](docs/tools.md) for the available operations and their parameters.

package/dist/chunk-3MLW5U2C.js

@@ -0,0 +1,148 @@
+import { createRequire } from "node:module"; const require = createRequire(import.meta.url);
+import {
+  array,
+  callsInput,
+  chatInput,
+  deliveryContent,
+  historyInput,
+  inputContent,
+  object,
+  resourceDescriptors,
+  string,
+  toolResult,
+  transferDescription,
+  transferInput
+} from "./chunk-ASDHNBR2.js";
+
+// src/local.ts
+var definitions = [
+  tool(
+    "sessions",
+    "List connected Chappie sessions and identify this local session.",
+    object({
+      sessionId: string().optional()
+    }),
+    async (session, { sessionId }, signal) => textResult(await session.sessions(sessionId, signal))
+  ),
+  tool(
+    "remote_tools",
+    "Read native tool definitions from a Chappie session. Follow the instructions at globalAgents.path when provided.",
+    object({
+      sessionId: string().min(1),
+      names: array(string()).min(1).optional()
+    }),
+    async (session, { sessionId, names }, signal) => {
+      const { inputs, ...result } = await session.tools(
+        sessionId,
+        names,
+        signal
+      );
+      return textResult(result, inputs);
+    }
+  ),
+  tool(
+    "remote_call",
+    "Execute one native tool batch in a Chappie session using definitions from remote_tools.",
+    object({
+      sessionId: string().min(1),
+      calls: callsInput
+    }),
+    async (session, { sessionId, calls }, signal) => remoteResult(session, await session.call(sessionId, calls, signal))
+  ),
+  tool(
+    "remote_chat",
+    "Send an assistant message to a Chappie session, or reply to its model request using replyTo.",
+    chatInput.extend({ sessionId: string().min(1) }),
+    async (session, { sessionId, text, replyTo }, signal) => remoteResult(
+      session,
+      await session.chat(sessionId, text, replyTo, signal)
+    )
+  ),
+  tool(
+    "history",
+    "Read this session's history, or a Chappie session identified by sessionId. Use before/after to page and wait to follow remote progress.",
+    historyInput.extend({
+      sessionId: string().optional()
+    }),
+    async (session, { sessionId, ...range }, signal) => {
+      const { content, ...page } = await session.history(
+        range,
+        sessionId,
+        signal
+      );
+      return {
+        content: [...textResult(page).content, ...nativeContent(content)]
+      };
+    }
+  ),
+  tool(
+    "transfer",
+    transferDescription,
+    transferInput,
+    (session, args, signal, update) => session.transfer(
+      args,
+      signal,
+      (details) => update?.({ content: [], details })
+    )
+  )
+];
+function localTools(session) {
+  return definitions.filter((tool2) => session.localTools || tool2.name === "transfer").map((tool2) => ({
+    ...tool2,
+    async execute(args, signal, update) {
+      const result = await tool2.execute(session, args, signal, update);
+      return {
+        ...result,
+        content: [...result.content, ...localDeliveries(session)]
+      };
+    }
+  }));
+}
+function localDeliveries(session) {
+  return nativeContent(deliveryContent(session.deliveries()));
+}
+function tool(name, description, parameters, execute) {
+  return {
+    name,
+    description,
+    parameters,
+    execute: (session, args, signal, update) => execute(session, parameters.parse(args), signal, update)
+  };
+}
+function textResult(value, inputs = []) {
+  return {
+    content: [
+      { type: "text", text: JSON.stringify(value) },
+      ...inputContent(inputs, "remote_chat")
+    ]
+  };
+}
+function remoteResult(session, result) {
+  const output = toolResult(result, "remote_chat");
+  const content = nativeContent(output.content);
+  if (output.isError)
+    throw new Error(
+      [...content, ...localDeliveries(session)].flatMap((block) => block.type === "text" ? [block.text] : []).join("\n")
+    );
+  return {
+    content,
+    ..."toolResults" in result ? {
+      details: {
+        resources: result.toolResults.flatMap(
+          (result2) => resourceDescriptors(result2.details)
+        )
+      }
+    } : {}
+  };
+}
+function nativeContent(content) {
+  return content.map(
+    (block) => block.type === "resource_link" ? { type: "text", text: JSON.stringify({ resource: block }) } : block
+  );
+}
+
+export {
+  definitions,
+  localTools,
+  localDeliveries
+};