viveworker 0.8.10 → 0.9.0

package/README.md

@@ -27,8 +27,9 @@ keep your AI session moving, keep context close, and keep your momentum.
 
 ## What Ships Today
 
-`viveworker` already covers five connected loops:
+`viveworker` already covers seven connected loops:
 
+- **Today**: see work that needs you, active agent runs, and results completed today across providers
 - **AI coding sessions**: approvals, plan checks, questions, completions, and mobile code review for Codex and Claude
 - **Thread Sharing**: pass context, plan-review requests, or full handoffs between Codex and Claude sessions
 - **Remote connection**: reach your Mac from a paired device outside your LAN through an end-to-end encrypted relay
@@ -409,7 +410,7 @@ Because the Claude hook opens browser windows and returns focus to Claude Deskto
 ### What it does
 
 - **Incoming reply drafts**: detects when other agents comment on your posts, drafts a contextual reply first, and sends it to your phone for approval
-- **Draft approval on phone**: reply drafts and original post drafts appear in `Tasks` and `Timeline`, where you can approve, deny, or edit them from your phone
+- **Draft approval on phone**: reply drafts and original post drafts appear in `Today` and `Timeline`, where you can approve, deny, or edit them from your phone
 - **Auto-scout replies**: every 2 minutes, handles pending incoming comments first, then scans the Moltbook feed, scores posts against your agent's persona (0–100), batches candidates over a 30-minute window, picks the best match, drafts a reply via LLM, and proposes it for your approval
 - **Original post drafts**: based on your daily coding activity, composes new posts in your agent's voice and proposes them at natural intervals — morning (yesterday recap), noon (morning progress), and evening (full-day summary). Up to 3 per day; deny any slot you don't want
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "viveworker",
-  "version": "0.8.10",
+  "version": "0.9.0",
   "description": "Mobile control plane for AI agents. Approve, answer, and hand off work for Codex, Claude, MCP-ready tools, and A2A from one phone.",
   "author": "Yuta Hoshino <hoshino.lireneo@gmail.com>",
   "license": "MIT",

package/scripts/lib/immutable-json-patch.mjs

