feat: add timeout metadata support in script parsing and enhance related tests

- Introduced support for a new `timeout` property in the metadata interface, allowing scripts to specify execution time limits.
- Updated the `parseScript` function to handle timeout metadata from comments and exports.
- Enhanced unit tests to validate timeout metadata parsing from various script formats, ensuring robust functionality.
- Improved type definitions to include the new timeout property, ensuring type safety across the application.

Author: johnlindquist

src/core/parser.ts

@@ -53,8 +53,8 @@ export let postprocessMetadata = (
 	if (metadata.background) {
 		if (metadata.background !== "auto") {
 			// @ts-ignore
-			result.background = typeof metadata.background === 'boolean' 
-				? metadata.background 
+			result.background = typeof metadata.background === 'boolean'
+				? metadata.background
 				: metadata.background === "true"
 		}
 	}
@@ -175,19 +175,18 @@ export let parseScript = async (filePath: string): Promise<Script> => {
 				})
 			}
 			return cachedEntry.script
-		} else {
-			if (parentPort) {
-				if (!cachedEntry) {
-					parentPort.postMessage({
-						channel: Channel.LOG_TO_PARENT,
-						value: `[parseScript] Cache miss (file not in cache): ${filePath}`
-					})
-				} else {
-					parentPort.postMessage({
-						channel: Channel.LOG_TO_PARENT,
-						value: `[parseScript] Cache miss (mtime mismatch on ${filePath} - Cached: ${cachedEntry.mtimeMs}, Current: ${currentMtimeMs})`
-					})
-				}
+		}
+		if (parentPort) {
+			if (!cachedEntry) {
+				parentPort.postMessage({
+					channel: Channel.LOG_TO_PARENT,
+					value: `[parseScript] Cache miss (file not in cache): ${filePath}`
+				})
+			} else {
+				parentPort.postMessage({
+					channel: Channel.LOG_TO_PARENT,
+					value: `[parseScript] Cache miss (mtime mismatch on ${filePath} - Cached: ${cachedEntry.mtimeMs}, Current: ${currentMtimeMs})`
+				})
 			}
 		}
 

src/core/utils.test.ts

@@ -56,6 +56,7 @@ ava('parseScript comment full metadata', async (t) => {
   let schedule = '0 0 * * *'
   let shortcut = `${cmd}+9`
   let normalizedShortcut = shortcutNormalizer(shortcut)
+  let timeout = 15000
   let fileName = slugify(name, { lower: true })
   let scriptContent = `
 import "@johnlindquist/kit"
@@ -64,6 +65,7 @@ import "@johnlindquist/kit"
 // Description: ${description}
 // Schedule: ${schedule}
 // Shortcut: ${shortcut}
+// Timeout: ${timeout}
   `.trim()
 
   let scriptPath = await outputTmpFile(`${fileName}.ts`, scriptContent)
@@ -74,6 +76,7 @@ import "@johnlindquist/kit"
   t.is(script.schedule, schedule as CronExpression)
   t.is(script.filePath, scriptPath)
   t.is(script.shortcut, normalizedShortcut)
+  t.is(script.timeout, timeout)
 })
 
 ava('parseScript multiline description in global metadata', async (t) => {
@@ -138,6 +141,67 @@ export const metadata = {
   t.is(script.filePath, scriptPath)
 })
 
+ava('parseScript timeout metadata from comments', async (t) => {
+  let name = 'Testing Timeout Metadata'
+  let timeout = 5000
+  let fileName = slugify(name, { lower: true })
+  let scriptContent = `
+import "@johnlindquist/kit"
+
+// Name: ${name}
+// Timeout: ${timeout}
+  `.trim()
+
+  let scriptPath = await outputTmpFile(`${fileName}.ts`, scriptContent)
+
+  let script = await parseScript(scriptPath)
+  t.is(script.name, name)
+  t.is(script.timeout, timeout)
+  t.is(script.filePath, scriptPath)
+})
+
+ava('parseScript timeout metadata from export', async (t) => {
+  let name = 'Testing Timeout Export Metadata'
+  let timeout = 10000
+  let fileName = slugify(name, { lower: true })
+  let scriptContent = `
+import "@johnlindquist/kit"
+
+export const metadata = {
+  name: "${name}",
+  timeout: ${timeout}
+}
+  `.trim()
+
+  let scriptPath = await outputTmpFile(`${fileName}.ts`, scriptContent)
+
+  let script = await parseScript(scriptPath)
+  t.is(script.name, name)
+  t.is(script.timeout, timeout)
+  t.is(script.filePath, scriptPath)
+})
+
+ava('parseScript timeout metadata from global', async (t) => {
+  let name = 'Testing Timeout Global Metadata'
+  let timeout = 30000
+  let fileName = slugify(name, { lower: true })
+  let scriptContent = `
+import "@johnlindquist/kit"
+
+metadata = {
+  name: "${name}",
+  timeout: ${timeout}
+}
+  `.trim()
+
+  let scriptPath = await outputTmpFile(`${fileName}.ts`, scriptContent)
+
+  let script = await parseScript(scriptPath)
+  t.is(script.name, name)
+  t.is(script.timeout, timeout)
+  t.is(script.filePath, scriptPath)
+})
+
 ava('parseScript global convention metadata name', async (t) => {
   let name = 'Testing Parse Script Convention Global'
   let fileName = slugify(name, { lower: true })

src/core/utils.ts

@@ -255,8 +255,11 @@ ${contents}`.trim()
   return contents
 }
 
-// Create a Set directly, type-checked against the Metadata interface keys.
-const VALID_METADATA_KEYS_SET = new Set<keyof Metadata>([
+// Exhaustive, compile-time-checked list of metadata keys.
+// `satisfies` ensures every entry is a valid `keyof Metadata` **and**
+// warns if we add an invalid key. Missing keys will surface when hovering the
+// `_MissingKeys` helper type during development.
+const META_KEYS = [
   "author",
   "name",
   "description",
@@ -284,7 +287,13 @@ const VALID_METADATA_KEYS_SET = new Set<keyof Metadata>([
   "tag",
   "longRunning",
   "mcp",
-]);
+  'timeout'
+] as const satisfies readonly (keyof Metadata)[];
+
+// Optional development-time check for forgotten keys.
+type _MissingKeys = Exclude<keyof Metadata, typeof META_KEYS[number]>; // should be never
+
+export const VALID_METADATA_KEYS_SET: ReadonlySet<keyof Metadata> = new Set(META_KEYS);
 
 const getMetadataFromComments = (contents: string): Record<string, any> => {
   const lines = contents.split('\n')

src/lib/ai-env-integration.test.ts

@@ -0,0 +1,81 @@
+import ava from 'ava'
+import { resolveModel } from './ai'
+import '../api/global.js'
+
+// This is a simple integration test to verify the basic functionality
+// For full unit testing, we would need to refactor the ai.ts module
+// to allow dependency injection of the apiKeyCache
+
+ava('resolveModel should create OpenAI model when API key exists', async t => {
+    // Set API key
+    process.env.OPENAI_API_KEY = 'test-openai-key'
+    
+    try {
+        const model = await resolveModel('gpt-4')
+        
+        // Verify model was created
+        t.truthy(model)
+        t.is(model.provider, 'openai.chat')
+        t.is(model.modelId, 'gpt-4')
+    } finally {
+        delete process.env.OPENAI_API_KEY
+    }
+})
+
+ava('resolveModel should create Anthropic model with prefix', async t => {
+    // Set API key
+    process.env.ANTHROPIC_API_KEY = 'test-anthropic-key'
+    
+    try {
+        const model = await resolveModel('anthropic:claude-3-opus-20240229')
+        
+        // Verify model was created
+        t.truthy(model)
+        t.is(model.provider, 'anthropic.messages')
+        t.is(model.modelId, 'claude-3-opus-20240229')
+    } finally {
+        delete process.env.ANTHROPIC_API_KEY
+    }
+})
+
+ava('resolveModel should use default provider when no prefix', async t => {
+    // Set API key for default provider (openai)
+    process.env.OPENAI_API_KEY = 'test-openai-key'
+    process.env.AI_DEFAULT_PROVIDER = 'openai'
+    
+    try {
+        const model = await resolveModel('some-model')
+        
+        // Verify model was created with default provider
+        t.truthy(model)
+        t.is(model.provider, 'openai.chat')
+        t.is(model.modelId, 'some-model')
+    } finally {
+        delete process.env.OPENAI_API_KEY
+        delete process.env.AI_DEFAULT_PROVIDER
+    }
+})
+
+ava('resolveModel should handle explicit provider parameter', async t => {
+    // Set API key
+    process.env.GOOGLE_API_KEY = 'test-google-key'
+    
+    try {
+        const model = await resolveModel('gemini-pro', 'google')
+        
+        // Verify model was created with explicit provider
+        t.truthy(model)
+        t.is(model.provider, 'google.generative-ai')
+        t.is(model.modelId, 'gemini-pro')
+    } finally {
+        delete process.env.GOOGLE_API_KEY
+    }
+})
+
+// Note: Testing the actual prompting behavior would require:
+// 1. Mocking the global.env function properly
+// 2. Clearing the internal apiKeyCache between tests
+// 3. Potentially refactoring the ai.ts module to support dependency injection
+//
+// For now, these integration tests verify the basic functionality
+// when API keys are already set.