@orchagent/cli 0.3.91 → 0.3.92

package/dist/commands/templates/cron-job.js

@@ -0,0 +1,259 @@
+"use strict";
+/**
+ * Cron-job template for `orch init --template cron-job`.
+ *
+ * Provides Python and JavaScript scaffolding for scheduled tasks —
+ * daily reports, data syncs, cleanups, notifications, etc.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CRON_JOB_SCHEMA = exports.CRON_JOB_MAIN_JS = exports.CRON_JOB_MAIN_PY = void 0;
+exports.cronJobReadme = cronJobReadme;
+// ---------------------------------------------------------------------------
+// Python template
+// ---------------------------------------------------------------------------
+exports.CRON_JOB_MAIN_PY = `"""
+orchagent scheduled job.
+
+Runs on a cron schedule to perform periodic tasks.
+
+Schedule examples:
+  orch schedule create org/my-job --cron "0 9 * * 1"    # Every Monday 9 AM UTC
+  orch schedule create org/my-job --cron "0 0 * * *"    # Daily at midnight
+  orch schedule create org/my-job --cron "0 */6 * * *"  # Every 6 hours
+
+Local test:
+  echo '{}' | python main.py
+"""
+
+import json
+import os
+import sys
+from datetime import datetime, timezone
+
+
+def main():
+    raw = sys.stdin.read()
+    try:
+        data = json.loads(raw) if raw.strip() else {}
+    except json.JSONDecodeError:
+        print(json.dumps({"error": "Invalid JSON input"}))
+        sys.exit(1)
+
+    dry_run = data.get("options", {}).get("dry_run", False)
+
+    # --- Your scheduled job logic here ---
+    # Common patterns:
+    #   - Fetch data from an API and store results
+    #   - Generate a daily/weekly report
+    #   - Clean up old records or files
+    #   - Send digest notifications (email, Slack, Discord)
+    #
+    # To use workspace secrets (API keys, webhook URLs):
+    #   1. Add to "required_secrets" in orchagent.json
+    #   2. Set in workspace: orch secrets set MY_SECRET <value>
+    #   3. Access via: os.environ["MY_SECRET"]
+    #
+    # Example: send to a webhook
+    #   import urllib.request
+    #   webhook_url = os.environ["WEBHOOK_URL"]
+    #   req = urllib.request.Request(webhook_url, data=json.dumps(payload).encode(),
+    #                                headers={"Content-Type": "application/json"})
+    #   urllib.request.urlopen(req)
+
+    now = datetime.now(timezone.utc).isoformat()
+
+    report = {
+        "generated_at": now,
+        "status": "completed" if not dry_run else "dry_run",
+        "summary": "Scheduled job ran successfully",
+        "items_processed": 0,
+    }
+    # --- End your logic ---
+
+    print(json.dumps({
+        "result": report,
+        "success": True,
+    }))
+
+
+if __name__ == "__main__":
+    main()
+`;
+// ---------------------------------------------------------------------------
+// JavaScript template
+// ---------------------------------------------------------------------------
+exports.CRON_JOB_MAIN_JS = `/**
+ * orchagent scheduled job.
+ *
+ * Runs on a cron schedule to perform periodic tasks.
+ *
+ * Schedule examples:
+ *   orch schedule create org/my-job --cron "0 9 * * 1"    # Every Monday 9 AM UTC
+ *   orch schedule create org/my-job --cron "0 0 * * *"    # Daily at midnight
+ *   orch schedule create org/my-job --cron "0 */6 * * *"  # Every 6 hours
+ *
+ * Local test:
+ *   echo '{}' | node main.js
+ */
+
+const fs = require('fs');
+
+function main() {
+  const raw = fs.readFileSync('/dev/stdin', 'utf-8');
+  let data;
+  try {
+    data = raw.trim() ? JSON.parse(raw) : {};
+  } catch {
+    console.log(JSON.stringify({ error: 'Invalid JSON input' }));
+    process.exit(1);
+  }
+
+  const dryRun = (data.options || {}).dry_run || false;
+
+  // --- Your scheduled job logic here ---
+  // Common patterns:
+  //   - Fetch data from an API and store results
+  //   - Generate a daily/weekly report
+  //   - Clean up old records or files
+  //   - Send digest notifications (email, Slack, Discord)
+  //
+  // To use workspace secrets (API keys, webhook URLs):
+  //   1. Add to "required_secrets" in orchagent.json
+  //   2. Set in workspace: orch secrets set MY_SECRET value
+  //   3. Access via: process.env.MY_SECRET
+  //
+  // Example: send to a webhook
+  //   const https = require('https');
+  //   const url = new URL(process.env.WEBHOOK_URL);
+  //   const req = https.request(url, { method: 'POST', headers: { 'Content-Type': 'application/json' } });
+  //   req.write(JSON.stringify(payload));
+  //   req.end();
+
+  const now = new Date().toISOString();
+
+  const report = {
+    generated_at: now,
+    status: dryRun ? 'dry_run' : 'completed',
+    summary: 'Scheduled job ran successfully',
+    items_processed: 0,
+  };
+  // --- End your logic ---
+
+  console.log(JSON.stringify({
+    result: report,
+    success: true,
+  }));
+}
+
+main();
+`;
+// ---------------------------------------------------------------------------
+// Schema
+// ---------------------------------------------------------------------------
+exports.CRON_JOB_SCHEMA = `{
+  "input": {
+    "type": "object",
+    "properties": {
+      "options": {
+        "type": "object",
+        "description": "Optional configuration for this run",
+        "properties": {
+          "dry_run": {
+            "type": "boolean",
+            "description": "If true, simulate without making changes"
+          }
+        }
+      }
+    }
+  },
+  "output": {
+    "type": "object",
+    "properties": {
+      "result": {
+        "type": "object",
+        "description": "Job results and summary"
+      },
+      "success": {
+        "type": "boolean",
+        "description": "Whether the job completed successfully"
+      }
+    },
+    "required": ["result", "success"]
+  }
+}
+`;
+// ---------------------------------------------------------------------------
+// README
+// ---------------------------------------------------------------------------
+function cronJobReadme(agentName) {
+    return `# ${agentName}
+
+A scheduled job that runs on a cron schedule.
+
+## Setup
+
+### 1. Edit the job logic
+
+Edit \`main.py\` (or \`main.js\`) with your scheduled task logic — data processing, report generation, API syncs, notifications, etc.
+
+### 2. Publish
+
+\`\`\`sh
+orch publish
+\`\`\`
+
+### 3. Schedule
+
+\`\`\`sh
+# Every Monday at 9 AM UTC
+orch schedule create <org>/${agentName} --cron "0 9 * * 1"
+
+# Every day at midnight
+orch schedule create <org>/${agentName} --cron "0 0 * * *"
+
+# Every 6 hours
+orch schedule create <org>/${agentName} --cron "0 */6 * * *"
+\`\`\`
+
+### 4. Monitor
+
+\`\`\`sh
+orch schedule list              # View all schedules
+orch logs <org>/${agentName}    # View recent runs
+orch metrics <org>/${agentName} # View execution stats
+\`\`\`
+
+## Common Cron Patterns
+
+| Pattern | Schedule |
+|---------|----------|
+| \`0 9 * * 1\` | Every Monday at 9 AM |
+| \`0 0 * * *\` | Daily at midnight |
+| \`0 */6 * * *\` | Every 6 hours |
+| \`0 9 * * 1-5\` | Weekdays at 9 AM |
+| \`0 0 1 * *\` | First of each month |
+
+## Input
+
+The job receives optional input when triggered:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| \`options.dry_run\` | boolean | If true, simulate without making changes |
+
+You can also trigger manually with custom input:
+
+\`\`\`sh
+orch run <org>/${agentName} --data '{"options": {"dry_run": true}}'
+\`\`\`
+
+## Environment Variables
+
+To use API keys or webhook URLs, add them to \`required_secrets\` in orchagent.json, then set them in your workspace:
+
+\`\`\`sh
+orch secrets set MY_API_KEY <value>
+orch secrets set WEBHOOK_URL <value>
+\`\`\`
+`;
+}

package/dist/commands/update.js

@@ -9,6 +9,7 @@ const path_1 = __importDefault(require("path"));
 const chalk_1 = __importDefault(require("chalk"));
 const config_1 = require("../lib/config");
 const api_1 = require("../lib/api");
+const errors_1 = require("../lib/errors");
 const analytics_1 = require("../lib/analytics");
 const adapters_1 = require("../adapters");
 const installed_1 = require("../lib/installed");
@@ -16,20 +17,47 @@ const agents_md_utils_1 = require("../lib/agents-md-utils");
 async function fetchLatestAgent(config, agentRef) {
     const [org, name] = agentRef.split('/');
     if (!org || !name)
-        return null;
+        return { status: 'bad_ref' };
+    // Try public endpoint first
     try {
-        // Try to get latest version
         const agent = await (0, api_1.publicRequest)(config, `/public/agents/${org}/${name}/latest`);
         return {
+            status: 'found',
             agent: { ...agent, org_slug: org },
-            latestVersion: agent.version
+            latestVersion: agent.version,
+            private: false,
         };
     }
     catch (err) {
-        if (err instanceof api_1.ApiError && err.status === 404) {
-            return null;
+        // Network errors should propagate — don't confuse with 404
+        if (err instanceof errors_1.NetworkError)
+            throw err;
+        if (!(err instanceof api_1.ApiError) || err.status !== 404)
+            throw err;
+    }
+    // Public endpoint returned 404 — try authenticated endpoint for private agents
+    if (!config.apiKey) {
+        return { status: 'not_found_no_auth' };
+    }
+    try {
+        const workspaceId = await (0, api_1.resolveWorkspaceIdForOrg)(config, org);
+        const userOrg = await (0, api_1.getOrg)(config, workspaceId);
+        if (userOrg.slug !== org) {
+            return { status: 'not_found' };
         }
-        throw err;
+        const myAgent = await (0, api_1.getMyAgent)(config, name, 'latest', workspaceId);
+        if (!myAgent) {
+            return { status: 'not_found' };
+        }
+        return {
+            status: 'found',
+            agent: { ...myAgent, org_slug: org },
+            latestVersion: myAgent.version,
+            private: true,
+        };
+    }
+    catch {
+        return { status: 'not_found' };
     }
 }
 function registerUpdateCommand(program) {
@@ -77,11 +105,20 @@ function registerUpdateCommand(program) {
                 fileStatuses.push({ item, status: await (0, installed_1.checkModified)(item) });
             }
             // Fetch latest version once per agent
-            const latest = await fetchLatestAgent(resolved, agentName);
-            if (!latest) {
-                process.stdout.write(`  ${chalk_1.default.yellow('?')} ${agentName} - could not fetch latest\n`);
+            const result = await fetchLatestAgent(resolved, agentName);
+            if (result.status === 'not_found_no_auth') {
+                process.stdout.write(`  ${chalk_1.default.yellow('?')} ${agentName} - not found publicly. Log in with ${chalk_1.default.cyan('orch login')} to check private agents.\n`);
+                continue;
+            }
+            if (result.status === 'not_found') {
+                process.stdout.write(`  ${chalk_1.default.yellow('?')} ${agentName} - agent not found\n`);
+                continue;
+            }
+            if (result.status === 'bad_ref') {
+                process.stdout.write(`  ${chalk_1.default.yellow('?')} ${agentName} - invalid agent reference\n`);
                 continue;
             }
+            const latest = result;
             // Use the version from the first entry (all entries for the same
             // agent should share the same version after install/update)
             const installedVersion = entries[0].version;

package/dist/commands/validate.js

@@ -0,0 +1,264 @@
+"use strict";
+/**
+ * `orch validate` — Validate agent or skill configuration without publishing.
+ *
+ * Runs all pre-publish checks locally: config files, schemas, prompt,
+ * dependencies, code scanning. Optionally runs server-side validation
+ * with --server flag.
+ *
+ * Exit codes: 0 = valid, 1 = errors found
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerValidateCommand = registerValidateCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+const validate_1 = require("../lib/validate");
+const publish_1 = require("./publish");
+const errors_1 = require("../lib/errors");
+const analytics_1 = require("../lib/analytics");
+function issueIcon(level) {
+    switch (level) {
+        case 'error': return chalk_1.default.red('✗');
+        case 'warning': return chalk_1.default.yellow('⚠');
+        case 'info': return chalk_1.default.blue('ℹ');
+    }
+}
+function formatIssue(issue) {
+    const icon = issueIcon(issue.level);
+    const file = issue.file ? chalk_1.default.dim(` (${issue.file})`) : '';
+    return `  ${icon} ${issue.message}${file}`;
+}
+function printResult(result, serverIssues) {
+    const allIssues = [...result.issues, ...(serverIssues || [])];
+    const errors = allIssues.filter(i => i.level === 'error');
+    const warnings = allIssues.filter(i => i.level === 'warning');
+    const infos = allIssues.filter(i => i.level === 'info');
+    const m = result.metadata;
+    // Header
+    const label = m.isSkill ? 'skill' : 'agent';
+    const name = m.agentName || '(unknown)';
+    process.stderr.write(`\nValidating ${label}: ${chalk_1.default.bold(name)}\n\n`);
+    // Summary line: type, engine, mode
+    if (!m.isSkill && m.agentType && m.executionEngine) {
+        process.stderr.write(chalk_1.default.dim(`  Type: ${m.agentType} (${m.executionEngine}), Run mode: ${m.runMode || 'on_demand'}\n\n`));
+    }
+    // All issues sorted: errors first, then warnings, then info
+    for (const issue of errors)
+        process.stderr.write(formatIssue(issue) + '\n');
+    for (const issue of warnings)
+        process.stderr.write(formatIssue(issue) + '\n');
+    for (const issue of infos)
+        process.stderr.write(formatIssue(issue) + '\n');
+    // Metadata summary (only if no critical errors)
+    if (errors.length === 0 && !m.isSkill) {
+        if (m.hasPrompt)
+            process.stderr.write(`  ${chalk_1.default.green('✓')} prompt.md found\n`);
+        if (m.hasSchema)
+            process.stderr.write(`  ${chalk_1.default.green('✓')} schema.json found\n`);
+        if (m.executionEngine === 'managed_loop') {
+            process.stderr.write(`  ${chalk_1.default.green('✓')} Custom tools: ${m.customToolCount}, Max turns: ${m.maxTurns || 25}\n`);
+        }
+        if (m.bundleEntrypoint) {
+            process.stderr.write(`  ${chalk_1.default.green('✓')} Entrypoint: ${m.bundleEntrypoint}\n`);
+        }
+        if (m.bundleSizeBytes !== undefined && m.bundleFileCount !== undefined) {
+            process.stderr.write(`  ${chalk_1.default.green('✓')} Bundle: ${m.bundleFileCount} files, ${(m.bundleSizeBytes / 1024).toFixed(1)} KB\n`);
+        }
+        if (m.sdkCompatible) {
+            process.stderr.write(`  ${chalk_1.default.green('✓')} SDK detected (Local Ready)\n`);
+        }
+    }
+    // Final verdict
+    process.stderr.write('\n');
+    const parts = [];
+    if (warnings.length > 0)
+        parts.push(`${warnings.length} warning${warnings.length > 1 ? 's' : ''}`);
+    if (infos.length > 0)
+        parts.push(`${infos.length} note${infos.length > 1 ? 's' : ''}`);
+    const suffix = parts.length > 0 ? ` (${parts.join(', ')})` : '';
+    if (errors.length > 0) {
+        process.stderr.write(chalk_1.default.red.bold(`✗ Validation failed: ${errors.length} error${errors.length > 1 ? 's' : ''}${suffix}\n`));
+    }
+    else {
+        process.stderr.write(chalk_1.default.green.bold(`✓ Validation passed${suffix}\n`));
+    }
+}
+function toJsonOutput(result, serverIssues) {
+    const allIssues = [...result.issues, ...(serverIssues || [])];
+    return {
+        valid: result.valid && allIssues.filter(i => i.level === 'error').length === 0,
+        errors: allIssues.filter(i => i.level === 'error').map(i => ({ message: i.message, file: i.file })),
+        warnings: allIssues.filter(i => i.level === 'warning').map(i => ({ message: i.message, file: i.file })),
+        info: allIssues.filter(i => i.level === 'info').map(i => ({ message: i.message, file: i.file })),
+        metadata: {
+            name: result.metadata.agentName,
+            type: result.metadata.agentType,
+            execution_engine: result.metadata.executionEngine,
+            run_mode: result.metadata.runMode,
+            is_skill: result.metadata.isSkill,
+            has_prompt: result.metadata.hasPrompt,
+            has_schema: result.metadata.hasSchema,
+            sdk_compatible: result.metadata.sdkCompatible,
+            entrypoint: result.metadata.bundleEntrypoint,
+            custom_tools: result.metadata.customToolCount,
+            max_turns: result.metadata.maxTurns,
+            bundle_size_bytes: result.metadata.bundleSizeBytes,
+            bundle_file_count: result.metadata.bundleFileCount,
+        },
+    };
+}
+function registerValidateCommand(program) {
+    program
+        .command('validate')
+        .alias('lint')
+        .description('Validate agent or skill configuration without publishing')
+        .option('--profile <name>', 'Use API key from named profile')
+        .option('--json', 'Output as JSON (for CI/CD)')
+        .option('--server', 'Also run server-side validation (requires auth)')
+        .option('--url <url>', 'Agent URL (for code-based agents without local code)')
+        .option('--docker', 'Validate with Dockerfile inclusion')
+        .action(async (options) => {
+        const cwd = process.cwd();
+        // Run local validation
+        const result = await (0, validate_1.validateAgentProject)(cwd, {
+            url: options.url,
+            docker: options.docker,
+        });
+        // Online checks (dependencies + server-side validation)
+        const serverIssues = [];
+        if (options.server || result.metadata.manifest?.manifest?.dependencies?.length) {
+            try {
+                const config = await (0, config_1.getResolvedConfig)({}, options.profile);
+                if (!config.apiKey) {
+                    if (options.server) {
+                        serverIssues.push({
+                            level: 'warning',
+                            message: 'Server validation skipped: not logged in. Run `orch login` first.',
+                        });
+                    }
+                }
+                else {
+                    // Resolve workspace
+                    const configFile = await (0, config_1.loadConfig)();
+                    let workspaceId;
+                    if (configFile.workspace && !options.profile) {
+                        try {
+                            const { workspaces } = await (0, api_1.request)(config, 'GET', '/workspaces');
+                            const ws = workspaces.find(w => w.slug === configFile.workspace);
+                            if (ws)
+                                workspaceId = ws.id;
+                        }
+                        catch { /* skip workspace resolution */ }
+                    }
+                    // Dependency checks
+                    const deps = result.metadata.manifest?.manifest?.dependencies;
+                    if (deps?.length) {
+                        try {
+                            const org = await (0, api_1.getOrg)(config, workspaceId);
+                            const depResults = await (0, publish_1.checkDependencies)(config, deps, org.slug, workspaceId);
+                            const notFound = depResults.filter(r => r.status === 'not_found');
+                            const notCallable = depResults.filter(r => r.status === 'found_not_callable');
+                            if (notFound.length > 0) {
+                                for (const dep of notFound) {
+                                    serverIssues.push({
+                                        level: 'warning',
+                                        message: `Unpublished dependency: ${dep.ref}`,
+                                    });
+                                }
+                            }
+                            if (notCallable.length > 0) {
+                                for (const dep of notCallable) {
+                                    serverIssues.push({
+                                        level: 'warning',
+                                        message: `Dependency has callable: false: ${dep.ref}`,
+                                    });
+                                }
+                            }
+                        }
+                        catch {
+                            serverIssues.push({
+                                level: 'warning',
+                                message: 'Could not check dependencies (network error)',
+                            });
+                        }
+                    }
+                    // Server-side validation
+                    if (options.server && result.valid && result.metadata.agentName) {
+                        try {
+                            const m = result.metadata;
+                            const manifest = m.manifest;
+                            const validation = await (0, api_1.validateAgentPublish)(config, {
+                                name: m.agentName,
+                                type: m.agentType || 'agent',
+                                run_mode: m.runMode,
+                                callable: m.callable,
+                                description: manifest?.description,
+                                is_public: false,
+                                supported_providers: m.supportedProviders,
+                                default_models: manifest?.default_models,
+                                timeout_seconds: manifest?.timeout_seconds,
+                                manifest: manifest?.manifest,
+                                required_secrets: m.requiredSecrets,
+                                default_skills: manifest?.default_skills,
+                                skills_locked: manifest?.skills_locked,
+                                environment: manifest?.environment,
+                            }, workspaceId);
+                            if (validation.warnings?.length) {
+                                for (const w of validation.warnings) {
+                                    serverIssues.push({ level: 'warning', message: `Server: ${w}` });
+                                }
+                            }
+                            if (!validation.valid) {
+                                for (const e of validation.errors) {
+                                    serverIssues.push({ level: 'error', message: `Server: ${e}` });
+                                }
+                            }
+                            else {
+                                serverIssues.push({ level: 'info', message: 'Server-side validation passed' });
+                            }
+                        }
+                        catch {
+                            serverIssues.push({
+                                level: 'warning',
+                                message: 'Could not reach server for validation (offline?)',
+                            });
+                        }
+                    }
+                }
+            }
+            catch {
+                if (options.server) {
+                    serverIssues.push({
+                        level: 'warning',
+                        message: 'Server validation skipped: authentication error',
+                    });
+                }
+            }
+        }
+        const allValid = result.valid && serverIssues.filter(i => i.level === 'error').length === 0;
+        await (0, analytics_1.track)('cli_validate', {
+            valid: allValid,
+            errors: [...result.issues, ...serverIssues].filter(i => i.level === 'error').length,
+            warnings: [...result.issues, ...serverIssues].filter(i => i.level === 'warning').length,
+            type: result.metadata.agentType,
+            engine: result.metadata.executionEngine,
+            server: options.server || false,
+            json: options.json || false,
+        });
+        if (options.json) {
+            process.stdout.write(JSON.stringify(toJsonOutput(result, serverIssues), null, 2) + '\n');
+        }
+        else {
+            printResult(result, serverIssues);
+        }
+        if (!allValid) {
+            const err = new errors_1.CliError('Validation failed', errors_1.ExitCodes.INVALID_INPUT);
+            err.displayed = true;
+            throw err;
+        }
+    });
+}