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

package/renderer/motion-facts.mjs

@@ -0,0 +1,108 @@
+const validId = value => typeof value === 'string' && value.length > 0 && value.length <= 256;
+const validExpiry = (value, now) => Number.isFinite(value) && value > now;
+const workKinds = new Set(['reasoning', 'tool', 'workspace', 'screen_reading']);
+const normalizeTravel = (travel, now, suppressed) => travel && validId(travel.eventId)
+  && travel.status === 'active' && Number.isFinite(travel.dx) && Number.isFinite(travel.dy)
+  && Math.hypot(travel.dx, travel.dy) >= 1 && validExpiry(travel.expiresAt, now)
+  && !suppressed.has(travel.eventId)
+  ? { eventId: travel.eventId, dx: travel.dx, dy: travel.dy, expiresAt: travel.expiresAt } : null;
+
+/** A bounded, expiring projection of Host-owned motion facts. */
+export class MotionFacts {
+  constructor({ now, setTimer, clearTimer, changed }) {
+    this.now = now;
+    this.setTimer = setTimer;
+    this.clearTimer = clearTimer;
+    this.changed = changed;
+    this.snapshot = { work: null, delivery: null, travel: null };
+    this.seenResults = new Map();
+    this.suppressedTravel = new Map();
+  }
+
+  sync(value, suppressTravel = false) {
+    const now = this.now();
+    this.prune(now);
+    const input = value && typeof value === 'object' ? value : {};
+    const work = input.work;
+    const delivery = input.delivery;
+    const travel = input.travel;
+    this.snapshot = {
+      work: work && validId(work.taskId) && work.status === 'active' && workKinds.has(work.kind)
+        && validExpiry(work.expiresAt, now)
+        ? { taskId: work.taskId, kind: work.kind, expiresAt: work.expiresAt } : null,
+      delivery: delivery && validId(delivery.resultId) && delivery.status === 'applied'
+        && validExpiry(delivery.expiresAt, now)
+        ? { resultId: delivery.resultId, expiresAt: delivery.expiresAt } : null,
+      travel: normalizeTravel(travel, now, this.suppressedTravel),
+    };
+    if (suppressTravel) this.suppressTravel();
+    this.scheduleExpiry();
+  }
+
+  syncNative(value) {
+    const now = this.now();
+    this.prune(now);
+    const input = value && typeof value === 'object' ? value : {};
+    const work = input.work;
+    const delivery = input.delivery;
+    const travel = this.snapshot.travel?.expiresAt > now ? this.snapshot.travel : null;
+    this.snapshot = {
+      work: work && validId(work.taskId) && work.status === 'active' && workKinds.has(work.kind)
+        && validExpiry(work.expiresAt, now)
+        ? { taskId: work.taskId, kind: work.kind, expiresAt: work.expiresAt } : null,
+      delivery: delivery && validId(delivery.resultId) && delivery.status === 'applied'
+        && validExpiry(delivery.expiresAt, now)
+        ? { resultId: delivery.resultId, expiresAt: delivery.expiresAt } : null,
+      travel,
+    };
+    this.scheduleExpiry();
+  }
+
+  syncTravel(value, suppressTravel = false) {
+    const now = this.now();
+    this.prune(now);
+    this.snapshot.travel = normalizeTravel(value, now, this.suppressedTravel);
+    if (suppressTravel) this.suppressTravel();
+    this.scheduleExpiry();
+  }
+
+  consumeDelivery() {
+    const delivery = this.snapshot.delivery;
+    if (!delivery || this.seenResults.has(delivery.resultId)) return null;
+    this.seenResults.set(delivery.resultId, this.now() + 3_600_000);
+    return delivery;
+  }
+
+  suppressTravel() {
+    if (!this.snapshot.travel) return;
+    this.suppressedTravel.set(this.snapshot.travel.eventId, this.now() + 3_600_000);
+    this.snapshot.travel = null;
+    this.scheduleExpiry();
+  }
+
+  close() {
+    if (this.timer !== undefined) this.clearTimer(this.timer);
+    this.timer = undefined;
+  }
+
+  scheduleExpiry() {
+    this.close();
+    const expiries = Object.values(this.snapshot).filter(Boolean).map(value => value.expiresAt);
+    if (!expiries.length) return;
+    this.timer = this.setTimer(() => {
+      this.timer = undefined;
+      const now = this.now();
+      for (const key of ['work', 'delivery', 'travel']) {
+        if (this.snapshot[key]?.expiresAt <= now) this.snapshot[key] = null;
+      }
+      this.scheduleExpiry();
+      this.changed();
+    }, Math.max(0, Math.min(...expiries) - this.now()));
+  }
+
+  prune(now) {
+    for (const collection of [this.seenResults, this.suppressedTravel]) {
+      for (const [id, expiresAt] of collection) if (expiresAt <= now) collection.delete(id);
+    }
+  }
+}

