claude-world-studio 1.0.0

package/server/server.ts

@@ -0,0 +1,261 @@
+import "dotenv/config";
+import express from "express";
+import cors from "cors";
+import { createServer } from "http";
+import { WebSocketServer } from "ws";
+import path from "path";
+import fs from "fs";
+import { fileURLToPath } from "url";
+import type { WSClient, IncomingWSMessage } from "./types.js";
+import store from "./db.js";
+import { Session } from "./session.js";
+import { getSettings } from "./mcp-config.js";
+import sessionsRouter from "./routes/sessions.js";
+import filesRouter from "./routes/files.js";
+import settingsRouter from "./routes/settings.js";
+import publishRouter from "./routes/publish.js";
+import accountsRouter from "./routes/accounts.js";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const PORT = parseInt(process.env.PORT || "3001", 10);
+// Security: bind to localhost only — this server runs bypassPermissions
+const HOST = process.env.HOST || "127.0.0.1";
+
+const app = express();
+// Only allow our own frontend origins (exact port match)
+const ALLOWED_ORIGINS = [
+  `http://localhost:${PORT}`,
+  `http://127.0.0.1:${PORT}`,
+  "http://localhost:5173",    // Vite dev server
+  "http://127.0.0.1:5173",
+];
+app.use(cors({ origin: ALLOWED_ORIGINS }));
+app.use(express.json());
+
+// Serve built assets in production, raw client in dev
+const distDir = path.join(__dirname, "../dist");
+if (fs.existsSync(distDir)) {
+  app.use(express.static(distDir));
+  app.get("/", (_req, res) => {
+    res.sendFile(path.join(distDir, "index.html"));
+  });
+} else {
+  app.use("/client", express.static(path.join(__dirname, "../client")));
+  app.get("/", (_req, res) => {
+    res.sendFile(path.join(__dirname, "../client/index.html"));
+  });
+}
+
+// REST API routes
+app.use("/api/sessions", sessionsRouter);
+app.use("/api/sessions", filesRouter);
+app.use("/api/settings", settingsRouter);
+app.use("/api/publish", publishRouter);
+app.use("/api/accounts", accountsRouter);
+
+// Session management (long-lived agent sessions)
+const sessions: Map<string, Session> = new Map();
+
+// Idle session cleanup interval (evict after 30 min without subscribers)
+const SESSION_IDLE_MS = 30 * 60 * 1000;
+const sessionLastActivity = new Map<string, number>();
+
+function touchSession(sessionId: string) {
+  sessionLastActivity.set(sessionId, Date.now());
+}
+
+const idleCleanup = setInterval(() => {
+  const now = Date.now();
+  for (const [id, lastActive] of sessionLastActivity) {
+    const session = sessions.get(id);
+    if (session && !session.hasSubscribers() && now - lastActive > SESSION_IDLE_MS) {
+      session.close();
+      sessions.delete(id);
+      sessionLastActivity.delete(id);
+      console.log(`[Session] Evicted idle session ${id}`);
+    }
+  }
+}, 60_000);
+
+/**
+ * Get or create an in-memory Session for a validated sessionId.
+ * Returns null if the session doesn't exist in DB.
+ */
+function getSession(sessionId: string): Session | null {
+  let session = sessions.get(sessionId);
+  if (session) {
+    touchSession(sessionId);
+    return session;
+  }
+
+  const dbSession = store.getSession(sessionId);
+  if (!dbSession) return null;
+
+  const settings = getSettings();
+  session = new Session(sessionId, dbSession.workspace_path, settings.language);
+  sessions.set(sessionId, session);
+  touchSession(sessionId);
+  return session;
+}
+
+/**
+ * Clean up an in-memory session (called on delete or interrupt).
+ */
+function removeSession(sessionId: string): void {
+  const session = sessions.get(sessionId);
+  if (session) {
+    session.close();
+    sessions.delete(sessionId);
+    sessionLastActivity.delete(sessionId);
+  }
+}
+
+// Expose removeSession so the sessions router can call it on DELETE
+export { removeSession };
+
+// Create HTTP server
+const server = createServer(app);
+
+// WebSocket server with origin check (same list as CORS)
+const wss = new WebSocketServer({
+  server,
+  path: "/ws",
+  verifyClient: ({ origin }: { origin?: string }) => {
+    // Allow connections without origin (e.g. from CLI tools)
+    if (!origin) return true;
+    return ALLOWED_ORIGINS.includes(origin);
+  },
+});
+
+wss.on("connection", (ws: WSClient) => {
+  ws.isAlive = true;
+
+  ws.send(
+    JSON.stringify({ type: "connected", message: "Connected to Claude World Studio" })
+  );
+
+  ws.on("pong", () => {
+    ws.isAlive = true;
+  });
+
+  ws.on("message", (data) => {
+    try {
+      const message: IncomingWSMessage = JSON.parse(data.toString());
+
+      switch (message.type) {
+        case "subscribe": {
+          // Unsubscribe from any previous session first
+          if (ws.sessionId) {
+            const prev = sessions.get(ws.sessionId);
+            if (prev) prev.unsubscribe(ws);
+          }
+
+          const session = getSession(message.sessionId);
+          if (!session) {
+            ws.send(JSON.stringify({
+              type: "error",
+              error: "Session not found",
+              sessionId: message.sessionId,
+            }));
+            break;
+          }
+          session.subscribe(ws);
+
+          // Send existing messages from DB
+          const messages = store.getMessages(message.sessionId);
+          ws.send(
+            JSON.stringify({
+              type: "history",
+              messages,
+              sessionId: message.sessionId,
+            })
+          );
+          break;
+        }
+
+        case "chat": {
+          if (!message.content?.trim()) {
+            ws.send(JSON.stringify({ type: "error", error: "Empty message" }));
+            break;
+          }
+          // Unsubscribe from previous session if switching
+          if (ws.sessionId && ws.sessionId !== message.sessionId) {
+            const prev = sessions.get(ws.sessionId);
+            if (prev) prev.unsubscribe(ws);
+          }
+          const session = getSession(message.sessionId);
+          if (!session) {
+            ws.send(JSON.stringify({
+              type: "error",
+              error: "Session not found",
+              sessionId: message.sessionId,
+            }));
+            break;
+          }
+          session.subscribe(ws);
+          session.sendMessage(message.content);
+          break;
+        }
+
+        case "interrupt": {
+          const session = sessions.get(message.sessionId);
+          if (session) {
+            removeSession(message.sessionId);
+            // Notify all subscribers that session was interrupted
+            const interruptMsg = JSON.stringify({
+              type: "interrupted",
+              sessionId: message.sessionId,
+            });
+            wss.clients.forEach((client) => {
+              const wsClient = client as WSClient;
+              if (wsClient.sessionId === message.sessionId && wsClient.readyState === wsClient.OPEN) {
+                wsClient.send(interruptMsg);
+              }
+            });
+          }
+          break;
+        }
+
+        default:
+          ws.send(JSON.stringify({ type: "error", error: "Unknown message type" }));
+      }
+    } catch (error) {
+      console.error("Error handling WebSocket message:", error);
+      ws.send(JSON.stringify({ type: "error", error: "Invalid message format" }));
+    }
+  });
+
+  ws.on("close", () => {
+    for (const session of sessions.values()) {
+      session.unsubscribe(ws);
+    }
+  });
+});
+
+// Heartbeat to detect dead connections
+const heartbeat = setInterval(() => {
+  wss.clients.forEach((ws) => {
+    const client = ws as WSClient;
+    if (client.isAlive === false) {
+      return client.terminate();
+    }
+    client.isAlive = false;
+    client.ping();
+  });
+}, 30000);
+
+wss.on("close", () => {
+  clearInterval(heartbeat);
+  clearInterval(idleCleanup);
+});
+
+// Start server — bound to localhost for security
+server.listen(PORT, HOST, () => {
+  console.log(`Claude World Studio running at http://${HOST}:${PORT}`);
+  console.log(`WebSocket endpoint at ws://${HOST}:${PORT}/ws`);
+  if (!fs.existsSync(distDir)) {
+    console.log(`Frontend dev server at http://localhost:5173`);
+  }
+});

