in10x-mcp 1.0.0

package/README.md

@@ -0,0 +1,103 @@
+# In10x MCP
+
+Turn boring coding sessions into interesting social content. An MCP server that generates engaging posts for X (Twitter) and the In10x platform.
+
+## Quick Install
+
+```bash
+npx in10x-mcp@latest
+```
+
+The installer will:
+1. Ask which editor you use (Claude Desktop, Cursor, or Windsurf)
+2. Ask for your In10x token (get one at https://in10x.com/connect/mcp)
+3. Configure the MCP automatically (preserving your existing MCPs)
+4. Save your token so you're ready to post
+
+Then restart your editor!
+
+## Manual Installation
+
+```bash
+npm install
+npm run build
+```
+
+Add to your editor's MCP config:
+
+| Editor | Config Path |
+|--------|-------------|
+| Claude Desktop | `~/Library/Application Support/Claude/claude_desktop_config.json` |
+| Cursor | `~/.cursor/mcp.json` |
+| Windsurf | `~/.windsurf/mcp.json` |
+
+```json
+{
+  "mcpServers": {
+    "in10x": {
+      "command": "node",
+      "args": ["/path/to/in10x/build/index.js"]
+    }
+  }
+}
+```
+
+Replace `/path/to/in10x` with the actual path to this directory.
+
+## Tools
+
+### generate_content
+
+Generate engaging social content from your coding session.
+
+**Parameters:**
+- `session_summary` (optional) - What was built or worked on
+- `tone` (optional) - "casual" | "professional" | "hype" (default: casual)
+- `struggle` (optional) - What was hard or surprising
+
+**Example:**
+```
+generate_content with session_summary="Built PDF export after trying 4 libraries" and struggle="jsPDF didn't support custom fonts"
+```
+
+### set_project_context
+
+Store project info for better content generation. Set once at session start.
+
+**Parameters:**
+- `project_name` (required) - Name of your project
+- `project_description` (optional) - One-liner description
+- `stack` (optional) - Tech stack (e.g., "Next.js + Supabase")
+- `started_at` (optional) - When project started
+
+### get_content_history
+
+View the last 5 generated posts from this session. No parameters.
+
+### quick_post
+
+Generate a quick post from a short update.
+
+**Parameters:**
+- `update` (required) - Quick update (e.g., "shipped payments")
+- `tone` (optional) - "casual" | "professional" | "hype"
+
+## Content Transformation
+
+The MCP transforms boring updates into engaging content:
+
+| Boring | Interesting |
+|--------|-------------|
+| "Fixed authentication bug" | "3 hours on auth. 20 minutes on payments. The hard part is never what you expect." |
+| "Added PDF export" | "Cracked PDF export after trying 4 libraries. Claude one-shotted it with vanilla JS." |
+| "Working on landing page" | "Shipped landing page in 2 hours. No Figma, no designer, just Claude + Tailwind." |
+
+## Tone Options
+
+- **casual** (default): Relatable, 1-2 emojis, conversational
+- **professional**: Outcomes-focused, minimal emoji, credible
+- **hype**: High energy, more emojis, celebratory
+
+## License
+
+MIT

package/bin/install.js

@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import * as readline from "readline";
+
+const EDITORS = {
+  1: {
+    name: "Claude Desktop",
+    configPath: path.join(
+      os.homedir(),
+      "Library/Application Support/Claude/claude_desktop_config.json"
+    ),
+  },
+  2: {
+    name: "Cursor",
+    configPath: path.join(os.homedir(), ".cursor/mcp.json"),
+  },
+  3: {
+    name: "Windsurf",
+    configPath: path.join(os.homedir(), ".windsurf/mcp.json"),
+  },
+};
+
+const TOKEN_DIR = path.join(os.homedir(), ".in10x");
+const TOKEN_FILE = path.join(TOKEN_DIR, "token");
+
+function createReadline() {
+  return readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+}
+
+function question(rl, prompt) {
+  return new Promise((resolve) => {
+    rl.question(prompt, resolve);
+  });
+}
+
+function detectNodePath() {
+  // Check for Homebrew Node 20 first (common on Mac)
+  const homebrewNode20 = "/opt/homebrew/opt/node@20/bin/node";
+  if (fs.existsSync(homebrewNode20)) {
+    return homebrewNode20;
+  }
+
+  // Check for Homebrew Node (latest)
+  const homebrewNode = "/opt/homebrew/bin/node";
+  if (fs.existsSync(homebrewNode)) {
+    return homebrewNode;
+  }
+
+  // Fallback to system node
+  return "node";
+}
+
+function getMcpPath() {
+  // The MCP build directory - resolve from this script's location
+  const scriptDir = path.dirname(new URL(import.meta.url).pathname);
+  const mcpPath = path.join(scriptDir, "..", "build", "index.js");
+  return path.resolve(mcpPath);
+}
+
+function readConfig(configPath) {
+  if (!fs.existsSync(configPath)) {
+    return { mcpServers: {} };
+  }
+
+  try {
+    const content = fs.readFileSync(configPath, "utf-8");
+    return JSON.parse(content);
+  } catch (e) {
+    // If file exists but is empty or invalid JSON, start fresh
+    return { mcpServers: {} };
+  }
+}
+
+function writeConfig(configPath, config) {
+  const dir = path.dirname(configPath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+}
+
+function saveToken(token) {
+  if (!fs.existsSync(TOKEN_DIR)) {
+    fs.mkdirSync(TOKEN_DIR, { recursive: true });
+  }
+  fs.writeFileSync(TOKEN_FILE, token, "utf-8");
+}
+
+async function main() {
+  console.log("\n  in10x MCP Installer\n");
+  console.log("  Turn coding sessions into social content.\n");
+
+  const rl = createReadline();
+
+  try {
+    // Step 1: Choose editor
+    console.log("  Which editor are you using?\n");
+    console.log("    1) Claude Desktop");
+    console.log("    2) Cursor");
+    console.log("    3) Windsurf\n");
+
+    const editorChoice = await question(rl, "  Enter choice (1-3): ");
+    const editorNum = parseInt(editorChoice.trim(), 10);
+
+    if (!EDITORS[editorNum]) {
+      console.log("\n  Invalid choice. Exiting.\n");
+      process.exit(1);
+    }
+
+    const editor = EDITORS[editorNum];
+    console.log(`\n  Selected: ${editor.name}`);
+
+    // Step 2: Get token
+    console.log("\n  Get your token at: https://www.in10x.com/connect/mcp\n");
+    const token = await question(rl, "  Paste your In10x token: ");
+
+    if (!token.trim()) {
+      console.log("\n  No token provided. Exiting.\n");
+      process.exit(1);
+    }
+
+    // Step 3: Detect node path
+    const nodePath = detectNodePath();
+    console.log(`\n  Detected node: ${nodePath}`);
+
+    // Step 4: Get MCP path
+    const mcpPath = getMcpPath();
+    console.log(`  MCP path: ${mcpPath}`);
+
+    // Step 5: Read existing config (preserve other MCPs)
+    const config = readConfig(editor.configPath);
+    console.log(`\n  Reading config: ${editor.configPath}`);
+
+    if (!config.mcpServers) {
+      config.mcpServers = {};
+    }
+
+    // Check if in10x already exists
+    if (config.mcpServers.in10x) {
+      console.log("  Updating existing in10x configuration...");
+    } else {
+      console.log("  Adding in10x to mcpServers...");
+    }
+
+    // Step 6: Add in10x config with PATH for reliability
+    config.mcpServers.in10x = {
+      command: nodePath,
+      args: [mcpPath],
+      env: {
+        PATH: "/opt/homebrew/opt/node@20/bin:/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin",
+      },
+    };
+
+    // Step 7: Write config
+    writeConfig(editor.configPath, config);
+    console.log("  Config saved!");
+
+    // Step 8: Save token
+    saveToken(token.trim());
+    console.log("  Token saved to ~/.in10x/token");
+
+    // Done!
+    console.log("\n  ----------------------------------------");
+    console.log(`  In10x MCP installed for ${editor.name}!`);
+    console.log("  ----------------------------------------\n");
+    console.log(`  Please restart ${editor.name} to activate.\n`);
+    console.log("  Available commands:");
+    console.log("    - generate_content  : Create posts from your session");
+    console.log("    - quick_post        : Fast updates");
+    console.log("    - push_to_in10x     : Publish to In10x\n");
+  } finally {
+    rl.close();
+  }
+}
+
+main().catch((err) => {
+  console.error("\n  Error:", err.message);
+  process.exit(1);
+});

package/build/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/build/index.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { registerGenerateContent } from "./tools/generateContent.js";
+import { registerSetProjectContext } from "./tools/setProjectContext.js";
+import { registerGetContentHistory } from "./tools/getContentHistory.js";
+import { registerQuickPost } from "./tools/quickPost.js";
+import { registerConnectAccount } from "./tools/connectAccount.js";
+import { registerPushToIn10x } from "./tools/pushToIn10x.js";
+const server = new McpServer({
+    name: "in10x-mcp",
+    version: "1.0.0",
+});
+// Register all tools
+registerGenerateContent(server);
+registerSetProjectContext(server);
+registerGetContentHistory(server);
+registerQuickPost(server);
+registerConnectAccount(server);
+registerPushToIn10x(server);
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("In10x MCP server running on stdio");
+}
+main().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+});

