@neolio42/pixel-office 0.1.0

package/src/lib/transcript.ts

@@ -0,0 +1,109 @@
+import { access, constants, stat } from 'fs/promises';
+
+/**
+ * Read the initial user task from a Claude Code JSONL transcript.
+ * Reads the first ~20KB, finds the first `type: "user"` entry.
+ */
+export async function readTaskFromTranscript(path: string): Promise<string | null> {
+  try {
+    await access(path, constants.R_OK);
+  } catch {
+    return null;
+  }
+
+  try {
+    const info = await stat(path);
+    const readSize = Math.min(info.size, 20_000);
+    const buf = Buffer.alloc(readSize);
+    const { open } = await import('fs/promises');
+    const fh = await open(path, 'r');
+    await fh.read(buf, 0, readSize, 0);
+    await fh.close();
+
+    const chunk = buf.toString('utf-8');
+    const lines = chunk.split('\n').filter(l => l.length > 0);
+
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        if (entry.type !== 'user') continue;
+
+        const raw = extractText(entry);
+        if (!raw) return null;
+
+        const firstLine = raw.split('\n')
+          .map(l => l.trim())
+          .filter(l => l.length > 0)
+          .map(l => l.replace(/^#+\s*/, '').replace(/^implement\s+the\s+following\s+(plan|task|request):\s*/i, '').trim())
+          .filter(l => l.length > 3)[0];
+
+        return firstLine?.slice(0, 120) ?? raw.slice(0, 120);
+      } catch {
+        continue;
+      }
+    }
+  } catch {
+    return null;
+  }
+
+  return null;
+}
+
+/**
+ * Read the latest assistant message from a transcript JSONL.
+ * Reads the last ~30KB of the file (tail), finds the last `type: "assistant"`
+ * entry with text content.
+ */
+export async function readLatestAssistantMessage(path: string): Promise<string | null> {
+  try {
+    await access(path, constants.R_OK);
+  } catch {
+    return null;
+  }
+
+  try {
+    const info = await stat(path);
+    const tailSize = Math.min(info.size, 200_000);
+    const buf = Buffer.alloc(tailSize);
+    const { open } = await import('fs/promises');
+    const fh = await open(path, 'r');
+    await fh.read(buf, 0, tailSize, Math.max(0, info.size - tailSize));
+    await fh.close();
+
+    const chunk = buf.toString('utf-8');
+    const lines = chunk.split('\n').filter(l => l.length > 0);
+
+    // Walk backwards to find the last assistant text
+    for (let i = lines.length - 1; i >= 0; i--) {
+      try {
+        const entry = JSON.parse(lines[i]);
+        if (entry.type !== 'assistant') continue;
+
+        const text = extractText(entry);
+        if (text && text.length > 5) return text;
+      } catch {
+        continue;
+      }
+    }
+  } catch {
+    return null;
+  }
+
+  return null;
+}
+
+/** Extract text content from a JSONL entry (user or assistant). */
+function extractText(entry: { message?: { content?: unknown } }): string | null {
+  const content = entry.message?.content;
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) {
+    for (const block of content) {
+      if (typeof block === 'object' && block !== null && 'type' in block && 'text' in block) {
+        if ((block as { type: string }).type === 'text') {
+          return (block as { text: string }).text;
+        }
+      }
+    }
+  }
+  return null;
+}

package/src/lib/types.ts

