viber-channel 0.5.3 → 0.6.0

package/package.json

@@ -1,13 +1,17 @@
 {
   "name": "viber-channel",
-  "version": "0.5.3",
+  "version": "0.6.0",
   "description": "Voice + text MCP channel between a Claude Code session and the Viber UI (https://viber.dgypx.dev). Push transcripts to Claude; send_message tool delivers text back to the UI.",
   "type": "module",
   "bin": {
-    "viber-channel": "./viber-channel.ts"
+    "viber-channel": "./viber-channel.ts",
+    "viber-codex-bridge": "./viber-codex-bridge.ts",
+    "viber-codex-supervisor": "./viber-codex-supervisor.ts"
   },
   "files": [
     "viber-channel.ts",
+    "viber-codex-bridge.ts",
+    "viber-codex-supervisor.ts",
     "lib/",
     "README.md"
   ],
@@ -31,6 +35,7 @@
   "license": "MIT",
   "scripts": {
     "start": "bun run viber-channel.ts",
+    "start:codex-bridge": "bun run viber-codex-bridge.ts",
     "test": "bun test"
   },
   "dependencies": {

package/viber-channel.ts

@@ -28,6 +28,7 @@ import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { ListToolsRequestSchema, CallToolRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import { mkdirSync, writeFileSync, readFileSync, unlinkSync } from "node:fs";
+import { createHash } from "node:crypto";
 import { join } from "node:path";
 import { runConnect } from "./lib/connect.ts";
 import { lockFilePath } from "./lib/lockfile.ts";
@@ -36,8 +37,13 @@ import { clientFingerprint } from "./lib/fingerprint.ts";
 import { MessageDedup } from "./lib/message_dedup.ts";
 import {
   acquireConversation,
+  ConversationMintError,
   DEFAULT_REATTACH_WINDOW_SECONDS,
+  type ConversationMintResponse,
 } from "./lib/conversation.ts";
+import { acquireInstance, registerInstance } from "./lib/instance.ts";
+import { runPersistentControlStream } from "./lib/control_stream.ts";
+import { isOwnMessage } from "./lib/self_echo.ts";
 import {
   createTokenRefreshScheduler,
   type TokenRefreshScheduler,
@@ -50,6 +56,22 @@ import { awaitStableStartup } from "./lib/startup_gate.ts";
 // exits — it does not start the MCP server. Any other invocation (no args, or
 // the unknown subcommand) falls through to the MCP server below.
 {
+  // #280 step-29: in an AGENT session (vibe-master terminal), the channel must
+  // be the PLUGIN copy (`--channels plugin:viber-channel@…` — only it can
+  // inject inbound messages). The manually-registered viber-dev-channel MCP
+  // loads in the same session with the same env; instead of racing it for the
+  // channel lock, it bows out deterministically here. Normal sessions
+  // (no VIBER_CHANNEL_AGENT_SESSION) are unaffected.
+  if (
+    process.env.VIBER_CHANNEL_AGENT_SESSION === "1" &&
+    process.env.VIBER_CHANNEL_PLUGIN !== "1"
+  ) {
+    process.stderr.write(
+      "[viber-channel] agent session: yielding to the plugin channel copy (manual MCP registration exits)\n",
+    );
+    process.exit(0);
+  }
+
   const sub = process.argv[2];
   if (sub === "--help" || sub === "-h") {
     process.stdout.write(
@@ -100,10 +122,23 @@ const LOCK_DIR =
     ? join(process.env.APPDATA, "viber")
     : join(process.env.HOME ?? "/tmp", ".config", "viber");
 const LOCK_BASE_URL = process.env.VIBER_BASE_URL ?? "https://viber.dgypx.dev";
-const LOCK_SESSION_ID = process.env.VIBER_CHANNEL_SESSION_ID ?? "";
+// #269: a fleet's parallel agents each carry their own VIBER_INSTANCE_TOKEN but
+// often no VIBER_CHANNEL_SESSION_ID. Fold a HASH of the instance token into the
+// lock's session axis so distinct env-injected instances get distinct locks
+// (parallel same-folder agents no longer collide) — without reordering instance
+// acquisition before the lock, which would defeat the #257 stability gate. An
+// explicit VIBER_CHANNEL_SESSION_ID still wins (back-compat). The token is
+// hashed (never raw) because LOCK_SESSION_ID is logged as a prefix below.
+const LOCK_SESSION_ID =
+  process.env.VIBER_CHANNEL_SESSION_ID ??
+  (process.env.VIBER_INSTANCE_TOKEN
+    ? `inst-${createHash("sha256").update(process.env.VIBER_INSTANCE_TOKEN).digest("hex").slice(0, 16)}`
+    : "");
 const LOCK_FINGERPRINT = clientFingerprint(process.cwd());
 const LOCK_FILE = lockFilePath(LOCK_BASE_URL, LOCK_FINGERPRINT, LOCK_SESSION_ID, LOCK_DIR);
-const SESSION_FILE = sessionFilePath(LOCK_BASE_URL, LOCK_FINGERPRINT, LOCK_SESSION_ID, LOCK_DIR);
+// SESSION_FILE (the conversation handle path) is computed AFTER the instance is
+// acquired (#269) — it is namespaced by the server-issued instance, not the
+// local fingerprint/sessionId. Declared as a `let` near the mint below.
 
 // VIBER_REATTACH_WINDOW_SECONDS overrides the default TTL-based window.
 // A handle older than this cannot point at a live conversation — skip reattach.
@@ -248,7 +283,7 @@ process.stdin.on("end", () => {
 
 // ---- Auth from .viber/auth.json ----
 
-import { authFilePath, loadAuth } from "./lib/auth.ts";
+import { authFilePath, loadAuth, persistInstanceCredentials } from "./lib/auth.ts";
 import { handleConversationTokenExpired } from "./lib/channel_errors.ts";
 import { buildSseUrl } from "./lib/urls.ts";
 
@@ -463,27 +498,106 @@ process.stderr.write(`[viber-channel] startup: stability gate passed (${STABILIT
 let CONVERSATION_TOKEN: string;
 let VOICE_BASE_URL: string;
 let CONVERSATION_ID: string;
+let SESSION_FILE = "";
+// This channel's own server-issued instance id (#280 step-16). Used by the
+// self-echo guard: messages posted by this instance are NOT surfaced back to
+// Claude when the conversation SSE replays them.
+let OWN_INSTANCE_ID = "";
 
-process.stderr.write(`[viber-channel] startup: acquiring conversation (project=${auth.project_id}, target=${auth.target_conversation_id ?? "null"}, session=${SESSION_FILE})\n`);
 try {
-  const minted = await acquireConversation(
-    SESSION_FILE,
-    BASE_URL,
-    auth.project_id,
-    auth.project_token,
-    auth.client_fingerprint,
-    label,
-    auth.target_conversation_id ?? null,
-    REATTACH_WINDOW_SECONDS,
-  );
+  // #269: acquire this channel's server-issued instance identity — env-injected
+  // VIBER_INSTANCE_TOKEN > persisted auth.json instance_token > register a new
+  // one with the stable project_token (self-healing auth.json). The conversation
+  // handle is namespaced by the instance, not the local fingerprint/sessionId.
+  const acquired = await acquireInstance(BASE_URL, auth, auth.client_fingerprint);
+  let instanceToken = acquired.instance_token;
+  // Self-echo guard (#280 step-16) needs the REAL server instance id — never the
+  // token that instance_key may fall back to (Codex review P1). Undefined → ""
+  // → the guard is a no-op (delivers everything), which is the safe default.
+  OWN_INSTANCE_ID = acquired.instance_id ?? "";
+  SESSION_FILE = sessionFilePath(LOCK_BASE_URL, acquired.instance_key, LOCK_DIR);
+
+  process.stderr.write(`[viber-channel] startup: acquiring conversation (project=${auth.project_id}, target=${auth.target_conversation_id ?? "null"}, session=${SESSION_FILE})\n`);
+
+  // Join the conversation with the instance_token. A 401 means the instance was
+  // revoked (the token is durable — no expiry case): re-register a fresh instance
+  // ONCE (a NEW instance_id, the correct post-revocation outcome) and retry. A
+  // second failure falls through to the catch below.
+  let minted: ConversationMintResponse;
+  try {
+    minted = await acquireConversation(
+      SESSION_FILE,
+      BASE_URL,
+      auth.project_id,
+      instanceToken,
+      auth.client_fingerprint,
+      label,
+      auth.target_conversation_id ?? null,
+      REATTACH_WINDOW_SECONDS,
+    );
+  } catch (err) {
+    if (err instanceof ConversationMintError && err.status === 401) {
+      process.stderr.write(
+        `[viber-channel] instance token rejected (401 revoked) — re-registering a fresh instance once\n`,
+      );
+      const reg = await registerInstance(
+        BASE_URL,
+        auth.project_id,
+        auth.project_token,
+        auth.client_fingerprint,
+      );
+      persistInstanceCredentials(authFilePath(), reg.instance_id, reg.instance_token);
+      instanceToken = reg.instance_token;
+      OWN_INSTANCE_ID = reg.instance_id;
+      SESSION_FILE = sessionFilePath(LOCK_BASE_URL, reg.instance_id, LOCK_DIR);
+      minted = await acquireConversation(
+        SESSION_FILE,
+        BASE_URL,
+        auth.project_id,
+        instanceToken,
+        auth.client_fingerprint,
+        label,
+        auth.target_conversation_id ?? null,
+        REATTACH_WINDOW_SECONDS,
+      );
+    } else {
+      throw err;
+    }
+  }
 
-  // project_token is now a stable, long-lived handshake credential (#274). It is
-  // never rotated by the mint response, so auth.json is never rewritten here.
+  // project_token / instance_token are stable, long-lived credentials (#274/#269);
+  // neither is rotated by the mint response. The membership conversation_token
+  // (below) is the short-lived tier and self-refreshes.
 
   CONVERSATION_TOKEN = minted.conversation_token;
   VOICE_BASE_URL = minted.ws_url;
   CONVERSATION_ID = minted.conversation_id;
 
+  // #280 step-27: hold the instance control stream open for the WHOLE session —
+  // it IS the "online" presence signal (step-02). Without it this agent never
+  // shows online in the control plane (sidebar Agents) and is not invitable.
+  // Pushed `join` events are logged but not acted on (an interactive session
+  // stays bound to its own conversation — option A); a `stop` (revoke) is
+  // logged only: the conversation-token path already fails closed.
+  if (OWN_INSTANCE_ID !== "") {
+    const controlStream = runPersistentControlStream(
+      { baseUrl: BASE_URL, instanceId: OWN_INSTANCE_ID, instanceToken },
+      {
+        log: (m) => process.stderr.write(m),
+        onJoin: (pushed) =>
+          process.stderr.write(
+            `[viber-channel] control stream: join for ${pushed.conversation_id} ignored — interactive session keeps its own conversation\n`,
+          ),
+        onStop: (reason) =>
+          process.stderr.write(`[viber-channel] control stream stopped (${reason})\n`),
+      },
+    );
+    // Presence-only consumer: firstJoin ALWAYS settles (rejected at loop end) —
+    // observe it so an ignored join/stop never becomes an unhandled rejection.
+    controlStream.firstJoin.catch(() => {});
+    controlStream.done.catch(() => {});
+  }
+
   // Schedule silent token refresh ahead of expiry (#237 step-03). On success
   // we mutate CONVERSATION_TOKEN in place — getHeaders() reads it by closure,
   // so subsequent SSE reconnects and send_message calls pick up the new token
@@ -658,8 +772,15 @@ async function pushMessage(msg: {
   id?: string | null;
   source?: string;
   artifact?: { content: string; format?: "markdown" | "code" | "json" | "html" } | null;
+  sender_instance_id?: string | null;
 }): Promise<void> {
   process.stderr.write(`[viber-channel] pushMessage ENTER: "${msg.content.slice(0, 60)}"\n`);
+  // Never echo this channel's OWN posted messages back to Claude (#280 step-16):
+  // send_message posts as this instance, and the conversation SSE replays it.
+  if (isOwnMessage(msg.sender_instance_id, OWN_INSTANCE_ID)) {
+    process.stderr.write(`[viber-channel] dropping own posted message (self-echo)\n`);
+    return;
+  }
   if (messageDedup.isDuplicate(msg)) {
     process.stderr.write(
       `[viber-channel] dropping duplicate persisted message (already delivered ephemerally)\n`,
@@ -776,6 +897,7 @@ async function sseLoop(): Promise<void> {
                 role?: string;
                 timestamp?: string;
                 artifact?: { content: string; format?: "markdown" | "code" | "json" | "html" } | null;
+                sender_instance_id?: string | null;
               };
               if (msg.content) {
                 await pushMessage(msg);