openkbs 0.0.92 → 0.0.93

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openkbs",
-  "version": "0.0.92",
+  "version": "0.0.93",
   "description": "OpenKBS - Command Line Interface",
   "main": "src/index.js",
   "scripts": {

package/src/actions.js

@@ -1135,6 +1135,8 @@ async function fnAction(subCommand, args = []) {
             return await fnEnvAction(kbToken, args[0], args.slice(1));
         case 'invoke':
             return await fnInvokeAction(kbToken, args[0], args.slice(1));
+        case 'schedule':
+            return await fnScheduleAction(kbToken, args[0], args.slice(1));
         default:
             console.log('Usage: openkbs fn <command> [options]');
             console.log('');
@@ -1145,11 +1147,14 @@ async function fnAction(subCommand, args = []) {
             console.log('  logs <name>             View function logs');
             console.log('  env <name> [KEY=value]  View or set environment variables');
             console.log('  invoke <name> [payload] Invoke a function');
+            console.log('  schedule <name> [expr]  View/set/enable/disable/remove schedule');
             console.log('');
             console.log('Options for push:');
             console.log('  --region <region>       Region (us-east-1, eu-central-1, ap-southeast-1)');
             console.log('  --memory <mb>           Memory size (128-3008 MB)');
             console.log('  --timeout <seconds>     Timeout (1-900 seconds)');
+            console.log('  --schedule <expr>       Schedule expression (e.g. "rate(1 hour)")');
+            console.log('  --http-access           Enable HTTP access for scheduled functions');
     }
 }
 
@@ -1182,8 +1187,9 @@ async function fnListAction(kbToken) {
         functions.forEach(f => {
             const name = f.functionName.padEnd(maxNameLen);
             const region = f.region || 'unknown';
-            const url = f.customUrl || f.functionUrl || 'N/A';
-            console.log(`  ${name}  ${region}  ${url}`);
+            const url = f.customUrl || f.functionUrl || (f.schedule ? '(scheduled)' : 'N/A');
+            const scheduleInfo = f.schedule ? ` [${f.schedule}]` : '';
+            console.log(`  ${name}  ${region}  ${url}${scheduleInfo}`);
         });
     } catch (error) {
         console.red('Error listing functions:', error.message);
@@ -1201,6 +1207,8 @@ async function fnDeployAction(kbToken, functionName, args) {
     let timeout = 30;
     let runtime = null;  // null = use default (nodejs24.x)
     let handler = null;  // null = use default (index.handler)
+    let schedule = null;
+    let httpAccess = null;
 
     for (let i = 0; i < args.length; i++) {
         if (args[i] === '--region' && args[i + 1]) {
@@ -1213,6 +1221,10 @@ async function fnDeployAction(kbToken, functionName, args) {
             runtime = args[++i];
         } else if (args[i] === '--handler' && args[i + 1]) {
             handler = args[++i];
+        } else if (args[i] === '--schedule' && args[i + 1]) {
+            schedule = args[++i];
+        } else if (args[i] === '--http-access') {
+            httpAccess = true;
         }
     }
 
@@ -1273,12 +1285,14 @@ async function fnDeployAction(kbToken, functionName, args) {
         if (existingFunc) {
             // Update existing function
             console.log('Updating existing function...');
-            response = await makePostRequest(KB_API_URL, {
+            const updateParams = {
                 token: kbToken,
                 action: 'updateElasticFunction',
                 functionName,
                 code
-            });
+            };
+            if (schedule) updateParams.schedule = schedule;
+            response = await makePostRequest(KB_API_URL, updateParams);
         } else {
             // Create new function
             console.log('Creating new function...');
@@ -1293,6 +1307,8 @@ async function fnDeployAction(kbToken, functionName, args) {
             };
             if (runtime) createParams.runtime = runtime;
             if (handler) createParams.handler = handler;
+            if (schedule) createParams.schedule = schedule;
+            if (httpAccess !== null) createParams.httpAccess = httpAccess;
             response = await makePostRequest(KB_API_URL, createParams);
         }
 
@@ -1307,6 +1323,9 @@ async function fnDeployAction(kbToken, functionName, args) {
         if (response.customUrl) {
             console.log(`Custom URL: ${response.customUrl}`);
         }
+        if (response.schedule) {
+            console.log(`Schedule: ${response.schedule}`);
+        }
     } catch (error) {
         console.red('Deploy failed:', error.message);
     }
@@ -1336,6 +1355,71 @@ async function fnDeleteAction(kbToken, functionName) {
     }
 }
 
+async function fnScheduleAction(kbToken, functionName, args) {
+    if (!functionName) {
+        return console.red('Function name required. Usage: openkbs fn schedule <name> [expression|enable|disable|remove]');
+    }
+
+    const subCommand = args[0];
+
+    try {
+        if (!subCommand) {
+            // Show current schedule
+            const response = await makePostRequest(KB_API_URL, {
+                token: kbToken,
+                action: 'getElasticFunction',
+                functionName
+            });
+            if (response.error) return console.red('Error:', response.error);
+            if (response.schedule) {
+                console.log(`Schedule: ${response.schedule}`);
+                console.log(`Name: ${response.scheduleName || 'N/A'}`);
+            } else {
+                console.log(`No schedule set for '${functionName}'.`);
+            }
+        } else if (subCommand === 'enable') {
+            const response = await makePostRequest(KB_API_URL, {
+                token: kbToken,
+                action: 'updateElasticFunctionSchedule',
+                functionName,
+                enabled: true
+            });
+            if (response.error) return console.red('Error:', response.error);
+            console.green(`Schedule for '${functionName}' enabled.`);
+        } else if (subCommand === 'disable') {
+            const response = await makePostRequest(KB_API_URL, {
+                token: kbToken,
+                action: 'updateElasticFunctionSchedule',
+                functionName,
+                enabled: false
+            });
+            if (response.error) return console.red('Error:', response.error);
+            console.green(`Schedule for '${functionName}' disabled.`);
+        } else if (subCommand === 'remove') {
+            const response = await makePostRequest(KB_API_URL, {
+                token: kbToken,
+                action: 'updateElasticFunctionSchedule',
+                functionName,
+                schedule: null
+            });
+            if (response.error) return console.red('Error:', response.error);
+            console.green(`Schedule for '${functionName}' removed.`);
+        } else {
+            // Set schedule expression
+            const response = await makePostRequest(KB_API_URL, {
+                token: kbToken,
+                action: 'updateElasticFunctionSchedule',
+                functionName,
+                schedule: subCommand
+            });
+            if (response.error) return console.red('Error:', response.error);
+            console.green(`Schedule for '${functionName}' set to: ${subCommand}`);
+        }
+    } catch (error) {
+        console.red('Schedule operation failed:', error.message);
+    }
+}
+
 async function fnLogsAction(kbToken, functionName, args) {
     if (!functionName) {
         return console.red('Function name required. Usage: openkbs fn logs <name>');
@@ -2477,6 +2561,8 @@ async function elasticDeployAction() {
             if (fnConfig.timeout) args.push('--timeout', String(fnConfig.timeout));
             if (fnConfig.runtime) args.push('--runtime', fnConfig.runtime);
             if (fnConfig.handler) args.push('--handler', fnConfig.handler);
+            if (fnConfig.schedule) args.push('--schedule', fnConfig.schedule);
+            if (fnConfig.httpAccess) args.push('--http-access');
 
             console.log(`  Deploying ${name}...`);
             await fnDeployAction(kbToken, name, args);

package/templates/.claude/skills/openkbs/SKILL.md

@@ -100,7 +100,8 @@ my-platform/
   },
   "pulse": true,
   "functions": [
-    { "name": "api", "runtime": "nodejs24.x", "memory": 512, "timeout": 30 }
+    { "name": "api", "runtime": "nodejs24.x", "memory": 512, "timeout": 30 },
+    { "name": "cleanup", "schedule": "rate(1 hour)", "timeout": 900 }
   ],
   "site": "./site"
 }
@@ -127,7 +128,10 @@ openkbs destroy          # Remove all resources (DANGEROUS)
 ```bash
 openkbs fn list          # List Lambda functions
 openkbs fn push api      # Deploy function
+openkbs fn push cleanup --schedule "rate(1 hour)"  # Deploy with schedule
 openkbs fn logs api      # View function logs
+openkbs fn schedule cleanup          # View schedule
+openkbs fn schedule cleanup disable  # Disable schedule
 openkbs postgres shell   # Connect to Postgres
 openkbs storage ls       # List S3 objects
 openkbs pulse status     # WebSocket status
@@ -246,6 +250,42 @@ Configure in `settings.json`:
 
 Priority items are auto-injected into LLM context.
 
+## Spec Mode
+
+When the user is in **Spec Mode**, you act as a Product Manager helping define specifications.
+
+### Workflow
+1. Discuss requirements with the user — ask clarifying questions
+2. Explore the codebase to understand the current architecture
+3. Write the specification as a `.md` file in the `spec/` folder
+4. Call `ExitPlanMode` to present the specification for user approval
+5. If rejected or changes requested, revise and re-submit
+
+### Spec File Format
+Create files in `spec/` folder with descriptive names (e.g., `spec/user-authentication.md`):
+
+- **Goals** — What this feature achieves
+- **Requirements** — Functional requirements (numbered list)
+- **User Stories** — As a [role], I want [action], so that [benefit]
+- **Acceptance Criteria** — Testable conditions for completeness
+- **Constraints** — Technical or business limitations
+- **Out of Scope** — What is explicitly NOT included
+
+### Markdown Features
+The spec viewer supports GitHub Flavored Markdown (GFM). Use these for well-structured specs:
+- **Tables** — for requirement matrices, field definitions, API specs
+- **Task lists** — `- [ ]` / `- [x]` for checklists
+- **Strikethrough** — `~~text~~` for deprecated items
+- **Autolinks** — URLs are automatically linked
+- **Headings, lists, bold, italic, code blocks** — all standard markdown
+
+### Rules
+- Do NOT write implementation code in spec mode
+- Focus on WHAT to build, not HOW
+- Keep specs concise and actionable
+- One spec file per feature/topic
+- Use tables for structured data (requirements, fields, APIs)
+
 ## Additional Resources
 
 ### Reference Documentation

package/templates/.claude/skills/openkbs/metadata.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.25"
+  "version": "0.1.27"
 }

package/templates/.claude/skills/openkbs/reference/elastic-services.md

@@ -23,7 +23,9 @@ OpenKBS provides managed cloud infrastructure that scales automatically.
   },
   "pulse": true,
   "functions": [
-    { "name": "hello", "runtime": "nodejs24.x", "memory": 512, "timeout": 30 }
+    { "name": "api", "runtime": "nodejs24.x", "memory": 512, "timeout": 30 },
+    { "name": "cleanup", "runtime": "nodejs24.x", "memory": 256, "timeout": 900, "schedule": "rate(1 hour)" },
+    { "name": "reports", "runtime": "nodejs24.x", "memory": 512, "timeout": 300, "schedule": "cron(0 12 * * ? *)" }
   ],
   "site": "./site"
 }
@@ -66,11 +68,62 @@ export const handler = async (event) => {
 ```bash
 openkbs fn list                           # List all functions
 openkbs fn push hello --region us-east-1  # Deploy function
+openkbs fn push hello --schedule "rate(1 hour)"  # Deploy with schedule
+openkbs fn push hello --schedule "rate(1 hour)" --http-access  # Schedule + HTTP
 openkbs fn delete hello                   # Delete function
 openkbs fn logs hello                     # View logs
 openkbs fn env hello                      # View env vars
 openkbs fn env hello API_KEY=secret       # Set env var
 openkbs fn invoke hello '{"test": true}'  # Invoke function
+openkbs fn schedule hello                 # View current schedule
+openkbs fn schedule hello "rate(5 minutes)"  # Set schedule
+openkbs fn schedule hello enable          # Enable schedule
+openkbs fn schedule hello disable         # Disable schedule
+openkbs fn schedule hello remove          # Remove schedule
+```
+
+### Scheduled Functions
+
+Functions with a `schedule` field are invoked automatically by EventBridge Scheduler. By default, scheduled functions do **not** get HTTP access (no Function URL / CloudFront). Add `"httpAccess": true` to enable both.
+
+**Schedule expressions:**
+- `rate(1 hour)`, `rate(5 minutes)`, `rate(1 day)`
+- `cron(0 12 * * ? *)` — daily at 12:00 UTC
+- `cron(0/15 * * * ? *)` — every 15 minutes
+
+**openkbs.json example:**
+```json
+{
+  "functions": [
+    { "name": "api", "runtime": "nodejs24.x", "memory": 512, "timeout": 30 },
+    { "name": "cleanup", "schedule": "rate(1 hour)", "timeout": 900 },
+    { "name": "reports", "schedule": "cron(0 12 * * ? *)", "httpAccess": true }
+  ]
+}
+```
+
+**Event payload** received by the Lambda handler:
+```json
+{
+  "source": "openkbs.scheduler",
+  "kbId": "abc123",
+  "functionName": "cleanup",
+  "scheduleExpression": "rate(1 hour)"
+}
+```
+
+**Handler example:**
+```javascript
+export const handler = async (event) => {
+    if (event.source === 'openkbs.scheduler') {
+        // Invoked by schedule
+        console.log(`Running scheduled task: ${event.functionName}`);
+        // ... do work ...
+        return { statusCode: 200, body: 'OK' };
+    }
+    // Invoked via HTTP (if httpAccess is enabled)
+    return { statusCode: 200, body: JSON.stringify({ message: 'Hello' }) };
+};
 ```
 
 ### Supported Runtimes

package/version.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.0.92",
-  "releaseDate": "2026-02-21",
-  "releaseNotes": "OpenKBS CLI version 0.0.92"
+  "version": "0.0.93",
+  "releaseDate": "2026-03-03",
+  "releaseNotes": "OpenKBS CLI version 0.0.93"
 }