upfynai-code 0.1.0 → 2.2.0

package/src/server/claude-session.ts

@@ -1,156 +0,0 @@
-import { spawn, type ChildProcess } from 'node:child_process';
-import { createInterface } from 'node:readline';
-import type { SDKMessage } from '../types/sdk-messages.js';
-
-interface SessionOptions {
-  cwd: string;
-  model?: string;
-  permissionMode?: string;
-  onMessage: (msg: SDKMessage) => void;
-}
-
-interface PendingPermission {
-  resolve: (approved: boolean) => void;
-}
-
-export class ClaudeSession {
-  private process: ChildProcess | null = null;
-  private options: SessionOptions;
-  private pendingPermissions = new Map<string, PendingPermission>();
-  private sessionId: string | null = null;
-  private isRunning = false;
-
-  constructor(options: SessionOptions) {
-    this.options = options;
-  }
-
-  async sendPrompt(prompt: string, resumeSessionId?: string): Promise<void> {
-    if (this.isRunning) {
-      // If already running with stream-json input, send as user message
-      if (this.process?.stdin?.writable) {
-        const msg = JSON.stringify({
-          type: 'user',
-          message: { role: 'user', content: prompt },
-        });
-        this.process.stdin.write(msg + '\n');
-        return;
-      }
-      throw new Error('Session is busy');
-    }
-
-    this.isRunning = true;
-
-    const args = [
-      '--print',
-      '--verbose',
-      '--output-format', 'stream-json',
-      '--input-format', 'stream-json',
-    ];
-
-    if (this.options.model) {
-      args.push('--model', this.options.model);
-    }
-
-    if (this.options.permissionMode && this.options.permissionMode !== 'default') {
-      args.push('--permission-mode', this.options.permissionMode);
-    }
-
-    if (resumeSessionId) {
-      args.push('--resume', resumeSessionId);
-    }
-
-    this.process = spawn('claude', args, {
-      stdio: ['pipe', 'pipe', 'pipe'],
-      cwd: this.options.cwd,
-      shell: true,
-    });
-
-    // Send the initial prompt
-    if (this.process.stdin) {
-      const msg = JSON.stringify({
-        type: 'user',
-        message: { role: 'user', content: prompt },
-      });
-      this.process.stdin.write(msg + '\n');
-    }
-
-    // Read NDJSON from stdout
-    if (this.process.stdout) {
-      const rl = createInterface({ input: this.process.stdout });
-      rl.on('line', (line: string) => {
-        if (!line.trim()) return;
-        try {
-          const event = JSON.parse(line) as SDKMessage;
-
-          // Track session ID
-          if (event.type === 'system' && 'subtype' in event && event.subtype === 'init') {
-            this.sessionId = event.session_id;
-          }
-
-          // Handle result — mark as not running
-          if (event.type === 'result') {
-            this.isRunning = false;
-          }
-
-          this.options.onMessage(event);
-        } catch {
-          // Non-JSON line (debug output)
-        }
-      });
-    }
-
-    // Log stderr
-    if (this.process.stderr) {
-      const rl = createInterface({ input: this.process.stderr });
-      rl.on('line', (line: string) => {
-        if (line.trim()) {
-          console.error(`  [claude stderr] ${line}`);
-        }
-      });
-    }
-
-    this.process.on('exit', (code) => {
-      this.isRunning = false;
-      this.process = null;
-    });
-
-    this.process.on('error', (err) => {
-      this.isRunning = false;
-      console.error('  Claude process error:', err.message);
-    });
-  }
-
-  resolvePermission(requestId: string, approved: boolean): void {
-    const pending = this.pendingPermissions.get(requestId);
-    if (pending) {
-      pending.resolve(approved);
-      this.pendingPermissions.delete(requestId);
-    }
-
-    // Also send permission response through stdin if process is running
-    if (this.process?.stdin?.writable) {
-      const response = JSON.stringify({
-        type: 'permission_response',
-        tool_use_id: requestId,
-        allowed: approved,
-      });
-      this.process.stdin.write(response + '\n');
-    }
-  }
-
-  getSessionId(): string | null {
-    return this.sessionId;
-  }
-
-  isActive(): boolean {
-    return this.isRunning;
-  }
-
-  kill(): void {
-    if (this.process) {
-      this.process.kill('SIGTERM');
-      this.process = null;
-      this.isRunning = false;
-    }
-  }
-}

