spawn-skill 1.0.1 → 1.1.0

package/bin/CLAUDE.md

@@ -7,5 +7,7 @@
 
 | ID | Time | T | Title | Read |
 |----|------|---|-------|------|
+| #905 | 9:07 PM | 🔵 | Spawn-Skill CLI Tool Complete Implementation | ~576 |
+| #894 | 8:55 PM | 🔵 | spawn-skill CLI contains embedded skill documentation | ~435 |
 | #794 | 11:11 AM | ✅ | Simplified spawn-skill CLI package.json generation to use direct ws dependency | ~353 |
 </claude-mem-context>

package/bin/cli.js

@@ -233,18 +233,15 @@ function connect() {
   });
 
   ws.on('open', () => {
-    console.log('Connected to relay, authenticating...');
-    send('auth', { token: TOKEN, name: NAME });
+    console.log('Connected to Spawn.wtf!');
+    // Auth happens via token in header - just start working
+    sendText(\`\${NAME} is online and ready.\`);
+    updateStatus('idle', 'Ready for commands');
   });
 
   ws.on('message', (data) => {
     const msg = JSON.parse(data.toString());
-
-    if (msg.type === 'auth_success') {
-      console.log('Authenticated! Agent is online.');
-      sendText(\`\${NAME} is online and ready.\`);
-      updateStatus('idle', 'Ready for commands');
-    }
+    console.log('Received:', msg.type);
 
     if (msg.type === 'message') {
       console.log('Message from app:', msg.payload);
@@ -341,6 +338,172 @@ if __name__ == '__main__':
 `;
 }
 
+function getMCPServer(token) {
+  return `#!/usr/bin/env node
+/**
+ * Spawn.wtf MCP Server
+ * Bridges Spawn.wtf with Claude Code
+ */
+
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+import WebSocket from 'ws';
+
+const RELAY_URL = 'wss://spawn-relay.ngvsqdjj5r.workers.dev/v1/agent';
+const TOKEN = process.env.SPAWN_TOKEN || '${token}';
+
+const messageQueue = [];
+let ws = null;
+let connected = false;
+let connectionError = null;
+
+function connectToRelay() {
+  if (!TOKEN) {
+    connectionError = 'SPAWN_TOKEN not set';
+    return;
+  }
+
+  ws = new WebSocket(RELAY_URL, {
+    headers: { 'Authorization': \\\`Bearer \\\${TOKEN}\\\` }
+  });
+
+  ws.on('open', () => {
+    connected = true;
+    connectionError = null;
+    sendMessage('status_update', { status: 'idle', label: 'Ready' });
+  });
+
+  ws.on('message', (data) => {
+    try {
+      const msg = JSON.parse(data.toString());
+      if (msg.type === 'message') {
+        messageQueue.push({
+          id: msg.id,
+          timestamp: msg.ts || Date.now(),
+          text: msg.payload?.text || '',
+          from: msg.payload?.from || 'user'
+        });
+      }
+    } catch (e) {}
+  });
+
+  ws.on('close', () => {
+    connected = false;
+    setTimeout(connectToRelay, 5000);
+  });
+
+  ws.on('error', (err) => {
+    connectionError = err.message;
+  });
+}
+
+function sendMessage(type, payload) {
+  if (ws?.readyState === WebSocket.OPEN) {
+    ws.send(JSON.stringify({
+      type,
+      id: \\\`msg_\\\${Date.now()}\\\`,
+      ts: Date.now(),
+      payload
+    }));
+  }
+}
+
+setInterval(() => {
+  if (ws?.readyState === WebSocket.OPEN) {
+    sendMessage('ping', {});
+  }
+}, 30000);
+
+connectToRelay();
+
+const server = new Server(
+  { name: 'spawn', version: '1.0.0' },
+  { capabilities: { tools: {} } }
+);
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [
+    {
+      name: 'spawn_check_messages',
+      description: 'Check for new messages from the Spawn.wtf iOS app',
+      inputSchema: { type: 'object', properties: {}, required: [] }
+    },
+    {
+      name: 'spawn_respond',
+      description: 'Send a response back to the user through Spawn.wtf',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          text: { type: 'string', description: 'Message to send' },
+          format: { type: 'string', enum: ['plain', 'markdown'], default: 'plain' }
+        },
+        required: ['text']
+      }
+    },
+    {
+      name: 'spawn_status',
+      description: 'Update your status in Spawn.wtf (idle/thinking/working)',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          status: { type: 'string', enum: ['idle', 'thinking', 'working'] },
+          label: { type: 'string', description: 'Status label' }
+        },
+        required: ['status']
+      }
+    },
+    {
+      name: 'spawn_connection_info',
+      description: 'Get Spawn.wtf connection status',
+      inputSchema: { type: 'object', properties: {}, required: [] }
+    }
+  ]
+}));
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+
+  switch (name) {
+    case 'spawn_check_messages': {
+      const messages = [...messageQueue];
+      messageQueue.length = 0;
+      if (messages.length > 0) {
+        sendMessage('status_update', { status: 'thinking', label: 'Reading messages' });
+      }
+      return { content: [{ type: 'text', text: JSON.stringify({ messages, count: messages.length }) }] };
+    }
+    case 'spawn_respond': {
+      if (!connected) {
+        return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: 'Not connected' }) }] };
+      }
+      sendMessage('message', { content_type: 'text', text: args.text, format: args.format || 'plain' });
+      sendMessage('status_update', { status: 'idle', label: 'Ready' });
+      return { content: [{ type: 'text', text: JSON.stringify({ success: true }) }] };
+    }
+    case 'spawn_status': {
+      if (!connected) {
+        return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: 'Not connected' }) }] };
+      }
+      sendMessage('status_update', { status: args.status, label: args.label });
+      return { content: [{ type: 'text', text: JSON.stringify({ success: true }) }] };
+    }
+    case 'spawn_connection_info': {
+      return { content: [{ type: 'text', text: JSON.stringify({ connected, error: connectionError, pendingMessages: messageQueue.length }) }] };
+    }
+    default:
+      throw new Error(\\\`Unknown tool: \\\${name}\\\`);
+  }
+});
+
+const transport = new StdioServerTransport();
+server.connect(transport);
+`;
+}
+
 function getPythonSDK() {
   return `"""
 Spawn.wtf Python SDK
@@ -376,16 +539,9 @@ class SpawnAgent:
             )
             self._connected = True
 
-            # Send auth message
-            await self._send({
-                'type': 'auth',
-                'id': f'auth_{int(asyncio.get_event_loop().time() * 1000)}',
-                'ts': int(asyncio.get_event_loop().time() * 1000),
-                'payload': {
-                    'token': self.token,
-                    'name': self.name
-                }
-            })
+            # Auth happens via token header - trigger connect immediately
+            if 'connect' in self._handlers:
+                await self._handlers['connect']()
 
             # Start message loop
             await self._message_loop()
@@ -402,10 +558,7 @@ class SpawnAgent:
                 data = json.loads(message)
                 msg_type = data.get('type', '')
 
-                if msg_type == 'auth_success':
-                    if 'connect' in self._handlers:
-                        await self._handlers['connect']()
-                elif msg_type == 'message':
+                if msg_type == 'message':
                     if 'message' in self._handlers:
                         await self._handlers['message'](data)
                 elif msg_type == 'pong':
@@ -486,7 +639,7 @@ class SpawnAgent:
 `;
 }
 
-async function createSkillFiles(token, agentName, language) {
+async function createSkillFiles(token, agentName, language, claudeCode = false) {
   const skillDir = path.join(process.cwd(), 'spawn');
 
   // Create spawn directory
@@ -502,7 +655,8 @@ async function createSkillFiles(token, agentName, language) {
     name: agentName,
     token: token,
     relay: 'wss://spawn-relay.ngvsqdjj5r.workers.dev/v1/agent',
-    language: language
+    language: language,
+    claudeCode: claudeCode
   };
   fs.writeFileSync(path.join(skillDir, 'config.json'), JSON.stringify(config, null, 2));
 
@@ -527,7 +681,45 @@ async function createSkillFiles(token, agentName, language) {
     fs.writeFileSync(path.join(skillDir, 'requirements.txt'), 'websockets>=12.0\n');
   }
 
-  return { skillDir, language };
+  // Claude Code MCP integration
+  if (claudeCode) {
+    const mcpDir = path.join(skillDir, 'mcp');
+    if (!fs.existsSync(mcpDir)) {
+      fs.mkdirSync(mcpDir, { recursive: true });
+    }
+
+    // Create MCP server
+    fs.writeFileSync(path.join(mcpDir, 'server.js'), getMCPServer(token));
+
+    // Create MCP package.json
+    const mcpPackageJson = {
+      name: "spawn-mcp-server",
+      version: "1.0.0",
+      type: "module",
+      dependencies: {
+        "@modelcontextprotocol/sdk": "^1.0.0",
+        "ws": "^8.16.0"
+      }
+    };
+    fs.writeFileSync(path.join(mcpDir, 'package.json'), JSON.stringify(mcpPackageJson, null, 2));
+
+    // Create Claude Code settings snippet
+    const mcpFullPath = path.resolve(mcpDir, 'server.js');
+    const settingsSnippet = {
+      mcpServers: {
+        spawn: {
+          command: "node",
+          args: [mcpFullPath],
+          env: {
+            SPAWN_TOKEN: token
+          }
+        }
+      }
+    };
+    fs.writeFileSync(path.join(mcpDir, 'claude-settings.json'), JSON.stringify(settingsSnippet, null, 2));
+  }
+
+  return { skillDir, language, claudeCode };
 }
 
 async function main() {
@@ -591,18 +783,26 @@ async function main() {
     });
   }
 
+  questions.push({
+    type: 'confirm',
+    name: 'claudeCode',
+    message: 'Add Claude Code integration? (MCP server for chatting via phone)',
+    default: true
+  });
+
   const answers = await inquirer.prompt(questions);
 
   token = token || answers.token;
   agentName = answers.agentName || agentName;
   language = language || answers.language;
+  const claudeCode = answers.claudeCode;
 
   console.log('');
 
   // Create files
   const createSpinner = ora('Creating skill files...').start();
   try {
-    const { skillDir } = await createSkillFiles(token, agentName, language);
+    const { skillDir } = await createSkillFiles(token, agentName, language, claudeCode);
     createSpinner.succeed('Created skill files');
   } catch (err) {
     createSpinner.fail('Failed to create skill files');
@@ -610,6 +810,18 @@ async function main() {
     process.exit(1);
   }
 
+  // Install MCP dependencies if needed
+  if (claudeCode) {
+    const mcpSpinner = ora('Installing MCP dependencies...').start();
+    try {
+      const { execSync } = await import('child_process');
+      execSync('npm install', { cwd: path.join(process.cwd(), 'spawn', 'mcp'), stdio: 'pipe' });
+      mcpSpinner.succeed('Installed MCP dependencies');
+    } catch (err) {
+      mcpSpinner.warn('Run "cd spawn/mcp && npm install" to finish MCP setup');
+    }
+  }
+
   console.log('');
   console.log(chalk.green.bold('✓ Spawn.wtf skill installed!'));
   console.log('');
@@ -620,14 +832,20 @@ async function main() {
     console.log(dim('    spawn/config.json'));
     console.log(dim('    spawn/connect.js'));
     console.log(dim('    spawn/package.json'));
+    if (claudeCode) {
+      console.log(dim('    spawn/mcp/server.js'));
+      console.log(dim('    spawn/mcp/package.json'));
+      console.log(dim('    spawn/mcp/claude-settings.json'));
+    }
     console.log('');
     console.log('  Next steps:');
     console.log('');
     console.log('  1. ' + chalk.cyan('Install dependencies:'));
-    console.log('     ' + dim('cd spawn && npm install'));
+    console.log('     ' + dim('cd spawn'));
+    console.log('     ' + dim('npm install'));
     console.log('');
     console.log('  2. ' + chalk.cyan('Run the connector:'));
-    console.log('     ' + dim('node spawn/connect.js'));
+    console.log('     ' + dim('node connect.js'));
   } else {
     console.log('  Files created:');
     console.log(dim('    spawn/SKILL.md'));
@@ -635,18 +853,49 @@ async function main() {
     console.log(dim('    spawn/connect.py'));
     console.log(dim('    spawn/spawn_sdk.py'));
     console.log(dim('    spawn/requirements.txt'));
+    if (claudeCode) {
+      console.log(dim('    spawn/mcp/server.js'));
+      console.log(dim('    spawn/mcp/package.json'));
+      console.log(dim('    spawn/mcp/claude-settings.json'));
+    }
     console.log('');
     console.log('  Next steps:');
     console.log('');
     console.log('  1. ' + chalk.cyan('Install dependencies:'));
-    console.log('     ' + dim('cd spawn && pip install -r requirements.txt'));
+    console.log('     ' + dim('cd spawn'));
+    console.log('     ' + dim('pip install -r requirements.txt'));
     console.log('');
     console.log('  2. ' + chalk.cyan('Run the connector:'));
-    console.log('     ' + dim('python spawn/connect.py'));
+    console.log('     ' + dim('python connect.py'));
   }
 
   console.log('');
   console.log('  3. ' + chalk.cyan('Open Spawn.wtf app') + ' - your agent should appear!');
+
+  if (claudeCode) {
+    console.log('');
+    console.log(pink('  ═══ Claude Code Integration ═══'));
+    console.log('');
+    console.log('  Add to your ' + chalk.cyan('.claude/settings.json') + ':');
+    console.log('');
+    const mcpPath = path.resolve(process.cwd(), 'spawn', 'mcp', 'server.js');
+    console.log(dim('  {'));
+    console.log(dim('    "mcpServers": {'));
+    console.log(dim('      "spawn": {'));
+    console.log(dim('        "command": "node",'));
+    console.log(dim(`        "args": ["${mcpPath}"],`));
+    console.log(dim('        "env": { "SPAWN_TOKEN": "' + token.slice(0, 12) + '..." }'));
+    console.log(dim('      }'));
+    console.log(dim('    }'));
+    console.log(dim('  }'));
+    console.log('');
+    console.log('  Or copy from: ' + dim('spawn/mcp/claude-settings.json'));
+    console.log('');
+    console.log('  Then restart Claude Code and ask:');
+    console.log('    ' + chalk.white('"Check Spawn messages"'));
+    console.log('    ' + chalk.white('"Respond: Hello from Claude!"'));
+  }
+
   console.log('');
   console.log('  Docs: ' + pink('https://github.com/SpawnWTF/spawn'));
   console.log('');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spawn-skill",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "Connect your AI agent to Spawn.wtf",
   "bin": {
     "spawn-skill": "./bin/cli.js"