@sinch/cli 0.3.3 → 0.3.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinch/cli",
-  "version": "0.3.3",
+  "version": "0.3.4",
   "description": "Official Sinch CLI - Manage all Sinch products from your terminal",
   "main": "dist/index.js",
   "bin": {
@@ -21,7 +21,8 @@
     "test:smoke": "node scripts/smoke-test.js",
     "setup": "npm run build && npm link && npm run build:binary && node scripts/setup-dev.js",
     "format": "prettier --write .",
-    "format:check": "prettier --check ."
+    "format:check": "prettier --check .",
+    "prepare": "husky"
   },
   "keywords": [],
   "author": "Sinch <support@sinch.com> (https://www.sinch.com)",
@@ -35,6 +36,7 @@
   "files": [
     "dist/",
     "bin/",
+    "scripts/",
     "README.md",
     "LICENSE"
   ],
@@ -51,26 +53,24 @@
     "axios-retry": "^4.5.0",
     "blessed": "^0.1.81",
     "chalk": "^4.1.2",
-    "cli-spinners": "^2.9.2",
     "cli-table3": "^0.6.3",
     "clipboardy": "^5.1.0",
     "commander": "^14.0.0",
     "form-data": "^4.0.0",
     "fs-extra": "^11.3.3",
-    "google-libphonenumber": "^3.2.44",
-    "inquirer": "8.2.7",
-    "ora": "^4.1.1"
+    "google-libphonenumber": "^3.2.44"
   },
   "devDependencies": {
     "@types/adm-zip": "^0.5.7",
     "@types/blessed": "^0.1.25",
     "@types/fs-extra": "^11.0.4",
     "@types/google-libphonenumber": "^7.4.30",
-    "@types/inquirer": "^9.0.9",
     "@types/jest": "^30.0.0",
     "@types/node": "24.10.9",
     "execa": "^5.1.1",
+    "husky": "^9.1.7",
     "jest": "^30.0.0",
+    "lint-staged": "^16.2.7",
     "nodemon": "^3.0.1",
     "prettier": "^3.8.1",
     "ts-jest": "^29.4.6",
@@ -81,5 +81,10 @@
   "engines": {
     "node": ">=20.0.0",
     "npm": ">=9.0.0"
+  },
+  "lint-staged": {
+    "*.{js,ts,json,md}": [
+      "prettier --write"
+    ]
   }
 }

package/scripts/README-E2E.md

