shsu 0.0.1 → 0.0.6

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

@@ -2,7 +2,7 @@
 
 **S**elf-**H**osted **S**upabase **U**tilities
 
-Deploy and manage Supabase Edge Functions on Coolify-hosted Supabase.
+Deploy and manage Supabase Edge Functions and migrations on Coolify-hosted Supabase.
 
 ## Install
 
@@ -27,17 +27,22 @@ This adds config to your `package.json`:
   "shsu": {
     "server": "root@your-coolify-server",
     "remotePath": "/data/coolify/services/YOUR_SERVICE_ID/volumes/functions",
-    "url": "https://your-supabase.example.com"
+    "url": "https://your-supabase.example.com",
+    "edgeContainer": "edge",
+    "dbContainer": "postgres"
   }
 }
 ```
 
-Find your `remotePath` by running on your server:
+### Finding Configuration Values
 
+**remotePath** - SSH to your server and run:
 ```bash
 docker inspect $(docker ps -q --filter 'name=edge') | grep -A 5 "Mounts"
 ```
 
+**Container names** - SSH to your server and run `docker ps` to list containers. Coolify names containers using the pattern `<service>-<uuid>` (e.g., `abc123-supabase-edge-functions-1`). The filter does substring matching, so `edge` matches any container with "edge" in its name.
+
 ## Usage
 
 ```bash
@@ -56,6 +61,9 @@ shsu deploy hello-world
 # Deploy without restarting edge-runtime
 shsu deploy hello-world --no-restart
 
+# Run database migrations
+shsu migrate
+
 # Stream logs
 shsu logs
 
@@ -75,6 +83,21 @@ shsu new my-function
 shsu restart
 ```
 
+## Migrations
+
+Place SQL files in `./supabase/migrations/` (or your configured `migrationsPath`). Files are sorted alphabetically and executed in order.
+
+```
+supabase/migrations/
+  001_create_users.sql
+  002_add_email_index.sql
+```
+
+Run with:
+```bash
+shsu migrate
+```
+
 ## Configuration
 
 Config is read from `package.json` "shsu" key. Environment variables override package.json values.
@@ -85,6 +108,78 @@ Config is read from `package.json` "shsu" key. Environment variables override pa
 | `remotePath` / `SHSU_REMOTE_PATH` | Yes | Remote path to functions directory |
 | `url` / `SHSU_URL` | For `invoke` | Supabase URL |
 | `localPath` / `SHSU_LOCAL_PATH` | No | Local functions path (default: `./supabase/functions`) |
+| `migrationsPath` / `SHSU_MIGRATIONS_PATH` | No | Local migrations path (default: `./supabase/migrations`) |
+| `edgeContainer` / `SHSU_EDGE_CONTAINER` | No | Edge runtime container filter (default: `edge`) |
+| `dbContainer` / `SHSU_DB_CONTAINER` | No | Database container filter (default: `postgres`) |
+
+## 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 MCP Tools
+
+- `deploy` - Deploy edge functions
+- `migrate` - Run database migrations
+- `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
 

package/bin/shsu.mjs

@@ -27,7 +27,10 @@ function loadConfig() {
     server: process.env.SHSU_SERVER || pkgConfig.server,
     remotePath: process.env.SHSU_REMOTE_PATH || pkgConfig.remotePath,
     localPath: process.env.SHSU_LOCAL_PATH || pkgConfig.localPath || './supabase/functions',
+    migrationsPath: process.env.SHSU_MIGRATIONS_PATH || pkgConfig.migrationsPath || './supabase/migrations',
     url: process.env.SHSU_URL || pkgConfig.url,
+    edgeContainer: process.env.SHSU_EDGE_CONTAINER || pkgConfig.edgeContainer || 'edge',
+    dbContainer: process.env.SHSU_DB_CONTAINER || pkgConfig.dbContainer || 'postgres',
   };
 }
 
@@ -85,7 +88,7 @@ function runSync(cmd) {
 }
 
 function getEdgeContainer() {
-  return runSync(`ssh ${config.server} "docker ps -q --filter 'name=edge'"`);
+  return runSync(`ssh ${config.server} "docker ps -q --filter 'name=${config.edgeContainer}'"`);
 }
 
 // ─────────────────────────────────────────────────────────────