package/server/services/social-publisher.ts

@@ -0,0 +1,74 @@
+import { execFile } from "child_process";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const SCRIPTS_DIR = path.join(__dirname, "../../scripts");
+const MAX_TEXT_LENGTH = 500;
+const MIN_PUBLISH_SCORE = 70;
+
+export interface PublishOptions {
+  text: string;
+  token: string;
+  score?: number;
+  imageUrl?: string;
+  pollOptions?: string;   // pipe-separated: "A|B|C"
+  linkComment?: string;
+  tag?: string;
+}
+
+export interface PublishResult {
+  id: string;
+  permalink: string;
+}
+
+export async function publishToThreads(opts: PublishOptions): Promise<PublishResult> {
+  if (opts.score !== undefined && opts.score < MIN_PUBLISH_SCORE) {
+    throw new Error(`Score ${opts.score} below minimum ${MIN_PUBLISH_SCORE}. Improve content before publishing.`);
+  }
+  if (opts.text.length > MAX_TEXT_LENGTH) {
+    throw new Error(`Text too long: ${opts.text.length} chars (max ${MAX_TEXT_LENGTH})`);
+  }
+  if (!opts.token) {
+    throw new Error("No token provided. Configure token in Settings for this account.");
+  }
+
+  return new Promise((resolve, reject) => {
+    const scriptPath = path.join(SCRIPTS_DIR, "threads_api.py");
+    const args = [scriptPath, "publish", "--token", opts.token, "--text", opts.text];
+
+    if (opts.imageUrl) {
+      args.push("--image", opts.imageUrl);
+    }
+    if (opts.pollOptions) {
+      args.push("--poll", opts.pollOptions);
+    }
+    if (opts.linkComment) {
+      args.push("--link-comment", opts.linkComment);
+    }
+    if (opts.tag) {
+      args.push("--tag", opts.tag);
+    }
+
+    execFile(
+      "python3",
+      args,
+      { timeout: 30000 },
+      (error, stdout, stderr) => {
+        if (error) {
+          reject(new Error(stderr || error.message));
+          return;
+        }
+
+        try {
+          const result = JSON.parse(stdout.trim());
+          resolve(result);
+        } catch {
+          resolve({ id: stdout.trim(), permalink: "" });
+        }
+      }
+    );
+  });
+}