package/build/lib/contentGenerator.d.ts

@@ -0,0 +1,10 @@
+import type { GenerateContentInput } from "./types.js";
+export declare function getPromptingQuestion(): string;
+export declare function needsMoreContext(input: GenerateContentInput): boolean;
+export declare function formatHistoryEntry(content: {
+    xPost: string;
+    in10xPost: string;
+    hashtags: string[];
+    suggestedTitle: string;
+    timestamp: Date;
+}, index: number): string;

package/build/lib/contentGenerator.js

@@ -0,0 +1,37 @@
+const PROMPTING_QUESTIONS = [
+    "What was the hardest part of today's session?",
+    "Any surprises while building?",
+    "How long did the main task take vs what you expected?",
+    "Would you do anything differently next time?",
+    "What made you proud today?",
+];
+export function getPromptingQuestion() {
+    const index = Math.floor(Math.random() * PROMPTING_QUESTIONS.length);
+    return PROMPTING_QUESTIONS[index];
+}
+export function needsMoreContext(input) {
+    return !input.sessionSummary && !input.struggle;
+}
+export function formatHistoryEntry(content, index) {
+    const timeAgo = getTimeAgo(content.timestamp);
+    return `
+### Post ${index + 1} (${timeAgo})
+**X:** ${content.xPost}
+**In10x:** ${content.in10xPost}
+**Tags:** ${content.hashtags.join(" ")}
+**Title:** ${content.suggestedTitle}
+`.trim();
+}
+function getTimeAgo(date) {
+    const now = new Date();
+    const diffMs = now.getTime() - date.getTime();
+    const diffMins = Math.floor(diffMs / 60000);
+    if (diffMins < 1)
+        return "just now";
+    if (diffMins < 60)
+        return `${diffMins}m ago`;
+    const diffHours = Math.floor(diffMins / 60);
+    if (diffHours < 24)
+        return `${diffHours}h ago`;
+    return `${Math.floor(diffHours / 24)}d ago`;
+}

