@neolio42/pixel-office 0.1.0

package/scripts/setup.ts

@@ -0,0 +1,158 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+const SETTINGS_PATH = join(homedir(), '.claude', 'settings.json');
+const CLAUDE_DIR = join(homedir(), '.claude');
+const BASE_URL = 'http://localhost:3000/api/hooks';
+const MARKER = 'pixel-office'; // used to identify our hooks
+
+// TTY enrichment prefix — detects the terminal device for session linking
+const TTY_PREFIX = [
+  '[ "$PIXEL_OFFICE_HAIKU" = "1" ] && exit 0',
+  'RAW_TTY=$(ps -o tty= -p $PPID 2>/dev/null | tr -d \' \')',
+  '[ -n "$RAW_TTY" ] && [ "$RAW_TTY" != "??" ] && TTY="/dev/$RAW_TTY" || TTY=""',
+  'INPUT=$(cat)',
+].join('; ');
+
+// Simple prefix — just read stdin and bail if disabled
+const SIMPLE_PREFIX = '[ "$PIXEL_OFFICE_HAIKU" = "1" ] && exit 0; INPUT=$(cat)';
+
+function curlCmd(endpoint: string, maxTime: number, enrichTty: boolean): string {
+  if (enrichTty) {
+    const body = `$(echo "$INPUT" | jq -c --arg tty "$TTY" '. + {tty: $tty}' 2>/dev/null || echo "$INPUT")`;
+    return `${TTY_PREFIX}; curl -sf -X POST ${BASE_URL}/${endpoint} -H 'Content-Type: application/json' -d "${body}" --max-time ${maxTime} 2>/dev/null || true`;
+  }
+  return `${SIMPLE_PREFIX}; curl -sf -X POST ${BASE_URL}/${endpoint} -H 'Content-Type: application/json' -d "$INPUT" --max-time ${maxTime} 2>/dev/null || true`;
+}
+
+interface HookEntry {
+  matcher?: string;
+  hooks: { type: string; command: string; timeout: number }[];
+}
+
+const PIXEL_OFFICE_HOOKS: Record<string, HookEntry> = {
+  SessionStart: {
+    hooks: [{ type: 'command', command: curlCmd('session-start', 5, true), timeout: 5 }],
+  },
+  PreToolUse: {
+    hooks: [{ type: 'command', command: curlCmd('pre-tool-use', 30, true), timeout: 30 }],
+  },
+  PostToolUse: {
+    hooks: [{ type: 'command', command: curlCmd('post-tool-use', 5, false), timeout: 5 }],
+  },
+  Notification: {
+    hooks: [{ type: 'command', command: curlCmd('notification', 5, false), timeout: 5 }],
+  },
+  UserPromptSubmit: {
+    hooks: [{ type: 'command', command: curlCmd('user-prompt', 5, false), timeout: 5 }],
+  },
+  Stop: {
+    hooks: [{ type: 'command', command: curlCmd('stop', 5, false), timeout: 5 }],
+  },
+  SessionEnd: {
+    hooks: [{ type: 'command', command: curlCmd('session-end', 5, false), timeout: 5 }],
+  },
+};
+
+function readSettings(): Record<string, unknown> {
+  if (!existsSync(SETTINGS_PATH)) {
+    mkdirSync(CLAUDE_DIR, { recursive: true });
+    return {};
+  }
+  return JSON.parse(readFileSync(SETTINGS_PATH, 'utf-8'));
+}
+
+function writeSettings(settings: Record<string, unknown>): void {
+  writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2) + '\n');
+}
+
+function hasPixelOfficeHook(entries: HookEntry[]): boolean {
+  return entries.some((entry) =>
+    entry.hooks?.some((h) => typeof h.command === 'string' && h.command.includes(MARKER))
+  );
+}
+
+// --- Install ---
+function install(): void {
+  const settings = readSettings();
+  const hooks = (settings.hooks ?? {}) as Record<string, HookEntry[]>;
+  let added = 0;
+
+  for (const [event, entry] of Object.entries(PIXEL_OFFICE_HOOKS)) {
+    const existing = hooks[event] ?? [];
+    if (hasPixelOfficeHook(existing)) {
+      console.log(`  ⏭  ${event} — already registered`);
+      continue;
+    }
+    hooks[event] = [...existing, entry];
+    console.log(`  ✓  ${event}`);
+    added++;
+  }
+
+  settings.hooks = hooks;
+  writeSettings(settings);
+
+  if (added === 0) {
+    console.log('\nAll hooks already registered. Nothing to do.');
+  } else {
+    console.log(`\n${added} hook(s) added to ${SETTINGS_PATH}`);
+  }
+
+  console.log('\nStart Pixel Office:  npm run dev');
+  console.log('Open:                http://localhost:3000');
+  console.log('Then start any Claude Code session — a worker will appear.\n');
+}
+
+// --- Uninstall ---
+function uninstall(): void {
+  if (!existsSync(SETTINGS_PATH)) {
+    console.log('No settings file found. Nothing to remove.');
+    return;
+  }
+
+  const settings = readSettings();
+  const hooks = (settings.hooks ?? {}) as Record<string, HookEntry[]>;
+  let removed = 0;
+
+  for (const event of Object.keys(hooks)) {
+    const before = hooks[event].length;
+    hooks[event] = hooks[event].filter(
+      (entry) => !entry.hooks?.some((h) => typeof h.command === 'string' && h.command.includes(MARKER))
+    );
+    const diff = before - hooks[event].length;
+    if (diff > 0) {
+      console.log(`  ✓  ${event} — removed`);
+      removed += diff;
+    }
+    // Clean up empty arrays
+    if (hooks[event].length === 0) {
+      delete hooks[event];
+    }
+  }
+
+  if (Object.keys(hooks).length === 0) {
+    delete settings.hooks;
+  } else {
+    settings.hooks = hooks;
+  }
+
+  writeSettings(settings);
+
+  if (removed === 0) {
+    console.log('No Pixel Office hooks found. Nothing to remove.');
+  } else {
+    console.log(`\n${removed} hook(s) removed from ${SETTINGS_PATH}`);
+  }
+}
+
+// --- CLI ---
+const cmd = process.argv[2];
+
+console.log('\n  Pixel Office — Hook Manager\n');
+
+if (cmd === 'uninstall') {
+  uninstall();
+} else {
+  install();
+}