package/renderer/native-window-travel.mjs

@@ -0,0 +1,89 @@
+const validPosition = value => value && Number.isFinite(value.x) && Number.isFinite(value.y);
+
+/** Observe the native window itself. Running animation follows measured desktop
+ * movement; renderer state never invents a target or claims a move succeeded. */
+export class NativeWindowTravel {
+  constructor({
+    readPosition,
+    changed,
+    now = Date.now,
+    setTimer = globalThis.setTimeout,
+    clearTimer = globalThis.clearTimeout,
+    intervalMs = 80,
+    expiresMs = 240,
+  }) {
+    this.readPosition = readPosition;
+    this.changed = changed;
+    this.now = now;
+    this.setTimer = (callback, delay) => setTimer.call(globalThis, callback, delay);
+    this.clearTimer = id => clearTimer.call(globalThis, id);
+    this.intervalMs = Math.max(32, intervalMs);
+    this.expiresMs = Math.max(this.intervalMs, expiresMs);
+    this.sequence = 0;
+    this.manual = false;
+    this.closed = false;
+    this.active = null;
+  }
+
+  start() {
+    if (this.closed || this.timer !== undefined) return;
+    this.previous = this.read();
+    this.schedule();
+  }
+
+  setManual(value) {
+    const manual = value === true;
+    if (manual === this.manual) return;
+    this.manual = manual;
+    this.previous = this.read();
+    if (manual) this.clearActive();
+  }
+
+  tick() {
+    this.timer = undefined;
+    if (this.closed) return;
+    const next = this.read();
+    const now = this.now();
+    if (next && this.previous) {
+      const dx = next.x - this.previous.x;
+      const dy = next.y - this.previous.y;
+      if (!this.manual && Math.hypot(dx, dy) >= 1) {
+        const eventId = this.active?.eventId ?? `native-${Math.trunc(now)}-${++this.sequence}`;
+        this.active = { eventId, status: 'active', dx, dy, expiresAt: now + this.expiresMs };
+        this.changed({ ...this.active });
+      } else if (this.active && this.active.expiresAt <= now) {
+        this.clearActive();
+      }
+    }
+    this.previous = next;
+    this.schedule();
+  }
+
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    if (this.timer !== undefined) this.clearTimer(this.timer);
+    this.timer = undefined;
+    this.clearActive();
+  }
+
+  read() {
+    try {
+      const value = this.readPosition();
+      return validPosition(value) ? { x: value.x, y: value.y } : null;
+    } catch {
+      return null;
+    }
+  }
+
+  schedule() {
+    if (this.closed || this.timer !== undefined) return;
+    this.timer = this.setTimer(() => this.tick(), this.intervalMs);
+  }
+
+  clearActive() {
+    if (!this.active) return;
+    this.active = null;
+    this.changed(null);
+  }
+}

package/renderer/native-work-motion.mjs

@@ -0,0 +1,39 @@
+const priority = { reasoning: 1, tool: 2, workspace_fetch: 3, workspace_dispatch: 4, screen_read: 5 };
+const semantic = {
+  reasoning: 'reasoning',
+  tool: 'tool',
+  workspace_fetch: 'workspace',
+  workspace_dispatch: 'workspace',
+  screen_read: 'screen_reading',
+};
+
+/** Normalize the Host's bounded call snapshot; never infer work from chat text. */
+export function normalizeNativeWork(value, now = Date.now()) {
+  if (!value || typeof value !== 'object' || !Array.isArray(value.active) || !Array.isArray(value.recent)) return null;
+  const active = value.active
+    .filter(entry => entry && semantic[entry.kind] && Number.isFinite(entry.expiresAt) && entry.expiresAt > now)
+    .sort((left, right) => priority[right.kind] - priority[left.kind] || right.startedAt - left.startedAt)[0];
+  const handed = [...value.recent].reverse().find(event => event?.kind === 'result'
+    && event.phase === 'result_handed_to_voice' && typeof event.resultId === 'string'
+    && event.resultId.length > 0 && Number.isFinite(event.expiresAt) && event.expiresAt > now);
+  return {
+    work: active ? { taskId: active.taskId, kind: semantic[active.kind], status: 'active', expiresAt: active.expiresAt } : null,
+    delivery: handed ? { resultId: handed.resultId, status: 'applied', expiresAt: handed.expiresAt } : null,
+    travel: null,
+  };
+}
+
+const workLabels = {
+  reasoning: '正在思考',
+  tool: '正在处理',
+  workspace: '正在处理家里的事务',
+  screen_reading: '正在查看共享画面',
+};
+
+/** Product wording for the same bounded work fact used by body motion. */
+export function nativeWorkLabel(snapshot, nativeActivity = 'none') {
+  const kind = snapshot
+    ? snapshot.work?.kind
+    : nativeActivity === 'reasoning' ? 'reasoning' : nativeActivity === 'tool_running' ? 'tool' : null;
+  return workLabels[kind] ?? '';
+}