package/build/lib/storage.d.ts

@@ -0,0 +1,17 @@
+import type { ProjectContext, GeneratedContent } from "./types.js";
+declare class Storage {
+    private projectContext;
+    private contentHistory;
+    private apiToken;
+    setProject(context: ProjectContext): void;
+    getProject(): ProjectContext | null;
+    addContent(content: GeneratedContent): void;
+    getHistory(): GeneratedContent[];
+    clearHistory(): void;
+    setToken(token: string): void;
+    getToken(): string | null;
+    clearToken(): void;
+    isConnected(): boolean;
+}
+export declare const storage: Storage;
+export {};

package/build/lib/storage.js

@@ -0,0 +1,59 @@
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+const MAX_HISTORY = 5;
+const CONFIG_DIR = path.join(os.homedir(), ".in10x");
+const TOKEN_FILE = path.join(CONFIG_DIR, "token");
+class Storage {
+    projectContext = null;
+    contentHistory = [];
+    apiToken = null;
+    setProject(context) {
+        this.projectContext = context;
+    }
+    getProject() {
+        return this.projectContext;
+    }
+    addContent(content) {
+        this.contentHistory.unshift(content);
+        if (this.contentHistory.length > MAX_HISTORY) {
+            this.contentHistory.pop();
+        }
+    }
+    getHistory() {
+        return [...this.contentHistory];
+    }
+    clearHistory() {
+        this.contentHistory = [];
+    }
+    // Token management - persisted to disk
+    setToken(token) {
+        this.apiToken = token;
+        // Persist to disk
+        if (!fs.existsSync(CONFIG_DIR)) {
+            fs.mkdirSync(CONFIG_DIR, { recursive: true });
+        }
+        fs.writeFileSync(TOKEN_FILE, token, "utf-8");
+    }
+    getToken() {
+        if (this.apiToken) {
+            return this.apiToken;
+        }
+        // Try to load from disk
+        if (fs.existsSync(TOKEN_FILE)) {
+            this.apiToken = fs.readFileSync(TOKEN_FILE, "utf-8").trim();
+            return this.apiToken;
+        }
+        return null;
+    }
+    clearToken() {
+        this.apiToken = null;
+        if (fs.existsSync(TOKEN_FILE)) {
+            fs.unlinkSync(TOKEN_FILE);
+        }
+    }
+    isConnected() {
+        return this.getToken() !== null;
+    }
+}
+export const storage = new Storage();

