shsu 0.0.1

package/.claude/settings.local.json

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

package/.github/workflows/publish.yml

@@ -0,0 +1,19 @@
+name: Publish to npm
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          registry-url: 'https://registry.npmjs.org'
+      - run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/README.md

@@ -0,0 +1,91 @@
+# shsu
+
+**S**elf-**H**osted **S**upabase **U**tilities
+
+Deploy and manage Supabase Edge Functions on Coolify-hosted Supabase.
+
+## Install
+
+```bash
+npm install -g shsu
+# or use directly
+npx shsu
+```
+
+## Setup
+
+Run the init command to configure your project:
+
+```bash
+npx shsu init
+```
+
+This adds config to your `package.json`:
+
+```json
+{
+  "shsu": {
+    "server": "root@your-coolify-server",
+    "remotePath": "/data/coolify/services/YOUR_SERVICE_ID/volumes/functions",
+    "url": "https://your-supabase.example.com"
+  }
+}
+```
+
+Find your `remotePath` by running on your server:
+
+```bash
+docker inspect $(docker ps -q --filter 'name=edge') | grep -A 5 "Mounts"
+```
+
+## Usage
+
+```bash
+# Configure project
+shsu init
+
+# Show current configuration
+shsu env
+
+# Deploy all functions
+shsu deploy
+
+# Deploy single function
+shsu deploy hello-world
+
+# Deploy without restarting edge-runtime
+shsu deploy hello-world --no-restart
+
+# Stream logs
+shsu logs
+
+# Stream logs filtered by function name
+shsu logs hello-world
+
+# List local and remote functions
+shsu list
+
+# Invoke a function
+shsu invoke hello-world '{"name":"Stefan"}'
+
+# Create new function from template
+shsu new my-function
+
+# Restart edge-runtime
+shsu restart
+```
+
+## Configuration
+
+Config is read from `package.json` "shsu" key. Environment variables override package.json values.
+
+| Key / Env Var | Required | Description |
+|---------------|----------|-------------|
+| `server` / `SHSU_SERVER` | Yes | SSH host (e.g., `root@your-server.com`) |
+| `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`) |
+
+## License
+
+MIT

package/bin/shsu.mjs