@@ -0,0 +1,242 @@
+# E2E Testing Documentation
+
+## Overview
+
+End-to-end testing infrastructure for the Sinch CLI that tests the complete workflow against the real API.
+
+## What is Tested
+
+The E2E test (`e2e-test.sh`) performs the following workflow:
+
+1. ✅ **CLI Installation** - Verifies CLI is installed and accessible
+2. ✅ **Authentication** - Checks credentials are configured
+3. ✅ **List Functions** - Verifies API connectivity
+4. ✅ **Init Function** - Creates a new function from template
+5. ✅ **Deploy Function** - Deploys function to production
+6. ✅ **Verify Deployment** - Confirms function is running
+7. ✅ **Check Status** - Validates function status endpoint
+8. ✅ **Check Logs** - Validates log streaming endpoint
+9. ✅ **Delete Function** - Cleans up test resources
+
+## Running E2E Tests
+
+### Option 1: GitLab CI (Automatic)
+
+E2E tests run automatically on:
+
+- Every push to `main` branch
+- Every merge request
+
+**Required GitLab CI Variables:**
+
+- `E2E_KEY_ID` (protected)
+- `E2E_KEY_SECRET` (protected, masked)
+- `E2E_APPLICATION_KEY` (protected)
+- `E2E_APPLICATION_SECRET` (protected, masked)
+
+### Option 2: Local with Node.js
+
+```bash
+# Build and install CLI
+npm run build
+npm install -g .
+
+# Set environment variables
+export SINCH_KEY_ID="your-key-id"
+export SINCH_KEY_SECRET="your-key-secret"
+export SINCH_APPLICATION_KEY="your-app-key"
+export SINCH_APPLICATION_SECRET="your-app-secret"
+
+# Run E2E test
+./scripts/e2e-test.sh
+```
+
+### Option 3: Docker (Isolated Environment)
+
+```bash
+# Build E2E Docker image
+docker build -f Dockerfile.e2e -t sinch-cli-e2e .
+
+# Run E2E tests in Docker
+docker run --rm \
+  -e SINCH_KEY_ID="your-key-id" \
+  -e SINCH_KEY_SECRET="your-key-secret" \
+  -e SINCH_APPLICATION_KEY="your-app-key" \
+  -e SINCH_APPLICATION_SECRET="your-app-secret" \
+  sinch-cli-e2e
+```
+
+**Docker Benefits:**
+
+- Clean, isolated environment every run
+- No local Node.js required
+- Same environment as CI
+- Great for testing before pushing
+
+## Test Output
+
+The test script provides colored output:
+
+- ✅ **Green** - Test passed
+- ❌ **Red** - Test failed
+- ⚠️ **Yellow** - Warning (non-fatal)
+
+Example output:
+
+```
+=== Sinch CLI E2E Test ===
+
+Test 1: CLI installation check
+✅ PASS: CLI installed (version: 0.1.0)
+
+Test 2: Authentication check
+✅ PASS: Authentication OK
+
+Test 3: List functions
+✅ PASS: List functions OK
+
+...
+
+=== E2E Test Complete ===
+✅ All tests passed!
+```
+
+## Credentials
+
+### CI/CD Environment
+
+In GitLab CI, credentials are provided via environment variables configured in GitLab:
+
+Settings → CI/CD → Variables
+
+### Local Development
+
+Two options:
+
+1. **Environment Variables** (recommended for E2E):
+
+   ```bash
+   export SINCH_KEY_ID="..."
+   export SINCH_KEY_SECRET="..."
+   export SINCH_APPLICATION_KEY="..."
+   export SINCH_APPLICATION_SECRET="..."
+   ```
+
+2. **OS Keychain** (normal CLI usage):
+   ```bash
+   sinch auth login
+   # Credentials stored securely in OS keychain
+   ```
+
+## Troubleshooting
+
+### Test Fails: Authentication not configured
+
+**Problem:** Environment variables not set
+
+**Solution:**
+
+```bash
+# Check env vars are set
+echo $SINCH_KEY_ID
+echo $SINCH_APPLICATION_KEY
+
+# Set them if missing
+export SINCH_KEY_ID="..."
+export SINCH_KEY_SECRET="..."
+export SINCH_APPLICATION_KEY="..."
+export SINCH_APPLICATION_SECRET="..."
+```
+
+### Test Fails: Deploy timeout
+
+**Problem:** API is slow or function deployment taking longer than expected
+
+**Solution:** The test allows up to 2 minutes for deployment. If it times out:
+
+1. Check API status
+2. Check function complexity
+3. Try again (might be temporary)
+
+### Test Fails: Function not found after delete
+
+**Problem:** This is actually expected - the test verifies deletion worked
+
+**Solution:** No action needed, this is correct behavior
+
+## Cleanup
+
+The E2E test **always cleans up** test functions, even on failure:
+
+- Uses a `cleanup()` trap function
+- Runs on EXIT, INT (Ctrl+C), or TERM signals
+- Deletes test function by ID
+- Safe to run multiple times
+
+## CI/CD Integration
+
+### Pipeline Stages
+
+```
+┌─────────┐
+│  Build  │ (26s)
+└────┬────┘
+     │
+┌────▼────┐
+│ Test:E2E│ (13s) ← New!
+└────┬────┘
+     │
+┌────▼────┐
+│ Publish │ (14s)
+└─────────┘
+```
+
+### When Tests Run
+
+- **Main branch:** Every commit
+- **Merge requests:** Every push to MR
+- **Tags:** No (only build + publish)
+
+### Failure Handling
+
+- `allow_failure: false` - Pipeline **fails** if E2E test fails
+- Prevents broken code from being published
+- Forces fixes before merge
+
+## Best Practices
+
+1. **Run E2E before pushing:**
+
+   ```bash
+   npm run build
+   npm install -g .
+   ./scripts/e2e-test.sh
+   ```
+
+2. **Use Docker for final verification:**
+
+   ```bash
+   docker build -f Dockerfile.e2e -t sinch-cli-e2e .
+   docker run --rm -e SINCH_KEY_ID="..." ... sinch-cli-e2e
+   ```
+
+3. **Watch CI pipeline:**
+
+   ```bash
+   glab ci view
+   ```
+
+4. **Never commit with failing E2E tests** - The pipeline will block you anyway
+
+## Files
+
+- `scripts/e2e-test.sh` - Main E2E test script
+- `Dockerfile.e2e` - Docker image for isolated testing
+- `.gitlab-ci.yml` - CI pipeline configuration
+- `scripts/README-E2E.md` - This documentation
+
+## Support
+
+- **Issues:** Report at GitLab project issues
+- **CI Logs:** View in GitLab CI pipeline
+- **Local Debugging:** Add `set -x` to script for verbose output