package/src/server/index.ts

@@ -1,149 +0,0 @@
-import { Hono } from 'hono';
-import { serve } from '@hono/node-server';
-import { streamSSE } from 'hono/streaming';
-import { cors } from 'hono/cors';
-import { ClaudeSession } from './claude-session.js';
-import type { SDKMessage } from '../types/sdk-messages.js';
-
-const app = new Hono();
-app.use('*', cors());
-
-let session: ClaudeSession | null = null;
-const sseClients: Set<(msg: SDKMessage) => void> = new Set();
-
-const PROJECT_CWD = process.env.UPFYN_CWD || process.cwd();
-
-// Broadcast to all SSE clients
-function broadcast(msg: SDKMessage) {
-  for (const send of sseClients) {
-    send(msg);
-  }
-}
-
-// SSE stream endpoint
-app.get('/api/stream', (c) => {
-  return streamSSE(c, async (stream) => {
-    const send = (msg: SDKMessage) => {
-      stream.writeSSE({ data: JSON.stringify(msg), event: 'message' });
-    };
-    sseClients.add(send);
-
-    // Keep alive
-    const keepAlive = setInterval(() => {
-      stream.writeSSE({ data: '', event: 'ping' });
-    }, 15000);
-
-    stream.onAbort(() => {
-      sseClients.delete(send);
-      clearInterval(keepAlive);
-    });
-
-    // Block until aborted
-    await new Promise(() => {});
-  });
-});
-
-// Send a prompt
-app.post('/api/prompt', async (c) => {
-  const body = await c.req.json<{ prompt: string; sessionId?: string; cwd?: string }>();
-
-  if (!session) {
-    session = new ClaudeSession({
-      cwd: body.cwd || PROJECT_CWD,
-      onMessage: broadcast,
-    });
-  }
-
-  try {
-    await session.sendPrompt(body.prompt, body.sessionId);
-    return c.json({ ok: true });
-  } catch (err: any) {
-    return c.json({ ok: false, error: err.message }, 500);
-  }
-});
-
-// Respond to permission request
-app.post('/api/permission/respond', async (c) => {
-  const body = await c.req.json<{ requestId: string; approved: boolean }>();
-
-  if (session) {
-    session.resolvePermission(body.requestId, body.approved);
-  }
-
-  return c.json({ ok: true });
-});
-
-// Get session info
-app.get('/api/session', (c) => {
-  return c.json({
-    active: session !== null,
-    cwd: PROJECT_CWD,
-  });
-});
-
-// Git status endpoint (for statusline)
-app.get('/api/git-status', async (c) => {
-  const cwd = c.req.query('cwd') || PROJECT_CWD;
-  const { execSync } = await import('child_process');
-
-  try {
-    const branch = execSync('git symbolic-ref --short HEAD 2>/dev/null || git rev-parse --short HEAD', { cwd, encoding: 'utf-8' }).trim();
-    let remoteUrl = '';
-    try { remoteUrl = execSync('git remote get-url origin', { cwd, encoding: 'utf-8' }).trim(); } catch {}
-
-    let ghUser = '', ghRepo = '';
-    const ghMatch = remoteUrl.match(/github\.com[:/]([^/]+)\/([^/.]+)/);
-    if (ghMatch) { ghUser = ghMatch[1]; ghRepo = ghMatch[2]; }
-
-    let staged = false, unstaged = false;
-    try { execSync('git diff --cached --quiet', { cwd }); } catch { staged = true; }
-    try { execSync('git diff --quiet', { cwd }); } catch { unstaged = true; }
-
-    return c.json({ branch, ghUser, ghRepo, staged, unstaged });
-  } catch {
-    return c.json({ branch: 'no-git', ghUser: '', ghRepo: '', staged: false, unstaged: false });
-  }
-});
-
-// Discover Claude Code projects from ~/.claude/projects/
-app.get('/api/projects', async (c) => {
-  const { readdirSync, statSync } = await import('fs');
-  const { join } = await import('path');
-  const home = process.env.HOME || process.env.USERPROFILE || '';
-  const projectsDir = join(home, '.claude', 'projects');
-
-  try {
-    const entries = readdirSync(projectsDir);
-    const projects = entries
-      .map((name) => {
-        const fullPath = join(projectsDir, name);
-        try {
-          const stat = statSync(fullPath);
-          if (!stat.isDirectory()) return null;
-          // Decode the project hash back to a path
-          let decoded = name
-            .replace(/^([A-Z])--/, '$1:/')
-            .replace(/-/g, '/');
-          return {
-            path: decoded,
-            name: decoded.split('/').pop() || name,
-            lastUsed: stat.mtimeMs,
-          };
-        } catch { return null; }
-      })
-      .filter(Boolean)
-      .sort((a: any, b: any) => b.lastUsed - a.lastUsed)
-      .slice(0, 20);
-
-    return c.json({ projects });
-  } catch {
-    return c.json({ projects: [] });
-  }
-});
-
-// Health check
-app.get('/api/health', (c) => c.json({ status: 'ok', version: '0.1.0' }));
-
-const port = parseInt(process.env.UPFYN_PORT || '3210');
-console.log(`  \x1b[38;2;34;197;94m✓\x1b[0m API server running on http://localhost:${port}`);
-serve({ fetch: app.fetch, port });

