@odvi/create-dtt-framework 0.1.12 → 0.1.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@odvi/create-dtt-framework",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "description": "CLI tool to scaffold new projects with DTT Framework",
   "type": "module",
   "bin": {

package/template/.env.example

@@ -104,6 +104,19 @@ AWS_ACCESS_SECRET_KEY=wJalr...
 # AWS Region where your S3 buckets are located (e.g., us-east-1)
 AWS_REGION=us-east-1
 
+
+# ========================================
+# Synology (Optional)
+# ========================================
+# Synology DSM Host URL
+SYNOLOGY_HOST=http://synology:5000
+
+# Synology Username
+SYNOLOGY_USERNAME=admin
+
+# Synology Password
+SYNOLOGY_PASSWORD=secret
+
 # ========================================
 # NextBank API (Placeholder)
 # ========================================

package/template/docs/framework/environment-variables.md

@@ -110,6 +110,19 @@ AWS_ACCESS_SECRET_KEY=wJalr...
 # AWS Region (e.g., us-east-1, ap-southeast-1)
 AWS_REGION=us-east-1
 
+# ============================================
+# Synology (Optional)
+# ============================================
+
+# Synology DSM Host URL
+SYNOLOGY_HOST=http://synology:5000
+
+# Synology Username
+SYNOLOGY_USERNAME=admin
+
+# Synology Password
+SYNOLOGY_PASSWORD=secret
+
 # ============================================
 # NextBank (Placeholder - Optional)
 # ============================================
@@ -470,6 +483,37 @@ AWS_REGION=us-east-1
 
 ---
 
+### Synology Variables (Optional)
+
+#### SYNOLOGY_HOST
+
+**Purpose:** URL of your Synology DSM
+
+**Example:**
+```bash
+SYNOLOGY_HOST=http://192.168.1.100:5000
+```
+
+#### SYNOLOGY_USERNAME
+
+**Purpose:** Username for Synology authentication
+
+**Example:**
+```bash
+SYNOLOGY_USERNAME=admin
+```
+
+#### SYNOLOGY_PASSWORD
+
+**Purpose:** Password for Synology authentication
+
+**Example:**
+```bash
+SYNOLOGY_PASSWORD=secret
+```
+
+---
+
 ### NextBank Variables (Placeholder)
 
 **Note:** NextBank is a placeholder integration. These variables are optional and not currently used.

package/template/docs/framework/integrations.md

@@ -0,0 +1,78 @@
+# Reusable Integrations
+
+The DTT Framework provides a unified interface to access all configured integrations through a single `framework` instance. This allows you to easily use third-party services in your application logic without manually managing connections or clients.
+
+## Usage
+
+You can import the `framework` instance from `@/lib/framework`.
+
+```typescript
+import { framework } from '@/lib/framework'
+
+async function myFunction() {
+  // 1. Clerk Authentication
+  const user = await framework.clerk.users.getUser('user_id')
+
+  // 2. Supabase (Admin Access)
+  const { data } = await framework.supabase
+    .from('my_table')
+    .select('*')
+
+  // 3. Snowflake Query
+  const rows = await framework.snowflake.query('SELECT * FROM PUBLIC.USERS LIMIT 10')
+
+  // 4. NextBank API
+  const account = await framework.nextbank.get('/accounts/123')
+  await framework.nextbank.post('/transfers', { amount: 100 })
+
+  // 5. Synology File Operations
+  const files = await framework.synology.listFiles('/home/user')
+  const fileContent = await framework.synology.getFile('/home/user/doc.pdf')
+
+  // 6. AWS S3
+  await framework.s3.uploadFile('my-bucket', 'uploads/hello.txt', 'Hello World')
+}
+```
+
+## Integration Details
+
+### Clerk (`framework.clerk`)
+Exposes the `@clerk/nextjs/server` client. Use this for server-side user management, organization handling, and session verification.
+
+### Supabase (`framework.supabase`)
+Exposes the Supabase Admin client (using `SUPABASE_SERVICE_ROLE_KEY`).
+**Note:** This client has full admin privileges. Be careful when using it in client-facing code (it should only be used server-side).
+
+### Snowflake (`framework.snowflake`)
+Provides a simplified `query` method that handles connection pooling, execution, and cleanup automatically.
+- `query(sqlText, binds?)`: Executes a SQL query.
+
+### NextBank (`framework.nextbank`)
+A wrapper around the NextBank API that automatically handles:
+- Base URL injection
+- Authentication headers
+- JSON parsing
+- Error handling
+
+Methods:
+- `get(endpoint)`
+- `post(endpoint, body)`
+- `put(endpoint, body)`
+- `delete(endpoint)`
+
+### Synology (`framework.synology`)
+Provides methods to interact with Synology File Station.
+- `listFiles(folderPath)`
+- `getFile(filePath)`
+- `deleteFile(filePath)`
+
+### AWS S3 (`framework.s3`)
+Wraps the AWS SDK S3 Client.
+- `listBuckets()`
+- `listFiles(bucket, prefix?)`
+- `uploadFile(bucket, key, body, contentType?)`
+- `getFile(bucket, key)`
+- `deleteFile(bucket, key)`
+- `getPresignedUrl(bucket, key, expiresIn?)`
+- `getClient()`: Returns the raw AWS S3 Client for advanced operations.
+

package/template/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@odvi/dtt-framework",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "private": false,
   "type": "module",
   "bin": {
@@ -64,6 +64,7 @@
   },
   "dependencies": {
     "@aws-sdk/client-s3": "^3.958.0",
+    "@aws-sdk/s3-request-presigner": "^3.958.0",
     "@clerk/nextjs": "^6.36.5",
     "@radix-ui/react-collapsible": "^1.1.12",
     "@radix-ui/react-dialog": "^1.1.15",
@@ -80,6 +81,7 @@
     "gray-matter": "^4.0.3",
     "highlight.js": "^11.11.1",
     "hono": "^4.11.3",
+    "https-proxy-agent": "^7.0.6",
     "lucide-react": "^0.562.0",
     "next": "^15.2.3",
     "postgres": "^3.4.4",

package/template/src/config/env.ts

@@ -35,6 +35,11 @@ const envSchema = z.object({
   AWS_ACCESS_KEY_ID: z.string().optional(),
   AWS_ACCESS_SECRET_KEY: z.string().optional(),
   AWS_REGION: z.string().optional(),
+
+  // Synology (optional)
+  SYNOLOGY_HOST: z.string().url().optional(),
+  SYNOLOGY_USERNAME: z.string().optional(),
+  SYNOLOGY_PASSWORD: z.string().optional(),
 })
 
 export const env = envSchema.parse(process.env)

package/template/src/features/health-check/config.ts

@@ -52,6 +52,14 @@ export const SERVICES = [
       { name: 'Ping API', endpoint: '/nextbank/ping' },
     ],
   },
+  {
+    name: 'Synology',
+    icon: 'server',
+    checks: [
+      { name: 'Ping Host', endpoint: '/synology/ping' },
+      { name: 'Authentication', endpoint: '/synology/auth' },
+    ],
+  },
   {
     name: 'AWS S3',
     icon: 'cloud',

package/template/src/lib/aws-s3/client.ts

@@ -0,0 +1,103 @@
+import { 
+  S3Client, 
+  ListBucketsCommand, 
+  PutObjectCommand, 
+  GetObjectCommand, 
+  DeleteObjectCommand,
+  ListObjectsV2Command
+} from '@aws-sdk/client-s3'
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner'
+import { env } from '@/config/env'
+
+export class S3IntegrationClient {
+  private client: S3Client
+  private region: string
+
+  constructor() {
+    this.region = env.AWS_REGION ?? 'us-east-1'
+    
+    // Initialize with credentials from env
+    this.client = new S3Client({
+      region: this.region,
+      credentials: {
+        accessKeyId: env.AWS_ACCESS_KEY_ID ?? '',
+        secretAccessKey: env.AWS_ACCESS_SECRET_KEY ?? '',
+      },
+    })
+  }
+
+  /**
+   * Get the underlying S3 Client
+   */
+  getClient(): S3Client {
+    return this.client
+  }
+
+  /**
+   * List all buckets
+   */
+  async listBuckets() {
+    const command = new ListBucketsCommand({})
+    return this.client.send(command)
+  }
+
+  /**
+   * List files in a bucket
+   */
+  async listFiles(bucket: string, prefix?: string) {
+    const command = new ListObjectsV2Command({
+      Bucket: bucket,
+      Prefix: prefix,
+    })
+    return this.client.send(command)
+  }
+
+  /**
+   * Upload a file to S3
+   */
+  async uploadFile(bucket: string, key: string, body: Buffer | Uint8Array | Blob | string, contentType?: string) {
+    const command = new PutObjectCommand({
+      Bucket: bucket,
+      Key: key,
+      Body: body,
+      ContentType: contentType,
+    })
+    return this.client.send(command)
+  }
+
+  /**
+   * Get a file from S3 (returns the raw output)
+   */
+  async getFile(bucket: string, key: string) {
+    const command = new GetObjectCommand({
+      Bucket: bucket,
+      Key: key,
+    })
+    return this.client.send(command)
+  }
+
+  /**
+   * Generate a presigned URL for a file
+   */
+  async getPresignedUrl(bucket: string, key: string, expiresIn = 3600) {
+    const command = new GetObjectCommand({
+      Bucket: bucket,
+      Key: key,
+    })
+    return getSignedUrl(this.client, command, { expiresIn })
+  }
+
+  /**
+   * Delete a file from S3
+   */
+  async deleteFile(bucket: string, key: string) {
+    const command = new DeleteObjectCommand({
+      Bucket: bucket,
+      Key: key,
+    })
+    return this.client.send(command)
+  }
+}
+
+export const s3Client = new S3IntegrationClient()
+

package/template/src/lib/framework.ts

@@ -0,0 +1,47 @@
+import { clerkClient } from '@clerk/nextjs/server'
+import { supabaseAdmin } from './supabase/admin'
+import { nextbankClient } from './nextbank/client'
+import { synologyClient } from './synology/client'
+import { snowflakeClient } from './snowflake/client'
+import { s3Client } from './aws-s3/client'
+
+export class Framework {
+  /**
+   * Clerk Authentication SDK
+   * Use this to manage users, sessions, and organizations.
+   */
+  public clerk = clerkClient
+
+  /**
+   * Supabase Admin Client (Service Role)
+   * Use this for database and storage operations with full privileges.
+   */
+  public supabase = supabaseAdmin
+
+  /**
+   * Snowflake Client
+   * Use this to execute SQL queries against your Snowflake data warehouse.
+   */
+  public snowflake = snowflakeClient
+
+  /**
+   * AWS S3 Client
+   * Use this to manage files in AWS S3 buckets.
+   */
+  public s3 = s3Client
+
+  /**
+   * NextBank Integration
+   * Use this to interact with the NextBank API.
+   */
+  public nextbank = nextbankClient
+
+  /**
+   * Synology Integration
+   * Use this to manage files on a Synology NAS.
+   */
+  public synology = synologyClient
+}
+
+export const framework = new Framework()
+

package/template/src/lib/nextbank/client.ts

@@ -17,22 +17,21 @@ class NextBankClient {
     return { Authorization: `Basic ${token}` }
   }
 
-  async ping(fingerprint: string): Promise<{ status: string; timestamp: string }> {
-    const url = `${this.apiUrl}/management/status`
-    console.log(`[NextBank] Pinging ${url}`)
+  private async request<T = any>(endpoint: string, options: RequestInit = {}): Promise<T> {
+    const url = `${this.apiUrl}${endpoint.startsWith('/') ? endpoint : `/${endpoint}`}`
     
+    const headers = {
+      ...this.getAuthHeader(),
+      'Content-Type': 'application/json',
+      'Accept': 'application/json',
+      'User-Agent': 'dtt-framework-client',
+      ...options.headers,
+    }
+
     try {
       const response = await fetch(url, {
-        method: 'POST',
-        headers: {
-          ...this.getAuthHeader(),
-          'Content-Type': 'application/json',
-          'Accept': 'application/json',
-          'User-Agent': 'dtt-framework-health-check',
-        },
-        body: JSON.stringify({
-          fingerprint: fingerprint,
-        }),
+        ...options,
+        headers,
       })
 
       const contentType = response.headers.get('content-type')
@@ -40,28 +39,54 @@ class NextBankClient {
       if (!response.ok) {
         if (contentType && contentType.includes('text/html')) {
            const text = await response.text()
-           console.error('[NextBank] Received HTML error response. Possible causes:')
-           console.error('1. NEXTBANK_API is pointing to the wrong server (e.g. Next.js app instead of NextBank API)')
-           console.error('2. The endpoint /management/status does not exist or does not support POST')
-           console.error(`[NextBank] Response preview: ${text.substring(0, 150)}...`)
-           throw new Error(`NextBank API error: ${response.status} (HTML response)`)
+           throw new Error(`NextBank API error: ${response.status} (HTML response): ${text.substring(0, 100)}...`)
         }
         throw new Error(`NextBank API error: ${response.status} ${response.statusText}`)
       }
 
       if (contentType && contentType.includes('application/json')) {
         return await response.json()
-      } else {
-        const text = await response.text()
-        console.error('[NextBank] Invalid response content type:', contentType)
-        console.error('[NextBank] Response preview:', text.substring(0, 200))
-        throw new Error(`Invalid response format. Expected JSON, got ${contentType}`)
+      }
+      
+      // If not JSON, return text if generic T is string, or try to return as is?
+      // For now, assume JSON or void.
+      const text = await response.text()
+      try {
+          return JSON.parse(text)
+      } catch {
+          return text as unknown as T
       }
     } catch (error) {
-      console.error('[NextBank] Ping failed:', error)
+      console.error(`[NextBank] Request to ${endpoint} failed:`, error)
       throw error
     }
   }
+
+  async get<T = any>(endpoint: string): Promise<T> {
+    return this.request<T>(endpoint, { method: 'GET' })
+  }
+
+  async post<T = any>(endpoint: string, body: any): Promise<T> {
+    return this.request<T>(endpoint, { 
+      method: 'POST',
+      body: JSON.stringify(body)
+    })
+  }
+
+  async put<T = any>(endpoint: string, body: any): Promise<T> {
+    return this.request<T>(endpoint, { 
+      method: 'PUT',
+      body: JSON.stringify(body)
+    })
+  }
+
+  async delete<T = any>(endpoint: string): Promise<T> {
+    return this.request<T>(endpoint, { method: 'DELETE' })
+  }
+
+  async ping(fingerprint: string): Promise<{ status: string; timestamp: string }> {
+    return this.post('/management/status', { fingerprint })
+  }
 }
 
 export const nextbankClient = new NextBankClient()

package/template/src/lib/snowflake/client.ts

@@ -100,3 +100,40 @@ export async function destroyConnection(connection: Connection): Promise<void> {
     })
   })
 }
