tower-studio 0.1.3 → 0.1.5

package/src/hooks/use-assistant-chat.ts

@@ -1,190 +0,0 @@
-"use client";
-
-import { useCallback, useRef, useState } from "react";
-import { applySSEEvent } from "./sse-event-reducer";
-import type { SSEEvent } from "./sse-event-reducer";
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-export type MessageRole = "user" | "assistant" | "thinking" | "tool";
-
-export interface ChatMessage {
-  id: string;
-  role: MessageRole;
-  content: string;
-  toolName?: string;
-  isStreaming?: boolean;
-  imageFilenames?: string[];
-}
-
-export interface UseAssistantChatReturn {
-  messages: ChatMessage[];
-  isThinking: boolean;
-  sendMessage: (text: string) => void;
-  status: "idle" | "connecting" | "streaming" | "error";
-}
-
-// ---------------------------------------------------------------------------
-// ID generator
-// ---------------------------------------------------------------------------
-
-function nextId(): string {
-  return typeof crypto !== "undefined" && crypto.randomUUID
-    ? crypto.randomUUID()
-    : `msg-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
-}
-
-// ---------------------------------------------------------------------------
-// Hook
-// ---------------------------------------------------------------------------
-
-export function useAssistantChat(opts: {
-  enabled: boolean;
-}): UseAssistantChatReturn {
-  const { enabled } = opts;
-
-  const [messages, setMessages] = useState<ChatMessage[]>([]);
-  const [status, setStatus] = useState<"idle" | "connecting" | "streaming" | "error">("idle");
-
-  // Use ref as the source of truth for messages — avoids React batching issues
-  // with closures in async stream processing
-  const msgsRef = useRef<ChatMessage[]>([]);
-  const sessionIdRef = useRef<string | null>(null);
-  const abortRef = useRef<AbortController | null>(null);
-
-  // Sync ref → state (triggers re-render)
-  const flush = useCallback(() => {
-    setMessages([...msgsRef.current]);
-  }, []);
-
-  const sendMessage = useCallback(
-    async (text: string) => {
-      if (!enabled || !text.trim()) return;
-
-      abortRef.current?.abort();
-      const controller = new AbortController();
-      abortRef.current = controller;
-
-      // Add user message + thinking indicator
-      const thinkingId = nextId();
-      msgsRef.current = [
-        ...msgsRef.current,
-        { id: nextId(), role: "user", content: text },
-        { id: thinkingId, role: "thinking", content: "", isStreaming: true },
-      ];
-      flush();
-      setStatus("connecting");
-
-      let assistantMsgId: string | null = null;
-
-      try {
-        const res = await fetch("/api/internal/assistant/chat", {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({
-            message: text,
-            sessionId: sessionIdRef.current,
-          }),
-          signal: controller.signal,
-        });
-
-        if (!res.ok || !res.body) {
-          const errorText = await res.text().catch(() => "");
-          throw new Error(`HTTP ${res.status}: ${errorText}`);
-        }
-
-        setStatus("streaming");
-
-        const reader = res.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 });
-
-          // Parse SSE events: split on \n, process "data: " lines
-          const lines = buffer.split("\n");
-          buffer = lines.pop() ?? "";
-
-          for (const line of lines) {
-            if (!line.startsWith("data: ")) continue;
-            const jsonStr = line.slice(6).trim();
-            if (!jsonStr) continue;
-
-            let event: SSEEvent;
-            try {
-              event = JSON.parse(jsonStr) as SSEEvent;
-            } catch {
-              continue;
-            }
-
-            if (event.sessionId) {
-              sessionIdRef.current = event.sessionId;
-            }
-
-            // Apply event via pure reducer — delegates state transformation out of the hook
-            const next = applySSEEvent(
-              { messages: msgsRef.current, assistantMsgId, status: "streaming" },
-              event,
-              thinkingId,
-              nextId
-            );
-            msgsRef.current = next.messages;
-            assistantMsgId = next.assistantMsgId;
-            if (next.status === "error" || next.status === "idle") {
-              setStatus(next.status);
-            }
-            flush();
-          }
-        }
-
-        // Process remaining buffer
-        if (buffer.trim()) {
-          const remaining = buffer + "\n";
-          const lines = remaining.split("\n");
-          for (const line of lines) {
-            if (!line.startsWith("data: ")) continue;
-            try {
-              const event = JSON.parse(line.slice(6).trim()) as SSEEvent;
-              if (event.type === "done") {
-                msgsRef.current = msgsRef.current.filter((m) => m.id !== thinkingId);
-                flush();
-                setStatus("idle");
-              }
-            } catch { /* skip */ }
-          }
-        }
-
-        // Final cleanup
-        msgsRef.current = msgsRef.current.filter((m) => m.id !== thinkingId);
-        flush();
-        setStatus((s) => (s === "streaming" ? "idle" : s));
-      } catch (err: unknown) {
-        if ((err as Error).name === "AbortError") return;
-        msgsRef.current = [
-          ...msgsRef.current.filter((m) => m.id !== thinkingId),
-          {
-            id: nextId(),
-            role: "assistant" as MessageRole,
-            content: `Connection error: ${(err as Error).message ?? "Unknown error"}`,
-          },
-        ];
-        flush();
-        setStatus("error");
-      }
-    },
-    [enabled, flush]
-  );
-
-  const lastMsg = messages[messages.length - 1];
-  const isThinking =
-    status === "connecting" || status === "streaming" ||
-    (lastMsg?.role === "thinking" && lastMsg.isStreaming === true);
-
-  return { messages, isThinking, sendMessage, status };
-}

package/src/hooks/use-image-upload.ts

@@ -1,140 +0,0 @@
-"use client";
-
-import { useState, useRef, useEffect, useCallback } from "react";
-
-export interface PendingImage {
-  id: string;
-  file: File;
-  blobUrl: string;
-  status: "uploading" | "done" | "error";
-  progress: number; // 0-100
-  filename?: string; // populated after successful upload
-}
-
-export function useImageUpload() {
-  const [pendingImages, setPendingImages] = useState<PendingImage[]>([]);
-  const xhrMap = useRef<Map<string, XMLHttpRequest>>(new Map());
-  const imagesRef = useRef<PendingImage[]>([]);
-
-  // Keep imagesRef in sync for cleanup
-  useEffect(() => {
-    imagesRef.current = pendingImages;
-  }, [pendingImages]);
-
-  // Cleanup on unmount: revoke all blob URLs and abort in-flight XHRs
-  useEffect(() => {
-    return () => {
-      imagesRef.current.forEach((img) => URL.revokeObjectURL(img.blobUrl));
-      xhrMap.current.forEach((xhr) => xhr.abort());
-      xhrMap.current.clear();
-    };
-  }, []);
-
-  const addImages = useCallback((files: File[]) => {
-    const newImages: PendingImage[] = files.map((file) => ({
-      id: crypto.randomUUID(),
-      file,
-      blobUrl: URL.createObjectURL(file),
-      status: "uploading",
-      progress: 0,
-    }));
-
-    // Sync ref immediately so unmount cleanup can revoke these blob URLs
-    imagesRef.current = [...imagesRef.current, ...newImages];
-    setPendingImages((prev) => [...prev, ...newImages]);
-
-    for (const image of newImages) {
-      const xhr = new XMLHttpRequest();
-      xhrMap.current.set(image.id, xhr);
-
-      xhr.upload.onprogress = (e) => {
-        if (e.lengthComputable) {
-          const progress = Math.round((e.loaded / e.total) * 100);
-          setPendingImages((prev) =>
-            prev.map((img) =>
-              img.id === image.id ? { ...img, progress } : img
-            )
-          );
-        }
-      };
-
-      xhr.onload = () => {
-        xhrMap.current.delete(image.id);
-        if (xhr.status === 200) {
-          try {
-            const data = JSON.parse(xhr.responseText) as { filename?: unknown };
-            const filename = typeof data.filename === "string" && data.filename ? data.filename : null;
-            if (!filename) throw new Error("Invalid upload response");
-            setPendingImages((prev) =>
-              prev.map((img) =>
-                img.id === image.id
-                  ? { ...img, status: "done", progress: 100, filename }
-                  : img
-              )
-            );
-          } catch {
-            setPendingImages((prev) =>
-              prev.map((img) =>
-                img.id === image.id ? { ...img, status: "error" } : img
-              )
-            );
-          }
-        } else {
-          setPendingImages((prev) =>
-            prev.map((img) =>
-              img.id === image.id ? { ...img, status: "error" } : img
-            )
-          );
-        }
-      };
-
-      xhr.onerror = () => {
-        xhrMap.current.delete(image.id);
-        setPendingImages((prev) =>
-          prev.map((img) =>
-            img.id === image.id ? { ...img, status: "error" } : img
-          )
-        );
-      };
-
-      const formData = new FormData();
-      formData.append("file", image.file);
-      xhr.open("POST", "/api/internal/assistant/images");
-      xhr.send(formData);
-    }
-  }, []);
-
-  const removeImage = useCallback((id: string) => {
-    const xhr = xhrMap.current.get(id);
-    if (xhr) {
-      xhr.abort();
-      xhrMap.current.delete(id);
-    }
-    setPendingImages((prev) => {
-      const img = prev.find((i) => i.id === id);
-      if (img) {
-        URL.revokeObjectURL(img.blobUrl);
-      }
-      return prev.filter((i) => i.id !== id);
-    });
-  }, []);
-
-  const clearAll = useCallback(() => {
-    setPendingImages((prev) => {
-      prev.forEach((img) => {
-        const xhr = xhrMap.current.get(img.id);
-        if (xhr) {
-          xhr.abort();
-          xhrMap.current.delete(img.id);
-        }
-        URL.revokeObjectURL(img.blobUrl);
-      });
-      xhrMap.current.clear();
-      return [];
-    });
-  }, []);
-
-  const hasUploading = pendingImages.some((i) => i.status === "uploading");
-
-  return { pendingImages, addImages, removeImage, clearAll, hasUploading };
-}

package/src/instrumentation.ts

@@ -1,18 +0,0 @@
-export async function register() {
-  if (process.env.NEXT_RUNTIME === "nodejs") {
-    const { pruneOrphanedWorktrees, cleanupStaleExecutions, ensureTowerLabel } = await import(
-      "@/lib/instrumentation-tasks"
-    );
-    await pruneOrphanedWorktrees();
-    await cleanupStaleExecutions();
-    await ensureTowerLabel();
-
-    // WS-01: Start WebSocket server on port 3001 for PTY terminal sessions
-    const { startWsServer } = await import("@/lib/pty/ws-server");
-    await startWsServer();
-
-    // Ensure .tower/ directory exists for the assistant persona
-    const { ensureTowerDir } = await import("@/lib/init-tower");
-    ensureTowerDir();
-  }
-}

package/src/lib/__tests__/assistant-message-converter.test.ts

@@ -1,162 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  convertSessionMessages,
-  type SDKSessionMessage,
-} from "../assistant-message-converter";
-
-function makeMsg(
-  type: "user" | "assistant" | "system",
-  message: unknown,
-  uuid = crypto.randomUUID()
-): SDKSessionMessage {
-  return { type, uuid, session_id: "test-session", message, parent_tool_use_id: null };
-}
-
-describe("convertSessionMessages", () => {
-  it("should convert user messages", () => {
-    const msgs = [makeMsg("user", { content: "Hello" })];
-    const result = convertSessionMessages(msgs);
-
-    expect(result).toHaveLength(1);
-    expect(result[0].role).toBe("user");
-    expect(result[0].content).toBe("Hello");
-  });
-
-  it("should strip /tower prefix from user messages", () => {
-    const msgs = [makeMsg("user", { content: "/tower 帮我创建任务" })];
-    const result = convertSessionMessages(msgs);
-
-    expect(result).toHaveLength(1);
-    expect(result[0].content).toBe("帮我创建任务");
-  });
-
-  it("should convert assistant text messages", () => {
-    const msgs = [
-      makeMsg("assistant", {
-        content: [{ type: "text", text: "Hi there!" }],
-      }),
-    ];
-    const result = convertSessionMessages(msgs);
-
-    expect(result).toHaveLength(1);
-    expect(result[0].role).toBe("assistant");
-    expect(result[0].content).toBe("Hi there!");
-  });
-
-  it("should concatenate multiple text blocks in one assistant message", () => {
-    const msgs = [
-      makeMsg("assistant", {
-        content: [
-          { type: "text", text: "Part 1. " },
-          { type: "text", text: "Part 2." },
-        ],
-      }),
-    ];
-    const result = convertSessionMessages(msgs);
-
-    expect(result).toHaveLength(1);
-    expect(result[0].content).toBe("Part 1. Part 2.");
-  });
-
-  it("should convert tool_use blocks as separate tool messages", () => {
-    const msgs = [
-      makeMsg("assistant", {
-        content: [
-          { type: "text", text: "Let me check." },
-          { type: "tool_use", name: "list_tasks", input: { projectId: "abc" } },
-        ],
-      }),
-    ];
-    const result = convertSessionMessages(msgs);
-
-    expect(result).toHaveLength(2);
-    expect(result[0].role).toBe("assistant");
-    expect(result[0].content).toBe("Let me check.");
-    expect(result[1].role).toBe("tool");
-    expect(result[1].toolName).toBe("list_tasks");
-  });
-
-  it("should skip system messages", () => {
-    const msgs = [
-      makeMsg("user", { content: "Hello" }),
-      makeMsg("system", { subtype: "compact_boundary" }),
-      makeMsg("assistant", { content: [{ type: "text", text: "Hi" }] }),
-    ];
-    const result = convertSessionMessages(msgs);
-
-    expect(result).toHaveLength(2);
-    expect(result[0].role).toBe("user");
-    expect(result[1].role).toBe("assistant");
-  });
-
-  it("should handle empty input", () => {
-    expect(convertSessionMessages([])).toEqual([]);
-  });
-
-  it("should handle tool_result in system messages", () => {
-    const msgs = [
-      makeMsg("user", { content: "List tasks" }),
-      makeMsg("assistant", {
-        content: [
-          { type: "tool_use", name: "list_tasks", input: {} },
-        ],
-      }),
-      makeMsg("system", {
-        subtype: "tool_result",
-        tool_name: "list_tasks",
-        content: '[{"id":"1","title":"Task 1"}]',
-      }),
-    ];
-    const result = convertSessionMessages(msgs);
-
-    // user + tool_use + tool_result
-    expect(result).toHaveLength(3);
-    expect(result[2].role).toBe("tool");
-    expect(result[2].toolName).toContain("list_tasks");
-  });
-
-  it("should handle assistant message with only tool_use (no text)", () => {
-    const msgs = [
-      makeMsg("assistant", {
-        content: [
-          { type: "tool_use", name: "search", input: { query: "test" } },
-        ],
-      }),
-    ];
-    const result = convertSessionMessages(msgs);
-
-    // Only tool message, no empty assistant message
-    expect(result).toHaveLength(1);
-    expect(result[0].role).toBe("tool");
-    expect(result[0].toolName).toBe("search");
-  });
-
-  it("should handle a full multi-turn conversation", () => {
-    const msgs = [
-      makeMsg("user", { content: "Show my tasks" }),
-      makeMsg("assistant", {
-        content: [
-          { type: "text", text: "I'll look that up." },
-          { type: "tool_use", name: "list_tasks", input: { projectId: "p1" } },
-        ],
-      }),
-      makeMsg("system", {
-        subtype: "tool_result",
-        tool_name: "list_tasks",
-        content: "Found 3 tasks",
-      }),
-      makeMsg("assistant", {
-        content: [{ type: "text", text: "You have 3 tasks." }],
-      }),
-    ];
-    const result = convertSessionMessages(msgs);
-
-    expect(result.map((m) => m.role)).toEqual([
-      "user",
-      "assistant",
-      "tool",
-      "tool",
-      "assistant",
-    ]);
-  });
-});