cli4ai 0.8.2 → 0.9.0

package/package.json

@@ -1,28 +1,29 @@
 {
   "name": "cli4ai",
-  "version": "0.8.2",
-  "description": "The package manager for AI CLI tools - cliforai.com",
+  "version": "0.9.0",
+  "description": "The package manager for AI CLI tools - cli4ai.com",
   "type": "module",
   "bin": {
     "cli4ai": "./src/bin.ts"
   },
   "scripts": {
-    "dev": "bun run src/bin.ts",
-    "build": "bun build src/bin.ts --outdir dist --target node",
+    "dev": "npx tsx src/bin.ts",
     "typecheck": "tsc --noEmit",
-    "test": "bun test",
-    "test:watch": "bun test --watch",
-    "test:coverage": "bun test --coverage"
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
   },
   "dependencies": {
     "commander": "^14.0.0",
+    "cron-parser": "^4.9.0",
     "semver": "^7.6.0"
   },
   "devDependencies": {
-    "@types/bun": "^1.3.4",
     "@types/node": "^22.0.0",
     "@types/semver": "^7.5.0",
-    "typescript": "^5.7.0"
+    "tsx": "^4.0.0",
+    "typescript": "^5.7.0",
+    "vitest": "^2.0.0"
   },
   "author": "cliforai",
   "license": "MIT",
@@ -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()
@@ -49,7 +57,7 @@ export function createProgram(): Command {
     .command('init [name]')
     .description('Create a new cli4ai tool project')
     .option('-t, --template <template>', 'Template to use (basic, api, browser)', 'basic')
-    .option('-r, --runtime <runtime>', 'Runtime (bun, node)', 'bun')
+    .option('-r, --runtime <runtime>', 'Runtime (node, bun)', 'node')
     .option('-y, --yes', 'Skip prompts, use defaults')
     .action(withErrorHandling(initCommand));
 
@@ -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
  */
@@ -196,15 +237,13 @@ async function installNpmDependencies(pkgPath: string, dependencies: Record<stri
 
   log(`Installing npm dependencies: ${deps.join(', ')}`);
 
-  const proc = Bun.spawn(['bun', 'add', ...deps], {
+  const result = spawnSync('npm', ['install', ...deps], {
     cwd: pkgPath,
-    stdout: 'inherit',
-    stderr: 'inherit'
+    stdio: 'inherit'
   });
 
-  const exitCode = await proc.exited;
-  if (exitCode !== 0) {
-    throw new Error(`Failed to install dependencies (exit code: ${exitCode})`);
+  if (result.status !== 0) {
+    throw new Error(`Failed to install dependencies (exit code: ${result.status})`);
   }
 }
 
@@ -446,6 +485,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/info.ts

@@ -66,7 +66,7 @@ function outputPackageInfo(manifest: Manifest, path: string, installed: boolean)
     description: manifest.description,
     author: manifest.author,
     license: manifest.license,
-    runtime: manifest.runtime || 'bun',
+    runtime: manifest.runtime || 'node',
     entry: manifest.entry,
     path,
     installed,

package/src/commands/init.test.ts

@@ -2,7 +2,7 @@
  * Integration tests for init command
  */
 
-import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
+import { describe, test, expect, beforeEach, afterEach } from 'vitest';
 import { mkdtempSync, rmSync, existsSync, readFileSync } from 'fs';
 import { join } from 'path';
 import { tmpdir } from 'os';
@@ -88,11 +88,11 @@ describe('init command', () => {
       expect(manifest.version).toBe('1.0.0');
     });
 
-    test('manifest has default runtime bun', async () => {
+    test('manifest has default runtime node', async () => {
       await initCommand('tool', {});
 
       const manifest = JSON.parse(readFileSync(join(tempDir, 'tool', 'cli4ai.json'), 'utf-8'));
-      expect(manifest.runtime).toBe('bun');
+      expect(manifest.runtime).toBe('node');
     });
 
     test('manifest has entry pointing to run.ts', async () => {
@@ -110,7 +110,7 @@ describe('init command', () => {
       expect(manifest.commands?.hello?.description).toBe('Say hello');
     });
 
-    test('manifest includes dependencies for bun runtime', async () => {
+    test('manifest includes dependencies', async () => {
       await initCommand('tool', {});
 
       const manifest = JSON.parse(readFileSync(join(tempDir, 'tool', 'cli4ai.json'), 'utf-8'));
@@ -121,11 +121,11 @@ describe('init command', () => {
   });
 
   describe('entry file content', () => {
-    test('run.ts starts with shebang', async () => {
+    test('run.ts starts with tsx shebang', async () => {
       await initCommand('tool', {});
 
       const content = readFileSync(join(tempDir, 'tool', 'run.ts'), 'utf-8');
-      expect(content.startsWith('#!/usr/bin/env bun')).toBe(true);
+      expect(content.startsWith('#!/usr/bin/env npx tsx')).toBe(true);
     });
 
     test('run.ts has hello command', async () => {
@@ -139,25 +139,73 @@ describe('init command', () => {
       await initCommand('tool', {});
 
       const content = readFileSync(join(tempDir, 'tool', 'run.ts'), 'utf-8');
-      expect(content).toContain("@cli4ai/lib/cli.ts");
+      expect(content).toContain("@cli4ai/lib");
       expect(content).toContain('output(');
     });
   });
 
   describe('runtime option', () => {
     test('respects runtime option', async () => {
-      await initCommand('tool', { runtime: 'node' });
+      await initCommand('tool', { runtime: 'bun' });
 
       const manifest = JSON.parse(readFileSync(join(tempDir, 'tool', 'cli4ai.json'), 'utf-8'));
-      expect(manifest.runtime).toBe('node');
+      expect(manifest.runtime).toBe('bun');
     });
 
-    test('node runtime uses run.mjs entry', async () => {
+    test('both runtimes use run.ts with tsx', async () => {
+      // Node runtime (default)
       await initCommand('tool', { runtime: 'node' });
+      let manifest = JSON.parse(readFileSync(join(tempDir, 'tool', 'cli4ai.json'), 'utf-8'));
+      expect(manifest.entry).toBe('run.ts');
+      expect(existsSync(join(tempDir, 'tool', 'run.ts'))).toBe(true);
 
-      const manifest = JSON.parse(readFileSync(join(tempDir, 'tool', 'cli4ai.json'), 'utf-8'));
-      expect(manifest.entry).toBe('run.mjs');
-      expect(existsSync(join(tempDir, 'tool', 'run.mjs'))).toBe(true);
+      // Bun runtime
+      rmSync(join(tempDir, 'tool'), { recursive: true, force: true });
+      await initCommand('tool', { runtime: 'bun' });
+      manifest = JSON.parse(readFileSync(join(tempDir, 'tool', 'cli4ai.json'), 'utf-8'));
+      expect(manifest.entry).toBe('run.ts');
+      expect(existsSync(join(tempDir, 'tool', 'run.ts'))).toBe(true);
+    });
+  });
+
+  describe('test scaffolding', () => {
+    test('creates vitest.config.ts', async () => {
+      await initCommand('tool', {});
+      expect(existsSync(join(tempDir, 'tool', 'vitest.config.ts'))).toBe(true);
+    });
+
+    test('creates run.test.ts with vitest imports', async () => {
+      await initCommand('tool', {});
+      const content = readFileSync(join(tempDir, 'tool', 'run.test.ts'), 'utf-8');
+      expect(content).toContain("from 'vitest'");
+      expect(content).toContain('describe(');
+    });
+
+    test('package.json has vitest dev dependency', async () => {
+      await initCommand('tool', {});
+      const pkg = JSON.parse(readFileSync(join(tempDir, 'tool', 'package.json'), 'utf-8'));
+      expect(pkg.devDependencies).toBeDefined();
+      expect(pkg.devDependencies['vitest']).toBeDefined();
+      expect(pkg.devDependencies['tsx']).toBeDefined();
+    });
+
+    test('package.json has test script', async () => {
+      await initCommand('tool', {});
+      const pkg = JSON.parse(readFileSync(join(tempDir, 'tool', 'package.json'), 'utf-8'));
+      expect(pkg.scripts?.test).toBe('vitest run');
+    });
+  });
+
+  describe('tsconfig.json', () => {
+    test('creates tsconfig.json', async () => {
+      await initCommand('tool', {});
+      expect(existsSync(join(tempDir, 'tool', 'tsconfig.json'))).toBe(true);
+    });
+
+    test('tsconfig uses NodeNext module resolution', async () => {
+      await initCommand('tool', {});
+      const tsconfig = JSON.parse(readFileSync(join(tempDir, 'tool', 'tsconfig.json'), 'utf-8'));
+      expect(tsconfig.compilerOptions.moduleResolution).toBe('NodeNext');
     });
   });
 });