opencode-collaboration 0.6.1 → 0.8.0

package/README.md

@@ -98,6 +98,10 @@ Use send_message to tell "backend" that the login form now posts to /v2/login.
 
 The receiving session gets the text immediately as a synthetic user message, including the sender's exact endpoint ID and how to reply. The receiver is told to reply via `send_message` only when a response is actually expected, and is explicitly told not to send acknowledgement-only messages — so two agents do not loop politely forever. `send_message` returns a tracking ID; use `peer_message_status` or `/peers-outbox` to distinguish transport receipt from final delivery.
 
+By default only peers in the same working directory are visible and targetable (`peerScope: "directory"`); cross-directory peers stay hidden from `list_agents`/`/peers` and `send_message`. Set `peerScope: "all"` to collaborate across directories. Inbound messages are never restricted by scope.
+
+An injected peer turn runs under the agent/mode of the session's **last human input** (message or command) — e.g. if the receiver last typed in `plan`, peer turns arrive in plan mode and cannot edit. opencode only persists a mode once a message is sent in it, so a bare UI mode toggle is not yet visible to the plugin. To have peers reach you in a specific mode, send any message in that mode first.
+
 **Review held messages** (when `inboundPolicy` is `"hold"`):
 
 ```
@@ -123,6 +127,7 @@ Options can be passed via the tuple form in `opencode.json`:
 |---|---|---|
 | `inboundPolicy` | `"accept"` | `accept` delivers immediately; `auto` accepts only when sender and receiver directories match and otherwise holds; `hold` parks messages for review; `refuse` rejects them |
 | `peerPermissions` | `"allow"` | Peer-origin permission requests: `allow` auto-approves ordinary requests, `ask` leaves native prompts untouched, `deny` rejects. Even in `allow`, OpenCode/plugin permission configuration, `AGENTS.md`, credentials/secrets and permission escalation are never auto-approved; existing OpenCode deny rules always win |
+| `peerScope` | `"directory"` | `directory` (default) restricts `list_agents`/`/peers`/`send_message` to peers whose working directory is exactly this session's directory; `"all"` restores cross-directory visibility. Inbound delivery is never restricted |
 | `name` | `<dir>-<hex4>` | display name other peers use to address you; the default appends a short hex suffix (from the instance ID) to the directory basename so same-directory instances are distinguishable, matching Claude Code's `my-app-3f` pattern |
 | `showNameInTitle` | `true` | Append this process's peer name to its root session titles (e.g. `Fix login bug(张三)`); the suffix is removed on graceful exit |
 | `storageDir` | `$XDG_DATA_HOME/opencode-collaboration` | where the registry and held inbox live |
@@ -214,12 +219,15 @@ The credential-free real-host test starts actual OpenCode processes and drives t
 
 ```bash
 npm install
-npm run build       # tsc → dist/
-npm test            # build + node --test tests/*.test.mjs
+npm run build              # tsc → dist/ (plain, for fast local iteration)
+npm run build:obfuscated   # clean + tsc + obfuscation → dist/ (the shippable artifact)
+npm test                   # build:obfuscated + node --test tests/*.test.mjs
 npm run typecheck
-npm run dry-run     # npm publish --dry-run
+npm run dry-run            # npm publish --dry-run
 ```
 
+`npm test` runs against the shippable `dist/`; `tests/obfuscation.test.mjs` only passes there. Sourcemaps for the shipped build are written to `.obfuscate-maps/` and are never published.
+
 Zero runtime dependencies beyond `@opencode-ai/plugin` (peer) and `zod` (tool schemas).
 
 ## License

package/README.zh-CN.md

@@ -98,6 +98,10 @@ Use send_message to tell "backend" that the login form now posts to /v2/login.
 
 接收方会话会立即收到这条文本，以一条合成的用户消息形式出现，其中包含发送方精确的端点 ID 以及回复方式。接收方被要求**只在确实需要回应时**才通过 `send_message` 回复，并明确禁止仅确认/致谢类消息——避免两个 agent 无限礼貌往返。`send_message` 返回一个追踪 ID；用 `peer_message_status` 或 `/peers-outbox` 来区分"传输层已收到"和"最终已投递"。
 
+默认情况下，只有与本会话工作目录完全相同的对端才可见、可寻址（`peerScope: "directory"`）；跨目录的对端在 `list_agents`/`/peers` 和 `send_message` 中不可见。设置 `peerScope: "all"` 即可跨目录协作。入站消息永远不受 scope 限制。
+
+注入的 peer 回合会以该会话**最后一条人类输入（消息/命令）的 agent/mode** 运行——例如接收方最后在 `plan` 模式下发过消息，那么 peer 回合就以 plan 模式到达、无法编辑。opencode 只有在某个 mode 下发过消息才会持久化它，因此"仅切换 UI mode"插件还无法感知。若希望 peer 以指定 mode 找到你，请先在该 mode 下发送一条消息。
+
 **审阅待审消息**（当 `inboundPolicy` 为 `"hold"` 时）：
 
 ```