@@ -0,0 +1,142 @@
+function isContainer(value) {
+  return Boolean(value) && typeof value === "object";
+}
+
+function isArrayPointerSegment(segment) {
+  return segment === "-" || /^\d+$/u.test(String(segment || ""));
+}
+
+function decodeJsonPointer(pointer) {
+  if (Array.isArray(pointer)) {
+    return pointer.map((segment) => String(segment));
+  }
+  if (!pointer || pointer === "/") {
+    return [];
+  }
+  return String(pointer)
+    .split("/")
+    .slice(1)
+    .map((segment) => segment.replace(/~1/gu, "/").replace(/~0/gu, "~"));
+}
+
+function cloneContainer(value, nextSegment = "") {
+  if (Array.isArray(value)) {
+    return value.slice();
+  }
+  if (isContainer(value)) {
+    return { ...value };
+  }
+  return isArrayPointerSegment(nextSegment) ? [] : {};
+}
+
+function arrayIndex(segment, length, { allowEnd = false } = {}) {
+  if (segment === "-") {
+    return allowEnd ? length : -1;
+  }
+  const parsed = Number.parseInt(String(segment), 10);
+  if (!Number.isInteger(parsed) || parsed < 0) {
+    return -1;
+  }
+  if (parsed < length || (allowEnd && parsed === length)) {
+    return parsed;
+  }
+  return -1;
+}
+
+function readPointerChild(container, segment) {
+  if (Array.isArray(container)) {
+    const index = arrayIndex(segment, container.length, { allowEnd: true });
+    return index >= 0 && index < container.length ? container[index] : undefined;
+  }
+  return isContainer(container) ? container[segment] : undefined;
+}
+
+function writeObjectKey(target, key, value) {
+  Object.defineProperty(target, key, {
+    value,
+    writable: true,
+    enumerable: true,
+    configurable: true,
+  });
+}
+
+function writePointerChild(container, segment, value) {
+  if (Array.isArray(container)) {
+    const index = arrayIndex(segment, container.length, { allowEnd: true });
+    if (index < 0) return false;
+    if (index === container.length) container.push(value);
+    else container[index] = value;
+    return true;
+  }
+  writeObjectKey(container, segment, value);
+  return true;
+}
+
+function applyLeafOperation(container, segment, operation, value) {
+  if (Array.isArray(container)) {
+    if (operation === "add") {
+      const index = arrayIndex(segment, container.length, { allowEnd: true });
+      if (index < 0) return false;
+      if (index === container.length) container.push(value);
+      else container.splice(index, 0, value);
+      return true;
+    }
+
+    const index = arrayIndex(segment, container.length);
+    if (index < 0) return false;
+    if (operation === "remove") container.splice(index, 1);
+    else if (operation === "replace") container[index] = value;
+    else return false;
+    return true;
+  }
+
+  if (operation === "remove") {
+    delete container[segment];
+    return true;
+  }
+  if (operation === "add" || operation === "replace") {
+    writeObjectKey(container, segment, value);
+    return true;
+  }
+  return false;
+}
+
+export function applyJsonPatch(document, patch) {
+  const operation = String(patch?.op || "");
+  if (!["add", "remove", "replace"].includes(operation)) {
+    return document;
+  }
+
+  const pathSegments = decodeJsonPointer(patch.path);
+  if (pathSegments.length === 0) {
+    if (operation === "remove") return {};
+    return patch.value;
+  }
+
+  const root = cloneContainer(document, pathSegments[0]);
+  let sourceNode = document;
+  let targetNode = root;
+
+  for (let index = 0; index < pathSegments.length - 1; index += 1) {
+    const segment = pathSegments[index];
+    const nextSegment = pathSegments[index + 1];
+    const sourceChild = readPointerChild(sourceNode, segment);
+    const targetChild = cloneContainer(sourceChild, nextSegment);
+    if (!writePointerChild(targetNode, segment, targetChild)) {
+      return document;
+    }
+    sourceNode = sourceChild;
+    targetNode = targetChild;
+  }
+
+  const changed = applyLeafOperation(targetNode, pathSegments.at(-1), operation, patch.value);
+  return changed ? root : document;
+}
+
+export function applyJsonPatches(document, patches) {
+  let next = isContainer(document) ? document : {};
+  for (const patch of Array.isArray(patches) ? patches : []) {
+    next = applyJsonPatch(next, patch);
+  }
+  return next;
+}

package/scripts/lib/ipc-frame-worker.mjs

@@ -0,0 +1,30 @@
+import { parentPort } from "node:worker_threads";
+
+import { projectIpcMessage } from "./ipc-message-projector.mjs";
+
+if (!parentPort) {
+  throw new Error("ipc-frame-worker requires a parent port");
+}
+
+parentPort.on("message", (payload) => {
+  if (payload?.type !== "frame" || !payload.frame) return;
+  const startedAt = performance.now();
+  const frame = Buffer.from(payload.frame.buffer, payload.frame.byteOffset, payload.frame.byteLength);
+  try {
+    const message = JSON.parse(frame.toString("utf8"));
+    const parsedAt = performance.now();
+    parentPort.postMessage({
+      type: "message",
+      message: projectIpcMessage(message),
+      frameBytes: frame.length,
+      parseMs: Math.round(parsedAt - startedAt),
+      totalMs: Math.round(performance.now() - startedAt),
+    });
+  } catch (error) {
+    parentPort.postMessage({
+      type: "error",
+      error: String(error?.message || error || "IPC frame parse failed"),
+      frameBytes: frame.length,
+    });
+  }
+});

package/scripts/lib/ipc-message-projector.mjs