package/src/services/stream-consumer.ts

@@ -1,330 +0,0 @@
-import type { SDKMessage, ContentBlockToolUse, ToolResultContent } from '../types/sdk-messages';
-import { useSessionStore } from '../store/session-store';
-import { useChatStore } from '../store/chat-store';
-import { useStatuslineStore } from '../store/statusline-store';
-import { usePermissionStore } from '../store/permission-store';
-import { useCanvasStore } from '../store/canvas-store';
-
-let eventSource: EventSource | null = null;
-let messageCounter = 0;
-
-function nextId(): string {
-  return `msg-${++messageCounter}-${Date.now()}`;
-}
-
-export function connectSSE(baseUrl = '') {
-  if (eventSource) {
-    eventSource.close();
-  }
-
-  eventSource = new EventSource(`${baseUrl}/api/stream`);
-
-  eventSource.addEventListener('message', (event) => {
-    if (!event.data) return;
-
-    try {
-      const msg: SDKMessage = JSON.parse(event.data);
-      handleMessage(msg);
-    } catch {
-      // Ignore parse errors
-    }
-  });
-
-  eventSource.addEventListener('open', () => {
-    useSessionStore.getState().setConnected(true);
-  });
-
-  eventSource.addEventListener('error', () => {
-    useSessionStore.getState().setConnected(false);
-    // Auto-reconnect is handled by EventSource
-  });
-
-  return eventSource;
-}
-
-export function disconnectSSE() {
-  if (eventSource) {
-    eventSource.close();
-    eventSource = null;
-  }
-  useSessionStore.getState().setConnected(false);
-}
-
-function handleMessage(msg: SDKMessage) {
-  const chat = useChatStore.getState();
-  const session = useSessionStore.getState();
-  const statusline = useStatuslineStore.getState();
-  const permissions = usePermissionStore.getState();
-  const canvas = useCanvasStore.getState();
-
-  switch (msg.type) {
-    case 'system': {
-      if ('subtype' in msg && msg.subtype === 'init') {
-        session.setInit({
-          sessionId: msg.session_id,
-          model: msg.model,
-          cwd: msg.cwd,
-          tools: msg.tools,
-          permissionMode: msg.permissionMode,
-        });
-        statusline.updateFromInit(msg.model, msg.cwd, msg.session_id, msg.permissionMode);
-
-        // Fetch git status
-        fetchGitStatus(msg.cwd);
-
-        // Canvas: session node
-        canvas.addNode({
-          id: `session-${msg.session_id}`,
-          type: 'session',
-          label: msg.model,
-          data: { model: msg.model, cwd: msg.cwd, session_id: msg.session_id, tools: msg.tools },
-          timestamp: Date.now(),
-        });
-
-        chat.addMessage({
-          id: nextId(),
-          role: 'system',
-          content: `Connected to Claude Code (${msg.model})`,
-          timestamp: Date.now(),
-        });
-      }
-      if ('subtype' in msg && msg.subtype === 'compact_boundary') {
-        statusline.markCompaction(msg.compact_metadata.pre_tokens);
-
-        // Canvas: compaction node
-        canvas.addNode({
-          id: `compact-${Date.now()}`,
-          type: 'compaction',
-          label: 'Compaction',
-          data: { pre_tokens: msg.compact_metadata.pre_tokens, trigger: msg.compact_metadata.trigger },
-          timestamp: Date.now(),
-        });
-
-        chat.addMessage({
-          id: nextId(),
-          role: 'system',
-          content: `Context compacted (was ${Math.round(msg.compact_metadata.pre_tokens / 1000)}k tokens)`,
-          timestamp: Date.now(),
-        });
-      }
-      break;
-    }
-
-    case 'stream_event': {
-      session.setStreaming(true);
-      const evt = msg.event;
-
-      if (evt.type === 'content_block_delta' && evt.delta) {
-        if (evt.delta.type === 'text_delta' && evt.delta.text) {
-          chat.appendStreamDelta(evt.delta.text);
-        }
-      }
-
-      if (evt.type === 'content_block_start' && evt.content_block) {
-        if (evt.content_block.type === 'tool_use' && evt.content_block.name) {
-          chat.setStreamingToolName(evt.content_block.name);
-          statusline.updateSkill(evt.content_block.name);
-        }
-      }
-
-      if (evt.type === 'message_stop') {
-        session.setStreaming(false);
-      }
-      break;
-    }
-
-    case 'assistant': {
-      // Finalize any streaming text
-      chat.finalizeStreaming(msg.message.usage);
-
-      // Process content blocks
-      for (const block of msg.message.content) {
-        if (block.type === 'tool_use') {
-          const toolBlock = block as ContentBlockToolUse;
-          chat.addMessage({
-            id: nextId(),
-            role: 'tool_call',
-            content: JSON.stringify(toolBlock.input, null, 2),
-            toolName: toolBlock.name,
-            toolUseId: toolBlock.id,
-            timestamp: Date.now(),
-          });
-          statusline.updateSkill(toolBlock.name);
-
-          // Canvas: tool call node
-          canvas.addNode({
-            id: `tool-${toolBlock.id}`,
-            type: 'toolCall',
-            label: toolBlock.name,
-            data: { name: toolBlock.name, input: toolBlock.input, id: toolBlock.id },
-            timestamp: Date.now(),
-          });
-        }
-
-        // Canvas: text response for non-tool text blocks
-        const textBlocks = msg.message.content.filter(b => b.type === 'text');
-        if (textBlocks.length > 0) {
-          const fullText = textBlocks.map(b => (b as { text: string }).text).join('');
-          if (fullText.trim()) {
-            canvas.addNode({
-              id: `text-${msg.uuid}`,
-              type: 'textResponse',
-              label: 'Response',
-              data: { text: fullText },
-              timestamp: Date.now(),
-            });
-          }
-        }
-      }
-
-      // Update statusline with usage
-      if (msg.message.usage) {
-        statusline.updateFromUsage(msg.message.usage);
-      }
-      break;
-    }
-
-    case 'user': {
-      if (Array.isArray(msg.message.content)) {
-        for (const block of msg.message.content) {
-          if ((block as ToolResultContent).type === 'tool_result') {
-            const result = block as ToolResultContent;
-            chat.addMessage({
-              id: nextId(),
-              role: 'tool_result',
-              content: typeof result.content === 'string'
-                ? result.content.slice(0, 2000)
-                : JSON.stringify(result.content).slice(0, 2000),
-              toolUseId: result.tool_use_id,
-              isError: result.is_error,
-              timestamp: Date.now(),
-            });
-
-            // Canvas: tool result node
-            canvas.addNode({
-              id: `result-${result.tool_use_id}`,
-              type: 'toolResult',
-              label: 'Result',
-              data: {
-                toolName: result.tool_use_id,
-                content: typeof result.content === 'string' ? result.content.slice(0, 200) : '',
-                is_error: result.is_error,
-              },
-              timestamp: Date.now(),
-            });
-          }
-        }
-      }
-      break;
-    }
-
-    case 'result': {
-      session.setStreaming(false);
-      chat.finalizeStreaming();
-      chat.setWaiting(false);
-
-      statusline.updateFromResult({
-        cost: msg.total_cost_usd,
-        duration: msg.duration_ms,
-        numTurns: msg.num_turns,
-        usage: msg.usage,
-        modelUsage: msg.modelUsage,
-      });
-
-      if (msg.is_error && msg.errors) {
-        chat.addMessage({
-          id: nextId(),
-          role: 'system',
-          content: `Error: ${msg.errors.join(', ')}`,
-          isError: true,
-          timestamp: Date.now(),
-        });
-      }
-      break;
-    }
-
-    case 'permission_request': {
-      permissions.addRequest({
-        requestId: msg.requestId,
-        toolName: msg.toolName,
-        toolInput: msg.toolInput,
-        timestamp: Date.now(),
-      });
-      break;
-    }
-  }
-}
-
-async function fetchGitStatus(cwd: string) {
-  try {
-    const res = await fetch(`/api/git-status?cwd=${encodeURIComponent(cwd)}`);
-    if (res.ok) {
-      const data = await res.json();
-      useStatuslineStore.getState().updateGit(data);
-    }
-  } catch {
-    // Git status not available
-  }
-}
-
-export async function sendPrompt(prompt: string) {
-  const chat = useChatStore.getState();
-  const session = useSessionStore.getState();
-
-  // Add user message to chat
-  chat.addMessage({
-    id: nextId(),
-    role: 'user',
-    content: prompt,
-    timestamp: Date.now(),
-  });
-  chat.setInput('');
-  chat.setWaiting(true);
-
-  try {
-    const res = await fetch('/api/prompt', {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        prompt,
-        sessionId: session.sessionId,
-        cwd: session.cwd,
-      }),
-    });
-
-    if (!res.ok) {
-      const err = await res.json();
-      chat.addMessage({
-        id: nextId(),
-        role: 'system',
-        content: `Failed to send: ${err.error || 'Unknown error'}`,
-        isError: true,
-        timestamp: Date.now(),
-      });
-      chat.setWaiting(false);
-    }
-  } catch (err: any) {
-    chat.addMessage({
-      id: nextId(),
-      role: 'system',
-      content: `Connection error: ${err.message}`,
-      isError: true,
-      timestamp: Date.now(),
-    });
-    chat.setWaiting(false);
-  }
-}
-
-export async function respondPermission(requestId: string, approved: boolean) {
-  usePermissionStore.getState().removeRequest(requestId);
-
-  try {
-    await fetch('/api/permission/respond', {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ requestId, approved }),
-    });
-  } catch {
-    // Best effort
-  }
-}