@@ -123,6 +127,7 @@ Use send_message to tell "backend" that the login form now posts to /v2/login.
 |---|---|---|
 | `inboundPolicy` | `"accept"` | `accept` 立即投递；`auto` 仅当发送方与接收方目录相同时接受，否则进入待审；`hold` 暂存消息供人工审阅；`refuse` 直接拒绝 |
 | `peerPermissions` | `"allow"` | 对端来源的权限请求：`allow` 自动批准普通请求，`ask` 保持原生提示不变，`deny` 拒绝。即使在 `allow` 模式下，OpenCode/插件权限配置、`AGENTS.md`、凭据/密钥以及权限升级也永远不会被自动批准；已存在的 OpenCode 拒绝规则始终优先 |
+| `peerScope` | `"directory"` | `directory`（默认）将 `list_agents`/`/peers`/`send_message` 限定为与本会话工作目录完全相同的对端；`"all"` 恢复跨目录可见性。入站消息不受 scope 限制 |
 | `name` | `<dir>-<hex4>` | 其他对端用来寻址你的显示名；默认值在目录名后追加一个短十六进制后缀（取自实例 ID），使同目录的多个实例可以区分，与 Claude Code 的 `my-app-3f` 命名方式一致 |
 | `showNameInTitle` | `true` | 把本进程的 peer 名字追加到根会话标题后面（如 `Fix login bug(张三)`）；优雅退出时会自动移除该后缀 |
 | `storageDir` | `$XDG_DATA_HOME/opencode-collaboration` | 注册表与待审收件箱的存储目录 |
@@ -214,12 +219,15 @@ cd /tmp/proj-b && opencode serve --port 14101 &
 
 ```bash
 npm install
-npm run build       # tsc → dist/
-npm test            # build + node --test tests/*.test.mjs
+npm run build              # tsc → dist/（明文，本地快速迭代用）
+npm run build:obfuscated   # clean + tsc + 混淆 → dist/（发布产物）
+npm test                   # build:obfuscated + node --test tests/*.test.mjs
 npm run typecheck
-npm run dry-run     # npm publish --dry-run
+npm run dry-run            # npm publish --dry-run
 ```
 
+`npm test` 跑的是发布产物 dist；`tests/obfuscation.test.mjs` 只在发布产物上通过。发布产物的 sourcemap 输出到 `.obfuscate-maps/`，不随包发布。
+
 除 `@opencode-ai/plugin`（peer 依赖）和 `zod`（工具 schema）外，零运行时依赖。
 
 ## 许可证

package/dist/commands.d.ts

@@ -8,6 +8,7 @@ import type { RegistryInstance } from "./registry.js";
 import type { QueueInstance } from "./queue.js";
 import type { DeliveryInstance } from "./delivery.js";
 import type { OutboxInstance } from "./outbox.js";
