@clowder-ai/companion 0.1.0-alpha.3 → 0.1.0-alpha.30

package/renderer/call-transcript-view.mjs

@@ -0,0 +1,240 @@
+const MAX_LIVE_ROWS = 8;
+
+/**
+ * Projection of the Host-bound transcript for one trusted call.
+ *
+ * Durable rows are keyed only by Host messageId. Ephemeral audio is keyed by
+ * provider item/turn identity and is discarded when the Host projects the
+ * matching durable source. Text equality is deliberately never used.
+ */
+export class CallTranscriptView {
+  constructor(container, { onUnread = () => {} } = {}) {
+    this.container = container;
+    this.onUnread = onUnread;
+    this.durableRows = new Map();
+    this.liveRows = new Map();
+    this.liveSequence = 0;
+    this.optimisticIds = new Set();
+    this.unread = 0;
+    this.initialized = false;
+    container.addEventListener?.('scroll', () => {
+      if (this.nearBottom()) this.setUnread(0);
+    });
+  }
+
+  setCall(callId) {
+    if (this.callId === callId) return;
+    this.callId = callId ?? null;
+    this.scope = undefined;
+    this.durableRows.clear();
+    this.liveRows.clear();
+    this.liveSequence = 0;
+    this.optimisticIds.clear();
+    this.initialized = false;
+    this.container.replaceChildren();
+    this.container.dataset.callId = this.callId ?? '';
+    this.container.dataset.hasMore = 'false';
+    this.setUnread(0);
+  }
+
+  reset() { this.setCall(null); }
+
+  nearBottom() {
+    return this.container.scrollHeight - this.container.scrollTop - this.container.clientHeight < 32;
+  }
+
+  scrollToBottom() {
+    this.container.scrollTop = this.container.scrollHeight;
+    this.setUnread(0);
+  }
+
+  setUnread(count) {
+    if (this.unread === count) return;
+    this.unread = count;
+    this.onUnread(count);
+  }
+
+  visibleAnchor() {
+    const viewport = this.container.getBoundingClientRect?.();
+    if (!viewport) return null;
+    for (const [id, row] of this.durableRows) {
+      const rect = row.getBoundingClientRect?.();
+      if (rect && rect.bottom > viewport.top && rect.top < viewport.bottom) {
+        return { id, offset: rect.top - viewport.top };
+      }
+    }
+    return null;
+  }
+
+  createRow() {
+    return this.container.ownerDocument.createElement('p');
+  }
+
+  updateDurable(row, value) {
+    row.className = `call-transcript-row ${value.source.kind} ${value.role}`;
+    row.textContent = value.text;
+    row.dataset.messageId = value.messageId;
+    row.dataset.source = value.source.kind;
+    row.dataset.role = value.role;
+    delete row.dataset.live;
+    delete row.dataset.itemId;
+    delete row.dataset.turnId;
+    delete row.dataset.optimistic;
+    if (value.source.kind === 'voice') {
+      row.dataset.itemId = value.source.nativeItemId;
+      if (value.source.nativeTurnId) row.dataset.turnId = value.source.nativeTurnId;
+      delete row.dataset.clientMessageId;
+    } else {
+      row.dataset.clientMessageId = value.source.clientMessageId;
+    }
+    row.setAttribute?.('aria-label', value.source.kind === 'typed'
+      ? `你打字说：${value.text}`
+      : value.role === 'assistant' ? `猫猫：${value.text}` : `语音转写：${value.text}`);
+    return row;
+  }
+
+  removeReconciledLive(source) {
+    if (source.kind !== 'voice') return false;
+    let removed = false;
+    for (const [key, row] of this.liveRows) {
+      if ((row.dataset.itemId && row.dataset.itemId === source.nativeItemId)
+        || (source.nativeTurnId && row.dataset.turnId === source.nativeTurnId)) {
+        this.liveRows.delete(key);
+        removed = true;
+      }
+    }
+    return removed;
+  }
+
+  render() {
+    this.container.replaceChildren(...this.durableRows.values(), ...this.liveRows.values());
+  }
+
+  load(reply) {
+    if (!this.callId || reply?.kind !== 'transcript' || reply.scope?.callId !== this.callId) return false;
+    const pinned = this.nearBottom();
+    const readingPosition = this.container.scrollTop;
+    const anchor = pinned ? null : this.visibleAnchor();
+    const previous = this.durableRows;
+    const previousIds = new Set(previous.keys());
+    const next = new Map();
+    let added = 0;
+
+    for (const value of reply.rows) {
+      const reconciledLive = this.removeReconciledLive(value.source);
+      const row = previous.get(value.messageId) ?? this.createRow();
+      this.updateDurable(row, value);
+      this.optimisticIds.delete(value.messageId);
+      next.set(value.messageId, row);
+      if (this.initialized && !previousIds.has(value.messageId) && !reconciledLive) added += 1;
+    }
+    // An accepted delivery already has a durable Host messageId. A transcript
+    // read can race the MessageStore projection, so keep that exact row until
+    // the same id appears; never fall back to matching its text.
+    for (const id of this.optimisticIds) {
+      const row = previous.get(id);
+      if (row && !next.has(id)) next.set(id, row);
+    }
+
+    this.scope = reply.scope;
+    this.durableRows = next;
+    this.container.dataset.callId = reply.scope.callId;
+    this.container.dataset.hasMore = String(reply.hasMore);
+    this.render();
+
+    if (pinned) {
+      this.container.scrollTop = this.container.scrollHeight;
+      this.setUnread(0);
+    } else if (anchor) {
+      const row = this.durableRows.get(anchor.id) ?? this.durableRows.values().next().value;
+      const rect = row?.getBoundingClientRect?.();
+      const viewport = this.container.getBoundingClientRect?.();
+      this.container.scrollTop = rect && viewport
+        ? this.container.scrollTop + rect.top - viewport.top - anchor.offset
+        : readingPosition;
+      if (added) this.setUnread(this.unread + added);
+    } else {
+      this.container.scrollTop = readingPosition;
+      if (added) this.setUnread(this.unread + added);
+    }
+    this.initialized = true;
+    return true;
+  }
+
+  liveKey(event) {
+    if (event.itemId) return `item:${event.itemId}`;
+    if (event.turnId) return `turn:${event.turnId}`;
+    return `ephemeral:${++this.liveSequence}`;
+  }
+
+  appendLive(event) {
+    if (!this.callId || event?.type !== 'transcript' || event.callId !== this.callId) return false;
+    const pinned = this.nearBottom();
+    const key = this.liveKey(event);
+    let row = this.liveRows.get(key);
+    const isNew = !row;
+    if (!row) {
+      row = this.createRow();
+      row.className = `call-transcript-row voice ${event.role}`;
+      row.dataset.live = 'true';
+      row.dataset.source = 'voice';
+      row.dataset.role = event.role;
+      if (event.itemId) row.dataset.itemId = event.itemId;
+      if (event.turnId) row.dataset.turnId = event.turnId;
+      this.liveRows.set(key, row);
+      while (this.liveRows.size > MAX_LIVE_ROWS) this.liveRows.delete(this.liveRows.keys().next().value);
+    }
+    row.textContent = `${row.textContent}${event.text}`.slice(-16000);
+    row.setAttribute?.('aria-label', `${event.role === 'assistant' ? '猫猫' : '语音转写'}，实时：${row.textContent}`);
+    this.render();
+    if (pinned) {
+      this.container.scrollTop = this.container.scrollHeight;
+      this.setUnread(0);
+    } else if (isNew) this.setUnread(this.unread + 1);
+    return row;
+  }
+
+  rowForMessage(messageId) { return this.durableRows.get(messageId); }
+
+  appendTyped({ receipt, text }) {
+    if (!this.callId || receipt?.delivery !== 'accepted' || receipt.callId !== this.callId) return false;
+    const pinned = this.nearBottom();
+    let row = this.durableRows.get(receipt.messageId);
+    const isNew = !row;
+    if (!row) {
+      row = this.createRow();
+      this.durableRows.set(receipt.messageId, row);
+    }
+    this.updateDurable(row, {
+      messageId: receipt.messageId,
+      role: 'user',
+      text,
+      source: { kind: 'typed', clientMessageId: receipt.clientMessageId, callId: receipt.callId },
+    });
+    row.dataset.optimistic = 'true';
+    this.optimisticIds.add(receipt.messageId);
+    while (this.optimisticIds.size > MAX_LIVE_ROWS) {
+      const oldest = this.optimisticIds.values().next().value;
+      this.optimisticIds.delete(oldest);
+      if (this.durableRows.get(oldest)?.dataset.optimistic === 'true') this.durableRows.delete(oldest);
+    }
+    this.render();
+    if (pinned) {
+      this.container.scrollTop = this.container.scrollHeight;
+      this.setUnread(0);
+    } else if (isNew) this.setUnread(this.unread + 1);
+    return true;
+  }
+
+  finish(event) {
+    if (!this.callId || event?.type !== 'turn-done' || event.callId !== this.callId) return false;
+    for (const row of this.liveRows.values()) {
+      const matchesTurn = event.turnId && row.dataset.turnId === event.turnId;
+      const matchesUnkeyedRole = !event.turnId && event.role && !row.dataset.itemId
+        && !row.dataset.turnId && row.dataset.role === event.role;
+      if (matchesTurn || matchesUnkeyedRole) row.dataset.complete = 'true';
+    }
+    this.render();
+    return true;
+  }
+}