package/server.ts

@@ -0,0 +1,53 @@
+import { createServer } from 'http';
+import next from 'next';
+import { initWSS, broadcast } from './src/lib/ws-server';
+import { cleanupStaleSessions, getAllSessions } from './src/lib/store';
+import { getAllPtyEntries, killPty } from './src/lib/pty-manager';
+
+// Use globalThis to avoid duplicate intervals across module re-evaluations.
+declare global {
+  // eslint-disable-next-line no-var
+  var __staleSessionCleanup: ReturnType<typeof setInterval> | undefined;
+}
+
+const dev = process.env.NODE_ENV !== 'production';
+const port = parseInt(process.env.PORT || '3000', 10);
+
+const app = next({ dev });
+const handle = app.getRequestHandler();
+
+app.prepare().then(() => {
+  const server = createServer((req, res) => {
+    handle(req, res);
+  });
+
+  initWSS(server);
+
+  // Stale session cleanup is a safety net only — normal cleanup happens via
+  // SessionEnd hooks when terminals close. This catches crashed/force-killed
+  // sessions that never sent SessionEnd. 30 min timeout, checks every 5 min.
+  if (!globalThis.__staleSessionCleanup) {
+    globalThis.__staleSessionCleanup = setInterval(() => {
+      const isAlivePty = (ptyId: string) => { const e = getAllPtyEntries().find(p => p.ptyId === ptyId); return !!e && !e.exited; };
+      const removed = cleanupStaleSessions(30 * 60_000, isAlivePty);
+      for (const sessionId of removed) {
+        console.log(`[cleanup] Removed stale session: ${sessionId}`);
+        broadcast({ type: 'session-remove', sessionId });
+      }
+
+      // Clean up orphaned PTYs — exited PTYs with no active session
+      // Don't kill live unlinked PTYs — they may be waiting for re-link after /clear
+      const activePtyIds = new Set(getAllSessions().filter(s => s.ptyId).map(s => s.ptyId!));
+      for (const entry of getAllPtyEntries()) {
+        if (!activePtyIds.has(entry.ptyId) && entry.exited) {
+          killPty(entry.ptyId);
+          console.log(`[cleanup] Removed orphaned PTY: ${entry.ptyId}`);
+        }
+      }
+    }, 5 * 60_000);
+  }
+
+  server.listen(port, () => {
+    console.log(`> Pixel Office ready on http://localhost:${port}`);
+  });
+});