@@ -121,7 +124,7 @@ async function cmdDeploy(funcName, noRestart = false) {
     info('Restarting edge-runtime...');
     await run('ssh', [
       config.server,
-      `docker restart $(docker ps -q --filter 'name=edge')`,
+      `docker restart $(docker ps -q --filter 'name=${config.edgeContainer}')`,
     ], { stdio: ['inherit', 'pipe', 'inherit'] });
     success(`Deployed${funcName ? ` ${funcName}` : ''}`);
   } else {
@@ -136,7 +139,7 @@ async function cmdLogs(filter, lines = 100) {
 
   const sshArgs = [
     config.server,
-    `docker logs -f $(docker ps -q --filter 'name=edge') --tail ${lines} 2>&1`,
+    `docker logs -f $(docker ps -q --filter 'name=${config.edgeContainer}') --tail ${lines} 2>&1`,
   ];
 
   if (filter) {
@@ -196,11 +199,62 @@ async function cmdRestart() {
   info('Restarting edge-runtime...');
   await run('ssh', [
     config.server,
-    `docker restart $(docker ps -q --filter 'name=edge')`,
+    `docker restart $(docker ps -q --filter 'name=${config.edgeContainer}')`,
   ], { stdio: ['inherit', 'pipe', 'inherit'] });
   success('Restarted');
 }
 
+async function cmdMigrate() {
+  requireServer();
+
+  if (!existsSync(config.migrationsPath)) {
+    error(`Migrations folder not found: ${config.migrationsPath}`);
+  }
+
+  // Get list of migration files
+  const migrations = readdirSync(config.migrationsPath)
+    .filter((f) => f.endsWith('.sql'))
+    .sort();
+
+  if (migrations.length === 0) {
+    info('No migration files found.');
+    return;
+  }
+
+  info(`Found ${migrations.length} migration(s): ${migrations.join(', ')}`);
+
+  // Copy migrations to server
+  const remoteMigrationsPath = '/tmp/shsu-migrations';
+  info('Syncing migrations to server...');
+  await run('rsync', [
+    '-avz', '--delete',
+    `${config.migrationsPath}/`,
+    `${config.server}:${remoteMigrationsPath}/`,
+  ]);
+
+  // Find the database container
+  const dbContainer = runSync(`ssh ${config.server} "docker ps -q --filter 'name=${config.dbContainer}'"`);
+  if (!dbContainer) {
+    error(`Database container not found (filter: ${config.dbContainer})`);
+  }
+
+  // Run each migration
+  for (const migration of migrations) {
+    info(`Running ${migration}...`);
+    try {
+      await run('ssh', [
+        config.server,
+        `docker exec -i ${dbContainer} psql -U postgres -d postgres -f /tmp/shsu-migrations/${migration}`,
+      ]);
+      success(`Applied ${migration}`);
+    } catch (e) {
+      error(`Failed to apply ${migration}: ${e.message}`);
+    }
+  }
+
+  success('All migrations applied');
+}
+
 async function cmdNew(funcName) {
   if (!funcName) {
     error('Usage: shsu new <function-name>');
@@ -239,23 +293,26 @@ function cmdEnv() {
   console.log(`
 ${c.yellow('Configuration (package.json "shsu" key or environment variables):')}
 
-  server        SSH host for your Coolify server
-  remotePath    Remote path to functions directory
-  url           Supabase URL (for invoke command)
-  localPath     Local functions path (default: ./supabase/functions)
-
-${c.yellow('Environment variables override package.json:')}
-
-  SHSU_SERVER, SHSU_REMOTE_PATH, SHSU_URL, SHSU_LOCAL_PATH
+  server          SSH host for your Coolify server
+  remotePath      Remote path to functions directory
+  url             Supabase URL (for invoke command)
+  localPath       Local functions path (default: ./supabase/functions)
+  migrationsPath  Local migrations path (default: ./supabase/migrations)
+  edgeContainer   Edge runtime container filter (default: edge)
+  dbContainer     Database container filter (default: postgres)
 
 ${c.yellow('Current values:')}
 
-  server       = ${config.server || c.dim('(not set)')}
-  remotePath   = ${config.remotePath || c.dim('(not set)')}
-  url          = ${config.url || c.dim('(not set)')}
-  localPath    = ${config.localPath}
+  server          = ${config.server || c.dim('(not set)')}
+  remotePath      = ${config.remotePath || c.dim('(not set)')}
+  url             = ${config.url || c.dim('(not set)')}
+  localPath       = ${config.localPath}
+  migrationsPath  = ${config.migrationsPath}
+  edgeContainer   = ${config.edgeContainer}
+  dbContainer     = ${config.dbContainer}
 
 ${c.dim('Run "shsu init" to configure via prompts.')}
+${c.dim('Find container names in Coolify: Services → Your Service → look for container name prefix')}
 `);
 }
 
@@ -285,6 +342,8 @@ async function cmdInit() {
   const remotePath = await ask('Remote path to functions', config.remotePath);
   const url = await ask('Supabase URL', config.url);
   const localPath = await ask('Local functions path', config.localPath || './supabase/functions');
+  const edgeContainer = await ask('Edge container name filter', config.edgeContainer || 'edge');
+  const dbContainer = await ask('Database container name filter', config.dbContainer || 'postgres');
 
   rl.close();
 
@@ -295,6 +354,8 @@ async function cmdInit() {
     remotePath: remotePath || undefined,
     url: url || undefined,
     localPath: localPath !== './supabase/functions' ? localPath : undefined,
+    edgeContainer: edgeContainer !== 'edge' ? edgeContainer : undefined,
+    dbContainer: dbContainer !== 'postgres' ? dbContainer : undefined,
   };
 
   // Remove undefined values
@@ -308,6 +369,277 @@ 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: {} },
+    },
+    {
+      name: 'migrate',
+      description: 'Run SQL migrations on the database. Syncs migration files via rsync and executes them via psql.',
+      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=${config.edgeContainer}')"`);
+        }
+
+        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=${config.edgeContainer}')"`);
+        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}\n  migrationsPath: ${config.migrationsPath}\n  edgeContainer: ${config.edgeContainer}\n  dbContainer: ${config.dbContainer}`,
+          }],
+        };
+      }
+
+      case 'migrate': {
+        if (!config.server) {
+          return { content: [{ type: 'text', text: 'Error: server must be configured.' }] };
+        }
+        if (!existsSync(config.migrationsPath)) {
+          return { content: [{ type: 'text', text: `Error: Migrations folder not found: ${config.migrationsPath}` }] };
+        }
+        const migrations = readdirSync(config.migrationsPath)
+          .filter((f) => f.endsWith('.sql'))
+          .sort();
+        if (migrations.length === 0) {
+          return { content: [{ type: 'text', text: 'No migration files found.' }] };
+        }
+        let output = `Found ${migrations.length} migration(s): ${migrations.join(', ')}\n\n`;
+        // Sync migrations
+        output += captureExec(`rsync -avz --delete "${config.migrationsPath}/" "${config.server}:/tmp/shsu-migrations/"`) + '\n';
+        // Find db container
+        const dbContainer = captureExec(`ssh ${config.server} "docker ps -q --filter 'name=${config.dbContainer}'"`);
+        if (!dbContainer) {
+          return { content: [{ type: 'text', text: `Error: Database container not found (filter: ${config.dbContainer})` }] };
+        }
+        // Run migrations
+        for (const migration of migrations) {
+          output += `\nRunning ${migration}...\n`;
+          output += captureExec(`ssh ${config.server} "docker exec -i ${dbContainer} psql -U postgres -d postgres -f /tmp/shsu-migrations/${migration}"`) + '\n';
+        }
+        output += '\nAll migrations applied.';
+        return { content: [{ type: 'text', text: output }] };
+      }
+
+      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
@@ -323,6 +655,8 @@ ${c.yellow('Commands:')}
                        - With name: deploy single function
                        Options: --no-restart
 
+  migrate              Run SQL migrations on database
+
   logs [filter]        Stream edge-runtime logs
                        - Optional filter string
 
@@ -336,10 +670,13 @@ ${c.yellow('Commands:')}
 
   env                  Show current configuration
 
+  mcp                  Start MCP server (for AI assistants)
+
 ${c.yellow('Examples:')}
   shsu init
   shsu deploy
   shsu deploy hello-world --no-restart
+  shsu migrate
   shsu logs hello-world
   shsu invoke hello-world '{"name":"Stefan"}'
   shsu new my-function
@@ -379,6 +716,11 @@ async function main() {
       case 'restart':
         await cmdRestart();
         break;
+      case 'migrate':
+      case 'migration':
+      case 'migrations':
+        await cmdMigrate();
+        break;
       case 'new':
       case 'create':
         await cmdNew(args[1]);
@@ -386,6 +728,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.6",
   "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:*)"
-    ]
-  }
-}