package/renderer/chat-unread.mjs

@@ -0,0 +1,44 @@
+/** Counts new assistant call-message identities only after the owner folds an opened chat. */
+export class FoldedChatUnread {
+  constructor(changed = () => {}) {
+    this.changed = changed;
+    this.seen = new Set();
+    this.count = 0;
+    this.armed = false;
+    this.folded = false;
+  }
+
+  publish(count) {
+    if (this.count === count) return;
+    this.count = count;
+    this.changed(count);
+  }
+
+  open() {
+    this.armed = true;
+    this.folded = false;
+    this.publish(0);
+  }
+
+  fold() {
+    if (this.armed) this.folded = true;
+  }
+
+  receive(message) {
+    const { messageId, role } = message ?? {};
+    if (!messageId || this.seen.has(messageId)) return;
+    this.seen.add(messageId);
+    if (role === 'assistant' && this.armed && this.folded) this.publish(this.count + 1);
+  }
+
+  receiveMany(messages) {
+    for (const message of messages) this.receive(message);
+  }
+
+  reset() {
+    this.seen.clear();
+    this.armed = false;
+    this.folded = false;
+    this.publish(0);
+  }
+}

package/renderer/client.mjs

@@ -16,16 +16,62 @@ export function createCompanionClient(bridge) {
             throw new CompanionRequestError('unavailable');
         return reply;
     }
