sparkecoder 0.1.16 → 0.1.18

package/web/.next/standalone/web/src/lib/api.ts

@@ -0,0 +1,568 @@
+import { getApiUrl } from './config';
+
+// Get API base URL synchronously from localStorage
+function getApiBase(): string {
+  return getApiUrl();
+}
+
+export interface SessionConfig {
+  toolApprovals?: Record<string, boolean>;
+}
+
+export interface Session {
+  id: string;
+  name: string;
+  model: string;
+  workingDirectory: string;
+  status: 'active' | 'waiting' | 'completed' | 'error';
+  isStreaming?: boolean;
+  config?: SessionConfig;
+  createdAt: string;
+  updatedAt?: string;
+  messageCount?: number;
+}
+
+// AI SDK ModelMessage content types
+export interface TextContentPart {
+  type: 'text';
+  text: string;
+}
+
+export interface ReasoningContentPart {
+  type: 'reasoning';
+  text: string;
+}
+
+export interface ToolCallContentPart {
+  type: 'tool-call';
+  toolCallId: string;
+  toolName: string;
+  input?: unknown;
+  args?: unknown; // AI SDK uses 'args' in some places
+}
+
+export interface ToolResultContentPart {
+  type: 'tool-result';
+  toolCallId: string;
+  toolName: string;
+  output?: unknown;
+  result?: unknown; // AI SDK uses 'result' in some places
+}
+
+export type ContentPart = TextContentPart | ReasoningContentPart | ToolCallContentPart | ToolResultContentPart;
+
+// AI SDK ModelMessage format (as returned by backend)
+export interface Message {
+  id: string;
+  role: 'user' | 'assistant' | 'tool' | 'system';
+  // Content can be a string OR array of content parts
+  content: string | ContentPart[];
+  createdAt: string;
+}
+
+export interface ToolCall {
+  toolCallId: string;
+  toolName: string;
+  input: unknown;
+}
+
+export interface ToolResult {
+  toolCallId: string;
+  toolName: string;
+  output: unknown;
+}
+
+export interface PendingApproval {
+  id: string;
+  toolCallId: string;
+  toolName: string;
+  input: unknown;
+  createdAt: string;
+}
+
+export interface TodoItem {
+  id: string;
+  content: string;
+  status: 'pending' | 'in_progress' | 'completed' | 'cancelled';
+  order: number;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface TodosResponse {
+  todos: TodoItem[];
+  stats: {
+    total: number;
+    pending: number;
+    inProgress: number;
+    completed: number;
+    cancelled: number;
+  };
+  nextTodo: {
+    id: string;
+    content: string;
+    status: string;
+  } | null;
+}
+
+// Sessions API
+export async function getSessions(): Promise<Session[]> {
+  const res = await fetch(`${getApiBase()}/sessions`);
+  const data = await res.json();
+  return data.sessions || [];
+}
+
+export async function getSession(id: string): Promise<Session> {
+  const res = await fetch(`${getApiBase()}/sessions/${id}`);
+  return res.json();
+}
+
+export async function createSession(params: {
+  name?: string;
+  model?: string;
+  workingDirectory?: string;
+  toolApprovals?: Record<string, boolean>;
+}): Promise<Session> {
+  const res = await fetch(`${getApiBase()}/sessions`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(params),
+  });
+  return res.json();
+}
+
+export async function deleteSession(id: string): Promise<void> {
+  await fetch(`${getApiBase()}/sessions/${id}`, { method: 'DELETE' });
+}
+
+export async function getSessionTodos(sessionId: string): Promise<TodosResponse> {
+  const res = await fetch(`${getApiBase()}/sessions/${sessionId}/todos`);
+  return res.json();
+}
+
+export async function updateSession(id: string, updates: { model?: string; name?: string; toolApprovals?: Record<string, boolean> }): Promise<Session> {
+  const res = await fetch(`${getApiBase()}/sessions/${id}`, {
+    method: 'PATCH',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(updates),
+  });
+  return res.json();
+}
+
+/**
+ * Update a specific tool's approval setting for a session
+ * If `requiresApproval` is false, the tool will run without asking
+ * Note: Backend merges with existing tool approvals, so we only need to send the changed tool
+ */
+export async function updateToolApproval(
+  sessionId: string,
+  toolName: string,
+  requiresApproval: boolean,
+  _currentConfig?: SessionConfig // Kept for backwards compatibility but not used
+): Promise<Session> {
+  return updateSession(sessionId, {
+    toolApprovals: {
+      [toolName]: requiresApproval,
+    },
+  });
+}
+
+// Agent API
+export async function getSessionMessages(sessionId: string): Promise<Message[]> {
+  const res = await fetch(`${getApiBase()}/sessions/${sessionId}/messages`);
+  const data = await res.json();
+  return data.messages || [];
+}
+
+export async function getPendingApprovals(sessionId: string): Promise<PendingApproval[]> {
+  const res = await fetch(`${getApiBase()}/agents/${sessionId}/approvals`);
+  const data = await res.json();
+  return data.pendingApprovals || [];
+}
+
+export async function approveExecution(sessionId: string, executionId: string): Promise<void> {
+  await fetch(`${getApiBase()}/agents/${sessionId}/approve/${executionId}`, {
+    method: 'POST',
+  });
+}
+
+export async function rejectExecution(
+  sessionId: string,
+  executionId: string,
+  reason?: string
+): Promise<void> {
+  await fetch(`${getApiBase()}/agents/${sessionId}/reject/${executionId}`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ reason }),
+  });
+}
+
+// Get active stream info for a session
+export async function getActiveStream(sessionId: string): Promise<{
+  hasActiveStream: boolean;
+  stream: { streamId: string; status: string; createdAt: string } | null;
+}> {
+  const res = await fetch(`${getApiBase()}/agents/${sessionId}/stream`);
+  return res.json();
+}
+
+// Abort/stop an active stream for a session
+export async function abortStream(sessionId: string): Promise<{
+  success: boolean;
+  streamId?: string;
+  aborted?: boolean;
+  message?: string;
+}> {
+  const res = await fetch(`${getApiBase()}/agents/${sessionId}/abort`, {
+    method: 'POST',
+  });
+  return res.json();
+}
+
+// Internal helper to parse SSE stream
+function parseSSEStream(
+  response: Response,
+  onEvent: (event: SSEEvent) => void,
+  onStreamId?: (streamId: string) => void
+): Promise<void> {
+  return new Promise(async (resolve, reject) => {
+    const reader = response.body?.getReader();
+    if (!reader) {
+      reject(new Error('No response body'));
+      return;
+    }
+
+    const decoder = new TextDecoder();
+    let buffer = '';
+
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
+
+        for (const line of lines) {
+          if (line.startsWith('data: ')) {
+            const data = line.slice(6);
+            if (data === '[DONE]') continue;
+
+            try {
+              const event = JSON.parse(data);
+              
+              // Capture stream ID for reconnection
+              if (event.type === 'data-stream-id' && onStreamId) {
+                onStreamId(event.streamId);
+              }
+              
+              onEvent(event as SSEEvent);
+            } catch {
+              // Skip invalid JSON
+            }
+          }
+        }
+      }
+      resolve();
+    } catch (err) {
+      reject(err);
+    }
+  });
+}
+
+// Streaming run with resumable stream support
+export function runAgent(
+  sessionId: string,
+  prompt: string,
+  onEvent: (event: SSEEvent) => void,
+  options?: {
+    onStreamId?: (streamId: string) => void;
+  }
+): () => void {
+  const controller = new AbortController();
+
+  fetch(`${getApiBase()}/agents/${sessionId}/run`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ prompt }),
+    signal: controller.signal,
+  })
+    .then(async (response) => {
+      const streamId = response.headers.get('x-stream-id');
+      if (streamId && options?.onStreamId) {
+        options.onStreamId(streamId);
+      }
+      await parseSSEStream(response, onEvent, options?.onStreamId);
+    })
+    .catch((err) => {
+      if (err.name !== 'AbortError') {
+        console.error('Stream error:', err);
+      }
+    });
+
+  return () => controller.abort();
+}
+
+// Watch/subscribe to an existing stream (for multiple tabs/clients)
+export function watchStream(
+  sessionId: string,
+  onEvent: (event: SSEEvent) => void,
+  options?: {
+    streamId?: string;
+    resumeAt?: number;
+    onStreamId?: (streamId: string) => void;
+  }
+): () => void {
+  const controller = new AbortController();
+
+  const params = new URLSearchParams();
+  if (options?.streamId) params.set('streamId', options.streamId);
+  if (options?.resumeAt !== undefined) params.set('resumeAt', String(options.resumeAt));
+
+  const url = `${getApiBase()}/agents/${sessionId}/watch${params.toString() ? '?' + params.toString() : ''}`;
+
+  fetch(url, { signal: controller.signal })
+    .then(async (response) => {
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({ error: 'Unknown error' }));
+        console.error('Watch stream error:', error);
+        onEvent({ type: 'error', errorText: error.error || 'Failed to watch stream' });
+        return;
+      }
+
+      const streamId = response.headers.get('x-stream-id');
+      if (streamId && options?.onStreamId) {
+        options.onStreamId(streamId);
+      }
+
+      await parseSSEStream(response, onEvent, options?.onStreamId);
+    })
+    .catch((err) => {
+      if (err.name !== 'AbortError') {
+        console.error('Watch stream error:', err);
+      }
+    });
+
+  return () => controller.abort();
+}
+
+export type SSEEvent =
+  | { type: 'start'; messageId: string }
+  | { type: 'text-start'; id: string }
+  | { type: 'text-delta'; id: string; delta: string }
+  | { type: 'text-end'; id: string }
+  | { type: 'reasoning-start'; id: string }
+  | { type: 'reasoning-delta'; id: string; delta: string }
+  | { type: 'reasoning-end'; id: string }
+  | { type: 'tool-input-start'; toolCallId: string; toolName: string }
+  | { type: 'tool-input-delta'; toolCallId: string; argsTextDelta: string }
+  | { type: 'tool-input-available'; toolCallId: string; toolName: string; input: unknown }
+  | { type: 'tool-output-available'; toolCallId: string; output: unknown }
+  | { type: 'tool-progress'; toolName: string; data: { terminalId: string; status: 'started' | 'running' | 'completed'; command?: string } }
+  | { type: 'data-approval-required'; data: PendingApproval }
+  | { type: 'data-stream-id'; streamId: string }
+  | { type: 'data-session'; data: { id: string; name: string; workingDirectory: string; model: string } }
+  | { type: 'data-user-message'; data: { id: string; content: string } }
+  | { type: 'finish-step' }
+  | { type: 'finish'; finishReason?: string }
+  | { type: 'abort' }
+  | { type: 'error'; errorText: string };
+
+// Terminal stream events
+export interface TerminalStreamEvent {
+  type: 'status' | 'stdout' | 'exit';
+  data?: string;
+  terminalId?: string;
+  status?: string;
+}
+
+/**
+ * Subscribe to a terminal's output stream
+ * Returns a cancel function
+ */
+export function streamTerminal(
+  terminalId: string,
+  onOutput: (data: string) => void,
+  onExit?: () => void
+): () => void {
+  const controller = new AbortController();
+  
+  const connect = async () => {
+    try {
+      const response = await fetch(`${getApiBase()}/terminals/stream/${terminalId}`, {
+        signal: controller.signal,
+      });
+      
+      if (!response.ok || !response.body) {
+        console.error('Failed to connect to terminal stream');
+        return;
+      }
+      
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = '';
+      
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n\n');
+        buffer = lines.pop() || '';
+        
+        for (const chunk of lines) {
+          if (!chunk.trim()) continue;
+          
+          // Parse SSE format: "event: type\ndata: {...}"
+          const eventMatch = chunk.match(/event:\s*(\w+)/);
+          const dataMatch = chunk.match(/data:\s*(.+)/);
+          
+          if (eventMatch && dataMatch) {
+            const eventType = eventMatch[1];
+            try {
+              const data = JSON.parse(dataMatch[1]);
+              
+              if (eventType === 'stdout' && data.data) {
+                onOutput(data.data);
+              } else if (eventType === 'exit') {
+                onExit?.();
+              }
+            } catch {
+              // Skip invalid JSON
+            }
+          }
+        }
+      }
+    } catch (error) {
+      if (error instanceof Error && error.name !== 'AbortError') {
+        console.error('Terminal stream error:', error);
+      }
+    }
+  };
+  
+  connect();
+  
+  return () => controller.abort();
+}
+
+// ============================================
+// API Key Management
+// ============================================
+
+export interface ApiKeyStatus {
+  provider: string;
+  envVar: string;
+  configured: boolean;
+  source: 'env' | 'storage' | 'none';
+  maskedKey: string | null;
+}
+
+export interface ApiKeysResponse {
+  providers: ApiKeyStatus[];
+  supportedProviders: string[];
+}
+
+export async function getApiKeys(): Promise<ApiKeysResponse> {
+  const res = await fetch(`${getApiBase()}/health/api-keys`);
+  return res.json();
+}
+
+export async function setApiKey(provider: string, apiKey: string): Promise<{
+  success: boolean;
+  provider: string;
+  maskedKey: string;
+  message: string;
+}> {
+  const res = await fetch(`${getApiBase()}/health/api-keys`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ provider, apiKey }),
+  });
+  return res.json();
+}
+
+export async function removeApiKey(provider: string): Promise<{
+  success: boolean;
+  provider: string;
+  message: string;
+}> {
+  const res = await fetch(`${getApiBase()}/health/api-keys/${provider}`, {
+    method: 'DELETE',
+  });
+  return res.json();
+}
+
+// ============================================
+// Checkpoint / Revert API
+// ============================================
+
+export interface Checkpoint {
+  id: string;
+  messageSequence: number;
+  gitHead: string | null;
+  createdAt: string;
+}
+
+export interface CheckpointsResponse {
+  sessionId: string;
+  checkpoints: Checkpoint[];
+  count: number;
+}
+
+export interface RevertResponse {
+  success: boolean;
+  sessionId: string;
+  checkpointId: string;
+  filesRestored: number;
+  filesDeleted: number;
+  messagesDeleted: number;
+  checkpointsDeleted: number;
+  error?: string;
+}
+
+export interface SessionDiffFile {
+  path: string;
+  status: 'created' | 'modified' | 'deleted';
+  hasOriginal: boolean;
+  hasCurrent: boolean;
+}
+
+export interface SessionDiffResponse {
+  sessionId: string;
+  files: SessionDiffFile[];
+  summary: {
+    created: number;
+    modified: number;
+    deleted: number;
+    total: number;
+  };
+}
+
+export async function getSessionCheckpoints(sessionId: string): Promise<CheckpointsResponse> {
+  const res = await fetch(`${getApiBase()}/sessions/${sessionId}/checkpoints`);
+  if (!res.ok) {
+    throw new Error(`Failed to get checkpoints: ${res.statusText}`);
+  }
+  return res.json();
+}
+
+export async function revertToCheckpoint(sessionId: string, checkpointId: string): Promise<RevertResponse> {
+  const res = await fetch(`${getApiBase()}/sessions/${sessionId}/revert/${checkpointId}`, {
+    method: 'POST',
+  });
+  if (!res.ok) {
+    const error = await res.json();
+    throw new Error(error.error || `Failed to revert: ${res.statusText}`);
+  }
+  return res.json();
+}
+
+export async function getSessionDiff(sessionId: string): Promise<SessionDiffResponse> {
+  const res = await fetch(`${getApiBase()}/sessions/${sessionId}/diff`);
+  if (!res.ok) {
+    throw new Error(`Failed to get diff: ${res.statusText}`);
+  }
+  return res.json();
+}