package/src/app/api/focus-terminal/route.ts

@@ -0,0 +1,65 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { execSync } from 'child_process';
+import { getSession } from '@/lib/store';
+
+export async function POST(req: NextRequest) {
+  const body = await req.json();
+  const { sessionId } = body;
+
+  if (!sessionId) {
+    return NextResponse.json({ error: 'Missing sessionId' }, { status: 400 });
+  }
+
+  const session = getSession(sessionId);
+  if (!session) {
+    return NextResponse.json({ error: 'Session not found' }, { status: 404 });
+  }
+
+  const tty = session.tty; // e.g. /dev/ttys003
+
+  try {
+    if (tty) {
+      // Match iTerm2 session by tty — this is the exact terminal
+      const script = `
+tell application "iTerm2"
+  activate
+  repeat with w in windows
+    repeat with t in tabs of w
+      repeat with s in sessions of t
+        set sessionTTY to tty of s
+        if sessionTTY is "${tty}" then
+          select t
+          select s
+          set index of w to 1
+          return "found"
+        end if
+      end repeat
+    end repeat
+  end repeat
+end tell
+return "not_found"
+`;
+
+      const result = execSync('osascript -', {
+        input: script,
+        encoding: 'utf-8',
+        timeout: 3000,
+      }).trim();
+
+      if (result === 'found') {
+        return NextResponse.json({ ok: true, cwd: session.cwd, tty, matched: true });
+      }
+    }
+
+    // Fallback: just activate iTerm2
+    execSync('osascript -e \'tell application "iTerm2" to activate\'', { timeout: 2000 });
+    return NextResponse.json({ ok: true, cwd: session.cwd, tty, matched: false });
+  } catch {
+    try {
+      execSync('osascript -e \'tell application "iTerm2" to activate\'', { timeout: 2000 });
+    } catch {
+      // iTerm2 not running
+    }
+    return NextResponse.json({ ok: true, cwd: session.cwd, tty, matched: false });
+  }
+}

package/src/app/api/hooks/notification/route.ts

@@ -0,0 +1,19 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getSession, updateSession } from '@/lib/store';
+import { broadcast } from '@/lib/ws-server';
+
+export async function POST(req: NextRequest) {
+  const body = await req.json();
+  const sessionId = body.session_id;
+  const message = body.message || body.notification || '';
+
+  // Notification = Claude is asking the user something, worker goes idle
+  const session = updateSession(sessionId, 'idle', null);
+  if (session) {
+    broadcast({ type: 'session-update', session });
+  }
+
+  broadcast({ type: 'notification', sessionId, message });
+
+  return NextResponse.json({ status: 'ok' });
+}

package/src/app/api/hooks/post-tool-use/route.ts

@@ -0,0 +1,26 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getSession, addSession, updateSession } from '@/lib/store';
+import { broadcast } from '@/lib/ws-server';
+
+export async function POST(req: NextRequest) {
+  const body = await req.json();
+  const sessionId = body.session_id;
+  const cwd = body.cwd || '';
+
+  // Auto-create session if it doesn't exist (e.g. session-start was missed)
+  if (!getSession(sessionId)) {
+    addSession(sessionId, cwd);
+  }
+
+  // Don't set idle immediately — the next pre-tool-use will come within ms
+  // for rapid tool calls. Instead, just update lastSeen and let the client
+  // handle the idle transition after a timeout.
+  const session = getSession(sessionId);
+  if (session) {
+    session.lastSeen = Date.now();
+    session.currentTool = null;
+    broadcast({ type: 'session-update', session });
+  }
+
+  return NextResponse.json({ status: 'ok' });
+}