package/scripts/e2e-test.sh

@@ -0,0 +1,155 @@
+#!/bin/sh
+set -e  # Exit on error
+
+echo "=== Sinch CLI E2E Test ==="
+echo ""
+
+# Generate unique test name
+TEST_NAME="e2e-test"
+FUNCTION_ID=""
+FAILED=0
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# Function to cleanup on exit
+cleanup() {
+  EXIT_CODE=$?
+
+  if [ -n "$FUNCTION_ID" ]; then
+    echo ""
+    echo "${YELLOW}Cleaning up test function: $FUNCTION_ID${NC}"
+    sinch functions delete "$FUNCTION_ID" --force 2>/dev/null || true
+  fi
+
+  # If script exited with error and FAILED wasn't set, set it now
+  if [ $EXIT_CODE -ne 0 ] && [ $FAILED -eq 0 ]; then
+    FAILED=$EXIT_CODE
+  fi
+
+  if [ $FAILED -eq 0 ]; then
+    echo ""
+    echo "${GREEN}=== E2E Test Complete ===${NC}"
+    echo "${GREEN}All tests passed!${NC}"
+  else
+    echo ""
+    echo "${RED}=== E2E Test Failed ===${NC}"
+    echo "${RED}Exit code: $FAILED${NC}"
+  fi
+
+  exit $FAILED
+}
+trap cleanup EXIT INT TERM
+
+# Test 1: Check CLI is installed
+echo "Test 1: CLI installation check"
+if ! command -v sinch >/dev/null 2>&1; then
+  echo "${RED}FAIL: sinch command not found${NC}"
+  FAILED=1
+  exit 1
+fi
+CLI_VERSION=$(sinch --version)
+echo "${GREEN}PASS: CLI installed (version: $CLI_VERSION)${NC}"
+echo ""
+
+# Test 2: List functions (will fail if auth not configured via env vars)
+echo "Test 2: List functions"
+if ! sinch functions list >/dev/null 2>&1; then
+  echo "${RED}FAIL: Cannot list functions${NC}"
+  echo "Make sure these environment variables are set:"
+  echo "  - SINCH_KEY_ID"
+  echo "  - SINCH_KEY_SECRET"
+  echo "  - SINCH_APPLICATION_KEY"
+  echo "  - SINCH_APPLICATION_SECRET"
+  FAILED=1
+  exit 1
+fi
+echo "${GREEN}PASS: List functions OK${NC}"
+echo ""
+
+# Test 3: Init function
+echo "Test 3: Initialize function"
+TEST_DIR="/tmp/$TEST_NAME"
+cd /tmp
+
+if ! sinch functions init simple-voice-ivr \
+  --name "$TEST_NAME" \
+  --skip-install \
+  --non-interactive >/dev/null 2>&1; then
+  echo "${RED}FAIL: Function init failed${NC}"
+  FAILED=1
+  exit 1
+fi
+echo "${GREEN}PASS: Function initialized${NC}"
+echo ""
+
+# Test 4: Deploy function
+echo "Test 4: Deploy function (this may take a minute...)"
+cd "$TEST_NAME" || {
+  echo "${RED}FAIL: Cannot change to function directory${NC}"
+  FAILED=1
+  exit 1
+}
+DEPLOY_OUTPUT=$(sinch functions deploy --non-interactive 2>&1) || {
+  echo "${RED}FAIL: Deploy command failed${NC}"
+  echo "$DEPLOY_OUTPUT"
+  FAILED=1
+  exit 1
+}
+
+# Extract function ID from deploy output
+FUNCTION_ID=$(echo "$DEPLOY_OUTPUT" | grep "Function ID:" | awk '{print $NF}')
+if [ -z "$FUNCTION_ID" ]; then
+  echo "${RED}FAIL: Deploy succeeded but no function ID found${NC}"
+  echo "$DEPLOY_OUTPUT"
+  FAILED=1
+  exit 1
+fi
+echo "${GREEN}PASS: Function deployed (ID: $FUNCTION_ID)${NC}"
+echo ""
+
+# Test 5: Verify deployment
+echo "Test 5: Verify function is accessible"
+sleep 2  # Give it a moment to be fully available
+if ! sinch functions list | grep -q "$TEST_NAME"; then
+  echo "${RED}FAIL: Function not found in list${NC}"
+  FAILED=1
+  exit 1
+fi
+echo "${GREEN}PASS: Function is accessible${NC}"
+echo ""
+
+# Test 6: Check function status
+echo "Test 6: Check function status"
+if ! sinch functions status "$FUNCTION_ID" >/dev/null 2>&1; then
+  echo "${YELLOW}WARN: Cannot fetch function status (non-fatal)${NC}"
+else
+  echo "${GREEN}PASS: Function status OK${NC}"
+fi
+echo ""
+
+# Test 7: Check logs are accessible
+echo "Test 7: Check logs are accessible"
+if ! sinch functions logs "$FUNCTION_ID" --limit 10 >/dev/null 2>&1; then
+  echo "${YELLOW}WARN: Cannot fetch logs (non-fatal)${NC}"
+else
+  echo "${GREEN}PASS: Logs accessible${NC}"
+fi
+echo ""
+
+# Test 8: Delete function (cleanup will also handle this)
+echo "Test 8: Delete function"
+if ! sinch functions delete "$FUNCTION_ID" --force >/dev/null 2>&1; then
+  echo "${RED}FAIL: Delete failed${NC}"
+  FAILED=1
+  exit 1
+fi
+echo "${GREEN}PASS: Function deleted${NC}"
+FUNCTION_ID=""  # Clear so cleanup doesn't try again
+echo ""
+
+# All tests passed
+exit 0