@@ -0,0 +1,221 @@
+const THREAD_STATE_SCALAR_KEYS = [
+  "id",
+  "cwd",
+  "thread_name",
+  "threadName",
+  "title",
+  "name",
+  "conversationTitle",
+  "threadTitle",
+  "label",
+  "summary",
+  "archived",
+  "isArchived",
+  "hidden",
+  "isHidden",
+  "deleted",
+  "isDeleted",
+  "closed",
+  "isClosed",
+  "status",
+  "state",
+  "visibility",
+  "lifecycle",
+];
+
+const METADATA_KEYS = [
+  "thread_name",
+  "threadName",
+  "title",
+  "archived",
+  "isArchived",
+  "hidden",
+  "isHidden",
+  "deleted",
+  "isDeleted",
+  "status",
+  "state",
+  "visibility",
+];
+
+const THREAD_KEYS = [
+  "id",
+  "title",
+  "name",
+  "archived",
+  "isArchived",
+  "hidden",
+  "isHidden",
+  "deleted",
+  "isDeleted",
+  "status",
+  "state",
+  "visibility",
+];
+
+const RELEVANT_PATCH_ROOTS = new Set([
+  ...THREAD_STATE_SCALAR_KEYS,
+  "requests",
+  "latestCollaborationMode",
+  "metadata",
+  "thread",
+]);
+
+function isObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+function own(value, key) {
+  return Object.prototype.hasOwnProperty.call(value, key);
+}
+
+function boundedLabelValue(value) {
+  return typeof value === "string" && value.length > 512 ? value.slice(0, 512) : value;
+}
+
+function pickObject(value, keys) {
+  if (!isObject(value)) return undefined;
+  const projected = {};
+  for (const key of keys) {
+    if (own(value, key)) projected[key] = boundedLabelValue(value[key]);
+  }
+  return projected;
+}
+
+function projectCollaborationMode(value) {
+  if (!isObject(value)) return undefined;
+  const projected = {};
+  if (own(value, "mode")) projected.mode = value.mode;
+  if (isObject(value.settings)) {
+    projected.settings = {
+      ...(own(value.settings, "model") ? { model: value.settings.model } : {}),
+      ...(own(value.settings, "reasoning_effort")
+        ? { reasoning_effort: value.settings.reasoning_effort }
+        : {}),
+    };
+  }
+  return projected;
+}
+
+function projectRequest(value) {
+  if (!isObject(value)) return value;
+  return {
+    ...(own(value, "id") ? { id: value.id } : {}),
+    ...(own(value, "method") ? { method: value.method } : {}),
+    ...(own(value, "params") ? { params: value.params } : {}),
+  };
+}
+
+function projectRequests(value) {
+  return Array.isArray(value) ? value.map(projectRequest) : value;
+}
+
+export function projectConversationState(value) {
+  if (!isObject(value)) return {};
+  const projected = {};
+  for (const key of THREAD_STATE_SCALAR_KEYS) {
+    if (own(value, key)) projected[key] = boundedLabelValue(value[key]);
+  }
+  if (own(value, "requests")) projected.requests = projectRequests(value.requests);
+  if (own(value, "latestCollaborationMode")) {
+    projected.latestCollaborationMode = projectCollaborationMode(value.latestCollaborationMode);
+  }
+  if (own(value, "metadata")) projected.metadata = pickObject(value.metadata, METADATA_KEYS);
+  if (own(value, "thread")) projected.thread = pickObject(value.thread, THREAD_KEYS);
+  return projected;
+}
+
+function pointerSegments(pointer) {
+  if (Array.isArray(pointer)) return pointer.map(String);
+  if (!pointer || pointer === "/") return [];
+  return String(pointer)
+    .split("/")
+    .slice(1)
+    .map((segment) => segment.replace(/~1/gu, "/").replace(/~0/gu, "~"));
+}
+
+function projectPatchValue(segments, value) {
+  if (segments.length === 0) return projectConversationState(value);
+  const root = segments[0];
+  if (root === "requests") {
+    if (segments.length === 1) return projectRequests(value);
+    if (segments.length === 2) return projectRequest(value);
+    return value;
+  }
+  if (root === "latestCollaborationMode" && segments.length === 1) {
+    return projectCollaborationMode(value);
+  }
+  if (root === "metadata" && segments.length === 1) return pickObject(value, METADATA_KEYS);
+  if (root === "thread" && segments.length === 1) return pickObject(value, THREAD_KEYS);
+  return boundedLabelValue(value);
+}
+
+function isRelevantPatchPath(segments) {
+  if (segments.length === 0) return true;
+  const root = segments[0];
+  if (!RELEVANT_PATCH_ROOTS.has(root)) return false;
+  if (root === "metadata") return segments.length === 1 || METADATA_KEYS.includes(segments[1]);
+  if (root === "thread") return segments.length === 1 || THREAD_KEYS.includes(segments[1]);
+  if (root === "latestCollaborationMode") {
+    return (
+      segments.length === 1 ||
+      segments[1] === "mode" ||
+      (segments[1] === "settings" && [undefined, "model", "reasoning_effort"].includes(segments[2]))
+    );
+  }
+  return true;
+}
+
+function projectPatch(patch) {
+  if (!isObject(patch)) return null;
+  const segments = pointerSegments(patch.path);
+  if (!isRelevantPatchPath(segments)) return null;
+  return {
+    op: patch.op,
+    path: patch.path,
+    ...(own(patch, "value") ? { value: projectPatchValue(segments, patch.value) } : {}),
+  };
+}
+
+function projectPatches(value) {
+  const patches = Array.isArray(value) ? value : value ? [value] : [];
+  return patches.map(projectPatch).filter(Boolean);
+}
+
+function projectThreadStateParams(params) {
+  const source = isObject(params) ? params : {};
+  const projected = {};
+  for (const key of ["conversationId", "threadId", "id"]) {
+    if (own(source, key)) projected[key] = source[key];
+  }
+  if (isObject(source.change)) {
+    if (source.change.type === "snapshot") {
+      projected.change = {
+        type: "snapshot",
+        conversationState: projectConversationState(source.change.conversationState),
+      };
+    } else if (source.change.type === "patches") {
+      projected.change = { type: "patches", patches: projectPatches(source.change.patches) };
+    }
+  }
+  if (own(source, "state")) projected.state = projectConversationState(source.state);
+  if (own(source, "conversation")) projected.conversation = projectConversationState(source.conversation);
+  if (own(source, "thread")) projected.thread = projectConversationState(source.thread);
+  if (own(source, "requests")) projected.requests = projectRequests(source.requests);
+  for (const key of ["patch", "patches", "operations", "ops"]) {
+    if (own(source, key)) projected[key] = projectPatches(source[key]);
+  }
+  return projected;
+}
+
+export function projectIpcMessage(message) {
+  if (!isObject(message) || message.type !== "broadcast" || message.method !== "thread-stream-state-changed") {
+    return message;
+  }
+  return {
+    type: message.type,
+    method: message.method,
+    ...(own(message, "sourceClientId") ? { sourceClientId: message.sourceClientId } : {}),
+    params: projectThreadStateParams(message.params),
+  };
+}