package/server/services/studio-mcp.ts

@@ -0,0 +1,107 @@
+import { tool, createSdkMcpServer } from "@anthropic-ai/claude-agent-sdk";
+import { z } from "zod";
+import store from "../db.js";
+import { publishToThreads } from "./social-publisher.js";
+
+const publishTool = tool(
+  "publish_to_threads",
+  "Publish content to Threads via Graph API. Quality gate: score >= 70 required. Pass account_id from the Social Accounts table.",
+  {
+    text: z.string().describe("Post text content (max 500 chars)"),
+    account_id: z.string().describe("Account ID from Social Accounts table"),
+    score: z.number().describe("Content quality score (must be >= 70)"),
+    image_url: z.string().optional().describe("Public image URL to attach"),
+    poll_options: z.string().optional().describe("Poll options separated by | (2-4 options, max 25 chars each)"),
+    link_comment: z.string().optional().describe("Auto-reply with this link (avoids reach penalty)"),
+    tag: z.string().optional().describe("Topic tag (no # prefix, one per post)"),
+  },
+  async (args) => {
+    const account = store.getAccount(args.account_id);
+    if (!account) {
+      return { content: [{ type: "text" as const, text: `Error: Account not found: ${args.account_id}` }], isError: true };
+    }
+    if (!account.token) {
+      return { content: [{ type: "text" as const, text: `Error: No token configured for account "${account.name}". Add token in Settings.` }], isError: true };
+    }
+    if (account.platform !== "threads") {
+      return { content: [{ type: "text" as const, text: `Error: Account "${account.name}" is ${account.platform}, not threads.` }], isError: true };
+    }
+
+    try {
+      const result = await publishToThreads({
+        text: args.text,
+        token: account.token,
+        score: args.score,
+        imageUrl: args.image_url,
+        pollOptions: args.poll_options,
+        linkComment: args.link_comment,
+        tag: args.tag,
+      });
+
+      // Log to publish history
+      store.addPublish({
+        session_id: null,
+        platform: "threads",
+        account: args.account_id,
+        content: args.text,
+        post_id: result.id,
+        post_url: result.permalink,
+        status: "published",
+      });
+
+      return {
+        content: [{
+          type: "text" as const,
+          text: JSON.stringify({
+            success: true,
+            post_id: result.id,
+            permalink: result.permalink,
+            account: account.name,
+            handle: account.handle,
+          }),
+        }],
+      };
+    } catch (err) {
+      // Log failed attempt
+      store.addPublish({
+        session_id: null,
+        platform: "threads",
+        account: args.account_id,
+        content: args.text,
+        post_id: null,
+        post_url: null,
+        status: "failed",
+      });
+
+      return {
+        content: [{ type: "text" as const, text: `Error: ${(err as Error).message}` }],
+        isError: true,
+      };
+    }
+  }
+);
+
+const historyTool = tool(
+  "get_publish_history",
+  "Get recent publish history from local database. No API token needed.",
+  {
+    limit: z.number().optional().describe("Number of records to return (default 20, max 500)"),
+  },
+  async (args) => {
+    const limit = Math.min(Math.max(args.limit || 20, 1), 500);
+    const history = store.getPublishHistory(limit);
+    return {
+      content: [{
+        type: "text" as const,
+        text: JSON.stringify(history, null, 2),
+      }],
+    };
+  }
+);
+
+export function createStudioMcpServer() {
+  return createSdkMcpServer({
+    name: "studio",
+    tools: [publishTool, historyTool],
+  });
+}