@@ -0,0 +1,58 @@
+export type WorkerState = 'idle' | 'typing' | 'reading' | 'waiting' | 'walking';
+
+export interface Session {
+  sessionId: string;
+  deskIndex: number;
+  state: WorkerState;
+  currentTool: string | null;
+  cwd: string;
+  tty: string;
+  startedAt: number;
+  lastSeen: number;
+  recentTools: { toolName: string; summary: string; timestamp: number }[];
+  task?: string;
+  currentFocus?: string;
+  transcriptPath?: string;
+  inPlanMode?: boolean;
+  /** Set by UserPromptSubmit, cleared after first PreToolUse reads transcript. */
+  needsFocusUpdate?: boolean;
+  /** Present if this session was spawned by Pixel Office's embedded terminal. */
+  ptyId?: string;
+}
+
+export interface PendingApproval {
+  id: string;
+  sessionId: string;
+  toolName: string;
+  toolInput: Record<string, unknown>;
+  createdAt: number;
+  resolve: (decision: 'allow' | 'deny') => void;
+}
+
+export type WSMessageToClient =
+  | { type: 'sessions'; sessions: Session[] }
+  | { type: 'session-update'; session: Session }
+  | { type: 'session-remove'; sessionId: string }
+  | { type: 'approval-request'; approval: { id: string; sessionId: string; toolName: string; toolInput: Record<string, unknown> } }
+  | { type: 'approval-resolved'; approvalId: string }
+  | { type: 'notification'; sessionId: string; message: string }
+  | { type: 'terminal-output'; ptyId: string; data: string }
+  | { type: 'terminal-scrollback'; ptyId: string; data: string }
+  | { type: 'terminal-exited'; ptyId: string; exitCode: number }
+  | { type: 'spawn-result'; ptyId: string; success: boolean; error?: string };
+
+export type WSMessageFromClient =
+  | { type: 'approval-response'; approvalId: string; decision: 'allow' | 'deny' }
+  | { type: 'terminal-input'; ptyId: string; data: string }
+  | { type: 'terminal-resize'; ptyId: string; cols: number; rows: number }
+  | { type: 'terminal-subscribe'; ptyId: string; cols?: number; rows?: number }
+  | { type: 'terminal-unsubscribe'; ptyId: string }
+  | { type: 'spawn-session'; cwd: string; prompt?: string };
+
+export interface HookPayload {
+  session_id: string;
+  tool_name?: string;
+  tool_input?: Record<string, unknown>;
+  cwd?: string;
+  transcript_path?: string;
+}

package/src/lib/ws-server.ts