package/scripts/lib/length-prefixed-frame-decoder.mjs

@@ -0,0 +1,128 @@
+const DEFAULT_MAX_FRAME_BYTES = 1024 * 1024 * 1024;
+
+export class LengthPrefixedFrameDecoder {
+  constructor({ maxFrameBytes = DEFAULT_MAX_FRAME_BYTES } = {}) {
+    this.maxFrameBytes = Math.max(1, Number(maxFrameBytes) || DEFAULT_MAX_FRAME_BYTES);
+    this.reset();
+  }
+
+  get bufferedBytes() {
+    return this.byteLength;
+  }
+
+  reset() {
+    this.chunks = [];
+    this.headIndex = 0;
+    this.byteLength = 0;
+  }
+
+  push(value) {
+    const chunk = Buffer.isBuffer(value) ? value : Buffer.from(value || []);
+    if (chunk.length > 0) {
+      this.chunks.push(chunk);
+      this.byteLength += chunk.length;
+    }
+
+    const frames = [];
+    while (this.byteLength >= 4) {
+      const frameBytes = this.peekUInt32LE();
+      if (frameBytes > this.maxFrameBytes) {
+        this.reset();
+        throw new RangeError(`IPC frame exceeds ${this.maxFrameBytes} bytes`);
+      }
+      if (this.byteLength < frameBytes + 4) {
+        break;
+      }
+      this.consume(4);
+      frames.push(this.consume(frameBytes));
+    }
+    return frames;
+  }
+
+  peekUInt32LE() {
+    const first = this.chunks[this.headIndex];
+    if (first?.length >= 4) {
+      return first.readUInt32LE(0);
+    }
+    const prefix = Buffer.allocUnsafe(4);
+    this.copyInto(prefix, 4, false);
+    return prefix.readUInt32LE(0);
+  }
+
+  consume(length) {
+    if (length === 0) {
+      return Buffer.alloc(0);
+    }
+    if (length < 0 || length > this.byteLength) {
+      throw new RangeError("Cannot consume beyond buffered IPC bytes");
+    }
+
+    const first = this.chunks[this.headIndex];
+    if (first.length >= length) {
+      const result = first.subarray(0, length);
+      if (first.length === length) {
+        this.headIndex += 1;
+      } else {
+        this.chunks[this.headIndex] = first.subarray(length);
+      }
+      this.byteLength -= length;
+      this.compactChunks();
+      return result;
+    }
+
+    const result = Buffer.allocUnsafe(length);
+    this.copyInto(result, length, true);
+    return result;
+  }
+
+  copyInto(target, length, consume) {
+    let remaining = length;
+    let targetOffset = 0;
+    let chunkIndex = this.headIndex;
+    let firstChunkOffset = 0;
+
+    while (remaining > 0) {
+      const chunk = this.chunks[chunkIndex];
+      if (!chunk) {
+        throw new RangeError("Incomplete IPC frame buffer");
+      }
+      const available = chunk.length - firstChunkOffset;
+      const copyLength = Math.min(remaining, available);
+      chunk.copy(target, targetOffset, firstChunkOffset, firstChunkOffset + copyLength);
+      targetOffset += copyLength;
+      remaining -= copyLength;
+
+      if (!consume) {
+        chunkIndex += 1;
+        firstChunkOffset = 0;
+        continue;
+      }
+
+      if (copyLength === available) {
+        this.headIndex += 1;
+        chunkIndex = this.headIndex;
+      } else {
+        this.chunks[this.headIndex] = chunk.subarray(copyLength);
+        chunkIndex = this.headIndex;
+      }
+      firstChunkOffset = 0;
+      this.byteLength -= copyLength;
+    }
+
+    if (consume) {
+      this.compactChunks();
+    }
+  }
+
+  compactChunks() {
+    if (this.headIndex === this.chunks.length) {
+      this.chunks = [];
+      this.headIndex = 0;
+      return;
+    }
+    if (this.headIndex >= 1024 && this.headIndex * 2 >= this.chunks.length) {
+      this.chunks = this.chunks.slice(this.headIndex);
+      this.headIndex = 0;
+    }
+  }
+}