package/server/session.ts

@@ -0,0 +1,167 @@
+import type { WSClient, Language } from "./types.js";
+import { AgentSession } from "./ai-client.js";
+import store from "./db.js";
+
+export class Session {
+  public readonly sessionId: string;
+  private subscribers: Set<WSClient> = new Set();
+  private agentSession: AgentSession;
+  private isListening = false;
+
+  constructor(sessionId: string, workspacePath?: string, language?: Language) {
+    this.sessionId = sessionId;
+    this.agentSession = new AgentSession(workspacePath, language);
+  }
+
+  private async startListening() {
+    if (this.isListening) return;
+    this.isListening = true;
+
+    try {
+      for await (const message of this.agentSession.getOutputStream()) {
+        this.handleSDKMessage(message);
+      }
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      console.error(`Error in session ${this.sessionId}:`, errorMsg);
+      this.broadcastError(errorMsg);
+    } finally {
+      this.isListening = false;
+    }
+  }
+
+  sendMessage(content: string) {
+    store.addMessage(this.sessionId, { role: "user", content });
+
+    this.broadcast({
+      type: "user_message",
+      content,
+      sessionId: this.sessionId,
+    });
+
+    this.agentSession.sendMessage(content);
+
+    if (!this.isListening) {
+      this.startListening();
+    }
+  }
+
+  private handleSDKMessage(message: any) {
+    if (message.type === "assistant") {
+      const content = message.message?.content;
+      if (!content) return;
+
+      if (typeof content === "string") {
+        store.addMessage(this.sessionId, { role: "assistant", content });
+        this.broadcast({
+          type: "assistant_message",
+          content,
+          sessionId: this.sessionId,
+        });
+      } else if (Array.isArray(content)) {
+        for (const block of content) {
+          if (block.type === "text" && block.text) {
+            store.addMessage(this.sessionId, {
+              role: "assistant",
+              content: block.text,
+            });
+            this.broadcast({
+              type: "assistant_message",
+              content: block.text,
+              sessionId: this.sessionId,
+            });
+          } else if (block.type === "tool_use" && block.name) {
+            store.addMessage(this.sessionId, {
+              role: "tool_use",
+              tool_name: block.name,
+              tool_id: block.id,
+              tool_input: JSON.stringify(block.input),
+            });
+            this.broadcast({
+              type: "tool_use",
+              toolName: block.name,
+              toolId: block.id,
+              toolInput: block.input,
+              sessionId: this.sessionId,
+            });
+          } else if (block.type === "tool_result") {
+            const resultContent =
+              typeof block.content === "string"
+                ? block.content
+                : JSON.stringify(block.content);
+            store.addMessage(this.sessionId, {
+              role: "tool_result",
+              tool_id: block.tool_use_id,
+              content: resultContent,
+            });
+            this.broadcast({
+              type: "tool_result",
+              toolId: block.tool_use_id,
+              content: resultContent,
+              sessionId: this.sessionId,
+            });
+          }
+        }
+      }
+    } else if (message.type === "result") {
+      const costUsd = message.total_cost_usd;
+      const durationMs = message.duration_ms;
+
+      store.addMessage(this.sessionId, {
+        role: "result",
+        content: JSON.stringify({
+          success: message.subtype === "success",
+          cost: costUsd,
+          duration: durationMs,
+        }),
+        cost_usd: costUsd,
+      });
+
+      this.broadcast({
+        type: "result",
+        success: message.subtype === "success",
+        sessionId: this.sessionId,
+        cost: costUsd,
+        duration: durationMs,
+      });
+    }
+  }
+
+  subscribe(client: WSClient) {
+    this.subscribers.add(client);
+    client.sessionId = this.sessionId;
+  }
+
+  unsubscribe(client: WSClient) {
+    this.subscribers.delete(client);
+  }
+
+  hasSubscribers(): boolean {
+    return this.subscribers.size > 0;
+  }
+
+  private broadcast(message: any) {
+    const messageStr = JSON.stringify(message);
+    for (const client of this.subscribers) {
+      try {
+        if (client.readyState === client.OPEN) {
+          client.send(messageStr);
+        }
+      } catch {
+        this.subscribers.delete(client);
+      }
+    }
+  }
+
+  private broadcastError(error: string) {
+    this.broadcast({
+      type: "error",
+      error,
+      sessionId: this.sessionId,
+    });
+  }
+
+  close() {
+    this.agentSession.close();
+  }
+}