package/build/lib/types.d.ts

@@ -0,0 +1,30 @@
+export type Tone = "casual" | "professional" | "hype";
+export interface ProjectContext {
+    projectName: string;
+    projectDescription?: string;
+    stack?: string;
+    startedAt?: string;
+}
+export interface GeneratedContent {
+    xPost: string;
+    in10xPost: string;
+    hashtags: string[];
+    suggestedTitle: string;
+    timestamp: Date;
+}
+export interface GenerateContentInput {
+    sessionSummary?: string;
+    tone?: Tone;
+    struggle?: string;
+}
+export interface GenerationResult {
+    xPost: string | null;
+    in10xPost: string | null;
+    hashtags: string[];
+    suggestedTitle: string | null;
+    promptingQuestion: string | null;
+}
+export interface QuickPostInput {
+    update: string;
+    tone?: Tone;
+}

package/build/lib/types.js

@@ -0,0 +1 @@
+export {};

package/build/tools/connectAccount.d.ts

@@ -0,0 +1,6 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare const connectAccountSchema: {
+    token: z.ZodOptional<z.ZodString>;
+};
+export declare function registerConnectAccount(server: McpServer): void;

package/build/tools/connectAccount.js

@@ -0,0 +1,127 @@
+import { z } from "zod";
+import { storage } from "../lib/storage.js";
+const TOOL_DESCRIPTION = `Connect your In10x account to push posts directly from your coding sessions.
+
+WHEN TO USE:
+- User wants to connect their In10x account
+- User says 'connect', 'connect account', 'link account'
+- Before using push_to_in10x for the first time
+
+FLOW:
+1. If no token provided, show the connection URL
+2. If token provided, save it and confirm connection`;
+const PLATFORM_URL = process.env.IN10X_URL || "https://www.in10x.com";
+export const connectAccountSchema = {
+    token: z
+        .string()
+        .optional()
+        .describe("Your In10x API token (get it from in10x.com/connect/mcp)"),
+};
+export function registerConnectAccount(server) {
+    server.tool("connect_account", TOOL_DESCRIPTION, connectAccountSchema, async (args) => {
+        const token = args.token;
+        // Check if already connected
+        if (storage.isConnected() && !token) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `✅ **Already connected to In10x!**
+
+Your account is linked and ready to go.
+
+Use \`push_to_in10x\` to publish your posts.
+
+Want to reconnect with a different account? Provide a new token.`,
+                    },
+                ],
+            };
+        }
+        // If no token provided, show instructions
+        if (!token) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `🔗 **Connect your In10x account**
+
+1. Go to: **${PLATFORM_URL}/connect/mcp**
+2. Log in (or create an account)
+3. Click "Generate Token"
+4. Copy the token
+5. Run this tool again with the token:
+   \`connect_account token="in10x_xxxxx..."\`
+
+Once connected, you can use \`push_to_in10x\` to publish posts directly!`,
+                    },
+                ],
+            };
+        }
+        // Validate token format
+        if (!token.startsWith("in10x_")) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `❌ **Invalid token format**
+
+The token should start with \`in10x_\`.
+
+Get your token at: ${PLATFORM_URL}/connect/mcp`,
+                    },
+                ],
+            };
+        }
+        // Verify token with API
+        try {
+            const response = await fetch(`${PLATFORM_URL}/api/me`, {
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                },
+            });
+            if (!response.ok) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `❌ **Invalid token**
+
+This token doesn't seem to be valid. Please get a new one at:
+${PLATFORM_URL}/connect/mcp`,
+                        },
+                    ],
+                };
+            }
+            const user = await response.json();
+            // Save the token
+            storage.setToken(token);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `✅ **Connected as @${user.username}!**
+
+Your In10x account is now linked. You can now use:
+- \`push_to_in10x\` - Publish posts directly to In10x
+
+Happy shipping! 🚀`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `❌ **Connection failed**
+
+Could not connect to In10x. Please try again later.
+
+Error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                    },
+                ],
+            };
+        }
+    });
+}

package/build/tools/generateContent.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare const generateContentSchema: {
+    session_summary: z.ZodOptional<z.ZodString>;
+    tone: z.ZodOptional<z.ZodEnum<["casual", "professional", "hype"]>>;
+    struggle: z.ZodOptional<z.ZodString>;
+};
+export declare function registerGenerateContent(server: McpServer): void;

package/build/tools/generateContent.js

@@ -0,0 +1,97 @@
+import { z } from "zod";
+import { storage } from "../lib/storage.js";
+import { getPromptingQuestion, needsMoreContext } from "../lib/contentGenerator.js";
+const TOOL_DESCRIPTION = `Generates social content for X and In10x platform.
+
+PROACTIVE TRIGGERS - Offer this tool when user:
+- Ships or finishes something ('done', 'shipped', 'finally works', 'got it working')
+- Fixes a bug ('fixed', 'solved', 'cracked it')
+- Completes a session ('that's it for today', 'stopping here')
+- Expresses a win ('yes!', 'boom', 'let's go')
+
+When you detect these, ask: 'Nice! Want me to generate a post about this?'
+
+MANUAL TRIGGERS - Run immediately when user says:
+- 'generate content'
+- 'in10x'
+- 'gc'
+- '/post'
+
+AFTER GENERATING: Once you generate the posts, ask:
+'Want me to push this to In10x?' - then use push_to_in10x with the In10x post content.
+
+IMPORTANT: The tool returns a template. Claude must ALWAYS generate the actual posts from this template and show the finished content to the user. Never display the raw template.`;
+export const generateContentSchema = {
+    session_summary: z
+        .string()
+        .optional()
+        .describe("What was built or worked on this session"),
+    tone: z
+        .enum(["casual", "professional", "hype"])
+        .optional()
+        .describe("Tone for the generated content (default: casual)"),
+    struggle: z
+        .string()
+        .optional()
+        .describe("What was hard, surprising, or took longer than expected"),
+};
+function getToneGuidelines(tone) {
+    switch (tone) {
+        case "casual":
+            return "Conversational, 1-2 emojis max, relatable, words like 'finally', 'turns out', 'plot twist'";
+        case "professional":
+            return "Outcomes-focused, minimal emoji, clear and direct, credible";
+        case "hype":
+            return "High energy, 2-3 emojis, celebratory, 'LET'S GO' vibes";
+    }
+}
+export function registerGenerateContent(server) {
+    server.tool("generate_content", TOOL_DESCRIPTION, generateContentSchema, async (args) => {
+        const sessionSummary = args.session_summary;
+        const struggle = args.struggle;
+        const tone = (args.tone || "casual");
+        const project = storage.getProject();
+        // If no context provided, ask a prompting question
+        if (needsMoreContext({ sessionSummary, struggle })) {
+            const question = getPromptingQuestion();
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `I need a bit more context to generate a great post.\n\n**${question}**\n\nOnce you answer, I'll generate your posts.`,
+                    },
+                ],
+            };
+        }
+        // Build prompt for Claude to generate content
+        const parts = [
+            "Generate social media posts based on this coding session:",
+            "",
+        ];
+        if (sessionSummary) {
+            parts.push(`**What was built:** ${sessionSummary}`);
+        }
+        if (struggle) {
+            parts.push(`**Challenge/struggle:** ${struggle}`);
+        }
+        if (project) {
+            parts.push(`**Project:** ${project.projectName}${project.stack ? ` (${project.stack})` : ""}`);
+        }
+        parts.push(`**Tone:** ${tone} - ${getToneGuidelines(tone)}`);
+        parts.push("");
+        parts.push("Generate:");
+        parts.push("1. **X Post** (max 280 characters) - punchy, engaging, includes the struggle/win");
+        parts.push("2. **In10x Post** (2-4 sentences) - fuller narrative of what happened");
+        parts.push("3. **Hashtags** - 2-4 relevant tags like #buildinpublic #vibecoding");
+        parts.push("");
+        parts.push("Transform boring updates into interesting content. Focus on the human story, not just the technical details.");
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: parts.join("\n"),
+                },
+            ],
+        };
+    });
+}