package/scripts/lib/remote-pairing/bridge-relay-client.mjs

@@ -68,6 +68,10 @@ import {
  * (long-poll + a few short ones), so 64 is way above the working set.
  */
 export const MAX_INFLIGHT_PER_SESSION = 64;
+export const BRIDGE_RELAY_FAILURE_THRESHOLD = 2;
+export const BRIDGE_RELAY_CIRCUIT_BREAKER_MS = 5 * 60_000;
+export const BRIDGE_RELAY_MAX_CIRCUIT_BREAKER_MS = 30 * 60_000;
+export const BRIDGE_RELAY_STABLE_CONNECTION_MS = 60_000;
 
 // ---------------------------------------------------------------------------
 // BridgeRelayClient — coordinates many BridgePairingSessions
@@ -89,6 +93,11 @@ export const MAX_INFLIGHT_PER_SESSION = 64;
  * @property {number[]} [backoffMs]                forwarded to the transport
  * @property {number} [handshakeTimeoutMs]         forwarded to the transport
  * @property {Uint8Array} [prologue]               forwarded to the transport
+ * @property {number} [failureThreshold]           bridge-side relay reset circuit threshold
+ * @property {number} [failureWindowMs]            bridge-side relay reset circuit window
+ * @property {number} [circuitBreakerMs]           bridge-side relay reset cooldown
+ * @property {number} [maxCircuitBreakerMs]        bridge-side max relay reset cooldown
+ * @property {number} [stableConnectionMs]         bridge-side stable duration before clearing circuit
  */
 
 /**
@@ -284,6 +293,11 @@ export class BridgeRelayClient {
       backoffMs: this._opts.backoffMs,
       handshakeTimeoutMs: this._opts.handshakeTimeoutMs,
       prologue: this._opts.prologue,
+      failureThreshold: this._opts.failureThreshold,
+      failureWindowMs: this._opts.failureWindowMs,
+      circuitBreakerMs: this._opts.circuitBreakerMs,
+      maxCircuitBreakerMs: this._opts.maxCircuitBreakerMs,
+      stableConnectionMs: this._opts.stableConnectionMs,
     });
     this._sessions.set(pairing.pairingId, session);
     session.start().catch((err) => {
@@ -334,6 +348,11 @@ class BridgePairingSession {
     backoffMs,
     handshakeTimeoutMs,
     prologue,
+    failureThreshold,
+    failureWindowMs,
+    circuitBreakerMs,
+    maxCircuitBreakerMs,
+    stableConnectionMs,
   }) {
     this.pairing = pairing;
     this._dispatch = dispatch;
@@ -370,6 +389,11 @@ class BridgePairingSession {
       backoffMs,
       handshakeTimeoutMs,
       prologue,
+      failureThreshold: failureThreshold ?? BRIDGE_RELAY_FAILURE_THRESHOLD,
+      failureWindowMs,
+      circuitBreakerMs: circuitBreakerMs ?? BRIDGE_RELAY_CIRCUIT_BREAKER_MS,
+      maxCircuitBreakerMs: maxCircuitBreakerMs ?? BRIDGE_RELAY_MAX_CIRCUIT_BREAKER_MS,
+      stableConnectionMs: stableConnectionMs ?? BRIDGE_RELAY_STABLE_CONNECTION_MS,
       logger: logger,
     };
     this._transport = this._createTransport();

package/scripts/lib/remote-pairing/orchestrator.mjs

@@ -68,6 +68,11 @@ const RELOAD_DEBOUNCE_MS = 250;
  * @property {number[]} [backoffMs]               forwarded to BridgeRelayClient
  * @property {number} [handshakeTimeoutMs]        forwarded to BridgeRelayClient
  * @property {Uint8Array} [prologue]              forwarded to BridgeRelayClient
+ * @property {number} [failureThreshold]          forwarded to BridgeRelayClient
+ * @property {number} [failureWindowMs]           forwarded to BridgeRelayClient
+ * @property {number} [circuitBreakerMs]          forwarded to BridgeRelayClient
+ * @property {number} [maxCircuitBreakerMs]       forwarded to BridgeRelayClient
+ * @property {number} [stableConnectionMs]        forwarded to BridgeRelayClient
  * @property {boolean} [watchPairingsFile]        defaults to true
  * @property {(event: object) => void | Promise<void>} [auditEventSink]
  */
@@ -227,6 +232,11 @@ export async function startRemotePairingRelay(opts) {
     backoffMs: opts.backoffMs,
     handshakeTimeoutMs: opts.handshakeTimeoutMs,
     prologue: opts.prologue,
+    failureThreshold: opts.failureThreshold,
+    failureWindowMs: opts.failureWindowMs,
+    circuitBreakerMs: opts.circuitBreakerMs,
+    maxCircuitBreakerMs: opts.maxCircuitBreakerMs,
+    stableConnectionMs: opts.stableConnectionMs,
     logger: log,
   });