package/server/types.ts

@@ -0,0 +1,86 @@
+import type { WebSocket } from "ws";
+
+export interface WSClient extends WebSocket {
+  sessionId?: string;
+  isAlive?: boolean;
+}
+
+export interface Session {
+  id: string;
+  title: string;
+  workspace_path: string;
+  created_at: string;
+  updated_at: string;
+  status: string;
+}
+
+export interface Message {
+  id: string;
+  session_id: string;
+  role: "user" | "assistant" | "tool_use" | "tool_result" | "result";
+  content: string | null;
+  tool_name: string | null;
+  tool_id: string | null;
+  tool_input: string | null;
+  cost_usd: number | null;
+  created_at: string;
+}
+
+export type Language = "zh-TW" | "en" | "ja";
+
+export type Platform = "threads" | "instagram";
+
+export interface SocialAccount {
+  id: string;
+  name: string;
+  handle: string;
+  platform: Platform;
+  token: string;
+  user_id: string;
+  style: string;
+  persona_prompt: string;
+  created_at: string;
+}
+
+export interface Settings {
+  language: Language;
+  trendPulseVenvPython: string;
+  cfBrowserVenvPython: string;
+  notebooklmServerPath: string;
+  cfBrowserUrl: string;
+  cfBrowserApiKey: string;
+  defaultWorkspace: string;
+}
+
+export interface PublishRecord {
+  id: string;
+  session_id: string | null;
+  platform: string;
+  account: string;
+  content: string;
+  post_id: string | null;
+  post_url: string | null;
+  status: string;
+  created_at: string;
+}
+
+export interface WSChatMessage {
+  type: "chat";
+  content: string;
+  sessionId: string;
+}
+
+export interface WSSubscribeMessage {
+  type: "subscribe";
+  sessionId: string;
+}
+
+export interface WSInterruptMessage {
+  type: "interrupt";
+  sessionId: string;
+}
+
+export type IncomingWSMessage =
+  | WSChatMessage
+  | WSSubscribeMessage
+  | WSInterruptMessage;

package/tailwind.config.js

@@ -0,0 +1,8 @@
+/** @type {import('tailwindcss').Config} */
+export default {
+  content: ["./client/**/*.{js,ts,jsx,tsx,html}"],
+  theme: {
+    extend: {},
+  },
+  plugins: [require("@tailwindcss/typography")],
+};