@@ -0,0 +1,406 @@
+#!/usr/bin/env node
+
+import { spawn, execSync } from 'node:child_process';
+import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { createInterface } from 'node:readline';
+
+// ─────────────────────────────────────────────────────────────
+// Configuration (package.json + environment variables)
+// ─────────────────────────────────────────────────────────────
+function loadConfig() {
+  let pkgConfig = {};
+
+  // Try to load from package.json
+  const pkgPath = join(process.cwd(), 'package.json');
+  if (existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+      pkgConfig = pkg.shsu || {};
+    } catch (e) {
+      // Ignore parse errors
+    }
+  }
+
+  // Env vars override package.json
+  return {
+    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',
+    url: process.env.SHSU_URL || pkgConfig.url,
+  };
+}
+
+const config = loadConfig();
+
+// ─────────────────────────────────────────────────────────────
+// Colors
+// ─────────────────────────────────────────────────────────────
+const c = {
+  red: (s) => `\x1b[31m${s}\x1b[0m`,
+  green: (s) => `\x1b[32m${s}\x1b[0m`,
+  yellow: (s) => `\x1b[33m${s}\x1b[0m`,
+  blue: (s) => `\x1b[34m${s}\x1b[0m`,
+  dim: (s) => `\x1b[2m${s}\x1b[0m`,
+};
+
+const info = (msg) => console.log(`${c.blue('▸')} ${msg}`);
+const success = (msg) => console.log(`${c.green('✓')} ${msg}`);
+const error = (msg) => {
+  console.error(`${c.red('✗')} ${msg}`);
+  process.exit(1);
+};
+
+// ─────────────────────────────────────────────────────────────
+// Helpers
+// ─────────────────────────────────────────────────────────────
+function requireVar(name) {
+  if (!config[name]) {
+    error(`Missing required env var: SHSU_${name.toUpperCase()} (see 'shsu env')`);
+  }
+}
+
+function requireServer() {
+  requireVar('server');
+  requireVar('remotePath');
+}
+
+function run(cmd, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn(cmd, args, { stdio: 'inherit', ...options });
+    proc.on('close', (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`Command failed with code ${code}`));
+    });
+    proc.on('error', reject);
+  });
+}
+
+function runSync(cmd) {
+  try {
+    return execSync(cmd, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+  } catch (e) {
+    return null;
+  }
+}
+
+function getEdgeContainer() {
+  return runSync(`ssh ${config.server} "docker ps -q --filter 'name=edge'"`);
+}
+
+// ─────────────────────────────────────────────────────────────
+// Commands
+// ─────────────────────────────────────────────────────────────
+
+async function cmdDeploy(funcName, noRestart = false) {
+  requireServer();
+
+  if (!funcName) {
+    info('Deploying all functions...');
+    await run('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)) {
+      error(`Function not found: ${funcPath}`);
+    }
+    info(`Deploying ${funcName}...`);
+    await run('rsync', [
+      '-avz',
+      `${funcPath}/`,
+      `${config.server}:${config.remotePath}/${funcName}/`,
+    ]);
+  }
+
+  if (!noRestart) {
+    info('Restarting edge-runtime...');
+    await run('ssh', [
+      config.server,
+      `docker restart $(docker ps -q --filter 'name=edge')`,
+    ], { stdio: ['inherit', 'pipe', 'inherit'] });
+    success(`Deployed${funcName ? ` ${funcName}` : ''}`);
+  } else {
+    success(`Synced${funcName ? ` ${funcName}` : ''} (no restart)`);
+  }
+}
+
+async function cmdLogs(filter, lines = 100) {
+  requireServer();
+
+  info(`Streaming logs${filter ? ` (filter: ${filter})` : ''}... (Ctrl+C to exit)`);
+
+  const sshArgs = [
+    config.server,
+    `docker logs -f $(docker ps -q --filter 'name=edge') --tail ${lines} 2>&1`,
+  ];
+
+  if (filter) {
+    const ssh = spawn('ssh', sshArgs, { stdio: ['inherit', 'pipe', 'inherit'] });
+    const grep = spawn('grep', ['--line-buffered', '-i', filter], {
+      stdio: ['pipe', 'inherit', 'inherit'],
+    });
+    ssh.stdout.pipe(grep.stdin);
+    
+    await new Promise((resolve) => {
+      ssh.on('close', resolve);
+      grep.on('close', resolve);
+    });
+  } else {
+    await run('ssh', sshArgs);
+  }
+}
+
+async function cmdList() {
+  requireServer();
+
+  info('Remote functions:');
+  const remote = runSync(`ssh ${config.server} "ls -1 ${config.remotePath} 2>/dev/null"`);
+  if (remote) {
+    remote.split('\n').filter(Boolean).forEach((f) => console.log(`  • ${f}`));
+  }
+
+  console.log('');
+  info('Local functions:');
+  if (existsSync(config.localPath)) {
+    readdirSync(config.localPath, { withFileTypes: true })
+      .filter((d) => d.isDirectory())
+      .forEach((d) => console.log(`  • ${d.name}`));
+  }
+}
+
+async function cmdInvoke(funcName, data = '{}') {
+  requireVar('url');
+
+  if (!funcName) {
+    error('Usage: shsu invoke <function-name> [json-data]');
+  }
+
+  info(`Invoking ${funcName}...`);
+  await run('curl', [
+    '-s', '-X', 'POST',
+    `${config.url}/functions/v1/${funcName}`,
+    '-H', 'Content-Type: application/json',
+    '-d', data,
+  ]);
+  console.log('');
+}
+
+async function cmdRestart() {
+  requireServer();
+
+  info('Restarting edge-runtime...');
+  await run('ssh', [
+    config.server,
+    `docker restart $(docker ps -q --filter 'name=edge')`,
+  ], { stdio: ['inherit', 'pipe', 'inherit'] });
+  success('Restarted');
+}
+
+async function cmdNew(funcName) {
+  if (!funcName) {
+    error('Usage: shsu new <function-name>');
+  }
+
+  const funcPath = join(config.localPath, funcName);
+  if (existsSync(funcPath)) {
+    error(`Function already exists: ${funcName}`);
+  }
+
+  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" } }
+    )
+  }
+})
+`
+  );
+
+  success(`Created ${funcPath}/index.ts`);
+}
+
+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
+
+${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}
+
+${c.dim('Run "shsu init" to configure via prompts.')}
+`);
+}
+
+async function cmdInit() {
+  const pkgPath = join(process.cwd(), 'package.json');
+
+  if (!existsSync(pkgPath)) {
+    error('No package.json found. Run "npm init" first.');
+  }
+
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  const ask = (question, defaultVal) =>
+    new Promise((resolve) => {
+      const prompt = defaultVal ? `${question} [${defaultVal}]: ` : `${question}: `;
+      rl.question(prompt, (answer) => {
+        resolve(answer.trim() || defaultVal || '');
+      });
+    });
+
+  console.log(`\n${c.blue('shsu init')} - Configure project\n`);
+
+  const server = await ask('Server (e.g. root@server.com)', config.server);
+  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');
+
+  rl.close();
+
+  // Read and update package.json
+  const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+  pkg.shsu = {
+    server: server || undefined,
+    remotePath: remotePath || undefined,
+    url: url || undefined,
+    localPath: localPath !== './supabase/functions' ? localPath : undefined,
+  };
+
+  // Remove undefined values
+  Object.keys(pkg.shsu).forEach((key) => {
+    if (pkg.shsu[key] === undefined) delete pkg.shsu[key];
+  });
+
+  writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
+
+  console.log('');
+  success('Added shsu config to package.json');
+}
+
+function cmdHelp() {
+  console.log(`
+${c.blue('shsu')} - Self-Hosted Supabase Utilities
+
+${c.yellow('Usage:')}
+  shsu <command> [options]
+
+${c.yellow('Commands:')}
+  init                 Configure shsu for this project
+
+  deploy [name]        Deploy function(s) to server
+                       - No args: deploy all functions
+                       - With name: deploy single function
+                       Options: --no-restart
+
+  logs [filter]        Stream edge-runtime logs
+                       - Optional filter string
+
+  list                 List functions (local and remote)
+
+  invoke <n> [json]    Invoke a function
+
+  restart              Restart edge-runtime container
+
+  new <name>           Create new function from template
+
+  env                  Show current configuration
+
+${c.yellow('Examples:')}
+  shsu init
+  shsu deploy
+  shsu deploy hello-world --no-restart
+  shsu logs hello-world
+  shsu invoke hello-world '{"name":"Stefan"}'
+  shsu new my-function
+
+${c.yellow('Setup:')}
+  Run 'shsu init' to configure, or set values in package.json "shsu" key.
+`);
+}
+
+// ─────────────────────────────────────────────────────────────
+// Main
+// ─────────────────────────────────────────────────────────────
+async function main() {
+  const args = process.argv.slice(2);
+  const cmd = args[0] || 'help';
+
+  try {
+    switch (cmd) {
+      case 'deploy': {
+        const noRestart = args.includes('--no-restart');
+        const funcName = args[1] === '--no-restart' ? args[2] : args[1];
+        await cmdDeploy(funcName, noRestart);
+        break;
+      }
+      case 'logs':
+      case 'log':
+        await cmdLogs(args[1], args[2] || 100);
+        break;
+      case 'list':
+      case 'ls':
+        await cmdList();
+        break;
+      case 'invoke':
+      case 'call':
+        await cmdInvoke(args[1], args[2]);
+        break;
+      case 'restart':
+        await cmdRestart();
+        break;
+      case 'new':
+      case 'create':
+        await cmdNew(args[1]);
+        break;
+      case 'init':
+        await cmdInit();
+        break;
+      case 'env':
+      case 'config':
+        cmdEnv();
+        break;
+      case 'help':
+      case '-h':
+      case '--help':
+        cmdHelp();
+        break;
+      default:
+        error(`Unknown command: ${cmd} (try 'shsu help')`);
+    }
+  } catch (e) {
+    error(e.message);
+  }
+}
+
+main();

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "shsu",
+  "version": "0.0.1",
+  "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"
+  },
+  "bin": {
+    "shsu": "./bin/shsu.mjs"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/YUZU-Hub/shsu.git"
+  },
+  "keywords": [
+    "supabase",
+    "edge-functions",
+    "deno",
+    "coolify",
+    "self-hosted",
+    "deploy",
+    "cli",
+    "serverless",
+    "docker",
+    "rsync"
+  ],
+  "author": "Stefan Lange-Hegermann <stefan@yuzuhub.com>",
+  "license": "MIT",
+  "type": "module",
+  "bugs": {
+    "url": "https://github.com/YUZU-Hub/shsu/issues"
+  },
+  "homepage": "https://github.com/YUZU-Hub/shsu#readme"
+}