shsu 0.0.1 → 0.0.5

package/.github/workflows/publish.yml

@@ -8,12 +8,13 @@ on:
 jobs:
   publish:
     runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      id-token: write
     steps:
       - uses: actions/checkout@v4
       - uses: actions/setup-node@v4
         with:
-          node-version: '20'
+          node-version: '24'
           registry-url: 'https://registry.npmjs.org'
-      - run: npm publish
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+      - run: npm publish --provenance --access public

package/README.md

@@ -86,6 +86,74 @@ Config is read from `package.json` "shsu" key. Environment variables override pa
 | `url` / `SHSU_URL` | For `invoke` | Supabase URL |
 | `localPath` / `SHSU_LOCAL_PATH` | No | Local functions path (default: `./supabase/functions`) |
 
+## MCP Server
+
+shsu can run as an MCP server for AI assistants.
+
+### Claude Code
+
+Add to `.mcp.json` in your project root:
+
+```json
+{
+  "mcpServers": {
+    "shsu": {
+      "command": "npx",
+      "args": ["shsu", "mcp"]
+    }
+  }
+}
+```
+
+### Claude Desktop
+
+Add to `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS) or `%APPDATA%\Claude\claude_desktop_config.json` (Windows):
+
+```json
+{
+  "mcpServers": {
+    "shsu": {
+      "command": "npx",
+      "args": ["shsu", "mcp"],
+      "cwd": "/path/to/your/project"
+    }
+  }
+}
+```
+
+### Cursor
+
+Add to `.cursor/mcp.json` in your project:
+
+```json
+{
+  "mcpServers": {
+    "shsu": {
+      "command": "npx",
+      "args": ["shsu", "mcp"]
+    }
+  }
+}
+```
+
+### Available Tools
+
+- `deploy` - Deploy edge functions
+- `list` - List local and remote functions
+- `invoke` - Invoke a function
+- `restart` - Restart edge-runtime
+- `new` - Create new function from template
+- `config` - Show current configuration
+
+## Releasing
+
+```bash
+npm version patch   # or minor/major
+git push --follow-tags
+```
+
+GitHub Actions will automatically publish to npm when the tag is pushed.
+
 ## License
 
 MIT

package/bin/shsu.mjs

@@ -308,6 +308,242 @@ async function cmdInit() {
   success('Added shsu config to package.json');
 }
 
+// ─────────────────────────────────────────────────────────────
+// MCP Server
+// ─────────────────────────────────────────────────────────────
+async function cmdMcp() {
+  const tools = [
+    {
+      name: 'deploy',
+      description: 'Deploy edge function(s) to the server. Syncs via rsync and restarts edge-runtime.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          name: { type: 'string', description: 'Function name to deploy. If omitted, deploys all functions.' },
+          noRestart: { type: 'boolean', description: 'Skip restarting edge-runtime after deploy.' },
+        },
+      },
+    },
+    {
+      name: 'list',
+      description: 'List edge functions (both local and remote).',
+      inputSchema: { type: 'object', properties: {} },
+    },
+    {
+      name: 'invoke',
+      description: 'Invoke an edge function with optional JSON data.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          name: { type: 'string', description: 'Function name to invoke.' },
+          data: { type: 'string', description: 'JSON data to send (default: {}).' },
+        },
+        required: ['name'],
+      },
+    },
+    {
+      name: 'restart',
+      description: 'Restart the edge-runtime container.',
+      inputSchema: { type: 'object', properties: {} },
+    },
+    {
+      name: 'new',
+      description: 'Create a new edge function from template.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          name: { type: 'string', description: 'Name for the new function.' },
+        },
+        required: ['name'],
+      },
+    },
+    {
+      name: 'config',
+      description: 'Get current shsu configuration.',
+      inputSchema: { type: 'object', properties: {} },
+    },
+  ];
+
+  const serverInfo = {
+    name: 'shsu',
+    version: '0.0.1',
+  };
+
+  // Helper to write JSON-RPC response
+  const respond = (id, result) => {
+    const response = { jsonrpc: '2.0', id, result };
+    process.stdout.write(JSON.stringify(response) + '\n');
+  };
+
+  const respondError = (id, code, message) => {
+    const response = { jsonrpc: '2.0', id, error: { code, message } };
+    process.stdout.write(JSON.stringify(response) + '\n');
+  };
+
+  // Capture output helper
+  const captureExec = (cmd) => {
+    try {
+      return execSync(cmd, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+    } catch (e) {
+      return e.message;
+    }
+  };
+
+  // Tool handlers
+  const handleTool = async (name, args = {}) => {
+    switch (name) {
+      case 'deploy': {
+        if (!config.server || !config.remotePath) {
+          return { content: [{ type: 'text', text: 'Error: server and remotePath must be configured. Run "shsu init" first.' }] };
+        }
+        const funcName = args.name;
+        const noRestart = args.noRestart || false;
+        let output = '';
+
+        if (!funcName) {
+          output = captureExec(`rsync -avz --delete --exclude='*.test.ts' --exclude='*.spec.ts' "${config.localPath}/" "${config.server}:${config.remotePath}/"`);
+        } else {
+          const funcPath = join(config.localPath, funcName);
+          if (!existsSync(funcPath)) {
+            return { content: [{ type: 'text', text: `Error: Function not found: ${funcPath}` }] };
+          }
+          output = captureExec(`rsync -avz "${funcPath}/" "${config.server}:${config.remotePath}/${funcName}/"`);
+        }
+
+        if (!noRestart) {
+          output += '\n' + captureExec(`ssh ${config.server} "docker restart \\$(docker ps -q --filter 'name=edge')"`);
+        }
+
+        return { content: [{ type: 'text', text: `Deployed${funcName ? ` ${funcName}` : ' all functions'}${noRestart ? ' (no restart)' : ''}\n\n${output}` }] };
+      }
+
+      case 'list': {
+        if (!config.server || !config.remotePath) {
+          return { content: [{ type: 'text', text: 'Error: server and remotePath must be configured.' }] };
+        }
+        const remote = captureExec(`ssh ${config.server} "ls -1 ${config.remotePath} 2>/dev/null"`) || '(none)';
+        let local = '(none)';
+        if (existsSync(config.localPath)) {
+          const dirs = readdirSync(config.localPath, { withFileTypes: true })
+            .filter((d) => d.isDirectory())
+            .map((d) => d.name);
+          local = dirs.length ? dirs.join('\n') : '(none)';
+        }
+        return { content: [{ type: 'text', text: `Remote functions:\n${remote}\n\nLocal functions:\n${local}` }] };
+      }
+
+      case 'invoke': {
+        if (!config.url) {
+          return { content: [{ type: 'text', text: 'Error: url must be configured for invoke.' }] };
+        }
+        if (!args.name) {
+          return { content: [{ type: 'text', text: 'Error: function name is required.' }] };
+        }
+        const data = args.data || '{}';
+        const output = captureExec(`curl -s -X POST "${config.url}/functions/v1/${args.name}" -H "Content-Type: application/json" -d '${data}'`);
+        return { content: [{ type: 'text', text: output }] };
+      }
+
+      case 'restart': {
+        if (!config.server) {
+          return { content: [{ type: 'text', text: 'Error: server must be configured.' }] };
+        }
+        const output = captureExec(`ssh ${config.server} "docker restart \\$(docker ps -q --filter 'name=edge')"`);
+        return { content: [{ type: 'text', text: `Restarted edge-runtime\n\n${output}` }] };
+      }
+
+      case 'new': {
+        if (!args.name) {
+          return { content: [{ type: 'text', text: 'Error: function name is required.' }] };
+        }
+        const funcPath = join(config.localPath, args.name);
+        if (existsSync(funcPath)) {
+          return { content: [{ type: 'text', text: `Error: Function already exists: ${args.name}` }] };
+        }
+        mkdirSync(funcPath, { recursive: true });
+        writeFileSync(
+          join(funcPath, 'index.ts'),
+          `Deno.serve(async (req) => {
+  try {
+    const { name } = await req.json()
+
+    return new Response(
+      JSON.stringify({ message: \`Hello \${name}!\` }),
+      { headers: { "Content-Type": "application/json" } }
+    )
+  } catch (error) {
+    return new Response(
+      JSON.stringify({ error: error.message }),
+      { status: 400, headers: { "Content-Type": "application/json" } }
+    )
+  }
+})
+`
+        );
+        return { content: [{ type: 'text', text: `Created ${funcPath}/index.ts` }] };
+      }
+
+      case 'config': {
+        return {
+          content: [{
+            type: 'text',
+            text: `Current configuration:\n  server: ${config.server || '(not set)'}\n  remotePath: ${config.remotePath || '(not set)'}\n  url: ${config.url || '(not set)'}\n  localPath: ${config.localPath}`,
+          }],
+        };
+      }
+
+      default:
+        return { content: [{ type: 'text', text: `Unknown tool: ${name}` }], isError: true };
+    }
+  };
+
+  // Process incoming messages
+  const rl = createInterface({ input: process.stdin });
+
+  for await (const line of rl) {
+    let msg;
+    try {
+      msg = JSON.parse(line);
+    } catch {
+      continue;
+    }
+
+    const { id, method, params } = msg;
+
+    switch (method) {
+      case 'initialize':
+        respond(id, {
+          protocolVersion: '2024-11-05',
+          capabilities: { tools: {} },
+          serverInfo,
+        });
+        break;
+
+      case 'notifications/initialized':
+        // No response needed for notifications
+        break;
+
+      case 'tools/list':
+        respond(id, { tools });
+        break;
+
+      case 'tools/call':
+        try {
+          const result = await handleTool(params.name, params.arguments || {});
+          respond(id, result);
+        } catch (e) {
+          respond(id, { content: [{ type: 'text', text: `Error: ${e.message}` }], isError: true });
+        }
+        break;
+
+      default:
+        if (id !== undefined) {
+          respondError(id, -32601, `Method not found: ${method}`);
+        }
+    }
+  }
+}
+
 function cmdHelp() {
   console.log(`
 ${c.blue('shsu')} - Self-Hosted Supabase Utilities
@@ -336,6 +572,8 @@ ${c.yellow('Commands:')}
 
   env                  Show current configuration
 
+  mcp                  Start MCP server (for AI assistants)
+
 ${c.yellow('Examples:')}
   shsu init
   shsu deploy
@@ -386,6 +624,9 @@ async function main() {
       case 'init':
         await cmdInit();
         break;
+      case 'mcp':
+        await cmdMcp();
+        break;
       case 'env':
       case 'config':
         cmdEnv();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shsu",
-  "version": "0.0.1",
+  "version": "0.0.5",
   "description": "CLI for deploying and managing Supabase Edge Functions on self-hosted Supabase (Coolify, Docker Compose). Sync functions via rsync, stream logs, and invoke endpoints.",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
@@ -31,4 +31,4 @@
     "url": "https://github.com/YUZU-Hub/shsu/issues"
   },
   "homepage": "https://github.com/YUZU-Hub/shsu#readme"
-}
+}

package/.claude/settings.local.json

@@ -1,7 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(node bin/shsu.mjs:*)"
-    ]
-  }
-}