@@ -0,0 +1,270 @@
+import { WebSocketServer, WebSocket } from 'ws';
+import { IncomingMessage } from 'http';
+import { Server } from 'http';
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+import { WSMessageToClient, WSMessageFromClient } from './types';
+import { resolveApproval } from './approval-queue';
+import { getAllSessions } from './store';
+import {
+  spawnSession,
+  writeToPty,
+  resizePty,
+  getScrollback,
+  getPtyEntry,
+  setPtyOutputHandler,
+  setPtyExitHandler,
+} from './pty-manager';
+
+// Use globalThis so the same WSS instance is shared across
+// Next.js App Router module instances and the custom server.ts
+declare global {
+  // eslint-disable-next-line no-var
+  var __wss: WebSocketServer | undefined;
+  // eslint-disable-next-line no-var
+  var __wsClientMeta: WeakMap<WebSocket, { subscriptions: Set<string> }> | undefined;
+}
+
+function getWSS(): WebSocketServer | null {
+  return globalThis.__wss ?? null;
+}
+
+function getClientMeta(): WeakMap<WebSocket, { subscriptions: Set<string> }> {
+  if (!globalThis.__wsClientMeta) {
+    globalThis.__wsClientMeta = new WeakMap();
+  }
+  return globalThis.__wsClientMeta;
+}
+
+function ensureMeta(ws: WebSocket): { subscriptions: Set<string> } {
+  const map = getClientMeta();
+  let meta = map.get(ws);
+  if (!meta) {
+    meta = { subscriptions: new Set() };
+    map.set(ws, meta);
+  }
+  return meta;
+}
+
+export function initWSS(server: Server) {
+  const wss = new WebSocketServer({ noServer: true });
+  globalThis.__wss = wss;
+
+  // Wire PTY output/exit to subscriber-only delivery
+  setPtyOutputHandler((ptyId, data) => {
+    sendToSubscribers(ptyId, { type: 'terminal-output', ptyId, data });
+  });
+
+  setPtyExitHandler((ptyId, exitCode) => {
+    sendToSubscribers(ptyId, { type: 'terminal-exited', ptyId, exitCode });
+  });
+
+  server.on('upgrade', (req: IncomingMessage, socket, head) => {
+    if (req.url === '/ws') {
+      wss.handleUpgrade(req, socket, head, (ws) => {
+        wss.emit('connection', ws, req);
+      });
+    }
+  });
+
+  wss.on('connection', (ws: WebSocket) => {
+    console.log('[WS] Client connected');
+    ensureMeta(ws);
+
+    // Send current state snapshot so late-joining clients are in sync
+    // Strip ptyId from sessions whose PTY no longer exists
+    const sessions = getAllSessions().map(s => {
+      if (s.ptyId && !getPtyEntry(s.ptyId)) {
+        return { ...s, ptyId: undefined };
+      }
+      return s;
+    });
+    ws.send(JSON.stringify({ type: 'sessions', sessions }));
+
+    ws.on('message', (raw) => {
+      try {
+        const msg: WSMessageFromClient = JSON.parse(raw.toString());
+        handleClientMessage(ws, msg);
+      } catch (e) {
+        console.error('[WS] Bad message:', e);
+      }
+    });
+
+    ws.on('close', () => {
+      console.log('[WS] Client disconnected');
+    });
+
+    ws.on('error', (err) => {
+      console.error('[WS] Socket error:', err);
+    });
+  });
+}
+
+function handleClientMessage(ws: WebSocket, msg: WSMessageFromClient) {
+  switch (msg.type) {
+    case 'approval-response': {
+      const resolved = resolveApproval(msg.approvalId, msg.decision);
+      if (resolved) {
+        broadcast({ type: 'approval-resolved', approvalId: msg.approvalId });
+      }
+      break;
+    }
+
+    case 'spawn-session': {
+      console.log('[WS] spawn-session received:', msg.cwd);
+      try {
+        // Normalize cwd to a clean absolute path
+        const home: string = process.env.HOME || os.homedir() || '/tmp';
+        let cwd = msg.cwd.trim() || home;
+        // Expand ~ to home
+        if (cwd === '~' || cwd === '~/') {
+          cwd = home;
+        } else if (cwd.startsWith('~/')) {
+          cwd = path.join(home, cwd.slice(2));
+        } else if (!cwd.startsWith('/')) {
+          cwd = path.join(home, cwd);
+        }
+        cwd = path.resolve(cwd);
+        // If doesn't exist, try prepending home (catches "/Desktop" → "/Users/ned/Desktop")
+        // Uses realpathSync which is case-insensitive on macOS (HFS+/APFS)
+        let resolved: string | null = null;
+        try {
+          resolved = fs.realpathSync(cwd);
+        } catch {
+          try {
+            resolved = fs.realpathSync(path.join(home, cwd));
+          } catch { /* neither exists */ }
+        }
+        if (!resolved) {
+          throw new Error(`Directory not found: ${cwd}`);
+        }
+        cwd = resolved;
+        const isHome = cwd === home || cwd.startsWith(home + '/');
+        const isTmp = cwd === '/tmp' || cwd.startsWith('/tmp/') || cwd.startsWith('/private/tmp');
+        if (!isHome && !isTmp) {
+          throw new Error('Directory is outside home');
+        }
+        const entry = spawnSession(cwd);
+        ws.send(JSON.stringify({
+          type: 'spawn-result',
+          ptyId: entry.ptyId,
+          success: true,
+        } satisfies WSMessageToClient));
+      } catch (err) {
+        const error = err instanceof Error ? err.message : String(err);
+        console.error('[WS] Spawn failed:', error);
+        ws.send(JSON.stringify({
+          type: 'spawn-result',
+          ptyId: '',
+          success: false,
+          error,
+        } satisfies WSMessageToClient));
+      }
+      break;
+    }
+
+    case 'terminal-input': {
+      writeToPty(msg.ptyId, msg.data);
+      break;
+    }
+
+    case 'terminal-resize': {
+      resizePty(msg.ptyId, msg.cols, msg.rows);
+      break;
+    }
+
+    case 'terminal-subscribe': {
+      const meta = ensureMeta(ws);
+      const ptyEntry = getPtyEntry(msg.ptyId);
+      // If PTY doesn't exist or already exited, notify client immediately
+      if (!ptyEntry) {
+        ws.send(JSON.stringify({
+          type: 'terminal-exited',
+          ptyId: msg.ptyId,
+          exitCode: -1,
+        } satisfies WSMessageToClient));
+        break;
+      }
+      meta.subscriptions.add(msg.ptyId);
+      // Resize PTY to match client before sending scrollback
+      if (msg.cols && msg.rows) {
+        resizePty(msg.ptyId, msg.cols, msg.rows);
+      }
+      // Send scrollback to this client
+      const scrollback = getScrollback(msg.ptyId);
+      if (scrollback) {
+        ws.send(JSON.stringify({
+          type: 'terminal-scrollback',
+          ptyId: msg.ptyId,
+          data: scrollback,
+        } satisfies WSMessageToClient));
+      }
+      // If already exited, send exit event after scrollback
+      if (ptyEntry.exited) {
+        ws.send(JSON.stringify({
+          type: 'terminal-exited',
+          ptyId: msg.ptyId,
+          exitCode: ptyEntry.exitCode ?? -1,
+        } satisfies WSMessageToClient));
+      }
+      break;
+    }
+
+    case 'terminal-unsubscribe': {
+      const meta = ensureMeta(ws);
+      meta.subscriptions.delete(msg.ptyId);
+      break;
+    }
+  }
+}
+
+/** Send a message only to clients subscribed to a specific ptyId. */
+function sendToSubscribers(ptyId: string, data: WSMessageToClient) {
+  const wss = getWSS();
+  if (!wss) return;
+  const json = JSON.stringify(data);
+  const clientMeta = getClientMeta();
+  for (const client of wss.clients) {
+    if (client.readyState === WebSocket.OPEN) {
+      const meta = clientMeta.get(client);
+      if (meta?.subscriptions.has(ptyId)) {
+        client.send(json);
+      }
+    }
+  }
+}
+
+export function hasConnectedClients(): boolean {
+  const wss = getWSS();
+  if (!wss) return false;
+  for (const client of wss.clients) {
+    if (client.readyState === WebSocket.OPEN) return true;
+  }
+  return false;
+}
+
+export function broadcast(data: WSMessageToClient) {
+  const wss = getWSS();
+  if (!wss) {
+    console.warn('[WS] broadcast called but WSS not initialized');
+    return;
+  }
+  // Strip ptyId from sessions whose PTY no longer exists on server
+  if (data.type === 'sessions') {
+    data = {
+      ...data,
+      sessions: data.sessions.map(s =>
+        s.ptyId && !getPtyEntry(s.ptyId) ? { ...s, ptyId: undefined } : s
+      ),
+    };
+  } else if (data.type === 'session-update' && data.session.ptyId && !getPtyEntry(data.session.ptyId)) {
+    data = { ...data, session: { ...data.session, ptyId: undefined } };
+  }
+  const json = JSON.stringify(data);
+  for (const client of wss.clients) {
+    if (client.readyState === WebSocket.OPEN) {
+      client.send(json);
+    }
+  }
+}

package/tsconfig.json

@@ -0,0 +1,34 @@
+{
+  "compilerOptions": {
+    "target": "ES2017",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "react-jsx",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "include": [
+    "next-env.d.ts",
+    "**/*.ts",
+    "**/*.tsx",
+    ".next/types/**/*.ts",
+    ".next/dev/types/**/*.ts",
+    "**/*.mts"
+  ],
+  "exclude": ["node_modules"]
+}