package/scripts/post-build.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+
+const fs = require('fs-extra');
+const path = require('path');
+
+async function postBuild() {
+  console.log('Running post-build tasks...');
+
+  // Ensure dist directory exists
+  await fs.ensureDir('dist');
+
+  // Copy package.json to dist for runtime requires
+  await fs.copy('package.json', 'dist/package.json');
+
+  // Copy skills folder to dist
+  const skillsSource = path.join(__dirname, '..', 'skills');
+  const skillsDest = path.join(__dirname, '..', 'dist', 'skills');
+  if (await fs.pathExists(skillsSource)) {
+    await fs.copy(skillsSource, skillsDest, { overwrite: true });
+    console.log('Copied skills to dist/skills');
+  }
+
+  // Ensure the CLI entry point works
+  const distIndex = path.join('dist', 'index.js');
+  if (await fs.pathExists(distIndex)) {
+    // Add shebang if not present
+    const content = await fs.readFile(distIndex, 'utf8');
+    if (!content.startsWith('#!/usr/bin/env node')) {
+      await fs.writeFile(distIndex, '#!/usr/bin/env node\n' + content);
+    }
+  }
+
+  console.log('Post-build tasks completed.');
+}
+
+postBuild().catch(console.error);

package/scripts/postinstall.js

@@ -0,0 +1,197 @@
+#!/usr/bin/env node
+
+/**
+ * postinstall.js — runs on `npm install -g @sinch/cli`
+ *
+ * 1. Writes ~/.sinch/completions.json (command tree for PowerShell)
+ * 2. Installs shell completion into the user's profile (PowerShell, zsh, or bash)
+ *
+ * Silent failure on ALL errors — must never break `npm install`.
+ *
+ * Keep COMPLETION_COMMANDS in sync with src/index.ts.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { spawn } = require('child_process');
+
+const SINCH_DIR = path.join(os.homedir(), '.sinch');
+
+// Keep in sync with COMPLETION_COMMANDS in src/index.ts.
+// The postAction hook overwrites completions.json on every CLI run, so drift self-heals.
+const COMPLETION_COMMANDS = {
+  functions: ['init', 'list', 'deploy', 'download', 'dev', 'status', 'logs', 'delete', 'docs'],
+  templates: ['list', 'show', 'node', 'csharp', 'python'],
+  voice: ['callback-url', 'get-callbacks', 'set-callback'],
+  secrets: ['list', 'add', 'get', 'delete', 'clear'],
+  auth: ['login', 'status', 'logout'],
+  sip: ['trunks', 'endpoints', 'acls', 'countries', 'credential-lists', 'calls'],
+  numbers: ['active', 'available', 'regions'],
+  fax: ['send', 'list', 'get', 'cancel', 'auth-status', 'status'],
+  conversation: ['send', 'messages', 'contacts', 'conversations', 'apps', 'webhooks'],
+  skills: ['install', 'list', 'uninstall', 'update'],
+  config: ['--set', '--get', '--list'],
+  completion: ['--shell', '--install'],
+};
+
+const SENTINEL_START = '# ── Sinch CLI completion ──';
+const SENTINEL_END = '# ── End Sinch CLI completion ──';
+
+function getVersion() {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf8'));
+    return pkg.version || '0.0.0';
+  } catch {
+    return '0.0.0';
+  }
+}
+
+function writeCompletionsJson(version) {
+  const filePath = path.join(SINCH_DIR, 'completions.json');
+  fs.writeFileSync(filePath, JSON.stringify({ version, commands: COMPLETION_COMMANDS }, null, 2));
+}
+
+function getPowerShellCompletionScript() {
+  return `${SENTINEL_START}
+# PowerShell completion for Sinch CLI
+# Reads command tree from ~/.sinch/completions.json (auto-updated by CLI)
+
+Register-ArgumentCompleter -Native -CommandName sinch -ScriptBlock {
+    param($wordToComplete, $commandAst, $cursorPosition)
+
+    try {
+        $jsonPath = Join-Path $env:USERPROFILE '.sinch' 'completions.json'
+        if (-not (Test-Path $jsonPath)) { return }
+
+        $data = Get-Content $jsonPath -Raw | ConvertFrom-Json
+        $line = $commandAst.CommandElements
+        $command = if ($line.Count -gt 1) { $line[1].Value } else { "" }
+
+        if ($line.Count -eq 2) {
+            $mainCommands = @($data.commands.PSObject.Properties.Name) + @('--version', '--help')
+            $mainCommands | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+                [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
+            }
+        }
+        elseif ($line.Count -eq 3 -and $data.commands.$command) {
+            @($data.commands.$command) | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+                [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
+            }
+        }
+    }
+    catch {
+        # Silently fail — prevents PowerShell startup errors
+    }
+}
+${SENTINEL_END}`;
+}
+
+// --- Profile installation helpers ---
+
+function shellEscapePath(p) {
+  return "'" + p.replace(/'/g, "'\\''") + "'";
+}
+
+function upsertBlock(content, block) {
+  const pattern =
+    SENTINEL_START.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') +
+    '[\\s\\S]*?' +
+    SENTINEL_END.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const replaced = content.replace(new RegExp(pattern, 'g'), block.trim());
+  if (replaced !== content) return replaced;
+  return content + (content && !content.endsWith('\n') ? '\n' : '') + '\n' + block.trim() + '\n';
+}
+
+function tryShell(cmd) {
+  return new Promise((resolve) => {
+    const ps = spawn(cmd, ['-NoProfile', '-Command', '$PROFILE'], {
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    let out = '';
+    ps.stdout.on('data', (d) => (out += d.toString()));
+    ps.on('close', (code) => resolve(code === 0 ? out.trim() : null));
+    ps.on('error', () => resolve(null));
+  });
+}
+
+async function installPowerShellCompletion() {
+  const completionFile = path.join(SINCH_DIR, 'sinch-completion.ps1');
+  fs.writeFileSync(completionFile, getPowerShellCompletionScript());
+
+  const profilePath = (await tryShell('pwsh')) ?? (await tryShell('powershell'));
+  if (!profilePath) return;
+
+  // Validate profile path is within user's home directory
+  const resolved = path.resolve(profilePath);
+  if (!resolved.startsWith(os.homedir())) return;
+
+  fs.mkdirSync(path.dirname(resolved), { recursive: true });
+
+  let content = '';
+  try {
+    content = fs.readFileSync(resolved, 'utf8');
+  } catch {
+    // Profile doesn't exist yet — will be created
+  }
+
+  const sourceLine = `. ${shellEscapePath(completionFile.replace(/\\/g, '\\\\'))}`;
+  const block = `${SENTINEL_START}\n${sourceLine}\n${SENTINEL_END}`;
+  fs.writeFileSync(resolved, upsertBlock(content, block));
+}
+
+function installBashZshCompletion() {
+  const completionFile = path.join(SINCH_DIR, 'sinch-completion.bash');
+  const sourceLine = `source ${shellEscapePath(completionFile)}`;
+  const block = `${SENTINEL_START}\n${sourceLine}\n${SENTINEL_END}`;
+
+  const home = os.homedir();
+  const zshrc = path.join(home, '.zshrc');
+  const bashrc = path.join(home, '.bashrc');
+
+  const rcFiles = [];
+  if (process.platform === 'darwin') {
+    rcFiles.push(zshrc);
+    if (fs.existsSync(bashrc)) rcFiles.push(bashrc);
+  } else {
+    if (fs.existsSync(bashrc)) rcFiles.push(bashrc);
+    if (fs.existsSync(zshrc)) rcFiles.push(zshrc);
+    if (rcFiles.length === 0) rcFiles.push(bashrc);
+  }
+
+  for (const rcFile of rcFiles) {
+    let content = '';
+    try {
+      content = fs.readFileSync(rcFile, 'utf8');
+    } catch {
+      // File doesn't exist yet — will be created
+    }
+    fs.writeFileSync(rcFile, upsertBlock(content, block));
+  }
+}
+
+// --- Main ---
+
+async function main() {
+  // Only run on global installs or when forced by setup-dev.js
+  if (process.env.npm_config_global !== 'true' && !process.env.SINCH_FORCE_POSTINSTALL) {
+    return;
+  }
+
+  try {
+    fs.mkdirSync(SINCH_DIR, { recursive: true });
+
+    const version = getVersion();
+    writeCompletionsJson(version);
+
+    if (process.platform === 'win32') {
+      await installPowerShellCompletion();
+    } else {
+      installBashZshCompletion();
+    }
+  } catch {
+    // Silent failure — never break npm install
+  }
+}
+
+main();