teleportation-cli 1.0.0 → 1.0.1

package/lib/utils/vault-errors.js

@@ -0,0 +1,353 @@
+/**
+ * Vault Error Utilities
+ *
+ * Custom error classes for Vault operations with actionable suggestions
+ */
+
+/**
+ * Base class for all Vault-related errors
+ */
+export class VaultError extends Error {
+  constructor(message, options = {}) {
+    super(message);
+    this.name = this.constructor.name;
+    this.code = options.code;
+    this.statusCode = options.statusCode;
+    this.suggestion = options.suggestion;
+    this.context = options.context || {};
+
+    // Maintain proper stack trace for where error was thrown (V8 only)
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      statusCode: this.statusCode,
+      suggestion: this.suggestion,
+      context: this.context,
+    };
+  }
+
+  toString() {
+    let str = `${this.name}: ${this.message}`;
+    if (this.suggestion) {
+      str += `\n\nSuggestion: ${this.suggestion}`;
+    }
+    return str;
+  }
+}
+
+/**
+ * Authentication failed error
+ * Thrown when API key or app ID is invalid or missing
+ */
+export class VaultAuthError extends VaultError {
+  constructor(message, options = {}) {
+    const defaultMessage = 'Authentication failed: Invalid API key or credentials';
+    const defaultSuggestion = `
+Please verify your credentials:
+1. Check that MECH_API_KEY is set correctly
+2. Check that MECH_APP_ID is set correctly
+3. Ensure your API key has not expired
+4. Run 'teleportation login' to refresh credentials
+    `.trim();
+
+    super(message || defaultMessage, {
+      code: 'VAULT_AUTH_FAILED',
+      statusCode: 401,
+      suggestion: options.suggestion || defaultSuggestion,
+      ...options,
+    });
+  }
+}
+
+/**
+ * Access denied error
+ * Thrown when user doesn't have permission to access resource
+ */
+export class VaultAccessDeniedError extends VaultError {
+  constructor(message, options = {}) {
+    const defaultMessage = 'Access denied: Insufficient permissions';
+    const defaultSuggestion = `
+This operation requires additional permissions:
+1. Verify your app has the required scopes in Mech Vault dashboard
+2. Check if the namespace belongs to your app
+3. Contact your administrator if you need elevated permissions
+    `.trim();
+
+    super(message || defaultMessage, {
+      code: 'VAULT_ACCESS_DENIED',
+      statusCode: 403,
+      suggestion: options.suggestion || defaultSuggestion,
+      ...options,
+    });
+  }
+}
+
+/**
+ * Secret not found error
+ * Thrown when requested secret doesn't exist
+ */
+export class SecretNotFoundError extends VaultError {
+  constructor(secretId, options = {}) {
+    const message = options.message || `Secret not found: ${secretId || 'unknown'}`;
+    const suggestion = options.suggestion || `
+The requested secret does not exist or has been deleted:
+1. Verify the secret ID is correct
+2. Check if the secret has expired
+3. Ensure you're using the correct namespace
+4. The secret may have been cleaned up automatically
+    `.trim();
+
+    super(message, {
+      code: 'SECRET_NOT_FOUND',
+      statusCode: 404,
+      suggestion,
+      context: { secretId, ...options.context },
+      ...options,
+    });
+  }
+}
+
+/**
+ * Network error
+ * Thrown when network request fails (timeout, connection refused, etc.)
+ */
+export class VaultNetworkError extends VaultError {
+  constructor(message, options = {}) {
+    const defaultMessage = 'Network error: Unable to reach Vault API';
+    const defaultSuggestion = `
+Failed to connect to Vault API:
+1. Check your internet connection
+2. Verify MECH_VAULT_URL is correct (${options.context?.vaultUrl || 'https://vault.mechdna.net/api'})
+3. Check if Vault service is operational (https://status.mechdna.net)
+4. Ensure no firewall is blocking the connection
+5. Try again in a few moments
+    `.trim();
+
+    super(message || defaultMessage, {
+      code: 'VAULT_NETWORK_ERROR',
+      suggestion: options.suggestion || defaultSuggestion,
+      ...options,
+    });
+  }
+}
+
+/**
+ * Server error
+ * Thrown when Vault API returns 5xx error
+ */
+export class VaultServerError extends VaultError {
+  constructor(message, options = {}) {
+    const defaultMessage = 'Vault server error: Service temporarily unavailable';
+    const defaultSuggestion = `
+The Vault service encountered an error:
+1. The service may be temporarily unavailable
+2. Check Vault status at https://status.mechdna.net
+3. Retry your request in a few moments
+4. If the problem persists, contact support with the error details
+    `.trim();
+
+    super(message || defaultMessage, {
+      code: 'VAULT_SERVER_ERROR',
+      statusCode: options.statusCode || 500,
+      suggestion: options.suggestion || defaultSuggestion,
+      ...options,
+    });
+  }
+}
+
+/**
+ * Validation error
+ * Thrown when input validation fails
+ */
+export class VaultValidationError extends VaultError {
+  constructor(message, options = {}) {
+    const defaultSuggestion = `
+Input validation failed:
+1. Check that all required fields are provided
+2. Verify field formats match requirements
+3. Ensure values are not empty or whitespace-only
+    `.trim();
+
+    super(message, {
+      code: 'VAULT_VALIDATION_ERROR',
+      statusCode: 400,
+      suggestion: options.suggestion || defaultSuggestion,
+      ...options,
+    });
+  }
+}
+
+/**
+ * Retry exhausted error
+ * Thrown when all retry attempts fail
+ */
+export class VaultRetryExhaustedError extends VaultError {
+  constructor(originalError, retryCount, options = {}) {
+    const message = `Failed after ${retryCount} retries: ${originalError.message}`;
+    const suggestion = options.suggestion || `
+All retry attempts have been exhausted:
+1. Check the underlying error for details
+2. Verify network connectivity
+3. Ensure Vault service is operational
+4. Consider increasing retry limits if transient failures are expected
+    `.trim();
+
+    super(message, {
+      code: 'VAULT_RETRY_EXHAUSTED',
+      suggestion,
+      context: {
+        originalError: originalError.message,
+        retryCount,
+        ...options.context,
+      },
+      ...options,
+    });
+
+    this.originalError = originalError;
+    this.retryCount = retryCount;
+  }
+}
+
+/**
+ * Format error for display to user
+ * @param {Error} error - Error to format
+ * @returns {string} Formatted error message
+ */
+export function formatVaultError(error) {
+  if (error instanceof VaultError) {
+    return error.toString();
+  }
+
+  // Handle generic errors
+  return `Error: ${error.message}`;
+}
+
+/**
+ * Create appropriate VaultError from HTTP response
+ * @param {Response} response - Fetch response object
+ * @param {Object} context - Additional context
+ * @returns {VaultError} Appropriate error instance
+ */
+export function createVaultErrorFromResponse(response, context = {}) {
+  const status = response.status;
+  const statusText = response.statusText;
+
+  let detailsText = '';
+  const responseBody = context && typeof context === 'object' ? context.responseBody : undefined;
+  if (responseBody && typeof responseBody === 'string') {
+    try {
+      const parsed = JSON.parse(responseBody);
+      const msg = parsed?.error?.message || parsed?.message;
+      const details = parsed?.error?.details;
+      const combined = details || msg;
+      if (combined && typeof combined === 'string') {
+        detailsText = `: ${combined}`;
+      }
+    } catch {
+      const trimmed = responseBody.trim();
+      if (trimmed) {
+        detailsText = `: ${trimmed.slice(0, 200)}`;
+      }
+    }
+  }
+
+  if (status === 401) {
+    return new VaultAuthError(
+      `Authentication failed: ${statusText}${detailsText}`,
+      { statusCode: status, context }
+    );
+  }
+
+  if (status === 403) {
+    return new VaultAccessDeniedError(
+      `Access denied: ${statusText}${detailsText}`,
+      { statusCode: status, context }
+    );
+  }
+
+  if (status === 404) {
+    return new SecretNotFoundError(
+      context.secretId || 'unknown',
+      { statusCode: status, context }
+    );
+  }
+
+  if (status >= 500) {
+    return new VaultServerError(
+      `Server error: ${statusText}${detailsText}`,
+      { statusCode: status, context }
+    );
+  }
+
+  if (status >= 400 && status < 500) {
+    return new VaultValidationError(
+      `Request failed: ${statusText}${detailsText}`,
+      { statusCode: status, context }
+    );
+  }
+
+  return new VaultError(
+    `Unexpected error: ${status} ${statusText}`,
+    { statusCode: status, context }
+  );
+}
+
+/**
+ * Wrap network errors with VaultNetworkError
+ * @param {Error} error - Original network error
+ * @param {Object} context - Additional context
+ * @returns {VaultNetworkError} Network error with context
+ */
+export function wrapNetworkError(error, context = {}) {
+  return new VaultNetworkError(
+    `Network error: ${error.message}`,
+    { context: { ...context, originalError: error.message } }
+  );
+}
+
+/**
+ * Check if error is retryable
+ * @param {Error} error - Error to check
+ * @returns {boolean} True if error should be retried
+ */
+export function isRetryableError(error) {
+  // Network errors are retryable
+  if (error instanceof VaultNetworkError) {
+    return true;
+  }
+
+  // Server errors (5xx) are retryable
+  if (error instanceof VaultServerError) {
+    return true;
+  }
+
+  // VaultError with 5xx status code
+  if (error instanceof VaultError && error.statusCode >= 500) {
+    return true;
+  }
+
+  // Generic network errors
+  if (error.message && (
+    error.message.includes('timeout') ||
+    error.message.includes('ECONNREFUSED') ||
+    error.message.includes('ETIMEDOUT') ||
+    error.message.includes('ENOTFOUND') ||
+    error.message.includes('Network')
+  )) {
+    return true;
+  }
+
+  // Client errors (4xx) are not retryable
+  if (error instanceof VaultError && error.statusCode >= 400 && error.statusCode < 500) {
+    return false;
+  }
+
+  return false;
+}

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "teleportation-cli",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Remote approval system for Claude Code - approve AI coding changes from your phone",
   "type": "module",
   "main": "teleportation-cli.cjs",
   "bin": {
-    "teleportation": "./teleportation-cli.cjs"
+    "teleportation": "teleportation-cli.cjs"
   },
   "engines": {
     "bun": "^1.3.0"
@@ -13,7 +13,7 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/dundas/teleportation-private.git"
+    "url": "git+https://github.com/dundas/teleportation-private.git"
   },
   "homepage": "https://github.com/dundas/teleportation-private#readme",
   "bugs": {
@@ -31,7 +31,7 @@
   ],
   "author": "Dundas",
   "scripts": {
-    "test": "bun --bun vitest run 'tests/**/*.test.js' 'lib/**/*.test.js'",
+    "test": "bun --bun vitest run",
     "test:watch": "bun --bun vitest",
     "test:coverage": "bun --bun vitest --coverage",
     "test:e2e": "bun --bun vitest run tests/e2e",
@@ -40,7 +40,7 @@
     "dev:relay": "cd relay && bun run dev",
     "dev:mobile": "cd mobile-ui && bun run dev",
     "dev:all": "bun run dev:relay & bun run dev:mobile",
-    "prepublishOnly": "echo 'Skipping tests for now - will fix test command post-publish'"
+    "prepublishOnly": "bun --bun vitest run"
   },
   "files": [
     "lib/**/*.js",