package/src/app/api/hooks/pre-tool-use/route.ts

@@ -0,0 +1,189 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { execSync } from 'child_process';
+import { getSession, addSession, updateSession, updateSessionTty, addToolCall, setSessionPlanMode, setSessionTask, setSessionFocus } from '@/lib/store';
+import { classifyTool } from '@/lib/tool-classifier';
+import { createApproval } from '@/lib/approval-queue';
+import { broadcast, hasConnectedClients } from '@/lib/ws-server';
+import { readTaskFromTranscript, readLatestAssistantMessage } from '@/lib/transcript';
+
+/**
+ * Extract a focus title from Claude's assistant response text.
+ * Claude's first sentence typically states what it's going to do:
+ *   "Let me fix the heuristic extraction..." → "Fix the heuristic extraction"
+ *   "I'll update the WorkerPanel component" → "Update the WorkerPanel component"
+ */
+/** Action verbs — things Claude says it's DOING. Matches verb roots + suffixes (fixing, edited, etc). */
+const ACTION_RE = /\b(fix|add|remove|delet|creat|updat|build|clean|mak|implement|refactor|debug|check|test|writ|mov|renam|chang|set|configur|deploy|push|install|upgrad|migrat|convert|pars|extract|handl|show|hid|enabl|disabl|run|start|stop|appl|us|open|clos|review|audit|verif|ensur|improv|optimiz|rewrit|redesign|simplif|merg|split|connect|wir|hook|scaffold|setup|integrat|strip|display|render|put|read|edit|search|reload|restart|clear|address|increas|bump|simulat|forc)\w*\b/i;
+
+function extractFocusFromAssistant(text: string): string | null {
+  // Split into sentences (by newlines and punctuation), scan first ~8
+  const sentences = text.split(/(?<=[.!?\n])\s+/).slice(0, 8);
+
+  const STRIP = [
+    /^(let me|I'll|I will|I'm going to|I need to|I want to|I should|I can)\s+/i,
+    /^(now |first |here's what|okay |ok |sure |right |alright |also )/i,
+    /^(let's |we'll |we need to |we should )/i,
+    /^(you're right\.?\s*)/i,
+    /^(good news:?\s*)/i,
+    /^(I'?m sorry\.?\s*)/i,
+  ];
+
+  // Skip patterns — observations, not actions
+  const SKIP = /^(here|the |this |that |there |it |I see|I can see|looking at|based on|but |so |and |two |one |a |an |for |with |since |because |if |when |after |before |no |yes |not )/i;
+
+  for (const sent of sentences) {
+    let s = sent.trim();
+    if (s.length < 10) continue;
+    if (SKIP.test(s) && !ACTION_RE.test(s.slice(0, 40))) continue;
+
+    // Strip assistant-style prefixes
+    for (const p of STRIP) {
+      s = s.replace(p, '');
+    }
+    s = s.trim();
+
+    if (s.length < 12) continue;
+    // After stripping, must contain an action verb
+    if (!ACTION_RE.test(s.slice(0, 50))) continue;
+
+    // Clean up
+    s = s.replace(/[.!:]+$/, '').replace(/\s*[—–\-]\s*$/, '').trim();
+
+    // Capitalize
+    if (s.length > 0) s = s[0].toUpperCase() + s.slice(1);
+
+    if (s.length < 10) continue;
+    return s;
+  }
+
+  return null;
+}
+
+export async function POST(req: NextRequest) {
+  const body = await req.json();
+  const sessionId = body.session_id;
+  const toolName = body.tool_name || 'Unknown';
+  const toolInput = body.tool_input || {};
+  const cwd = body.cwd || '';
+  const tty = body.tty || '';
+  const transcriptPath = body.transcript_path || undefined;
+
+  // Auto-create session if it doesn't exist (e.g. session-start was missed)
+  if (!getSession(sessionId)) {
+    addSession(sessionId, cwd, tty, transcriptPath);
+  } else if (tty) {
+    updateSessionTty(sessionId, tty);
+  }
+
+  // Fallback: if session has no task yet and transcript_path exists, try reading it
+  const existingSession = getSession(sessionId);
+  if (existingSession && !existingSession.task && (transcriptPath || existingSession.transcriptPath)) {
+    const tp = transcriptPath || existingSession.transcriptPath;
+    if (tp) {
+      if (!existingSession.transcriptPath) existingSession.transcriptPath = tp;
+      readTaskFromTranscript(tp).then((task) => {
+        if (task) {
+          const updated = setSessionTask(sessionId, task);
+          if (updated) broadcast({ type: 'session-update', session: updated });
+        }
+      }).catch(() => {});
+    }
+  }
+
+  // If UserPromptSubmit flagged a focus update, read the latest assistant message
+  if (existingSession?.needsFocusUpdate && (transcriptPath || existingSession.transcriptPath)) {
+    existingSession.needsFocusUpdate = false;
+    const tp = transcriptPath || existingSession.transcriptPath;
+    if (tp) {
+      readLatestAssistantMessage(tp).then((text) => {
+        if (!text) return;
+        const focus = extractFocusFromAssistant(text);
+        if (focus) {
+          const updated = setSessionFocus(sessionId, focus);
+          if (updated) broadcast({ type: 'session-update', session: updated });
+        }
+      }).catch(() => {});
+    }
+  }
+
+  // Handle plan mode transitions
+  if (toolName === 'EnterPlanMode') {
+    const updated = setSessionPlanMode(sessionId, true);
+    if (updated) broadcast({ type: 'session-update', session: updated });
+    return NextResponse.json({
+      hookSpecificOutput: {
+        hookEventName: 'PreToolUse',
+        permissionDecision: 'allow',
+        permissionDecisionReason: 'Auto-approved by Pixel Office',
+      },
+    });
+  }
+  if (toolName === 'ExitPlanMode') {
+    const updated = setSessionPlanMode(sessionId, false);
+    if (updated) broadcast({ type: 'session-update', session: updated });
+    return NextResponse.json({
+      hookSpecificOutput: {
+        hookEventName: 'PreToolUse',
+        permissionDecision: 'allow',
+        permissionDecisionReason: 'Auto-approved by Pixel Office',
+      },
+    });
+  }
+
+  // Record the tool call before classification
+  addToolCall(sessionId, toolName, toolInput);
+
+  const { state, needsApproval } = classifyTool(toolName, toolInput);
+
+  // Update worker state
+  const session = updateSession(sessionId, state, toolName);
+  if (session) {
+    broadcast({ type: 'session-update', session });
+  }
+
+  if (!needsApproval) {
+    return NextResponse.json({
+      hookSpecificOutput: {
+        hookEventName: 'PreToolUse',
+        permissionDecision: 'allow',
+        permissionDecisionReason: 'Auto-approved by Pixel Office',
+      },
+    });
+  }
+
+  // No browser connected — fall through so Claude Code handles approval in terminal
+  if (!hasConnectedClients()) {
+    console.log(`[Hook] No browser connected, falling through for ${toolName}`);
+    return NextResponse.json({});
+  }
+
+  // Play notification sound so the boss knows
+  try {
+    execSync('afplay /System/Library/Sounds/Bottle.aiff &', { timeout: 1000 });
+  } catch { /* ignore */ }
+
+  // Needs approval — block until boss decides in the browser
+  const { approval, promise } = createApproval(sessionId, toolName, toolInput);
+
+  broadcast({
+    type: 'approval-request',
+    approval: {
+      id: approval.id,
+      sessionId: approval.sessionId,
+      toolName: approval.toolName,
+      toolInput: approval.toolInput,
+    },
+  });
+
+  console.log(`[Hook] Awaiting approval for ${toolName} in session ${sessionId}`);
+  const decision = await promise;
+  console.log(`[Hook] Decision for ${toolName}: ${decision}`);
+
+  return NextResponse.json({
+    hookSpecificOutput: {
+      hookEventName: 'PreToolUse',
+      permissionDecision: decision,
+      permissionDecisionReason: decision === 'allow' ? 'Boss approved' : 'Boss denied',
+    },
+  });
+}

package/src/app/api/hooks/session-end/route.ts

@@ -0,0 +1,31 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getSession, removeSession, updateSession } from '@/lib/store';
+import { broadcast } from '@/lib/ws-server';
+import { unlinkSessionFromPty, getPtyEntry, killPty } from '@/lib/pty-manager';
+
+export async function POST(req: NextRequest) {
+  const body = await req.json();
+  const sessionId = body.session_id;
+
+  const session = getSession(sessionId);
+  if (session?.ptyId) {
+    const ptyEntry = getPtyEntry(session.ptyId);
+    if (ptyEntry && !ptyEntry.exited) {
+      // PTY is still alive — keep the session but mark it idle and unlink.
+      // The terminal is still usable (user can type new prompts).
+      // A new session-start will re-link when Claude restarts.
+      unlinkSessionFromPty(session.ptyId);
+      const updated = updateSession(sessionId, 'idle', null);
+      if (updated) broadcast({ type: 'session-update', session: updated });
+      console.log(`[Hook] Session ended (PTY alive, keeping): ${sessionId}`);
+      return NextResponse.json({ status: 'ok' });
+    }
+  }
+
+  // No PTY or PTY already exited — fully remove
+  if (session?.ptyId) killPty(session.ptyId);
+  removeSession(sessionId);
+  broadcast({ type: 'session-remove', sessionId });
+  console.log(`[Hook] Session ended: ${sessionId}`);
+  return NextResponse.json({ status: 'ok' });
+}

package/src/app/api/hooks/session-start/route.ts

@@ -0,0 +1,47 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { addSession, getAllSessions, removeSession, setSessionTask } from '@/lib/store';
+import { broadcast } from '@/lib/ws-server';
+import { readTaskFromTranscript } from '@/lib/transcript';
+import { findPtyByTty, findPtyByCwd, linkSessionToPty } from '@/lib/pty-manager';
+
+export async function POST(req: NextRequest) {
+  const body = await req.json();
+  const sessionId = body.session_id;
+  const cwd = body.cwd || '';
+  const tty = body.tty || '';
+  const transcriptPath = body.transcript_path || undefined;
+
+  const session = addSession(sessionId, cwd, tty, transcriptPath);
+
+  // Link to embedded PTY — try tty match first, then cwd match as fallback
+  let ptyEntry = tty ? findPtyByTty(tty) : undefined;
+  if (!ptyEntry && cwd) {
+    ptyEntry = findPtyByCwd(cwd);
+  }
+  if (ptyEntry) {
+    linkSessionToPty(sessionId, ptyEntry.ptyId);
+    session.ptyId = ptyEntry.ptyId;
+    // Remove orphan sessions from previous /clear cycles on the same PTY
+    for (const s of getAllSessions()) {
+      if (s.sessionId !== sessionId && s.ptyId === ptyEntry.ptyId) {
+        removeSession(s.sessionId);
+      }
+    }
+  }
+
+  broadcast({ type: 'sessions', sessions: getAllSessions() });
+
+  console.log(`[Hook] Session started: ${sessionId}`);
+
+  // Async: read the task from the JSONL transcript (don't block the hook response)
+  if (transcriptPath) {
+    readTaskFromTranscript(transcriptPath).then((task) => {
+      if (task) {
+        const updated = setSessionTask(sessionId, task);
+        if (updated) broadcast({ type: 'session-update', session: updated });
+      }
+    }).catch(() => {});
+  }
+
+  return NextResponse.json({ status: 'ok' });
+}

package/src/app/api/hooks/stop/route.ts

@@ -0,0 +1,19 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getSession, addSession, updateSession } from '@/lib/store';
+import { broadcast } from '@/lib/ws-server';
+
+export async function POST(req: NextRequest) {
+  const body = await req.json();
+  const sessionId = body.session_id;
+
+  if (!getSession(sessionId)) {
+    addSession(sessionId, '');
+  }
+
+  const session = updateSession(sessionId, 'idle', null);
+  if (session) {
+    broadcast({ type: 'session-update', session });
+  }
+
+  return NextResponse.json({ status: 'ok' });
+}