cli4ai 0.8.2 → 0.8.3

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "cli4ai",
-  "version": "0.8.2",
-  "description": "The package manager for AI CLI tools - cliforai.com",
+  "version": "0.8.3",
+  "description": "The package manager for AI CLI tools - cli4ai.com",
   "type": "module",
   "bin": {
     "cli4ai": "./src/bin.ts"
@@ -16,6 +16,7 @@
   },
   "dependencies": {
     "commander": "^14.0.0",
+    "cron-parser": "^4.9.0",
     "semver": "^7.6.0"
   },
   "devDependencies": {
@@ -30,7 +31,7 @@
     "type": "git",
     "url": "https://github.com/cliforai/framework"
   },
-  "homepage": "https://cliforai.com",
+  "homepage": "https://cli4ai.com",
   "keywords": [
     "cli",
     "ai",

package/src/bin.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env bun
 /**
  * cli4ai - The package manager for AI CLI tools
- * cliforai.com
+ * cli4ai.com
  */
 
 import { createProgram } from './cli.js';
@@ -32,13 +32,13 @@ async function showAnimation(): Promise<void> {
   const food = '·';
 
   for (let pos = 0; pos <= width; pos++) {
-    process.stdout.write('\r\x1B[K');
+    process.stderr.write('\r\x1B[K');
     const frame = robot[pos % robot.length];
     const trail = ' '.repeat(pos) + food.repeat(width - pos);
-    process.stdout.write(`  ${CYAN}${frame}${RESET}${DIM}${trail}${RESET}`);
+    process.stderr.write(`  ${CYAN}${frame}${RESET}${DIM}${trail}${RESET}`);
     await sleep(20);
   }
-  process.stdout.write('\r\x1B[K');
+  process.stderr.write('\r\x1B[K');
 }
 
 /**
@@ -46,19 +46,19 @@ async function showAnimation(): Promise<void> {
  */
 async function animateRobotFace(): Promise<void> {
   const faces = ['[•_•]', '[•_•]', '[-_-]', '[•_•]', '[•_•]', '[°_°]', '[•_•]'];
-  const line = ` ${BOLD}${CYAN}cli4ai${RESET} ${DIM}─${RESET} ${WHITE}cliforai.com${RESET}`;
+  const line = ` ${BOLD}${CYAN}cli4ai${RESET} ${DIM}─${RESET} ${WHITE}cli4ai.com${RESET}`;
 
   for (const face of faces) {
-    process.stdout.write(`\r  ${CYAN}${face}${RESET}${line}`);
+    process.stderr.write(`\r  ${CYAN}${face}${RESET}${line}`);
     await sleep(120);
   }
-  console.log('');
+  console.error('');
 }
 
 async function showBanner(): Promise<void> {
-  if (!process.stdout.isTTY) return;
+  if (!process.stderr.isTTY) return;
 
-  console.log('');
+  console.error('');
 
   // Fun robot eating animation
   await showAnimation();
@@ -66,18 +66,18 @@ async function showBanner(): Promise<void> {
   // Animated robot branding (blinking)
   await animateRobotFace();
 
-  console.log(`        ${DIM}The package manager for AI CLI tools${RESET}`);
-  console.log(`        ${DIM}v${VERSION}${RESET}`);
-  console.log('');
-  console.log(`  ${BOLD}Commands${RESET}`);
-  console.log(`  ${DIM}${'─'.repeat(40)}${RESET}`);
-  console.log(`  ${GREEN}browse${RESET}              ${DIM}Browse & install packages${RESET}`);
-  console.log(`  ${GREEN}run${RESET} ${CYAN}<pkg> <cmd>${RESET}    ${DIM}Run a tool command${RESET}`);
-  console.log(`  ${GREEN}ls${RESET}                  ${DIM}List installed packages${RESET}`);
-  console.log(`  ${GREEN}update${RESET}              ${DIM}Update all packages${RESET}`);
-  console.log('');
-  console.log(`  ${DIM}Run${RESET} ${WHITE}cli4ai --help${RESET} ${DIM}for all commands${RESET}`);
-  console.log('');
+  console.error(`        ${DIM}The package manager for AI CLI tools${RESET}`);
+  console.error(`        ${DIM}v${VERSION}${RESET}`);
+  console.error('');
+  console.error(`  ${BOLD}Commands${RESET}`);
+  console.error(`  ${DIM}${'─'.repeat(40)}${RESET}`);
+  console.error(`  ${GREEN}browse${RESET}              ${DIM}Browse & install packages${RESET}`);
+  console.error(`  ${GREEN}run${RESET} ${CYAN}<pkg> <cmd>${RESET}    ${DIM}Run a tool command${RESET}`);
+  console.error(`  ${GREEN}ls${RESET}                  ${DIM}List installed packages${RESET}`);
+  console.error(`  ${GREEN}update${RESET}              ${DIM}Update all packages${RESET}`);
+  console.error('');
+  console.error(`  ${DIM}Run${RESET} ${WHITE}cli4ai --help${RESET} ${DIM}for all commands${RESET}`);
+  console.error('');
 
   // Check for updates in background (non-blocking)
   checkUpdatesInBackground();

package/src/cli.ts

@@ -26,6 +26,14 @@ import {
 import { browseCommand } from './commands/browse.js';
 import { updateCommand } from './commands/update.js';
 import { routinesListCommand, routinesRunCommand, routinesShowCommand, routinesCreateCommand, routinesEditCommand, routinesRemoveCommand } from './commands/routines.js';
+import {
+  schedulerStartCommand,
+  schedulerStopCommand,
+  schedulerStatusCommand,
+  schedulerLogsCommand,
+  schedulerHistoryCommand,
+  schedulerRunCommand
+} from './commands/scheduler.js';
 
 export function createProgram(): Command {
   const program = new Command()
@@ -252,5 +260,47 @@ Pass-through:
     .option('--dry-run', 'Show execution plan without running')
     .action(withErrorHandling(routinesRunCommand));
 
+  // ═══════════════════════════════════════════════════════════════════════════
+  // SCHEDULER
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  const scheduler = program
+    .command('scheduler')
+    .description('Manage scheduled routine execution');
+
+  scheduler
+    .command('start')
+    .description('Start the scheduler daemon')
+    .option('-f, --foreground', 'Run in foreground (blocking)')
+    .action(withErrorHandling(schedulerStartCommand));
+
+  scheduler
+    .command('stop')
+    .description('Stop the scheduler daemon')
+    .action(withErrorHandling(schedulerStopCommand));
+
+  scheduler
+    .command('status')
+    .description('Show scheduler status and upcoming runs')
+    .action(withErrorHandling(schedulerStatusCommand));
+
+  scheduler
+    .command('logs')
+    .description('View scheduler logs')
+    .option('-f, --follow', 'Follow log output')
+    .option('-n, --lines <n>', 'Number of lines to show', '50')
+    .action(withErrorHandling(schedulerLogsCommand));
+
+  scheduler
+    .command('history [routine]')
+    .description('View routine execution history')
+    .option('-n, --limit <n>', 'Number of records to show', '20')
+    .action(withErrorHandling(schedulerHistoryCommand));
+
+  scheduler
+    .command('run <routine>')
+    .description('Manually trigger a scheduled routine')
+    .action(withErrorHandling(schedulerRunCommand));
+
   return program;
 }

package/src/commands/add.ts

@@ -45,6 +45,47 @@ interface InstallPlan {
   fromNpm?: boolean;
 }
 
+const PKG_NAME_PATTERN = /^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/;
+const CLI4AI_SCOPED_PKG_PATTERN = /^@cli4ai\/[a-z0-9]([a-z0-9-]*[a-z0-9])?$/;
+const URL_LIKE_PATTERN = /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//;
+
+function validatePackageSpecifier(pkg: string): void {
+  if (URL_LIKE_PATTERN.test(pkg)) {
+    let parsed: URL;
+    try {
+      parsed = new URL(pkg);
+    } catch {
+      outputError('INVALID_INPUT', 'Invalid URL', { url: pkg });
+    }
+    if (parsed.protocol !== 'https:') {
+      outputError('INVALID_INPUT', 'Unsupported URL protocol', {
+        url: pkg,
+        protocol: parsed.protocol,
+        allowed: ['https:']
+      });
+    }
+    outputError('INVALID_INPUT', 'Installing from URLs is not supported', {
+      url: pkg,
+      hint: 'Use a local path (./path) or a package name (e.g. github, @cli4ai/github)'
+    });
+  }
+
+  if (pkg.includes('\\') || pkg.includes('..')) {
+    outputError('INVALID_INPUT', 'Invalid package specifier', { package: pkg });
+  }
+
+  if (pkg.startsWith('@cli4ai/')) {
+    if (!CLI4AI_SCOPED_PKG_PATTERN.test(pkg)) {
+      outputError('INVALID_INPUT', 'Invalid package name', { package: pkg });
+    }
+    return;
+  }
+
+  if (!PKG_NAME_PATTERN.test(pkg)) {
+    outputError('INVALID_INPUT', 'Invalid package name', { package: pkg });
+  }
+}
+
 /**
  * Prompt user for confirmation
  */
@@ -446,6 +487,8 @@ async function resolvePackage(
     return { manifest, path: absolutePath };
   }
 
+  validatePackageSpecifier(pkg);
+
   // Check local registries first
   const config = loadConfig();
   for (const registryPath of config.localRegistries) {

package/src/commands/browse.ts

@@ -166,7 +166,7 @@ async function multiSelect(items: BrowseItem[]): Promise<string[]> {
     // Robot header
     log('');
     log(`  ${CYAN}${BOLD}[•_•]${RESET} ${BOLD}cli4ai${RESET} ${DIM}─${RESET} ${WHITE}Package Browser${RESET}`);
-    log(`        ${DIM}cliforai.com${RESET}`);
+    log(`        ${DIM}cli4ai.com${RESET}`);
     log('');
 
     // Box top

package/src/commands/config.ts

@@ -5,7 +5,7 @@
 import { output, outputError, log } from '../lib/cli.js';
 import {
   loadConfig,
-  saveConfig,
+  updateConfig,
   addLocalRegistry,
   removeLocalRegistry,
   CLI4AI_HOME,
@@ -72,8 +72,13 @@ export async function configCommand(
 
   // Set key=value
   if (key && value) {
-    const updated = setNestedValue(config, key, parseValue(value));
-    saveConfig(updated);
+    const parsed = parseValue(value);
+
+    if (key === 'registry') {
+      validateRegistryUrl(parsed);
+    }
+
+    const updated = updateConfig((current) => setNestedValue(current, key, parsed));
     log(`Set ${key} = ${value}`);
     output({
       action: 'set',
@@ -84,6 +89,29 @@ export async function configCommand(
   }
 }
 
+function validateRegistryUrl(value: unknown): void {
+  if (typeof value !== 'string' || value.trim().length === 0) {
+    outputError('INVALID_INPUT', 'Registry must be a non-empty URL string', {
+      got: value
+    });
+  }
+
+  let url: URL;
+  try {
+    url = new URL(value);
+  } catch {
+    outputError('INVALID_INPUT', `Invalid registry URL: ${value}`, {
+      hint: 'Use a valid http(s) URL, e.g. https://registry.cli4ai.com'
+    });
+  }
+
+  if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+    outputError('INVALID_INPUT', `Invalid registry URL protocol: ${url.protocol}`, {
+      hint: 'Registry URL must start with http:// or https://'
+    });
+  }
+}
+
 function getNestedValue(obj: Record<string, unknown>, path: string): unknown {
   const parts = path.split('.');
   let current: unknown = obj;

package/src/commands/list.ts

@@ -58,32 +58,15 @@ export async function listCommand(options: ListOptions): Promise<void> {
     }
   }
 
-  if (options.json || !process.stdout.isTTY) {
-    output({
-      packages: packages.map(p => ({
-        name: p.name,
-        version: p.version,
-        path: p.path,
-        source: p.source,
-        scope: p.scope
-      })),
-      count: packages.length
-    });
-  } else {
-    // Human-readable output
-    if (packages.length === 0) {
-      console.log('No packages installed');
-      console.log('\nRun "cli4ai browse" to find and install packages');
-      console.log('Or:  npm install -g @cli4ai/<package>');
-    } else {
-      console.log(`\nInstalled packages (${packages.length}):\n`);
-      for (const pkg of packages) {
-        const scopeTag = pkg.scope === 'local' ? '' :
-                         pkg.scope === 'npm' ? ' (npm)' : ' (cli4ai)';
-        console.log(`  ${pkg.name}@${pkg.version}${scopeTag}`);
-        console.log(`    ${pkg.path}`);
-      }
-      console.log('');
-    }
-  }
+  output({
+    packages: packages.map(p => ({
+      name: p.name,
+      version: p.version,
+      path: p.path,
+      source: p.source,
+      scope: p.scope
+    })),
+    count: packages.length,
+    location: options.global ? 'global' : 'all'
+  });
 }

package/src/commands/mcp-config.ts

@@ -2,11 +2,12 @@
  * cli4ai mcp-config - Generate MCP configuration for Claude Code
  */
 
-import { outputError } from '../lib/cli.js';
+import { output, outputError } from '../lib/cli.js';
 import {
   generateClaudeCodeConfig,
   formatClaudeCodeConfig,
-  generateConfigSnippet
+  generateConfigSnippet,
+  generateServerConfig
 } from '../mcp/config-gen.js';
 import { findPackage } from '../core/config.js';
 import { tryLoadManifest } from '../core/manifest.js';
@@ -36,8 +37,14 @@ export async function mcpConfigCommand(options: McpConfigOptions): Promise<void>
       outputError('INVALID_INPUT', `Package ${options.package} does not have MCP enabled`);
     }
 
+    const serverName = `cli4ai-${manifest!.name}`;
+    const serverConfig = generateServerConfig(manifest!, pkg!.path);
     const snippet = generateConfigSnippet(manifest!, pkg!.path);
-    console.log(snippet);
+    output({
+      serverName,
+      serverConfig,
+      snippet
+    });
     return;
   }
 
@@ -55,5 +62,8 @@ export async function mcpConfigCommand(options: McpConfigOptions): Promise<void>
   }
 
   // Output formatted config
-  console.log(formatClaudeCodeConfig(config));
+  output({
+    config,
+    formatted: formatClaudeCodeConfig(config)
+  });
 }

package/src/commands/remove.ts

@@ -18,6 +18,8 @@ interface RemoveResult {
   path: string;
 }
 
+const PKG_NAME_PATTERN = /^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/;
+
 export async function removeCommand(packages: string[], options: RemoveOptions): Promise<void> {
   const results: RemoveResult[] = [];
   const errors: { package: string; error: string }[] = [];
@@ -26,6 +28,10 @@ export async function removeCommand(packages: string[], options: RemoveOptions):
   const projectDir = process.cwd();
 
   for (const pkg of packages) {
+    if (!PKG_NAME_PATTERN.test(pkg)) {
+      errors.push({ package: pkg, error: 'Invalid package name' });
+      continue;
+    }
     const pkgPath = resolve(targetDir, pkg);
 
     if (!existsSync(pkgPath)) {

package/src/commands/routines.ts

@@ -389,5 +389,5 @@ export async function routinesEditCommand(name: string, options: { global?: bool
     shell: true
   });
 
-  process.exit(result.status ?? 0);
+  process.exit(result.status ?? 1);
 }

package/src/commands/run.ts

@@ -35,11 +35,13 @@ export async function runCommand(
       env: extraEnv,
       capture: 'inherit'
     });
-    process.exit(result.exitCode);
+    process.exitCode = result.exitCode;
+    return;
   } catch (err) {
     if (err instanceof ExecuteToolError) {
       outputError(err.code, err.message, err.details);
     }
-    throw err;
+    const message = err instanceof Error ? err.message : String(err);
+    outputError('API_ERROR', message);
   }
 }