claude-world-studio 1.0.0

package/server/ai-client.ts

@@ -0,0 +1,356 @@
+import { query } from "@anthropic-ai/claude-agent-sdk";
+import { buildMcpServers, getSettings } from "./mcp-config.js";
+import { createStudioMcpServer } from "./services/studio-mcp.js";
+import store from "./db.js";
+import type { Language, SocialAccount } from "./types.js";
+
+const LANGUAGE_INSTRUCTIONS: Record<Language, string> = {
+  "zh-TW": `**語言規則（最高優先級）**：
+你必須始終使用繁體中文（台灣用語）回覆使用者。
+所有對話、解釋、摘要、工具使用說明都必須使用繁體中文。
+程式碼內的變數名和註解可以用英文，但所有面向使用者的文字必須是繁體中文。`,
+
+  "en": `**Language Rule (highest priority)**:
+You must always respond to the user in English.
+All conversations, explanations, summaries, and tool usage descriptions must be in English.`,
+
+  "ja": `**言語ルール（最優先）**：
+ユーザーには必ず日本語で回答してください。
+すべての会話、説明、要約、ツール使用の説明は日本語で行ってください。
+コード内の変数名やコメントは英語で構いませんが、ユーザー向けのテキストはすべて日本語にしてください。`,
+};
+
+/** Escape markdown-breaking chars and newlines in user-supplied strings */
+function escMd(s: string): string {
+  return s.replace(/[|\\`*_{}[\]()#+\-!~>]/g, "\\$&").replace(/\n/g, " ");
+}
+
+function buildAccountsBlock(accounts: SocialAccount[]): string {
+  if (accounts.length === 0) {
+    return "No social accounts configured. User needs to add accounts in Settings first.";
+  }
+
+  const rows = accounts.map((a) =>
+    `| ${escMd(a.id)} | ${escMd(a.name)} | ${escMd(a.handle)} | ${escMd(a.platform)} | ${escMd(a.style || "-")} |`
+  ).join("\n");
+
+  const personas = accounts
+    .filter((a) => a.persona_prompt)
+    .map((a) => `**${escMd(a.name)}** (${escMd(a.handle)}, ${escMd(a.platform)}): ${escMd(a.persona_prompt)}`)
+    .join("\n");
+
+  return `| ID | Name | Handle | Platform | Style |
+|-----|------|--------|----------|-------|
+${rows}
+
+${personas ? `### Account Personas\n${personas}` : ""}
+
+When publishing, adapt content tone and style based on each account's persona.
+For matrix publishing (same topic, multiple accounts), generate unique content for EACH account based on their style.`;
+}
+
+function buildSystemPrompt(language: Language, accounts: SocialAccount[]): string {
+  return `${LANGUAGE_INSTRUCTIONS[language]}
+
+You are Claude World Studio assistant — an AI-powered content pipeline for trend discovery, deep research, and social publishing.
+
+## MCP Tools Available
+
+### 1. trend-pulse (12 tools — trends + content)
+
+**Trend Data (5 tools):**
+- **get_trending(sources, geo, count)**: Query ALL 20 free sources for real-time trends.
+  - sources: ALWAYS pass "" (empty) to use ALL 20 sources. Only filter if user explicitly asks.
+  - Sources: google_trends, hackernews, mastodon, bluesky, wikipedia, github, pypi, google_news, lobsters, devto, npm, reddit, coingecko, dockerhub, stackoverflow, producthunt, arxiv, lemmy, dcard, ptt
+  - geo: "TW"=Taiwan, "US"=USA, "JP"=Japan, ""=global
+  - count: Always 20
+- **search_trends(query, sources, geo)**: Cross-source keyword search. sources="" for all.
+- **list_sources()**: List all sources and their properties.
+- **take_snapshot(sources, geo, count)**: Save snapshot to SQLite for velocity tracking.
+- **get_trend_history(keyword, days, source)**: Historical data with direction (rising/stable/falling).
+
+**Content Guide (5 tools):**
+- **get_content_brief(topic)**: Writing brief with hook examples, patent strategies, CTA, scoring dimensions.
+- **get_scoring_guide()**: 5-dimension patent scoring (based on 7 Meta patents): Hook Power 25%, Engagement Trigger 25%, Conversation Durability 20%, Velocity Potential 15%, Format Score 15%. Score ≥70 (B grade) required to publish.
+- **get_platform_specs(platform)**: Platform specs: char limits, algorithm signals, best posting times.
+- **get_review_checklist()**: Quality review checklist (7 checks) before publishing.
+- **get_reel_guide()**: Reels script guide (tutorial/story/list — 3 styles).
+
+**Threads Search (1 tool):**
+- **search_threads_posts(query)**: Search Threads posts, sorted by heat score.
+
+### 4. studio (2 tools — publishing + history, in-process)
+- **publish_to_threads(text, account_id, score, image_url?, poll_options?, link_comment?, tag?)**: Publish to Threads via Graph API. Quality gate: score ≥ 70 required. Use account ID from the Social Accounts table below. Token is read from DB automatically.
+- **get_publish_history(limit?)**: Query local publish records (no API token needed).
+
+## Social Accounts
+${buildAccountsBlock(accounts)}
+
+### 2. cf-browser (10 tools — Cloudflare Browser Rendering)
+Headless Chrome for JS-rendered pages. WebFetch only gets raw HTML — cf-browser renders the full page.
+- **browser_markdown(url)**: Page content as clean Markdown. **Most used** — use this for deep research.
+- **browser_content(url)**: Full rendered HTML.
+- **browser_screenshot(url)**: Full page screenshot (PNG).
+- **browser_pdf(url)**: Generate PDF.
+- **browser_scrape(url, selector)**: CSS selector to extract specific elements.
+- **browser_json(url, schema)**: AI-driven structured data extraction.
+- **browser_links(url)**: Extract all hyperlinks from a page.
+- **browser_a11y(url)**: Accessibility tree (low token cost — use when you only need text structure).
+- **browser_crawl(url)**: Async multi-page crawl.
+- **browser_crawl_status(id)**: Check crawl progress.
+
+### 3. notebooklm (13 tools — Research + Artifact Generation)
+NotebookLM does deep research, Claude writes content. Supports 10 artifact types.
+
+**Notebook Management (3 tools):**
+- **create_notebook(title, sources?, text_sources?)**: Create notebook. sources=list of URLs/YouTube. text_sources=list of raw text.
+- **list_notebooks()**: List all notebooks.
+- **delete_notebook(name_or_id)**: Delete a notebook by name or ID.
+
+**Source & Research (5 tools):**
+- **add_source(name_or_id, url?, text?, pdf_path?)**: Add URL, text, YouTube, or PDF to notebook.
+- **ask(name_or_id, query)**: Ask a question against notebook sources. Returns answer with citations.
+- **summarize(name_or_id)**: Generate a summary of notebook content.
+- **list_sources(name_or_id)**: List all sources in a notebook.
+- **research(name_or_id, query, mode)**: Deep research. mode="fast" or "thorough".
+
+**Artifact Generation (2 tools):**
+- **generate_artifact(name_or_id, artifact_type, lang?)**: Generate an artifact. Types: podcast (M4A), slides (PDF), report, quiz, flashcards, mindmap, infographic, datasheet, study_guide.
+- **download_artifact(name_or_id, artifact_type, output_path)**: Download generated artifact.
+
+**IMPORTANT: Video Synthesis (slides + podcast → MP4)**
+NotebookLM does NOT produce usable video directly. To create a video:
+1. Generate \`slides\` (PDF) + \`audio\` (podcast M4A) — run these sequentially, NOT in parallel (MCP is single-connection)
+2. Download both artifacts to local files
+3. Convert PDF pages to images: \`pdftoppm -png -r 300 slides.pdf slides_page\`
+4. Combine with ffmpeg:
+\`\`\`bash
+# Calculate duration per slide: total_audio_duration / num_slides
+duration=$(ffprobe -v error -show_entries format=duration -of csv=p=0 audio.mp3)
+num_slides=$(ls slides_page-*.png | wc -l)
+per_slide=$(echo "$duration / $num_slides" | bc -l)
+# Create video with crossfade transitions
+ffmpeg -framerate 1/$per_slide -pattern_type glob -i 'slides_page-*.png' -i audio.mp3 -c:v libx264 -profile:v baseline -pix_fmt yuv420p -c:a aac -shortest output.mp4
+\`\`\`
+5. Always include the **full absolute path** of the output MP4 in your response.
+
+**Pipelines (3 tools):**
+- **research_pipeline(sources, questions, output_format?)**: Full pipeline: create notebook → add sources → research questions → generate output. output_format: "article", "threads", "newsletter".
+- **trend_research(geo?, count?, platform?)**: Auto-discover trending topics → research → generate content. Integrates with trend-pulse.
+- Use these for one-shot "research this topic and give me content" workflows.
+
+## Current Date
+Today is ${new Date().toISOString().split("T")[0]}. Always be aware of the current date when evaluating data freshness.
+
+## Important Rules
+- **Use ALL sources**: When calling get_trending, pass sources="" (empty string) to query ALL 20 sources. Do NOT filter to just 3-4 sources.
+- For ANY question about trends, news, or what's popular: ALWAYS use trend-pulse tools first. Do NOT rely on your training data.
+- For web content analysis: use cf-browser tools (browser_markdown for content, browser_screenshot for visuals).
+- For research requests: combine trend-pulse + cf-browser (browser_markdown) + WebSearch for comprehensive results.
+- **File paths**: When you create, download, or save ANY file, ALWAYS include the **full absolute file path** in backticks so the UI can make it clickable for preview.
+
+## MANDATORY: Read Original Sources (來源充足性)
+**NEVER write content based on titles/metadata alone.** For every topic you write about:
+- **Single topic**: Read at least 1 primary source (original article/announcement/README) via \`browser_markdown(url)\`
+- **Controversial topic**: Read at least 2 sources (both sides)
+- **Data claims**: Find the original data source (no second-hand citations)
+- Source types: Article → \`browser_markdown(url)\`, HN → original + top comments, GitHub → full README
+- **Exception**: Only skip if user explicitly says "this is the original, no need to verify"
+
+## MANDATORY: Timeline Verification (資訊新鮮度)
+**Every fact must have a verified timestamp.** After getting trend data:
+1. Check ALL timestamps. Discard anything older than 48 hours.
+2. For each fact, note the published date from the original source.
+3. Use the correct time words based on age:
+
+| Source age | Allowed words | Forbidden words |
+|---|---|---|
+| Today | 「今天」「剛剛」 | — |
+| 1-3 days ago | 「這兩天」「前幾天」 | 「剛」「最新」 |
+| 4-7 days ago | 「上週」「這週」 | 「剛」「昨天」 |
+| 8-30 days ago | 「最近」「這個月」 | 「上週」「剛」 |
+| >30 days | 「之前」「今年」 | Any freshness-implying words |
+
+4. For changing metrics (stars, upvotes): use 「超過 X」 not exact numbers.
+5. Version numbers: MUST match original source exactly.
+6. If trend data looks stale or has no timestamps, verify via WebSearch or browser_markdown.
+
+## MANDATORY: Meta Patent-Based Content Optimization (流量專利)
+When writing social posts, check ALL 5 dimensions from Meta's ranking patents:
+
+| # | Check | Patent | Requirement | Fix if fails |
+|---|---|---|---|---|
+| 1 | Hook: first line has number or contrast? | EdgeRank | 10-45 chars, number-first or curiosity gap | Move key data to first line |
+| 2 | CTA: anyone can answer? | Dear Algo | Direct 「你」address, low-barrier question | Remove assumed expertise |
+| 3 | Has contrast/both sides? | 72hr window | 「但是」「不過」creates discussion space | Add limitation/controversy/beta angle |
+| 4 | Timely hot topic? Short enough? | Andromeda | 50-300 chars, urgency language | Delete filler, add time markers |
+| 5 | Mobile-scannable? | Multi-modal | Line breaks, arrow lists, no text walls | Split long sentences, add separators |
+
+**Quality Gates (ALL must pass before publishing):**
+- Overall Score ≥ 70
+- **Conversation Durability ≥ 55** (most commonly missed — add 轉折/爭議面 if below)
+- Hook: 10-45 chars with number or contrast
+- CTA: clear question or poll
+- Timeline: all time words verified per table above
+- Source: every claim traceable to original source
+- Character limit: Threads ≤500, IG ≤2200
+- 台灣繁中語氣 (no 簡體/AI filler like 在當今/隨著/值得注意)
+
+## Publishing Rules
+- **Publishing flow**: get_content_brief → write → get_scoring_guide (self-score) → get_review_checklist → publish_to_threads
+- **Polls**: ALWAYS use \`--poll\` for A/B/C options, NEVER text-based polls in post body
+- **Links**: NEVER put URLs in post body (kills reach). Use \`--link-comment\` to auto-reply with link.
+- **Tags**: Use \`tag\` for topic categorization (no # prefix, one per post).
+- **Optimal times**: Threads 21:00 → IG 12:00 next day
+
+## Full Pipeline Workflow
+1. **Discover**: get_trending(sources="", geo, count=20) — ALL 20 sources
+2. **Read Source**: browser_markdown(url) for each candidate — MANDATORY, never skip
+3. **Verify Timeline**: Check dates, map to time words, discard stale data
+4. **Research**: browser_markdown + WebSearch for deep dive, read 2-3 sources minimum
+5. **Brief**: get_content_brief(topic) for writing strategy
+6. **Create**: Write content → patent check (5 dimensions) → format check
+7. **Score**: get_scoring_guide — self-score (must ≥ 70, Conversation Durability ≥ 55)
+8. **Review**: get_review_checklist — final quality check, remove AI filler
+9. **NotebookLM** (if requested): create notebook → generate slides → generate audio → download both → synthesize MP4 (pdftoppm + ffmpeg)
+10. **Publish**: mcp__studio__publish_to_threads(text, account_id, score)
+
+Be concise but thorough. Explain which tools you're using and why.`;
+}
+
+type UserMessage = {
+  type: "user";
+  message: { role: "user"; content: string };
+};
+
+class QueueClosedError extends Error {
+  constructor() {
+    super("Queue closed");
+    this.name = "QueueClosedError";
+  }
+}
+
+class MessageQueue {
+  private messages: UserMessage[] = [];
+  private waiting: {
+    resolve: (msg: UserMessage) => void;
+    reject: (err: Error) => void;
+  } | null = null;
+  private closed = false;
+
+  push(content: string) {
+    if (this.closed) return;
+
+    const msg: UserMessage = {
+      type: "user",
+      message: { role: "user", content },
+    };
+
+    if (this.waiting) {
+      this.waiting.resolve(msg);
+      this.waiting = null;
+    } else {
+      this.messages.push(msg);
+    }
+  }
+
+  async *[Symbol.asyncIterator](): AsyncIterableIterator<UserMessage> {
+    while (!this.closed) {
+      if (this.messages.length > 0) {
+        yield this.messages.shift()!;
+      } else {
+        try {
+          yield await new Promise<UserMessage>((resolve, reject) => {
+            this.waiting = { resolve, reject };
+          });
+        } catch (err) {
+          if (err instanceof QueueClosedError) break;
+          throw err;
+        }
+      }
+    }
+  }
+
+  close() {
+    this.closed = true;
+    if (this.waiting) {
+      this.waiting.reject(new QueueClosedError());
+      this.waiting = null;
+    }
+  }
+}
+
+export class AgentSession {
+  private queue = new MessageQueue();
+  private outputIterator: AsyncIterator<any> | null = null;
+  private abortController = new AbortController();
+
+  constructor(workspacePath?: string, language?: Language) {
+    const settings = getSettings();
+    const mcpServers = buildMcpServers(settings);
+    const cwd = workspacePath || settings.defaultWorkspace || process.cwd();
+    const lang = language || settings.language || "zh-TW";
+    const accounts = store.getAllAccounts();
+
+    // In-process Studio MCP server (direct DB access, no env vars)
+    const studioServer = createStudioMcpServer();
+
+    const allowedTools = [
+      "Bash",
+      "Read",
+      "Write",
+      "Edit",
+      "Glob",
+      "Grep",
+      "WebSearch",
+      "WebFetch",
+    ];
+
+    // Add MCP tool patterns so MCP tools are accessible
+    const allMcpServers: Record<string, any> = { ...mcpServers, studio: studioServer };
+    const mcpServerNames = Object.keys(allMcpServers);
+    for (const name of mcpServerNames) {
+      allowedTools.push(`mcp__${name}`);
+    }
+
+    const options: Record<string, any> = {
+      maxTurns: 200,
+      model: "sonnet",
+      // bypassPermissions: intentional — local single-user tool.
+      // All tool calls execute without prompting. Do NOT expose to untrusted networks.
+      permissionMode: "bypassPermissions",
+      abortController: this.abortController,
+      systemPrompt: buildSystemPrompt(lang, accounts),
+      cwd,
+      allowedTools,
+      // Prevent confusion: trend-pulse publish tool is superseded by studio
+      disallowedTools: ["mcp__trend-pulse__publish_to_threads", "mcp__trend-pulse__get_publish_history"],
+      mcpServers: allMcpServers,
+    };
+
+    this.outputIterator = query({
+      prompt: this.queue as any,
+      options,
+    })[Symbol.asyncIterator]();
+  }
+
+  sendMessage(content: string) {
+    this.queue.push(content);
+  }
+
+  async *getOutputStream() {
+    if (!this.outputIterator) {
+      throw new Error("Session not initialized");
+    }
+    while (true) {
+      const { value, done } = await this.outputIterator.next();
+      if (done) break;
+      yield value;
+    }
+  }
+
+  close() {
+    this.abortController.abort();
+    this.queue.close();
+  }
+}

package/server/db.ts

@@ -0,0 +1,299 @@
+import Database from "better-sqlite3";
+import { v4 as uuidv4 } from "uuid";
+import path from "path";
+import { fileURLToPath } from "url";
+import type { Session, Message, PublishRecord, SocialAccount } from "./types.js";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const DB_PATH = path.join(__dirname, "../data/studio.db");
+
+const db = new Database(DB_PATH);
+
+// Enable WAL mode for better concurrent read performance
+db.pragma("journal_mode = WAL");
+
+// Create tables
+db.exec(`
+  CREATE TABLE IF NOT EXISTS sessions (
+    id TEXT PRIMARY KEY,
+    title TEXT NOT NULL DEFAULT 'New Session',
+    workspace_path TEXT NOT NULL,
+    created_at TEXT DEFAULT (datetime('now')),
+    updated_at TEXT DEFAULT (datetime('now')),
+    status TEXT DEFAULT 'active'
+  );
+
+  CREATE TABLE IF NOT EXISTS messages (
+    id TEXT PRIMARY KEY,
+    session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+    role TEXT NOT NULL,
+    content TEXT,
+    tool_name TEXT,
+    tool_id TEXT,
+    tool_input TEXT,
+    cost_usd REAL,
+    created_at TEXT DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS settings (
+    key TEXT PRIMARY KEY,
+    value TEXT NOT NULL
+  );
+
+  CREATE TABLE IF NOT EXISTS publish_history (
+    id TEXT PRIMARY KEY,
+    session_id TEXT REFERENCES sessions(id),
+    platform TEXT NOT NULL,
+    account TEXT NOT NULL,
+    content TEXT NOT NULL,
+    post_id TEXT,
+    post_url TEXT,
+    status TEXT DEFAULT 'pending',
+    created_at TEXT DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS social_accounts (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    handle TEXT NOT NULL,
+    platform TEXT NOT NULL,
+    token TEXT NOT NULL DEFAULT '',
+    user_id TEXT NOT NULL DEFAULT '',
+    style TEXT NOT NULL DEFAULT '',
+    persona_prompt TEXT NOT NULL DEFAULT '',
+    created_at TEXT DEFAULT (datetime('now'))
+  );
+`);
+
+// Social accounts are configured via the Settings UI — no hardcoded accounts.
+
+// Prepared statements
+const stmts = {
+  // Sessions
+  createSession: db.prepare(
+    `INSERT INTO sessions (id, title, workspace_path) VALUES (?, ?, ?)`
+  ),
+  getSession: db.prepare(`SELECT * FROM sessions WHERE id = ? AND status = 'active'`),
+  getAllSessions: db.prepare(
+    `SELECT * FROM sessions WHERE status = 'active' ORDER BY updated_at DESC`
+  ),
+  updateSessionTitle: db.prepare(
+    `UPDATE sessions SET title = ?, updated_at = datetime('now') WHERE id = ?`
+  ),
+  updateSessionTimestamp: db.prepare(
+    `UPDATE sessions SET updated_at = datetime('now') WHERE id = ?`
+  ),
+  deleteSession: db.prepare(
+    `UPDATE sessions SET status = 'deleted', updated_at = datetime('now') WHERE id = ?`
+  ),
+
+  // Messages
+  addMessage: db.prepare(
+    `INSERT INTO messages (id, session_id, role, content, tool_name, tool_id, tool_input, cost_usd)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+  ),
+  getMessages: db.prepare(
+    `SELECT * FROM messages WHERE session_id = ? ORDER BY created_at ASC`
+  ),
+
+  // Settings
+  getSetting: db.prepare(`SELECT value FROM settings WHERE key = ?`),
+  setSetting: db.prepare(
+    `INSERT OR REPLACE INTO settings (key, value) VALUES (?, ?)`
+  ),
+  getAllSettings: db.prepare(`SELECT * FROM settings`),
+
+  // Publish History
+  addPublish: db.prepare(
+    `INSERT INTO publish_history (id, session_id, platform, account, content, post_id, post_url, status)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+  ),
+  getPublishHistory: db.prepare(
+    `SELECT * FROM publish_history ORDER BY created_at DESC LIMIT ?`
+  ),
+  updatePublishStatus: db.prepare(
+    `UPDATE publish_history SET status = ?, post_id = ?, post_url = ? WHERE id = ?`
+  ),
+
+  // Social Accounts
+  createAccount: db.prepare(
+    `INSERT INTO social_accounts (id, name, handle, platform, token, user_id, style, persona_prompt) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+  ),
+  getAccount: db.prepare(`SELECT * FROM social_accounts WHERE id = ?`),
+  getAllAccounts: db.prepare(`SELECT * FROM social_accounts ORDER BY created_at ASC`),
+  getAccountsByPlatform: db.prepare(`SELECT * FROM social_accounts WHERE platform = ? ORDER BY created_at ASC`),
+  updateAccount: db.prepare(
+    `UPDATE social_accounts SET name = ?, handle = ?, platform = ?, user_id = ?, style = ?, persona_prompt = ? WHERE id = ?`
+  ),
+  updateAccountToken: db.prepare(
+    `UPDATE social_accounts SET token = ? WHERE id = ?`
+  ),
+  deleteAccount: db.prepare(`DELETE FROM social_accounts WHERE id = ?`),
+};
+
+export const store = {
+  // Sessions
+  createSession(title?: string, workspacePath?: string): Session {
+    const id = uuidv4();
+    const ws = workspacePath || process.env.DEFAULT_WORKSPACE || process.cwd();
+    stmts.createSession.run(id, title || "New Session", ws);
+    return stmts.getSession.get(id) as Session;
+  },
+
+  getSession(id: string): Session | undefined {
+    return stmts.getSession.get(id) as Session | undefined;
+  },
+
+  getAllSessions(): Session[] {
+    return stmts.getAllSessions.all() as Session[];
+  },
+
+  updateSessionTitle(id: string, title: string) {
+    stmts.updateSessionTitle.run(title, id);
+  },
+
+  deleteSession(id: string): boolean {
+    const result = stmts.deleteSession.run(id);
+    return result.changes > 0;
+  },
+
+  // Messages
+  addMessage(
+    sessionId: string,
+    msg: {
+      role: string;
+      content?: string | null;
+      tool_name?: string | null;
+      tool_id?: string | null;
+      tool_input?: string | null;
+      cost_usd?: number | null;
+    }
+  ): Message {
+    const id = uuidv4();
+    stmts.addMessage.run(
+      id, sessionId, msg.role,
+      msg.content ?? null, msg.tool_name ?? null,
+      msg.tool_id ?? null, msg.tool_input ?? null,
+      msg.cost_usd ?? null
+    );
+    stmts.updateSessionTimestamp.run(sessionId);
+
+    // Auto-generate title from first user message
+    const session = stmts.getSession.get(sessionId) as Session | undefined;
+    if (session && session.title === "New Session" && msg.role === "user" && msg.content) {
+      const title = msg.content.slice(0, 50) + (msg.content.length > 50 ? "..." : "");
+      stmts.updateSessionTitle.run(title, sessionId);
+    }
+
+    return {
+      id,
+      session_id: sessionId,
+      role: msg.role as Message["role"],
+      content: msg.content ?? null,
+      tool_name: msg.tool_name ?? null,
+      tool_id: msg.tool_id ?? null,
+      tool_input: msg.tool_input ?? null,
+      cost_usd: msg.cost_usd ?? null,
+      created_at: new Date().toISOString(),
+    };
+  },
+
+  getMessages(sessionId: string): Message[] {
+    return stmts.getMessages.all(sessionId) as Message[];
+  },
+
+  // Settings
+  getSetting(key: string): string | undefined {
+    const row = stmts.getSetting.get(key) as { value: string } | undefined;
+    return row?.value;
+  },
+
+  setSetting(key: string, value: string) {
+    stmts.setSetting.run(key, value);
+  },
+
+  getAllSettings(): Record<string, string> {
+    const rows = stmts.getAllSettings.all() as { key: string; value: string }[];
+    const result: Record<string, string> = {};
+    for (const row of rows) {
+      result[row.key] = row.value;
+    }
+    return result;
+  },
+
+  // Publish History
+  addPublish(record: Omit<PublishRecord, "id" | "created_at">): PublishRecord {
+    const id = uuidv4();
+    stmts.addPublish.run(
+      id, record.session_id, record.platform, record.account,
+      record.content, record.post_id, record.post_url, record.status
+    );
+    return { id, created_at: new Date().toISOString(), ...record };
+  },
+
+  getPublishHistory(limit = 50): PublishRecord[] {
+    return stmts.getPublishHistory.all(limit) as PublishRecord[];
+  },
+
+  updatePublishStatus(id: string, status: string, postId?: string, postUrl?: string) {
+    stmts.updatePublishStatus.run(status, postId ?? null, postUrl ?? null, id);
+  },
+
+  // Social Accounts
+  createAccount(data: {
+    name: string;
+    handle: string;
+    platform: string;
+    token?: string;
+    user_id?: string;
+    style?: string;
+    persona_prompt?: string;
+  }): SocialAccount {
+    const id = uuidv4();
+    stmts.createAccount.run(
+      id, data.name, data.handle, data.platform,
+      data.token || "", data.user_id || "",
+      data.style || "", data.persona_prompt || ""
+    );
+    return stmts.getAccount.get(id) as SocialAccount;
+  },
+
+  getAccount(id: string): SocialAccount | undefined {
+    return stmts.getAccount.get(id) as SocialAccount | undefined;
+  },
+
+  getAllAccounts(): SocialAccount[] {
+    return stmts.getAllAccounts.all() as SocialAccount[];
+  },
+
+  getAccountsByPlatform(platform: string): SocialAccount[] {
+    return stmts.getAccountsByPlatform.all(platform) as SocialAccount[];
+  },
+
+  updateAccount(id: string, data: {
+    name: string;
+    handle: string;
+    platform: string;
+    user_id: string;
+    style: string;
+    persona_prompt: string;
+  }) {
+    stmts.updateAccount.run(
+      data.name, data.handle, data.platform,
+      data.user_id, data.style, data.persona_prompt, id
+    );
+  },
+
+  updateAccountToken(id: string, token: string) {
+    stmts.updateAccountToken.run(token, id);
+  },
+
+  deleteAccount(id: string): boolean {
+    const result = stmts.deleteAccount.run(id);
+    return result.changes > 0;
+  },
+};
+
+export default store;