+    async function readConversation() {
+        const response = await invoke({ kind: 'conversation.read' }, 'conversation');
+        if ('v' in response)
+            throw new CompanionRequestError('unavailable');
+        return response;
+    }
+    async function readConversationPage(options = {}) {
+        const command = options.before === undefined
+            ? options.limit === undefined
+                ? { kind: 'conversation.read', v: 2 }
+                : { kind: 'conversation.read', v: 2, limit: options.limit }
+            : options.limit === undefined
+                ? { kind: 'conversation.read', v: 2, before: options.before }
+                : { kind: 'conversation.read', v: 2, before: options.before, limit: options.limit };
+        const response = await invoke(command, 'conversation');
+        if (!('v' in response) || response.v !== 2)
+            throw new CompanionRequestError('unavailable');
+        return response;
+    }
+    async function readConversationBody(continuation) {
+        return invoke({ kind: 'conversation.body.read', v: 2, continuation }, 'conversation-body');
+    }
+    async function readConversationDraft() {
+        return invoke({ kind: 'conversation.draft.read', v: 1 }, 'conversation-draft');
+    }
+    async function saveConversationDraft(expectedRevision, text, scopeRef) {
+        return invoke({
+            kind: 'conversation.draft.save', v: 1, scopeRef, expectedRevision, text,
+        }, 'conversation-draft');
+    }
+    async function invokeDeliveryV2(command) {
+        const response = await invoke(command, 'delivery');
+        if (!('v' in response) || response.v !== 2)
+            throw new CompanionRequestError('unavailable');
+        return response;
+    }
+    async function submitConversationText(text, clientMessageId, submissionRevision, scopeRef) {
+        return invokeDeliveryV2({
+            kind: 'text', v: 2, scopeRef, text, clientMessageId, submissionRevision,
+        });
+    }
+    async function readConversationDelivery(clientMessageId, scopeRef) {
+        return invokeDeliveryV2({ kind: 'conversation.delivery.read', v: 1, scopeRef, clientMessageId });
+    }
     return {
         state: () => invoke({ kind: 'state' }, 'state'),
         prepare: () => invoke({ kind: 'prepare' }, 'state'),
-        connectAudio: () => invoke({ kind: 'audio.connect' }, 'ok'),
+        connectAudio: (mode) => invoke(mode === undefined ? { kind: 'audio.connect' } : { kind: 'audio.connect', mode }, 'ok'),
         closeAudio: () => invoke({ kind: 'audio.close' }, 'ok'),
         muteMicrophone: (muted) => invoke({ kind: 'audio.microphone', muted }, 'ok'),
         muteSpeaker: (muted) => invoke({ kind: 'audio.speaker', muted }, 'ok'),
         stop: () => invoke({ kind: 'stop' }, 'ok'),
         text: async (text, clientMessageId) => {
             const receipt = await invoke({ kind: 'text', text, clientMessageId }, 'delivery');
+            if ('v' in receipt)
+                throw new CompanionRequestError('unavailable');
             if (receipt.delivery !== 'accepted')
                 throw new CompanionRequestError('unconfirmed');
             return receipt;
@@ -36,11 +82,37 @@ export function createCompanionClient(bridge) {
         screenFrame: (selectionId, frame) => invoke({ kind: 'screen.frame', selectionId, frame }, 'ok'),
         screenClose: () => invoke({ kind: 'screen.close' }, 'ok'),
         openConversation: () => invoke({ kind: 'conversation.open' }, 'navigation'),
+        observePresentation: (observation) => invoke({
+            kind: 'presentation.observe',
+            event: observation.event,
+            observedAt: observation.observedAt,
+            callId: observation.callId,
+            reference: observation.reference,
+        }, 'ok'),
+        readWork: () => invoke({ kind: 'work.read' }, 'work'),
+        openWork: (entryRef) => invoke({ kind: 'work.open', entryRef }, 'navigation'),
+        readDecisions: (offset = 0, limit = 20) => invoke({ kind: 'decisions.read', offset, limit }, 'decisions'),
+        openDecision: (variantRef, target) => invoke({ kind: 'decision.open', variantRef, target }, 'navigation'),
+        inspectF221: (proposalId) => invoke({ kind: 'f221.inspect', proposalId }, 'decision-trial'),
         resize: (expanded) => invoke({ kind: 'view.resize', expanded }, 'ok'),
-        layout: (panel, width, height) => invoke({ kind: 'view.layout', panel, width, height }, 'layout'),
+        layout: (panel, width, height, call) => invoke(call === undefined
+            ? { kind: 'view.layout', panel, width, height }
+            : { kind: 'view.layout', panel, width, height, call }, 'layout'),
         drag: (phase) => invoke({ kind: 'view.drag', phase }, 'ok'),
         hide: () => invoke({ kind: 'view.hide' }, 'ok'),
-        readConversation: () => invoke({ kind: 'conversation.read' }, 'conversation'),
+        resetPosition: () => invoke({ kind: 'view.reset' }, 'ok'),
+        readSettings: () => invoke({ kind: 'settings.read' }, 'settings'),
+        updateSetting: (field, value) => invoke({ kind: 'settings.update', field, value }, 'settings-update'),
+        settleAppAssist: (scopeRef, offerRef, action) => invoke({ kind: 'app-assist.settle', scopeRef, offerRef, action }, 'app-assist-settlement'),
+        disableCompanion: () => invoke({ kind: 'companion.disable' }, 'companion-lifecycle'),
+        readConversation,
+        readConversationPage,
+        readConversationBody,
+        readConversationDraft,
+        saveConversationDraft,
+        submitConversationText,
+        readConversationDelivery,
+        readTranscript: () => invoke({ kind: 'transcript.read' }, 'transcript'),
         subscribe: (listener) => bridge.subscribe(listener),
     };
 }

package/renderer/compact-size.mjs

@@ -0,0 +1,8 @@
+export const COMPACT_BALL_SIZE = 43;
+export const DEFAULT_BALL_SIZE = 72;
+
+export function compactSizeAction(ballSize) {
+  return Number(ballSize) <= COMPACT_BALL_SIZE
+    ? { label: '放大', value: DEFAULT_BALL_SIZE }
+    : { label: '缩小', value: COMPACT_BALL_SIZE };
+}

package/renderer/companion-identity.mjs

@@ -0,0 +1,42 @@
+const named = value => typeof value === 'string' && value.trim().length > 0;
+const actor = value => value && named(value.catId) && named(value.displayName);
+const model = value => value === null || (named(value) && value.length <= 160);
+const snapshotActor = value => actor(value) && value.catId.length <= 160 && value.displayName.length <= 160;
+
+function validSnapshot(value) {
+  return value?.v === 1 && value.name === '猫猫球'
+    && snapshotActor(value.partner) && named(value.partner.skin) && value.partner.skin.length <= 160
+    && snapshotActor(value.live) && value.live.transport === 'gpt_live_v3' && model(value.live.verifiedModel)
+    && snapshotActor(value.deep) && value.deep.catId === value.partner.catId && model(value.deep.verifiedModel);
+}
+
+function display(snapshot, partnerLabel) {
+  return {
+    title: snapshot.name,
+    companionKnown: true,
+    partnerLabel,
+    avatarCatId: snapshot.partner.catId,
+    skin: snapshot.partner.skin,
+    liveLabel: `Live 快端：${snapshot.live.displayName} · ${snapshot.live.verifiedModel ?? '型号未核实'}`,
+    deepLabel: `深思端：${snapshot.deep.displayName} · ${snapshot.deep.verifiedModel ?? '型号未核实'}`,
+  };
+}
+
+/** The current face comes from the Host's selected duty, never the background carrier. */
+export function currentCompanionIdentity(state) {
+  if (!actor(state?.duty) || !actor(state?.carrier) || !named(state.skin)
+    || state.liveTransport?.kind !== 'gpt_live_v3' || !model(state.liveTransport.verifiedModel)) return null;
+  const snapshot = {
+    v: 1, name: '猫猫球',
+    partner: { ...state.duty, skin: state.skin },
+    live: { ...state.carrier, transport: state.liveTransport.kind, verifiedModel: state.liveTransport.verifiedModel },
+    deep: { ...state.duty, verifiedModel: null },
+  };
+  return display(snapshot, `${snapshot.partner.displayName}陪伴中`);
+}
+
+/** A missing old snapshot never borrows today's preference. Keep the message's real author visible. */
+export function historicalCompanionIdentity(snapshot, authorLabel) {
+  if (!validSnapshot(snapshot)) return { authorLabel, companionKnown: false };
+  return { ...display(snapshot, `当时由${snapshot.partner.displayName}陪伴`), authorLabel };
+}