+
+export class SnowflakeClient {
+  async query<T = unknown>(sqlText: string, binds?: Bind[]): Promise<T[]> {
+    let connection: Connection | undefined
+    try {
+      connection = await createSnowflakeConnection()
+      
+      // Connect
+      await new Promise<void>((resolve, reject) => {
+        connection!.connect((err) => {
+          if (err) reject(err)
+          else resolve()
+        })
+      })
+
+      // Execute
+      return await new Promise<T[]>((resolve, reject) => {
+        connection!.execute({
+          sqlText,
+          binds: binds as any,
+          complete: (err, stmt, rows) => {
+            if (err) reject(err)
+            else resolve((rows || []) as T[])
+          },
+        })
+      })
+    } finally {
+      if (connection) {
+        connection.destroy((err) => {
+          if (err) console.error('Error destroying Snowflake connection:', err)
+        })
+      }
+    }
+  }
+}
+
+export const snowflakeClient = new SnowflakeClient()

package/template/src/lib/synology/client.ts

@@ -0,0 +1,239 @@
+import { env } from '@/config/env'
+import https from 'https'
+
+class SynologyClient {
+  private host: string
+  private username: string
+  private password: string
+  private sessionID: string | null = null
+
+  constructor() {
+    this.host = env.SYNOLOGY_HOST ?? ''
+    this.username = env.SYNOLOGY_USERNAME ?? ''
+    this.password = env.SYNOLOGY_PASSWORD ?? ''
+  }
+
+  // Helper to perform fetch with custom agent for self-signed certs
+  private async fetchWithAgent(url: string, options: RequestInit = {}) {
+    // For local development with self-signed certs, especially with Next.js/Node fetch,
+    // explicitly ignoring certificate errors at the process level for this specific request 
+    // context is sometimes the most reliable way if agents aren't being picked up.
+    
+    // Create an agent that ignores self-signed certificate errors
+    const agent = new https.Agent({
+      rejectUnauthorized: false
+    });
+    
+    // Note: In Next.js App Router (server components/actions), fetch is patched.
+    // Standard https.Agent might not work as expected with the patched fetch.
+    // However, for API routes (Pages router) or Route Handlers (App router), it runs in Node environment.
+    // If the error persists, it's often because the fetch implementation doesn't support the 'agent' option directly
+    // or is using Undici which needs a Dispatcher.
+
+    // Let's try a more robust approach:
+    // 1. Pass 'agent' for node-fetch compatibility
+    // 2. Pass 'dispatcher' for Undici compatibility (Node 18+ native fetch)
+    // 3. Set 'cache: no-store' to ensure we aren't hitting cached responses
+    
+    // @ts-ignore
+    const fetchOptions: any = {
+        ...options,
+        cache: 'no-store',
+        // 'agent' is for node-fetch / older polyfills
+        agent: agent, 
+    };
+    
+    // Attempt to handle Undici (Node 18+ native fetch) which Next.js uses
+    // We can't easily import 'Agent' from undici without adding it as dependency,
+    // but we can try to rely on the fact that sometimes just the node-fetch 'agent' isn't enough.
+    
+    try {
+        return await fetch(url, fetchOptions);
+    } catch (err: any) {
+        // If fetch fails with a certificate error, it might be because 'agent' was ignored.
+        // As a fallback for development environments, we can temporarily disable TLS check
+        // WARNING: This is dangerous in production, but acceptable for "Synology local IP" scenarios 
+        // if strictly scoped or if the user explicitly configured it.
+        
+        if (err.message?.includes('certificate') || err.cause?.message?.includes('certificate') || err.cause?.code === 'DEPTH_ZERO_SELF_SIGNED_CERT') {
+            console.warn('[Synology] Certificate error detected. Retrying with permissive fetch...');
+            
+            // This is a hacky workaround for environments where Agent isn't working for fetch
+            const originalReject = process.env.NODE_TLS_REJECT_UNAUTHORIZED;
+            process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
+            
+            try {
+                const retryResponse = await fetch(url, { ...options, cache: 'no-store' });
+                return retryResponse;
+            } finally {
+                // Restore original setting immediately
+                process.env.NODE_TLS_REJECT_UNAUTHORIZED = originalReject;
+            }
+        }
+        throw err;
+    }
+  }
+
+  async listFiles(folderPath: string) {
+    if (!this.sessionID) await this.login()
+    
+    const params = new URLSearchParams({
+      api: 'SYNO.FileStation.List',
+      version: '2',
+      method: 'list',
+      folder_path: folderPath,
+      _sid: this.sessionID!
+    })
+
+    const url = `${this.host}/webapi/entry.cgi?${params.toString()}`
+    const response = await this.fetchWithAgent(url)
+    
+    if (!response.ok) {
+      throw new Error(`Synology ListFiles error: ${response.status}`)
+    }
+
+    const data = await response.json()
+    if (!data.success) {
+       throw new Error(`Synology ListFiles failed: ${JSON.stringify(data)}`)
+    }
+    return data.data.files
+  }
+
+  async getFile(filePath: string) {
+    if (!this.sessionID) await this.login()
+    
+    const params = new URLSearchParams({
+      api: 'SYNO.FileStation.Download',
+      version: '2',
+      method: 'download',
+      path: filePath,
+      mode: 'open',
+      _sid: this.sessionID!
+    })
+
+    const url = `${this.host}/webapi/entry.cgi?${params.toString()}`
+    const response = await this.fetchWithAgent(url)
+
+    if (!response.ok) {
+      throw new Error(`Synology GetFile error: ${response.status}`)
+    }
+    
+    // Return array buffer or blob?
+    return response.arrayBuffer()
+  }
+
+  async deleteFile(filePath: string) {
+    if (!this.sessionID) await this.login()
+      
+    const params = new URLSearchParams({
+      api: 'SYNO.FileStation.Delete',
+      version: '2',
+      method: 'delete',
+      path: filePath,
+      _sid: this.sessionID!
+    })
+
+    const url = `${this.host}/webapi/entry.cgi?${params.toString()}`
+    const response = await this.fetchWithAgent(url)
+    
+    if (!response.ok) {
+      throw new Error(`Synology DeleteFile error: ${response.status}`)
+    }
+
+    const data = await response.json()
+    if (!data.success) {
+       throw new Error(`Synology DeleteFile failed: ${JSON.stringify(data)}`)
+    }
+    return data
+  }
+
+  async ping(): Promise<{ status: string; timestamp: string; version?: string; sid?: string }> {
+    if (!this.host) {
+      throw new Error('Synology host not configured')
+    }
+
+    const params = new URLSearchParams({
+      api: 'SYNO.API.Info',
+      version: '1',
+      method: 'query',
+      query: 'SYNO.API.Auth'
+    })
+    
+    const infoUrl = `${this.host}/webapi/query.cgi?${params.toString()}`
+    console.log(`[Synology] Pinging ${infoUrl}`)
+    
+    try {
+      const response = await this.fetchWithAgent(infoUrl)
+      
+      if (!response.ok) {
+        throw new Error(`Synology API error: ${response.status} ${response.statusText}`)
+      }
+
+      const data = await response.json()
+      
+      if (!data.success) {
+         throw new Error(`Synology API returned error: ${JSON.stringify(data)}`)
+      }
+
+      let sid: string | undefined
+
+      // If we have credentials, try to login to verify them
+      if (this.username && this.password) {
+        sid = await this.login()
+      }
+
+      return {
+        status: 'healthy',
+        timestamp: new Date().toISOString(),
+        version: data.data?.['SYNO.API.Auth']?.maxVersion?.toString(),
+        sid
+      }
+    } catch (error) {
+      console.error('[Synology] Ping failed:', error)
+      throw error
+    }
+  }
+
+  private async login(): Promise<string> {
+    const loginUrl = `${this.host}/webapi/auth.cgi`
+    
+    const params = new URLSearchParams({
+      api: 'SYNO.API.Auth',
+      version: '6',
+      method: 'login',
+      account: this.username,
+      passwd: this.password,
+      session: 'FileStation',
+      format: 'sid'
+    })
+
+    console.log(`[Synology] Logging in...`)
+
+    try {
+      const response = await this.fetchWithAgent(`${loginUrl}?${params.toString()}`)
+
+      if (!response.ok) {
+          throw new Error(`Synology Auth error: ${response.status} ${response.statusText}`)
+      }
+      
+      const data = await response.json()
+      
+      if (!data.success) {
+          throw new Error(`Synology Auth failed: ${JSON.stringify(data)}`)
+      }
+
+      if (data.data?.sid) {
+          this.sessionID = data.data.sid
+          return this.sessionID!
+      }
+      
+      throw new Error('No SID in response')
+    } catch (error) {
+        console.error('[Synology] Login error:', error)
+        this.sessionID = null
+        throw error
+    }
+  }
+}
+
+export const synologyClient = new SynologyClient()