package/build/tools/getContentHistory.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerGetContentHistory(server: McpServer): void;

package/build/tools/getContentHistory.js

@@ -0,0 +1,26 @@
+import { storage } from "../lib/storage.js";
+import { formatHistoryEntry } from "../lib/contentGenerator.js";
+export function registerGetContentHistory(server) {
+    server.tool("get_content_history", "View the last 5 generated posts from this session.", {}, async () => {
+        const history = storage.getHistory();
+        if (history.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "No content generated yet this session.\n\nCall `generate_content` to create your first post!",
+                    },
+                ],
+            };
+        }
+        const formatted = history.map((entry, index) => formatHistoryEntry(entry, index));
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `# Content History (${history.length} posts)\n\n${formatted.join("\n\n")}`,
+                },
+            ],
+        };
+    });
+}

package/build/tools/pushToIn10x.d.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare const pushToIn10xSchema: {
+    content: z.ZodString;
+    x_content: z.ZodOptional<z.ZodString>;
+    hashtags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    project_id: z.ZodOptional<z.ZodString>;
+};
+export declare function registerPushToIn10x(server: McpServer): void;

package/build/tools/pushToIn10x.js

@@ -0,0 +1,147 @@
+import { z } from "zod";
+import { storage } from "../lib/storage.js";
+const TOOL_DESCRIPTION = `Push a post directly to In10x platform.
+
+WHEN TO USE:
+- After generating content with generate_content, offer: 'Want me to push this to In10x?'
+- User says 'push', 'publish', 'post to in10x', 'ship it', 'yes' (after you offer)
+- User wants to share their update
+
+WHAT TO PASS:
+- content: The In10x post you generated (2-4 sentences, the longer version)
+- x_content: The X/Twitter post you generated (280 char version)
+- hashtags: Array of hashtags like ["buildinpublic", "vibecoding"]
+
+REQUIRES: Connected account (use connect_account first). If not connected, the tool will prompt user to connect.`;
+const PLATFORM_URL = process.env.IN10X_URL || "https://www.in10x.com";
+export const pushToIn10xSchema = {
+    content: z
+        .string()
+        .describe("The post content (2-4 sentences, what you built/learned)"),
+    x_content: z
+        .string()
+        .optional()
+        .describe("Short version for X/Twitter (max 280 chars)"),
+    hashtags: z
+        .array(z.string())
+        .optional()
+        .describe("Hashtags like #buildinpublic #vibecoding"),
+    project_id: z
+        .string()
+        .optional()
+        .describe("Link to a specific project (optional)"),
+};
+export function registerPushToIn10x(server) {
+    server.tool("push_to_in10x", TOOL_DESCRIPTION, pushToIn10xSchema, async (args) => {
+        const { content, x_content, hashtags, project_id } = args;
+        // Check if connected
+        const token = storage.getToken();
+        if (!token) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `🔗 **Not connected to In10x**
+
+You need to connect your account first:
+
+1. Run \`connect_account\` to get started
+2. Then come back and push your post!
+
+Or visit: ${PLATFORM_URL}/connect/mcp`,
+                    },
+                ],
+            };
+        }
+        // Validate content
+        if (!content || content.trim().length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `❌ **Content required**
+
+Please provide the post content. Example:
+\`push_to_in10x content="Built a new auth system today. Took 3 hours but finally works!"\``,
+                    },
+                ],
+            };
+        }
+        // Push to platform
+        try {
+            const response = await fetch(`${PLATFORM_URL}/api/posts`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${token}`,
+                },
+                body: JSON.stringify({
+                    content,
+                    x_content: x_content || null,
+                    hashtags: hashtags || [],
+                    project_id: project_id || null,
+                }),
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                if (response.status === 401) {
+                    // Token might be invalid
+                    storage.clearToken();
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `❌ **Authentication failed**
+
+Your token seems to be invalid or expired.
+
+Please reconnect with \`connect_account\``,
+                            },
+                        ],
+                    };
+                }
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `❌ **Failed to post**
+
+${error.error || "Unknown error"}
+
+Please try again.`,
+                        },
+                    ],
+                };
+            }
+            const result = await response.json();
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `✅ **Posted to In10x!**
+
+Your post is now live: ${result.url}
+
+${x_content ? `📱 X version ready to copy:\n"${x_content}"` : ""}
+
+Keep shipping! 🚀`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `❌ **Connection error**
+
+Could not reach In10x. Please check your internet connection.
+
+Error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                    },
+                ],
+            };
+        }
+    });
+}

package/build/tools/quickPost.d.ts

@@ -0,0 +1,7 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare const quickPostSchema: {
+    update: z.ZodString;
+    tone: z.ZodOptional<z.ZodEnum<["casual", "professional", "hype"]>>;
+};
+export declare function registerQuickPost(server: McpServer): void;

package/build/tools/quickPost.js

@@ -0,0 +1,61 @@
+import { z } from "zod";
+import { storage } from "../lib/storage.js";
+const TOOL_DESCRIPTION = `Generate a quick X post from a short update.
+
+PROACTIVE TRIGGERS - Offer when user:
+- Ships something ('done', 'shipped', 'works now')
+- Quick wins ('fixed it', 'boom', 'yes!')
+
+MANUAL TRIGGERS:
+- 'quick post'
+- 'qp'
+
+AFTER GENERATING: Once you generate the post, ask:
+'Want me to push this to In10x?' - then use push_to_in10x with the content.
+
+IMPORTANT: The tool returns a template. Claude must ALWAYS generate the actual posts from this template and show the finished content to the user. Never display the raw template.`;
+export const quickPostSchema = {
+    update: z.string().describe("Quick update (e.g., 'shipped payments')"),
+    tone: z
+        .enum(["casual", "professional", "hype"])
+        .optional()
+        .describe("Tone for the post (default: casual)"),
+};
+function getToneGuidelines(tone) {
+    switch (tone) {
+        case "casual":
+            return "Conversational, 1-2 emojis, relatable";
+        case "professional":
+            return "Clear, minimal emoji, credible";
+        case "hype":
+            return "High energy, 2-3 emojis, celebratory";
+    }
+}
+export function registerQuickPost(server) {
+    server.tool("quick_post", TOOL_DESCRIPTION, quickPostSchema, async (args) => {
+        const update = args.update;
+        const tone = (args.tone || "casual");
+        const project = storage.getProject();
+        const parts = [
+            "Generate a quick X post for this update:",
+            "",
+            `**Update:** ${update}`,
+        ];
+        if (project) {
+            parts.push(`**Project:** ${project.projectName}`);
+        }
+        parts.push(`**Tone:** ${tone} - ${getToneGuidelines(tone)}`);
+        parts.push("");
+        parts.push("Generate:");
+        parts.push("- **X Post** (max 280 characters) - celebrate this quick win");
+        parts.push("- **Hashtags** - 1-2 tags like #buildinpublic #shipit");
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: parts.join("\n"),
+                },
+            ],
+        };
+    });
+}

package/build/tools/setProjectContext.d.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare const setProjectContextSchema: {
+    project_name: z.ZodString;
+    project_description: z.ZodOptional<z.ZodString>;
+    stack: z.ZodOptional<z.ZodString>;
+    started_at: z.ZodOptional<z.ZodString>;
+};
+export declare function registerSetProjectContext(server: McpServer): void;

package/build/tools/setProjectContext.js

@@ -0,0 +1,46 @@
+import { z } from "zod";
+import { storage } from "../lib/storage.js";
+export const setProjectContextSchema = {
+    project_name: z.string().describe("Name of the project you're building"),
+    project_description: z
+        .string()
+        .optional()
+        .describe("One-liner description of the project"),
+    stack: z
+        .string()
+        .optional()
+        .describe("Tech stack (e.g., 'Next.js + Supabase')"),
+    started_at: z
+        .string()
+        .optional()
+        .describe("When the project started (e.g., 'Dec 2024')"),
+};
+export function registerSetProjectContext(server) {
+    server.tool("set_project_context", "Store project info to improve content generation. Set this once at the start of a session.", setProjectContextSchema, async (args) => {
+        storage.setProject({
+            projectName: args.project_name,
+            projectDescription: args.project_description,
+            stack: args.stack,
+            startedAt: args.started_at,
+        });
+        const parts = [`Project context set: **${args.project_name}**`];
+        if (args.project_description) {
+            parts.push(`Description: ${args.project_description}`);
+        }
+        if (args.stack) {
+            parts.push(`Stack: ${args.stack}`);
+        }
+        if (args.started_at) {
+            parts.push(`Started: ${args.started_at}`);
+        }
+        parts.push("", "This context will be used to generate better content. Call `generate_content` when you're ready to create a post!");
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: parts.join("\n"),
+                },
+            ],
+        };
+    });
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "in10x-mcp",
+  "version": "1.0.0",
+  "description": "MCP server that generates engaging social content from coding sessions",
+  "type": "module",
+  "main": "build/index.js",
+  "bin": {
+    "in10x-mcp": "./bin/install.js"
+  },
+  "scripts": {
+    "build": "tsc && chmod 755 build/index.js",
+    "dev": "tsc --watch"
+  },
+  "keywords": [
+    "mcp",
+    "claude",
+    "content",
+    "social",
+    "vibecoding"
+  ],
+  "author": "",
+  "license": "MIT",
+  "files": [
+    "build",
+    "bin"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.25.1",
+    "zod": "^3.25.76"
+  },
+  "devDependencies": {
+    "@types/node": "^25.0.3",
+    "typescript": "^5.9.3"
+  }
+}