@mirrowel/opencode-openshare 0.1.1 → 0.2.0-dev.2

package/dist/v2-server.d.ts

@@ -1,30 +1,8 @@
-import { type MessageInfo, type PartInfo } from "./core.js";
 type V2Event = {
     type: string;
     data?: Record<string, unknown>;
     [key: string]: unknown;
 };
-type V2Message = {
-    id: string;
-    type: string;
-    time?: {
-        created?: number;
-        completed?: number;
-        streamed?: number;
-    };
-    text?: string;
-    agent?: string;
-    model?: {
-        providerID: string;
-        id?: string;
-        modelID?: string;
-    };
-    content?: Array<Record<string, unknown>>;
-    error?: {
-        message?: string;
-    } | null;
-    metadata?: Record<string, unknown>;
-};
 type V2SessionClient = {
     get(input: {
         sessionID: string;
@@ -72,10 +50,5 @@ type V2Context = {
     };
     signal?: AbortSignal;
 };
-/** v2 flat message -> { info, parts } in the v1 shapes the viewer speaks. */
-export declare function convertV2Message(message: V2Message, sessionID: string): {
-    info: MessageInfo;
-    parts: PartInfo[];
-} | undefined;
 export declare function createV2ServerSetup(): (context: V2Context) => Promise<(() => void) | void>;
 export {};

package/dist/v2-server.js

@@ -29,125 +29,10 @@ import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { METADATA_KEY, moduleDir, packageRoot } from "./config.js";
 import { createEngine } from "./core.js";
-// --- v2 message -> v1 items ---------------------------------------------------
-function toolContentText(content) {
-    if (typeof content === "string")
-        return content;
-    if (Array.isArray(content)) {
-        return content
-            .map((item) => {
-            if (typeof item === "string")
-                return item;
-            if (item && typeof item === "object") {
-                const record = item;
-                if (typeof record.text === "string")
-                    return record.text;
-            }
-            return "";
-        })
-            .join("");
-    }
-    return "";
-}
-function convertToolState(state) {
-    if (!state || typeof state !== "object")
-        return { status: "pending" };
-    const record = state;
-    const status = String(record.status ?? "pending");
-    const mapped = {};
-    if (status === "streaming" || status === "running")
-        mapped.status = "running";
-    else if (status === "completed")
-        mapped.status = "completed";
-    else if (status === "failed" || status === "error")
-        mapped.status = "error";
-    else
-        mapped.status = "pending";
-    if (record.input !== undefined)
-        mapped.input = record.input;
-    if (record.output !== undefined)
-        mapped.output = toolContentText(record.output);
-    if (record.error !== undefined)
-        mapped.error = record.error;
-    if (record.time !== undefined)
-        mapped.time = record.time;
-    return mapped;
-}
-/** v2 flat message -> { info, parts } in the v1 shapes the viewer speaks. */
-export function convertV2Message(message, sessionID) {
-    if (!message || typeof message.id !== "string")
-        return undefined;
-    const base = {
-        id: message.id,
-        sessionID,
-    };
-    if (message.type === "user") {
-        return {
-            info: {
-                ...base,
-                role: "user",
-                time: { created: message.time?.created ?? 0 },
-                text: message.text ?? "",
-            },
-            parts: [],
-        };
-    }
-    if (message.type === "assistant") {
-        const parts = [];
-        const content = Array.isArray(message.content) ? message.content : [];
-        content.forEach((block, index) => {
-            const record = block;
-            const kind = String(record.type ?? "");
-            if (kind === "text") {
-                parts.push({
-                    id: `${message.id}_t${index}`,
-                    messageID: message.id,
-                    sessionID,
-                    type: "text",
-                    text: String(record.text ?? ""),
-                    synthetic: false,
-                    time: { start: message.time?.created ?? 0, end: message.time?.completed ?? 0 },
-                });
-            }
-            else if (kind === "reasoning") {
-                parts.push({
-                    id: `${message.id}_r${index}`,
-                    messageID: message.id,
-                    sessionID,
-                    type: "reasoning",
-                    text: String(record.text ?? ""),
-                    synthetic: false,
-                    time: { start: message.time?.created ?? 0, end: message.time?.completed ?? 0 },
-                });
-            }
-            else if (kind === "tool") {
-                parts.push({
-                    id: String(record.id ?? `${message.id}_tool${index}`),
-                    messageID: message.id,
-                    sessionID,
-                    type: "tool",
-                    tool: String(record.name ?? "unknown"),
-                    state: convertToolState(record.state),
-                    synthetic: false,
-                });
-            }
-        });
-        return {
-            info: {
-                ...base,
-                role: "assistant",
-                agent: message.agent,
-                model: message.model
-                    ? { providerID: message.model.providerID, modelID: message.model.modelID ?? message.model.id }
-                    : undefined,
-                time: { created: message.time?.created ?? 0, completed: message.time?.completed ?? 0 },
-            },
-            parts,
-        };
-    }
-    return undefined;
-}
 // --- v2 client -> engine ClientApi ---------------------------------------------
+// Contract v2: messages pass through VERBATIM as v2 session messages (the
+// engine's ingestion detects v2-native shapes and enqueues them directly —
+// no v1 conversion, no dropped compaction, no dropped user text).
 function adaptSessionClient(session, message, directory) {
     if (!session)
         return undefined;
@@ -178,9 +63,9 @@ function adaptSessionClient(session, message, directory) {
             if (!Array.isArray(data))
                 break;
             for (const raw of data) {
-                const converted = convertV2Message(raw, sessionID);
-                if (converted)
-                    out.push(converted);
+                if (raw && typeof raw === "object" && typeof raw.id === "string") {
+                    out.push({ info: raw, parts: [] });
+                }
             }
             const next = res?.cursor?.next ?? undefined;
             if (!next || data.length === 0)
@@ -292,7 +177,20 @@ export function createV2ServerSetup() {
         // the client adapter and feed them into the engine as the v1 events it
         // understands (session.updated / message.updated / message.part.updated).
         // The engine's keyed queue makes repeated re-syncs idempotent.
+        // NOTE: no content-hash dedupe here — a refresh that runs while the
+        // session is still dormant (pre-flag) would poison the cache without
+        // emitting anything, and the flag-time refresh would then SKIP the
+        // unchanged messages (live-caught in the v2 mock suite: the share's
+        // first assistant content arrived only as the next change). The dedupe
+        // belongs engine-side, where dormancy is known, if it's ever needed.
         const pendingRefresh = new Map();
+        // queued inbox inputs per session: v2 persists the prompt in the inbox
+        // (delivery "queue") while the current turn still runs — the message
+        // row can exist before the model ever sees it, and a mid-turn refresh
+        // would surface it early. Held here until session.inbox.delivered
+        // fires (the turn actually starts); "steer" inputs inject into the
+        // live run, so they pass straight through.
+        const queuedInbox = new Map();
         const refresh = (sessionID) => {
             let timer = pendingRefresh.get(sessionID);
             if (timer)
@@ -307,7 +205,10 @@ export function createV2ServerSetup() {
                         });
                         const messages = await client.session.messages?.({ path: { id: sessionID } });
                         const list = (messages?.data ?? []);
+                        const held = queuedInbox.get(sessionID);
                         for (const message of list) {
+                            if (held?.has(message.info.id))
+                                continue; // still queued — not sent to the model yet
                             await engine.hooks.event({
                                 event: { type: "message.updated", properties: { sessionID, info: message.info } },
                             });
@@ -343,6 +244,45 @@ export function createV2ServerSetup() {
                             await engine.hooks.event({ event: { type, properties: { sessionID: sid } } });
                             continue;
                         }
+                        if (type.startsWith("session.inbox.")) {
+                            // queued-prompt lifecycle: hold delivery="queue" inputs off
+                            // the share until they are actually delivered to the model
+                            // (cancelled ones never appear). inboxID shares the message
+                            // id space (the inbox item promotes into that message row).
+                            const data = (event.data ?? {});
+                            const inboxID = data.inboxID;
+                            if (inboxID) {
+                                let set = queuedInbox.get(sid);
+                                if (!set) {
+                                    set = new Set();
+                                    queuedInbox.set(sid, set);
+                                }
+                                if (type === "session.inbox.enqueued" && data.item?.delivery === "queue") {
+                                    set.add(inboxID);
+                                }
+                                else if (type === "session.inbox.delivered") {
+                                    set.delete(inboxID);
+                                    refresh(sid); // the held prompt's turn is starting now
+                                }
+                                else if (type === "session.inbox.cancelled") {
+                                    // cancelled-before-run: the prompt never reaches the
+                                    // model — keep it held forever so no later refresh
+                                    // surfaces the orphaned row
+                                    set.add(inboxID);
+                                }
+                                else if (type === "session.inbox.delivery.changed") {
+                                    // steer inputs inject into the live run — the model
+                                    // sees them; only "queue" holds
+                                    if (data.item?.delivery === "queue")
+                                        set.add(inboxID);
+                                    else {
+                                        set.delete(inboxID);
+                                        refresh(sid);
+                                    }
+                                }
+                            }
+                            continue;
+                        }
                         if (type === "message.removed" || type === "message.part.removed") {
                             // undo cleanup: forwarded verbatim — the engine emits the
                             // tombstones that purge the reverted items from the share

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mirrowel/opencode-openshare",
-  "version": "0.1.1",
+  "version": "0.2.0-dev.2",
   "type": "module",
   "description": "Open(code)Share — re:share: self-hosted session sharing for opencode. Server plugin (single file or package), optional TUI for interactive opt-in sharing.",
   "license": "MIT",
@@ -76,6 +76,8 @@
     "test:v2": "node scripts/v2-mock-tests.mjs",
     "test:auth": "node scripts/auth-tests.mjs",
     "test:server-auth": "node scripts/auth-tests.mjs --backend bun",
+    "test:big": "node scripts/big-tests.mjs",
+    "test:server-big": "node scripts/big-tests.mjs --backend bun",
     "test:server-enroll": "node scripts/enroll-tests.mjs --backend bun",
     "test:enroll": "node scripts/enroll-tests.mjs",
     "test:fanout": "node scripts/fanout-tests.mjs",

package/src/binding-queue.ts

@@ -0,0 +1,26 @@
+/** Serialize session-metadata binding writes.
+ *
+ * Two writers read-modify-write `metadata.openshare` on the same session:
+ * the engine (`writeMetadata` in core.ts — preserves foreign keys, sets
+ * the servers map) and the TUI (`patchSessionBinding` in share-flow.ts —
+ * opt-outs, collision resolution). Their PATCHes interleave at the host:
+ * writer A reads at T0, writer B reads at T1, A PATCHes at T2, B PATCHes
+ * at T3 — A's change is silently lost (live-caught class: a TUI opt-out
+ * erased by the engine's binding refresh).
+ *
+ * Both route their whole read-modify-write through this per-session FIFO.
+ * The queue never breaks on errors; entries drop when the process exits.
+ */
+const queues = new Map<string, Promise<unknown>>()
+
+export function queueBindingWrite<T>(sid: string, fn: () => Promise<T>): Promise<T> {
+  const prev = queues.get(sid) ?? Promise.resolve()
+  // run regardless of the previous slot's outcome — one failed write must
+  // not wedge the session's binding updates forever
+  const run = prev.then(fn, fn)
+  queues.set(
+    sid,
+    run.catch(() => {}),
+  )
+  return run
+}