package/template/src/server/api/routes/health/index.ts

@@ -5,6 +5,7 @@ import { storageHealthRoutes } from './storage'
 import { edgeFunctionsHealthRoutes } from './edge-functions'
 import { snowflakeHealthRoutes } from './snowflake'
 import { nextbankHealthRoutes } from './nextbank'
+import { synologyHealthRoutes } from './synology'
 import { frameworkHealthRoutes } from './framework'
 import { awsS3HealthRoutes } from './aws-s3'
 
@@ -16,6 +17,7 @@ healthRoutes.route('/storage', storageHealthRoutes)
 healthRoutes.route('/edge', edgeFunctionsHealthRoutes)
 healthRoutes.route('/snowflake', snowflakeHealthRoutes)
 healthRoutes.route('/nextbank', nextbankHealthRoutes)
+healthRoutes.route('/synology', synologyHealthRoutes)
 healthRoutes.route('/framework', frameworkHealthRoutes)
 healthRoutes.route('/aws-s3', awsS3HealthRoutes)
 
@@ -40,6 +42,8 @@ healthRoutes.get('/all', async (c) => {
     { name: 'Snowflake Query', url: `${baseUrl}/api/health/snowflake/query` },
     { name: 'NextBank Ping', url: `${baseUrl}/api/health/nextbank/ping` },
     { name: 'NextBank Auth', url: `${baseUrl}/api/health/nextbank/auth` },
+    { name: 'Synology Ping', url: `${baseUrl}/api/health/synology/ping` },
+    { name: 'Synology Auth', url: `${baseUrl}/api/health/synology/auth` },
     { name: 'AWS S3 Connect', url: `${baseUrl}/api/health/aws-s3/connect` },
   ]
 

package/template/src/server/api/routes/health/synology.ts

@@ -0,0 +1,69 @@
+import { Hono } from 'hono'
+import { synologyClient } from '@/lib/synology/client'
+import { env } from '@/config/env'
+
+export const synologyHealthRoutes = new Hono()
+
+synologyHealthRoutes.get('/ping', async (c) => {
+  const start = performance.now()
+
+  if (!env.SYNOLOGY_HOST) {
+    return c.json({
+      status: 'unconfigured',
+      responseTimeMs: Math.round(performance.now() - start),
+      message: 'Synology Host not configured',
+    })
+  }
+
+  try {
+    const result = await synologyClient.ping()
+    return c.json({
+      status: 'healthy',
+      responseTimeMs: Math.round(performance.now() - start),
+      message: 'Successfully connected to Synology',
+      data: result,
+    })
+  } catch (error) {
+    return c.json(
+      {
+        status: 'error',
+        responseTimeMs: Math.round(performance.now() - start),
+        error: error instanceof Error ? error.message : 'Ping failed',
+      },
+      500
+    )
+  }
+})
+
+synologyHealthRoutes.get('/auth', async (c) => {
+    const start = performance.now()
+  
+    if (!env.SYNOLOGY_HOST || !env.SYNOLOGY_USERNAME || !env.SYNOLOGY_PASSWORD) {
+      return c.json({
+        status: 'unconfigured',
+        responseTimeMs: Math.round(performance.now() - start),
+        message: 'Synology credentials not configured',
+      })
+    }
+  
+    try {
+      // The ping method already does a login check if credentials are provided
+      const result = await synologyClient.ping()
+      return c.json({
+        status: 'healthy',
+        responseTimeMs: Math.round(performance.now() - start),
+        message: 'Successfully authenticated with Synology',
+        data: result,
+      })
+    } catch (error) {
+      return c.json(
+        {
+          status: 'error',
+          responseTimeMs: Math.round(performance.now() - start),
+          error: error instanceof Error ? error.message : 'Auth failed',
+        },
+        500
+      )
+    }
+  })
+