@mjasnikovs/pi-task 0.6.0 → 0.7.1

package/dist/remote/server.js

@@ -2,8 +2,11 @@ import { createServer } from 'node:http';
 import { networkInterfaces } from 'node:os';
 import { WebSocketServer } from 'ws';
 import { addClient, removeClient, clientCount, broadcast, sendTo } from './broadcast.js';
-import { getBridge, answerPrompt } from './bridge.js';
+import { answerPrompt } from './bridge.js';
+import { getState, snapshot } from './session-state.js';
 import { isClientMessage } from './protocol.js';
+import { swJs } from './sw.js';
+import { publicKey, addSubscription, getSubscriptions, logPush } from './push.js';
 export function getLocalIPs(nets = networkInterfaces()) {
     // Prefer Tailscale when available.
     let tailscale;
@@ -57,7 +60,7 @@ async function findPort(start, max) {
     }
     throw new Error(`No free port found in range ${start}–${start + max - 1}`);
 }
-export async function startServer(onMessage, getHtml, getHistory) {
+export async function startServer(onMessage, getHtml) {
     const port = await findPort(8800, 100);
     const ips = getLocalIPs();
     const ip = ips.primary;
@@ -68,6 +71,34 @@ export async function startServer(onMessage, getHtml, getHistory) {
             res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
             res.end(body);
         }
+        else if (req.method === 'GET' && req.url === '/sw.js') {
+            res.writeHead(200, { 'Content-Type': 'text/javascript; charset=utf-8' });
+            res.end(swJs());
+        }
+        else if (req.method === 'GET' && req.url === '/push-key') {
+            res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' });
+            res.end(publicKey());
+        }
+        else if (req.method === 'POST' && req.url === '/subscribe') {
+            const chunks = [];
+            req.on('data', c => chunks.push(c));
+            req.on('end', () => {
+                try {
+                    const sub = JSON.parse(Buffer.concat(chunks).toString());
+                    if (!sub || typeof sub.endpoint !== 'string')
+                        throw new Error('no endpoint');
+                    addSubscription(sub);
+                    logPush(`subscribe ${new URL(sub.endpoint).host} (total ${getSubscriptions().length})`);
+                    res.writeHead(201);
+                    res.end('ok');
+                }
+                catch {
+                    logPush('subscribe REJECTED (malformed body)');
+                    res.writeHead(400);
+                    res.end('bad subscription');
+                }
+            });
+        }
         else {
             res.writeHead(404);
             res.end('Not found');
@@ -88,16 +119,8 @@ export async function startServer(onMessage, getHtml, getHistory) {
         addClient(ws);
         handle.onFirstConnect?.();
         handle.onFirstConnect = null;
-        sendTo(ws, { type: 'history', turns: getHistory() });
-        const bridge = getBridge();
-        for (const [key, lines] of bridge.activeWidgets) {
-            sendTo(ws, { type: 'widget', key, lines });
-        }
-        if (bridge.activePrompt)
-            sendTo(ws, bridge.activePrompt);
-        if (bridge.lastContextUsage) {
-            sendTo(ws, { type: 'context', contextUsage: bridge.lastContextUsage });
-        }
+        // One authoritative snapshot — the client replaces its whole view with it.
+        sendTo(ws, snapshot());
         broadcast({ type: 'client_count', count: clientCount() });
         ws.on('message', data => {
             let msg;
@@ -115,7 +138,7 @@ export async function startServer(onMessage, getHtml, getHistory) {
             }
             // type === 'message': ignore while a prompt is pending (composer is
             // disabled in the browser; this is the server-side guard).
-            if (getBridge().activePrompt)
+            if (getState().prompt)
                 return;
             onMessage(msg.text);
         });

package/dist/remote/session-state.d.ts

@@ -0,0 +1,54 @@
+import { HistoryBuffer } from './history.js';
+import type { Turn, Part } from './history.js';
+import type { ContextUsage, PromptMessage } from './protocol.js';
+export interface LiveTurn {
+    /** Ordered assistant content (text segments + tool calls) for this run. */
+    parts: Part[];
+    /** Is the trailing text part still accumulating deltas? Closed by text_end /
+     *  a tool start, so the next text begins a fresh segment (separate bubble). */
+    textOpen: boolean;
+}
+export interface SnapshotMessage {
+    type: 'snapshot';
+    turns: Turn[];
+    live: LiveTurn | null;
+    agentRunning: boolean;
+    taskWidget: string[] | null;
+    prompt: PromptMessage | null;
+    context: ContextUsage | null;
+}
+interface SessionState {
+    history: HistoryBuffer;
+    live: LiveTurn | null;
+    agentRunning: boolean;
+    taskWidget: string[] | null;
+    prompt: PromptMessage | null;
+    context: ContextUsage | null;
+    /** Broadcast sink — swapped in tests via _setSink. */
+    sink: (msg: unknown) => void;
+}
+export declare function getState(): SessionState;
+/** @internal Test-only: swap the broadcast sink to capture emitted deltas. */
+export declare function _setSink(fn: (msg: unknown) => void): void;
+export declare function agentStart(): void;
+export declare function appendText(delta: string): void;
+export declare function textEnd(): void;
+export declare function startTool(toolCallId: string, toolName: string, args: unknown): void;
+export declare function updateTool(toolCallId: string, partialResult: unknown): void;
+export declare function endTool(toolCallId: string, toolName: string, result: unknown, isError: boolean): void;
+export declare function agentEnd(context: ContextUsage): void;
+export declare function addUserTurn(text: string): void;
+export declare function addError(message: string): void;
+/** A persistent inline note (committed to the transcript so it survives reconnect)
+ *  plus a live delta so connected clients render it immediately. */
+export declare function addSystemNote(text: string): void;
+/** The single task-widget slot. Empty/undefined lines clear it. */
+export declare function setTaskWidget(lines: string[] | null | undefined): void;
+export declare function setPrompt(prompt: PromptMessage): void;
+export declare function clearPrompt(id: string): void;
+export declare function setContext(context: ContextUsage): void;
+/** Wipe everything (new session) and tell connected clients to clear. */
+export declare function reset(): void;
+/** Serialize the whole state for a (re)connecting client. */
+export declare function snapshot(): SnapshotMessage;
+export {};

package/dist/remote/session-state.js

@@ -0,0 +1,179 @@
+// The single authoritative mirror of what a connected browser should be showing.
+//
+// Every change funnels through a mutator that (1) updates this object and (2)
+// broadcasts the matching live delta. On (re)connect the server serializes the
+// whole object with snapshot() and the client replaces its entire view. Because
+// the snapshot and the live deltas read/write the same object, they can never
+// disagree — which is what kills the duplicate-transcript / orphaned-widget /
+// two-task-widget drift the ad-hoc broadcasting used to cause.
+//
+// State lives on globalThis so it survives jiti module re-evaluation on session
+// switches, the same pattern broadcast.ts and bridge.ts use.
+import { broadcast as wsBroadcast } from './broadcast.js';
+import { HistoryBuffer } from './history.js';
+const g = globalThis;
+function fresh() {
+    return {
+        history: new HistoryBuffer(20),
+        live: null,
+        agentRunning: false,
+        taskWidget: null,
+        prompt: null,
+        context: null,
+        sink: wsBroadcast
+    };
+}
+export function getState() {
+    if (!g.__piSessionState)
+        g.__piSessionState = fresh();
+    return g.__piSessionState;
+}
+/** @internal Test-only: swap the broadcast sink to capture emitted deltas. */
+export function _setSink(fn) {
+    getState().sink = fn;
+}
+function ensureLive(s) {
+    if (!s.live)
+        s.live = { parts: [], textOpen: false };
+    return s.live;
+}
+// ─── Mutators ────────────────────────────────────────────────────────────────
+export function agentStart() {
+    const s = getState();
+    s.live = { parts: [], textOpen: false };
+    s.agentRunning = true;
+    s.sink({ type: 'agent_start' });
+}
+export function appendText(delta) {
+    const s = getState();
+    const live = ensureLive(s);
+    const last = live.parts[live.parts.length - 1];
+    if (live.textOpen && last && last.kind === 'text') {
+        last.text += delta;
+    }
+    else {
+        live.parts.push({ kind: 'text', text: delta });
+        live.textOpen = true;
+    }
+    s.sink({ type: 'text_delta', delta });
+}
+export function textEnd() {
+    const s = getState();
+    if (s.live)
+        s.live.textOpen = false; // next text starts a new segment
+    s.sink({ type: 'text_end' });
+}
+export function startTool(toolCallId, toolName, args) {
+    const s = getState();
+    const live = ensureLive(s);
+    live.textOpen = false;
+    live.parts.push({
+        kind: 'tool',
+        toolCallId,
+        toolName,
+        args,
+        result: undefined,
+        isError: false,
+        done: false
+    });
+    s.sink({ type: 'tool_start', toolCallId, toolName, args });
+}
+export function updateTool(toolCallId, partialResult) {
+    getState().sink({ type: 'tool_update', toolCallId, partialResult });
+}
+export function endTool(toolCallId, toolName, result, isError) {
+    const s = getState();
+    const live = ensureLive(s);
+    const part = live.parts.find((p) => p.kind === 'tool' && p.toolCallId === toolCallId);
+    if (part) {
+        part.result = result;
+        part.isError = isError;
+        part.done = true;
+    }
+    else {
+        // tool_end without a matching start (shouldn't happen) — append a done tool.
+        live.parts.push({
+            kind: 'tool',
+            toolCallId,
+            toolName,
+            args: undefined,
+            result,
+            isError,
+            done: true
+        });
+    }
+    s.sink({ type: 'tool_end', toolCallId, toolName, result, isError });
+}
+export function agentEnd(context) {
+    const s = getState();
+    if (s.live)
+        s.history.addAssistantTurn(s.live.parts);
+    s.live = null;
+    s.agentRunning = false;
+    s.context = context;
+    s.sink({ type: 'agent_end', contextUsage: context });
+}
+export function addUserTurn(text) {
+    const s = getState();
+    s.history.addUserMessage(text);
+    s.sink({ type: 'user_message', text });
+}
+export function addError(message) {
+    const s = getState();
+    s.history.addError(message);
+    s.live = null;
+    s.agentRunning = false;
+    s.sink({ type: 'agent_error', message });
+}
+/** A persistent inline note (committed to the transcript so it survives reconnect)
+ *  plus a live delta so connected clients render it immediately. */
+export function addSystemNote(text) {
+    const s = getState();
+    s.history.addSystemNote(text);
+    s.sink({ type: 'system_note', text });
+}
+/** The single task-widget slot. Empty/undefined lines clear it. */
+export function setTaskWidget(lines) {
+    const s = getState();
+    s.taskWidget = lines && lines.length ? lines : null;
+    s.sink({ type: 'widget', lines: s.taskWidget });
+}
+export function setPrompt(prompt) {
+    const s = getState();
+    s.prompt = prompt;
+    s.sink(prompt);
+}
+export function clearPrompt(id) {
+    const s = getState();
+    s.prompt = null;
+    s.sink({ type: 'prompt_resolved', id });
+}
+export function setContext(context) {
+    const s = getState();
+    s.context = context;
+    s.sink({ type: 'context', contextUsage: context });
+}
+/** Wipe everything (new session) and tell connected clients to clear. */
+export function reset() {
+    const s = getState();
+    s.history = new HistoryBuffer(20);
+    s.live = null;
+    s.agentRunning = false;
+    s.taskWidget = null;
+    s.prompt = null;
+    s.context = null;
+    s.sink({ type: 'reset' });
+}
+/** Serialize the whole state for a (re)connecting client. */
+export function snapshot() {
+    const s = getState();
+    return {
+        type: 'snapshot',
+        turns: s.history.getEntries(),
+        live: s.live ? { parts: [...s.live.parts], textOpen: s.live.textOpen } : null,
+        agentRunning: s.agentRunning,
+        taskWidget: s.taskWidget,
+        prompt: s.prompt,
+        context: s.context
+    };
+}

package/dist/remote/sw.d.ts

@@ -0,0 +1,8 @@
+/** Service worker source served at /sw.js. It must be a real same-origin URL
+ *  (a SW cannot be registered from a data: URL), and serving it at the root path
+ *  gives it root scope so it controls the whole app.
+ *
+ *  iOS home-screen PWAs deliver notifications ONLY through a service worker's
+ *  push event — the in-page `new Notification()` constructor is unavailable — so
+ *  this is the only path that reaches a backgrounded iPhone. */
+export declare function swJs(): string;

package/dist/remote/sw.js

@@ -0,0 +1,40 @@
+/** Service worker source served at /sw.js. It must be a real same-origin URL
+ *  (a SW cannot be registered from a data: URL), and serving it at the root path
+ *  gives it root scope so it controls the whole app.
+ *
+ *  iOS home-screen PWAs deliver notifications ONLY through a service worker's
+ *  push event — the in-page `new Notification()` constructor is unavailable — so
+ *  this is the only path that reaches a backgrounded iPhone. */
+export function swJs() {
+    return `self.addEventListener('install', function () { self.skipWaiting(); });
+self.addEventListener('activate', function (e) { e.waitUntil(self.clients.claim()); });
+
+self.addEventListener('push', function (event) {
+  var data = {};
+  try { data = event.data ? event.data.json() : {}; } catch (e) { data = {}; }
+  var title = data.title || 'pi-task remote';
+  var options = { body: data.body || '', tag: data.tag, renotify: !!data.tag };
+  event.waitUntil(
+    self.clients.matchAll({ type: 'window', includeUncontrolled: true }).then(function (cs) {
+      // Skip the banner if a window is already focused — the in-page UI shows it.
+      for (var i = 0; i < cs.length; i++) {
+        if (cs[i].visibilityState === 'visible' && cs[i].focused) return;
+      }
+      return self.registration.showNotification(title, options);
+    })
+  );
+});
+
+self.addEventListener('notificationclick', function (event) {
+  event.notification.close();
+  event.waitUntil(
+    self.clients.matchAll({ type: 'window', includeUncontrolled: true }).then(function (cs) {
+      for (var i = 0; i < cs.length; i++) {
+        if ('focus' in cs[i]) return cs[i].focus();
+      }
+      if (self.clients.openWindow) return self.clients.openWindow('/');
+    })
+  );
+});
+`;
+}