+import type { PeerScope } from "./types.js";
 export interface CommandContext {
     registry: RegistryInstance;
     queue: QueueInstance;
@@ -20,6 +21,10 @@ export interface CommandContext {
     selfInstanceId: string;
     /** Exact endpoint for the session that invoked this command. */
     selfEndpointId?: string;
+    /** Working directory for peerScope filtering. */
+    directory: string;
+    /** Visibility scope: "directory" (default) or "all". */
+    peerScope: PeerScope;
     outbox?: Pick<OutboxInstance, "list">;
 }
 export interface CommandResult {

package/dist/commands.js

@@ -6,17 +6,24 @@
  */
 import { validateName } from "./config.js";
 import { formatSessionList } from "./format.js";
+import { sameDirectory } from "./scope.js";
 export async function handlePeersCommand(ctx, command, args) {
     // "list-agents" is an alias of "peers", matching Claude Code's /list-agents.
     if (command === "peers" || command === "list-agents") {
         const selfId = ctx.selfEndpointId ?? ctx.selfInstanceId;
         const peers = (await ctx.registry.list()).filter((peer) => (peer.entry.version === 2 ? peer.entry.endpointId : peer.entry.instanceId) !== selfId);
-        const listing = formatSessionList(peers, Date.now());
+        const inScope = (peer) => ctx.peerScope !== "directory" || sameDirectory(peer.entry.directory, ctx.directory);
+        const listing = formatSessionList(peers.filter(inScope), Date.now());
         const held = ctx.queue.held();
         const pending = ctx.queue.size();
-        const suffix = held.length > 0 || pending > 0
-            ? `\n(${pending} queued, ${held.length} held — /peers-inbox to review)`
-            : "";
+        const suffixParts = [];
+        if (held.length > 0 || pending > 0) {
+            suffixParts.push(`(${pending} queued, ${held.length} held — /peers-inbox to review)`);
+        }
+        if (ctx.peerScope === "directory") {
+            suffixParts.push(`peerScope: "directory" — cross-directory peers are hidden; set peerScope "all" to show them.`);
+        }
+        const suffix = suffixParts.length > 0 ? `\n${suffixParts.join("\n")}` : "";
         const selfLine = `You are "${ctx.getName()}" — /peers-name to change.`;
         return { handled: true, message: `📋 ${selfLine}\n${listing}${suffix}` };
     }

package/dist/config.d.ts

@@ -1,4 +1,4 @@
-import type { PeerPermissionMode, PluginConfig } from "./types.js";
+import type { PeerPermissionMode, PeerScope, PluginConfig } from "./types.js";
 export interface ResolvedConfig {
     storageDir: string;
     peersDir: string;
@@ -8,6 +8,7 @@ export interface ResolvedConfig {
     showNameInTitle: boolean;
     inboundPolicy: "accept" | "auto" | "hold" | "refuse";
     peerPermissions: PeerPermissionMode;
+    peerScope: PeerScope;
     heartbeatMs: number;
     staleMs: number;
     maxQueue: number;

package/dist/config.js

@@ -17,6 +17,7 @@ export function resolveConfig(opts, env = process.env) {
         showNameInTitle: opts?.showNameInTitle ?? true,
         inboundPolicy: opts?.inboundPolicy ?? "accept",
         peerPermissions: opts?.peerPermissions ?? "allow",
+        peerScope: opts?.peerScope ?? "directory",
         heartbeatMs: opts?.heartbeatMs ?? 10_000,
         staleMs: opts?.staleMs ?? 30_000,
         maxQueue: opts?.maxQueue ?? 50,

package/dist/index.js

@@ -357,6 +357,8 @@ export const PeersPlugin = async (ctx, pluginOptions) => {
                     },
                     selfInstanceId: instanceId,
                     selfEndpointId: runtime.endpointIdForSession(input.sessionID) ?? instanceId,
+                    directory: ctx.directory,
+                    peerScope: config.peerScope,
                     outbox,
                 }, input.command, input.arguments || "");
                 message = result.message ?? "✅ Done.";
@@ -378,6 +380,8 @@ export const PeersPlugin = async (ctx, pluginOptions) => {
         maxMessageBytes: config.maxMessageBytes,
         selfName: () => currentName,
         selfInstanceId: instanceId,
+        selfDirectory: ctx.directory,
+        peerScope: config.peerScope,
         endpointForSession: (sessionId) => {
             const endpointId = runtime.endpointIdForSession(sessionId);
             const endpoint = runtime.registryEndpoints().find((entry) => entry.sessionId === sessionId);

package/dist/scope.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Normalize a filesystem path for scope comparison: resolve relative paths,
+ * strip a trailing separator (so `D:\a\b\` equals `D:\a\b`), and lowercase on
+ * Windows where the filesystem is case-insensitive. POSIX stays case-sensitive.
+ * Symlinks are not resolved — 8.3 short paths and network shares are out of
+ * scope for the directory-visibility feature.
+ */
+export declare function normalizeDirectory(directory: string, platform?: NodeJS.Platform): string;
+/**
+ * Exact same-directory match for peerScope: "directory". Directory strings in
+ * registry entries are session-scoped and can differ from the process launch
+ * directory in trailing slash or case, so both sides are normalized first.
+ */
+export declare function sameDirectory(a: string, b: string, platform?: NodeJS.Platform): boolean;

package/dist/scope.js

@@ -0,0 +1,23 @@
+import { resolve, sep } from "node:path";
+/**
+ * Normalize a filesystem path for scope comparison: resolve relative paths,
+ * strip a trailing separator (so `D:\a\b\` equals `D:\a\b`), and lowercase on
+ * Windows where the filesystem is case-insensitive. POSIX stays case-sensitive.
+ * Symlinks are not resolved — 8.3 short paths and network shares are out of
+ * scope for the directory-visibility feature.
+ */
+export function normalizeDirectory(directory, platform = process.platform) {
+    let normalized = resolve(directory);
+    if (normalized.length > 1 && normalized.endsWith(sep)) {
+        normalized = normalized.slice(0, -1);
+    }
+    return platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+/**
+ * Exact same-directory match for peerScope: "directory". Directory strings in
+ * registry entries are session-scoped and can differ from the process launch
+ * directory in trailing slash or case, so both sides are normalized first.
+ */
+export function sameDirectory(a, b, platform = process.platform) {
+    return normalizeDirectory(a, platform) === normalizeDirectory(b, platform);
+}

package/dist/session-runtime.js

@@ -387,22 +387,6 @@ export function SessionRuntime(opts) {
                     setStatus(endpoint, event.type === "session.idle" ? "idle" : normalizeStatus(properties.status));
                     return true;
                 }
-                // The user toggled the session's agent/mode (e.g. build<->plan). Peer
-                // injections use the last-known agent, so refreshing here keeps the
-                // next injected turn under the mode the user actually selected — even
-                // when the toggle happens without a follow-up user message.
-                if (event.type === "session.next.agent.switched" ||
-                    event.type === "session.next.agent.switched.1") {
-                    const sessionId = properties.sessionID;
-                    const agent = properties.agent;
-                    if (!sessionId || !agent)
-                        return false;
-                    const endpoint = await findSession(sessionId);
-                    if (!endpoint)
-                        return false;
-                    endpoint.agent = agent;
-                    return true;
-                }
                 return false;
             });
         },

package/dist/tools/peers-tools.d.ts

@@ -8,6 +8,7 @@ import type { ListedPeer, RegistryInstance } from "../registry.js";
 import type { Sender } from "../sender.js";
 import type { RateLimiter } from "../queue.js";
 import type { OutboxInstance } from "../outbox.js";
+import type { PeerScope } from "../types.js";
 export interface ToolsDeps {
     registry: RegistryInstance;
     sender: ReturnType<typeof Sender>;
@@ -15,6 +16,10 @@ export interface ToolsDeps {
     maxMessageBytes: number;
     selfName: () => string;
     selfInstanceId: string;
+    /** Fallback working directory (session-scoped endpointForSession takes precedence). */
+    selfDirectory: string;
+    /** Visibility scope: "directory" (default) or "all". */
+    peerScope: PeerScope;
     endpointForSession?: (sessionId: string) => {
         endpointId: string;
         name: string;

package/dist/tools/peers-tools.js

@@ -6,6 +6,7 @@
 import { tool } from "@opencode-ai/plugin/tool";
 import { z } from "zod";
 import { collapseToProcesses, sortPeers } from "../format.js";
+import { sameDirectory } from "../scope.js";
 function entryId(entry) {
     return entry.version === 2 ? entry.endpointId : entry.instanceId;
 }
@@ -59,7 +60,7 @@ export function buildPeerTools(deps) {
             },
         }),
         list_agents: tool({
-            description: "List other opencode session endpoints on this machine that you can exchange plain-text messages with. Shows each endpoint's name, id, directory, session and inbound policy.",
+            description: "List other opencode session endpoints on this machine that you can exchange plain-text messages with. Shows each endpoint's name, id, directory, session and inbound policy. Only peers in the same working directory are shown (peerScope \"directory\"); set peerScope \"all\" to see cross-directory peers.",
             args: {
                 include_offline: z
                     .boolean()
@@ -76,13 +77,16 @@ export function buildPeerTools(deps) {
                 }
                 const self = deps.endpointForSession?.(context.sessionID);
                 const selfId = self?.endpointId ?? deps.selfInstanceId;
+                const selfDir = self?.directory ?? deps.selfDirectory;
+                const inScope = (peer) => deps.peerScope !== "directory" || sameDirectory(peer.entry.directory, selfDir);
                 const shown = (args.include_offline ? peers : peers.filter((p) => p.alive))
-                    .filter((peer) => entryId(peer.entry) !== selfId);
+                    .filter((peer) => entryId(peer.entry) !== selfId)
+                    .filter(inScope);
                 return formatPeerList(shown, self?.name ?? deps.selfName(), selfId);
             },
         }),
         send_message: tool({
-            description: "Send a plain-text message immediately to an exact opencode session on this machine, including while it is busy. Text only — no files or conversation history. Resolve the target with list_agents first if unsure.",
+            description: "Send a plain-text message immediately to an exact opencode session on this machine, including while it is busy. Text only — no files or conversation history. Resolve the target with list_agents first if unsure. Targets are limited to peers in the same working directory unless peerScope is \"all\".",
             args: {
                 to: z.string().describe("Peer name or instanceId (see list_agents)"),
                 message: z.string().describe("Plain-text message body"),
@@ -99,6 +103,8 @@ export function buildPeerTools(deps) {
                     return `Error: sender session "${context.sessionID}" is not registered.`;
                 }
                 const selfId = self?.endpointId ?? deps.selfInstanceId;
+                const selfDir = self?.directory ?? deps.selfDirectory;
+                const inScope = (peer) => deps.peerScope !== "directory" || sameDirectory(peer.entry.directory, selfDir);
                 const listed = await deps.registry.list();
                 const target = args.to.trim();
                 const knownExact = listed.find((peer) => entryId(peer.entry) === target);
@@ -109,14 +115,17 @@ export function buildPeerTools(deps) {
                     if (!knownExact.alive) {
                         return `Error: endpoint "${target}" appears offline (${knownExact.staleReason}).`;
                     }
+                    if (!inScope(knownExact)) {
+                        return `Error: endpoint "${target}" is running in a different working directory (peerScope is "directory"). Set peerScope "all" to collaborate across directories.`;
+                    }
                 }
                 else if (isEndpointShaped(target)) {
                     return `Error: unknown endpoint ID "${target}".`;
                 }
-                const peers = listed.filter((p) => p.alive && entryId(p.entry) !== selfId);
+                const peers = listed.filter((p) => p.alive && entryId(p.entry) !== selfId && inScope(p));
                 let matches = knownExact ? [knownExact] : peers.filter((p) => p.entry.name === target);
                 if (matches.length === 0) {
-                    const stale = listed.find((p) => !p.alive && p.entry.name === target);
+                    const stale = listed.find((p) => !p.alive && inScope(p) && p.entry.name === target);
                     if (stale) {
                         return `Error: peer "${target}" appears offline (${stale.staleReason}).`;
                     }

package/dist/types.d.ts

@@ -1,5 +1,8 @@
 export type InboundPolicy = "accept" | "auto" | "hold" | "refuse";
 export type PeerPermissionMode = "allow" | "ask" | "deny";
+/** Visibility scope for other peers. "directory" shows/sends only to peers in
+ * the exact same working directory; "all" keeps the previous behavior. */
+export type PeerScope = "directory" | "all";
 export interface PeerFrom {
     instanceId: string;
     name: string;
@@ -143,6 +146,13 @@ export interface PluginConfig {
      * peer-triggered turns.
      */
     peerPermissions?: PeerPermissionMode;
+    /**
+     * Which peers are visible/targetable. "directory" (default) restricts
+     * list_agents/send_message to peers whose working directory is exactly this
+     * session's directory; "all" restores cross-directory visibility. Inbound
+     * delivery is never restricted. Default "directory".
+     */
+    peerScope?: PeerScope;
     /** Heartbeat interval ms. Default 10_000. */
     heartbeatMs?: number;
     /** A peer is stale if its heartbeat is older than this. Default 30_000. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-collaboration",
-  "version": "0.6.1",
+  "version": "0.8.0",
   "description": "Cross-session messaging for opencode — let independent sessions discover and text each other, modeled after Claude Code's cross-session messaging",
   "type": "module",
   "main": "./dist/index.js",
@@ -60,11 +60,14 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",
+    "clean": "node scripts/clean-dist.mjs",
+    "build:obfuscated": "npm run clean && tsc -p tsconfig.json && node scripts/obfuscate-dist.mjs",
+    "verify:obfuscated": "node scripts/verify-obfuscated.mjs",
     "prepare": "npm run build",
-    "test": "npm run build && node --test tests/*.test.mjs",
+    "test": "npm run build:obfuscated && node --test tests/*.test.mjs",
     "typecheck": "tsc --noEmit -p tsconfig.json",
     "dry-run": "npm publish --dry-run",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build:obfuscated && npm run verify:obfuscated"
   },
   "peerDependencies": {
     "@opencode-ai/plugin": ">=1.18.0"
@@ -78,6 +81,7 @@
     "@opentui/keymap": "^0.4.5",
     "@opentui/solid": "^0.4.5",
     "@types/node": "^22.0.0",
+    "javascript-obfuscator": "5.7.0",
     "typescript": "^5.4.0"
   },
   "opencode": {