package/renderer/peer.mjs

@@ -10,7 +10,7 @@ export class VoicePeer {
       }
     });
   }
-  async connect() { if (!this.closed) await this.client.connectAudio(); }
+  async connect(mode) { if (!this.closed) await this.client.connectAudio(mode); }
   muteMic(muted) { void this.client.muteMicrophone(muted).catch(() => this.failed()); }
   muteSpeaker(muted) { void this.client.muteSpeaker(muted).catch(() => this.failed()); }
   failed() { if (!this.closed) this.onEvent({ type: 'error', code: 'unavailable' }); }

package/renderer/pet-controls.mjs

@@ -1,29 +1,113 @@
 /** Transient controls. The Host owns native placement, movement and hiding. */
-export function bindPetControls(client, { action, error, changed }) {
+export function bindPetControls(client, {
+  action, error, changed, moved = () => {}, activate = () => false, escape = () => false,
+}) {
   const $ = id => document.getElementById(id);
   const body = $('pet');
-  let panel = 'none', layoutRevision = 0, drag, suppressClick = false;
+  const panelIds = ['actions', 'menu', 'chat', 'bubble', 'app-assist', 'decisions', 'transcript', 'settings'];
+  const callBubble = $('call-bubble');
+  const managedIds = [...panelIds, 'call-bubble'];
+  const desiredSizes = new WeakMap();
+  let panel = 'none', ambientPanel = 'none', layoutRevision = 0, layoutScheduled = false, drag, suppressClick = false;
+  const measure = node => {
+    if (!node) return { width: 120, height: 130 };
+    // Host placement is an applied cap, not the panel's desired geometry.
+    // Release it synchronously while measuring so CSS height and nested flex
+    // overflow can expose their natural demand, then restore it before paint.
+    const appliedMaxHeight = node.style.maxHeight;
+    node.style.maxHeight = '';
+    const desired = {
+      width: Math.min(420, Math.max(120, Math.ceil(Math.max(node.offsetWidth, node.scrollWidth)))),
+      height: Math.min(500, Math.max(32, Math.ceil(Math.max(node.offsetHeight, node.scrollHeight)))),
+    };
+    node.style.maxHeight = appliedMaxHeight;
+    return desired;
+  };
+  const hasCallBubble = () => callBubble?.querySelector('p:not([hidden])') !== null;
+  const callLayout = next => {
+    if (next !== 'actions') {
+      if (callBubble) callBubble.hidden = true;
+      return undefined;
+    }
+    const presentation = $('actions').dataset.presentation === 'controls' ? 'controls' : 'lite';
+    const call = { presentation };
+    if (callBubble && hasCallBubble()) {
+      callBubble.hidden = false;
+      call.bubble = measure(callBubble);
+    } else if (callBubble) callBubble.hidden = true;
+    return call;
+  };
+  const sizeKey = (desired, call) => [
+    desired.width, desired.height, call?.presentation ?? '',
+    call?.bubble?.width ?? '', call?.bubble?.height ?? '',
+  ].join(':');
   async function show(next) {
-    if (panel !== next && $(next)) $(next).style.maxHeight = '500px';
-    panel = next;
-    for (const id of ['actions', 'menu', 'chat']) $(id).hidden = id !== next;
-    body.setAttribute('aria-expanded', String(next !== 'none'));
+    if (next === 'none' && ambientPanel !== 'none') next = ambientPanel;
+    const previousPanel = panel;
     const node = $(next);
+    panel = next;
+    for (const id of panelIds) $(id).hidden = id !== next;
+    body.setAttribute('aria-expanded', String(!['none', 'bubble'].includes(next)));
+    const call = callLayout(next);
+    const desired = measure(node);
+    if (node) desiredSizes.set(node, sizeKey(desired, call));
     const revision = ++layoutRevision;
     try {
-      const placed = await client.layout(next, Math.max(120, Math.ceil(node?.offsetWidth ?? 120)), Math.max(32, Math.ceil(node?.offsetHeight ?? 130)));
+      const placed = await client.layout(next, desired.width, desired.height, call);
       if (revision !== layoutRevision) return;
       $('anchor').style.left = `${placed.pet.x}px`; $('anchor').style.top = `${placed.pet.y}px`;
       if (node) { node.style.left = `${placed.panel.x}px`; node.style.top = `${placed.panel.y}px`; node.style.maxHeight = `${placed.panel.height}px`; }
-      if (next === 'chat') $('message').focus({ preventScroll: true });
-      if (next === 'menu') $('menu').querySelector('button').focus({ preventScroll: true });
-      changed(next);
-    } catch (cause) { error(cause); }
+      if (callBubble) {
+        const visible = next === 'actions' && call?.bubble && placed.bubble;
+        callBubble.hidden = !visible;
+        if (visible) {
+          callBubble.style.left = `${placed.bubble.x}px`;
+          callBubble.style.top = `${placed.bubble.y}px`;
+          callBubble.style.maxHeight = `${placed.bubble.height}px`;
+        }
+      }
+      if (previousPanel !== next) {
+        if (next === 'chat') {
+          const mode = $('chat').dataset.replyMode;
+          const target = mode === 'reply'
+            ? ($('reply-close')?.hidden === false ? $('reply-close') : $('reply-retain'))
+            : mode === 'sent' ? $('reply-sent') : $('message');
+          target?.focus?.({ preventScroll: true });
+        }
+        if (next === 'transcript') $('call-message').focus({ preventScroll: true });
+        if (next === 'settings') $('settings-back').focus({ preventScroll: true });
+        if (next === 'decisions') $('decision-reload').focus({ preventScroll: true });
+        if (next === 'menu') $('menu').querySelector('button').focus({ preventScroll: true });
+        changed(next);
+      }
+    } catch (cause) {
+      if (revision !== layoutRevision) return;
+      panel = previousPanel;
+      for (const id of panelIds) $(id).hidden = id !== panel;
+      if (callBubble) callBubble.hidden = panel !== 'actions' || !hasCallBubble();
+      body.setAttribute('aria-expanded', String(!['none', 'bubble'].includes(panel)));
+      error(cause, { panel: next });
+    }
+  }
+  function remeasure() {
+    if (layoutScheduled) return;
+    layoutScheduled = true;
+    queueMicrotask(() => {
+      layoutScheduled = false;
+      const node = $(panel);
+      if (!node || node.hidden) return;
+      const call = callLayout(panel);
+      const desired = measure(node);
+      const key = sizeKey(desired, call);
+      if (desiredSizes.get(node) === key) return;
+      void show(panel);
+    });
   }
   body.onclick = event => {
     if (suppressClick) { suppressClick = false; return; }
     if (event.detail > 1) return;
-    void show(panel === 'actions' ? 'none' : 'actions');
+    if (activate('click')) return;
+    void show(panel === 'menu' ? 'none' : 'menu');
   };
   body.oncontextmenu = event => { event.preventDefault(); void show('menu'); };
   body.onkeydown = event => {
@@ -31,37 +115,65 @@ export function bindPetControls(client, { action, error, changed }) {
   };
   body.onpointerdown = event => {
     if (event.button !== 0) return;
-    drag = { id: event.pointerId, x: event.screenX, y: event.screenY };
+    const current = { id: event.pointerId, x: event.screenX, y: event.screenY, armed: false };
+    drag = current;
     body.setPointerCapture(event.pointerId);
-    void client.drag('start').catch(error);
+    void client.drag('start').then(() => { if (drag === current) current.armed = true; }).catch(error);
   };
   body.onpointermove = event => {
-    if (drag && Math.hypot(event.screenX - drag.x, event.screenY - drag.y) >= 6) suppressClick = true;
+    if (!drag) return;
+    const dx = event.screenX - drag.x, dy = event.screenY - drag.y;
+    if (Math.hypot(dx, dy) < 6) return;
+    suppressClick = true;
+    if (drag.armed) moved(dx, dy);
+    drag.x = event.screenX; drag.y = event.screenY;
   };
   for (const name of ['pointerup', 'pointercancel']) body.addEventListener(name, () => {
-    drag = undefined; void client.drag('end').catch(error);
+    drag = undefined; moved('stop'); void client.drag('end').catch(error);
   });
   document.addEventListener('pointerdown', event => {
     if (!event.target.closest('#anchor, .floating')) void show('none');
   });
   document.addEventListener('keydown', event => {
-    if (event.key === 'Escape' && panel !== 'none') { event.preventDefault(); void show('none'); body.focus(); }
+    if (event.key === 'Escape' && panel !== 'none') {
+      event.preventDefault();
+      if (!escape(panel)) void show('none');
+      body.focus();
+    }
   });
   document.querySelectorAll('[data-action]').forEach(button => button.onclick = () => {
     const kind = button.dataset.action;
-    if (kind === 'write' || kind === 'history') { void show('chat'); return; }
+    if (kind === 'write' || kind === 'history') { action(kind); void show('chat'); return; }
+    if (kind === 'transcript') { void show('transcript'); return; }
+    if (kind === 'settings') { void show('settings'); return; }
+    if (kind === 'decisions') { void show('decisions'); return; }
     if (kind === 'dismiss') { void show('none'); return; }
     action(kind);
   });
-  const sizes = new WeakMap();
-  const observer = new ResizeObserver(entries => {
-    for (const entry of entries) {
-      const size = `${entry.contentRect.width}:${entry.contentRect.height}`;
-      const previous = sizes.get(entry.target); sizes.set(entry.target, size);
-      if (previous && previous !== size && entry.target.id === panel && !entry.target.hidden) void show(panel);
-    }
+  const observer = new MutationObserver(records => {
+    const current = $(panel);
+    if (!current || current.hidden) return;
+    // Root visibility is already handled by show(). Descendant visibility and
+    // text/row mutations are content demand and may require a larger surface.
+    if (records.some(record => record.type !== 'attributes' || !managedIds.includes(record.target.id))) remeasure();
+  });
+  for (const id of panelIds) observer.observe($(id), {
+    subtree: true, childList: true, characterData: true, attributes: true, attributeFilter: ['hidden'],
+  });
+  if (callBubble) observer.observe(callBubble, {
+    subtree: true, childList: true, characterData: true, attributes: true, attributeFilter: ['hidden'],
   });
-  for (const id of ['actions', 'menu', 'chat']) observer.observe($(id));
   window.addEventListener('beforeunload', () => observer.disconnect());
-  return { get panel() { return panel; }, show, dismiss() { if (drag) suppressClick = true; void show('none'); } };
+  return {
+    get panel() { return panel; }, show, remeasure,
+    setAmbient(value) {
+      const next = value === true ? 'bubble' : value === false ? 'none' : value;
+      const ambientPanels = ['none', 'bubble', 'actions', 'app-assist'];
+      if (!ambientPanels.includes(next)) return Promise.resolve();
+      if (ambientPanel === next) return Promise.resolve();
+      ambientPanel = next;
+      return ambientPanels.includes(panel) ? show('none') : Promise.resolve();
+    },
+    dismiss() { if (drag) suppressClick = true; void show('none'); },
+  };
 }

package/renderer/pet-motion-assets.mjs

@@ -0,0 +1,22 @@
+// F229 pet.json frame durations, plus the three F258 rows pinned in source-lock.json.
+export const atlas = {
+  idle: { row: 0, frames: [1200, 400, 400, 500, 500, 800] },
+  'running-right': { row: 1, frames: [120, 120, 120, 120, 120, 120, 120, 220] },
+  'running-left': { row: 2, frames: [120, 120, 120, 120, 120, 120, 120, 220] },
+  waving: { row: 3, frames: [140, 140, 140, 280] },
+  jumping: { row: 4, frames: [140, 140, 140, 140, 280] },
+  failed: { row: 5, frames: [140, 140, 140, 140, 140, 140, 140, 240] },
+  waiting: { row: 6, frames: [150, 150, 150, 150, 150, 260] },
+  running: { row: 7, frames: [120, 120, 120, 120, 120, 220] },
+  review: { row: 8, frames: [150, 150, 150, 150, 150, 280] },
+};
+export const additional = {
+  sleeping: { file: 'xianxian-sleeping-row.png', frames: [700, 700, 700, 700, 700, 700] },
+  working: { file: 'xianxian-working-row.png', frames: [520, 560, 520, 640, 520, 560, 520, 640] },
+  staged_thought: { file: 'xianxian-staged-thought-row.png', frames: [1200, 500, 700, 900, 1200, 500] },
+};
+export const visualAlias = { fetching: 'working', studying: 'staged_thought', delivering: 'review', held: 'idle' };
+export const workAction = { reasoning: 'staged_thought', tool: 'working', workspace: 'fetching', screen_reading: 'studying' };
+export const signals = { connected: 'waving', received: 'jumping', failed: 'failed' };
+export const staticSkins = { 'ragdoll-v1': 'ragdoll-v1.png', 'yarn-ball': 'yarn-ball.png' };
+export const validId = value => typeof value === 'string' && value.length > 0 && value.length <= 256;