devvami 1.1.2 → 1.3.0

package/src/services/clickup.js

@@ -1,7 +1,7 @@
 import http from 'node:http'
 import { randomBytes } from 'node:crypto'
 import { openBrowser } from '../utils/open-browser.js'
-import { loadConfig } from './config.js'
+import { loadConfig, saveConfig } from './config.js'
 
 /** @import { ClickUpTask } from '../types.js' */
 
@@ -103,19 +103,25 @@ export async function oauthFlow(clientId, clientSecret) {
 
 /**
  * Make an authenticated request to the ClickUp API.
+ * Retries automatically on HTTP 429 (rate limit) up to MAX_RETRIES times.
  * @param {string} path
+ * @param {number} [retries]
  * @returns {Promise<unknown>}
  */
- async function clickupFetch(path) {
+ async function clickupFetch(path, retries = 0) {
+   const MAX_RETRIES = 5
    const token = await getToken()
    if (!token) throw new Error('ClickUp not authenticated. Run `dvmi init` to authorize.')
   const resp = await fetch(`${API_BASE}${path}`, {
     headers: { Authorization: token },
   })
   if (resp.status === 429) {
+    if (retries >= MAX_RETRIES) {
+      throw new Error(`ClickUp API rate limit exceeded after ${MAX_RETRIES} retries. Try again later.`)
+    }
     const reset = Number(resp.headers.get('X-RateLimit-Reset') ?? Date.now() + 1000)
     await new Promise((r) => setTimeout(r, Math.max(reset - Date.now(), 1000)))
-    return clickupFetch(path)
+    return clickupFetch(path, retries + 1)
   }
   if (!resp.ok) {
     const body = /** @type {any} */ (await resp.json().catch(() => ({})))

package/src/services/cloudwatch-logs.js

@@ -0,0 +1,92 @@
+import {
+  CloudWatchLogsClient,
+  paginateDescribeLogGroups,
+  FilterLogEventsCommand,
+} from '@aws-sdk/client-cloudwatch-logs'
+
+/** @import { LogGroup, LogEvent, LogFilterResult } from '../types.js' */
+
+/**
+ * Convert a human-readable "since" string to epoch millisecond timestamps.
+ * @param {'1h'|'24h'|'7d'} since
+ * @returns {{ startTime: number, endTime: number }}
+ */
+export function sinceToEpochMs(since) {
+  const now = Date.now()
+  const MS = {
+    '1h': 60 * 60 * 1000,
+    '24h': 24 * 60 * 60 * 1000,
+    '7d': 7 * 24 * 60 * 60 * 1000,
+  }
+  const offset = MS[since]
+  if (!offset) throw new Error(`Invalid since value: ${since}. Must be one of: 1h, 24h, 7d`)
+  return { startTime: now - offset, endTime: now }
+}
+
+/**
+ * List all CloudWatch log groups in the given region using pagination.
+ * @param {string} [region] - AWS region (defaults to 'eu-west-1')
+ * @returns {Promise<LogGroup[]>}
+ */
+export async function listLogGroups(region = 'eu-west-1') {
+  const client = new CloudWatchLogsClient({ region })
+  /** @type {LogGroup[]} */
+  const groups = []
+
+  const paginator = paginateDescribeLogGroups({ client }, {})
+  for await (const page of paginator) {
+    for (const lg of page.logGroups ?? []) {
+      groups.push({
+        name: lg.logGroupName ?? '',
+        storedBytes: lg.storedBytes,
+        retentionDays: lg.retentionInDays,
+        creationTime: lg.creationTime ? new Date(lg.creationTime).toISOString() : undefined,
+      })
+    }
+  }
+
+  return groups
+}
+
+/**
+ * Filter log events from a CloudWatch log group.
+ * @param {string} logGroupName
+ * @param {string} filterPattern - CloudWatch filter pattern ('' = all events)
+ * @param {number} startTime - Epoch milliseconds
+ * @param {number} endTime - Epoch milliseconds
+ * @param {number} limit - Max events to return (1–10000)
+ * @param {string} [region] - AWS region (defaults to 'eu-west-1')
+ * @returns {Promise<LogFilterResult>}
+ */
+export async function filterLogEvents(logGroupName, filterPattern, startTime, endTime, limit, region = 'eu-west-1') {
+  const client = new CloudWatchLogsClient({ region })
+
+  const command = new FilterLogEventsCommand({
+    logGroupName,
+    filterPattern: filterPattern || undefined,
+    startTime,
+    endTime,
+    limit,
+  })
+
+  const result = await client.send(command)
+
+  /** @type {LogEvent[]} */
+  const events = (result.events ?? []).map((e) => ({
+    eventId: e.eventId ?? '',
+    logStreamName: e.logStreamName ?? '',
+    timestamp: e.timestamp ?? 0,
+    message: e.message ?? '',
+  }))
+
+  const truncated = events.length >= limit || Boolean(result.nextToken)
+
+  return {
+    events,
+    truncated,
+    logGroupName,
+    startTime,
+    endTime,
+    filterPattern: filterPattern ?? '',
+  }
+}

package/src/services/config.js

@@ -1,5 +1,5 @@
 import { readFile, writeFile, mkdir, chmod } from 'node:fs/promises'
-import { existsSync } from 'node:fs'
+import { existsSync, readFileSync } from 'node:fs'
 import { join } from 'node:path'
 import { homedir } from 'node:os'
 
@@ -58,3 +58,19 @@ export async function saveConfig(config, configPath = CONFIG_PATH) {
 export function configExists(configPath = CONFIG_PATH) {
   return existsSync(configPath)
 }
+
+/**
+ * Load CLI config synchronously. Intended for use in static getters where async is unavailable.
+ * Returns defaults if file doesn't exist or cannot be parsed.
+ * @param {string} [configPath] - Override config path (used in tests)
+ * @returns {CLIConfig}
+ */
+export function loadConfigSync(configPath = process.env.DVMI_CONFIG_PATH ?? CONFIG_PATH) {
+  if (!existsSync(configPath)) return { ...DEFAULTS }
+  try {
+    const raw = readFileSync(configPath, 'utf8')
+    return { ...DEFAULTS, ...JSON.parse(raw) }
+  } catch {
+    return { ...DEFAULTS }
+  }
+}

package/src/services/docs.js

@@ -205,6 +205,10 @@ export function detectApiSpecType(path, content) {
       if (isOpenApi(/** @type {Record<string, unknown>} */ (doc))) return 'swagger'
       if (isAsyncApi(/** @type {Record<string, unknown>} */ (doc))) return 'asyncapi'
     }
-  } catch { /* ignore */ }
+  } catch (err) {
+    // File content is not valid YAML/JSON — not an API spec, return null.
+    // Log at debug level for troubleshooting without exposing parse errors to users.
+    if (process.env.DVMI_DEBUG) process.stderr.write(`[detectApiSpecType] parse failed: ${/** @type {Error} */ (err).message}\n`)
+  }
   return null
 }

package/src/services/prompts.js

@@ -237,8 +237,8 @@ export async function downloadPrompt(relativePath, localDir, opts = {}) {
 
   const content = serializeFrontmatter(fm, prompt.body)
 
-  await mkdir(dirname(destPath), { recursive: true })
-  await writeFile(destPath, content, 'utf8')
+  await mkdir(dirname(destPath), { recursive: true, mode: 0o700 })
+  await writeFile(destPath, content, { encoding: 'utf8', mode: 0o600 })
 
   return { path: destPath, skipped: false }
 }