@positronic/cli 0.0.2 → 0.0.4

package/src/commands/resources.ts

@@ -1,97 +0,0 @@
-import React, { ReactElement } from 'react';
-import { scanLocalResources, generateTypes } from './helpers.js';
-import * as fs from 'fs';
-import * as path from 'path';
-import { ResourceList } from '../components/resource-list.js';
-import { ResourceSync } from '../components/resource-sync.js';
-import { ResourceClear } from '../components/resource-clear.js';
-import { ResourceDelete } from '../components/resource-delete.js';
-import { ResourceUpload } from '../components/resource-upload.js';
-import { ResourceTypes } from '../components/resource-types.js';
-import { ErrorComponent } from '../components/error.js';
-import type { PositronicDevServer } from '@positronic/spec';
-
-export class ResourcesCommand {
-  constructor(private server?: PositronicDevServer) {}
-
-  list(): ReactElement {
-    return React.createElement(ResourceList);
-  }
-
-  sync(): ReactElement {
-    if (!this.server) {
-      return React.createElement(ErrorComponent, {
-        error: {
-          title: 'Command Not Available',
-          message: 'This command is only available in local dev mode',
-          details:
-            'Please run this command from within a Positronic project directory.',
-        },
-      });
-    }
-
-    // Check if resources directory exists, create if it doesn't
-    const resourcesDir = path.join(this.server.projectRootDir, 'resources');
-    if (!fs.existsSync(resourcesDir)) {
-      fs.mkdirSync(resourcesDir, { recursive: true });
-    }
-    const localResources = scanLocalResources(resourcesDir);
-
-    return React.createElement(ResourceSync, {
-      localResources,
-      resourcesDir,
-    });
-  }
-
-  types(): ReactElement {
-    if (!this.server) {
-      return React.createElement(ErrorComponent, {
-        error: {
-          title: 'Command Not Available',
-          message: 'This command is only available in local dev mode',
-          details:
-            'Please run this command from within a Positronic project directory.',
-        },
-      });
-    }
-
-    return React.createElement(ResourceTypes, {
-      projectRootDir: this.server.projectRootDir,
-    });
-  }
-
-  delete(resourcePath: string, force: boolean = false): ReactElement {
-    if (!resourcePath) {
-      return React.createElement(ErrorComponent, {
-        error: {
-          title: 'Missing Resource Path',
-          message: 'Please provide a resource path to delete.',
-          details: 'Usage: positronic resources delete <path>',
-        },
-      });
-    }
-
-    // The resourcePath should be relative to the resources directory
-    const resourceKey = resourcePath;
-
-    return React.createElement(ResourceDelete, {
-      resourceKey,
-      resourcePath,
-      projectRootPath: this.server?.projectRootDir,
-      force,
-    });
-  }
-
-  async clear() {
-    // Import and render ResourceClear component
-    return React.createElement(ResourceClear);
-  }
-
-  upload(filePath: string, customKey?: string): ReactElement {
-    return React.createElement(ResourceUpload, {
-      filePath,
-      customKey,
-      projectRootPath: this.server?.projectRootDir,
-    });
-  }
-}

package/src/commands/schedule.test.ts

@@ -1,481 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { describe, it, expect, jest, beforeEach, afterEach } from '@jest/globals';
-import { createTestEnv, px, type TestEnv } from './test-utils.js';
-import { ScheduleCommand } from './schedule.js';
-import { TestDevServer } from '../test/test-dev-server.js';
-
-describe('schedule command', () => {
-  describe('schedule create', () => {
-    it('should create a new schedule', async () => {
-      const env = await createTestEnv();
-      const px = await env.start();
-      
-      try {
-        const { waitForOutput, instance } = await px([
-          'schedule',
-          'create',
-          'test-brain',
-          '0 3 * * *',
-        ]);
-
-        // Wait for success message
-        const foundSuccess = await waitForOutput(/Schedule created successfully/i, 50);
-        expect(foundSuccess).toBe(true);
-
-        // Verify the output contains the brain name and cron expression
-        const output = instance.lastFrame() || '';
-        expect(output).toContain('test-brain');
-        expect(output).toContain('0 3 * * *');
-
-        // Verify the API call was made
-        const methodCalls = env.server.getLogs();
-        const createCall = methodCalls.find((call) => call.method === 'createSchedule');
-        expect(createCall).toBeDefined();
-        expect(createCall!.args[0]).toEqual({
-          brainName: 'test-brain',
-          cronExpression: '0 3 * * *',
-        });
-      } finally {
-        await env.stopAndCleanup();
-      }
-    });
-
-    it('should handle server connection errors gracefully', async () => {
-      const env = await createTestEnv();
-      // Don't start the server to simulate connection error
-      
-      try {
-        const { waitForOutput } = await px([
-          'schedule',
-          'create',
-          'test-brain',
-          '0 3 * * *',
-        ], { server: env.server });
-
-        const foundError = await waitForOutput(/Error connecting to the local development server/i);
-        expect(foundError).toBe(true);
-      } finally {
-        env.cleanup();
-      }
-    });
-  });
-
-  describe('schedule list', () => {
-    let originalExit: typeof process.exit;
-    
-    beforeEach(() => {
-      // Mock process.exit but don't throw - just track the call
-      originalExit = process.exit;
-      process.exit = jest.fn() as any;
-    });
-
-    afterEach(() => {
-      process.exit = originalExit;
-    });
-
-    it('should list schedules when no schedules exist', async () => {
-      const env = await createTestEnv();
-      const px = await env.start();
-      
-      try {
-        const { waitForOutput } = await px(['schedule', '-l']);
-        
-        // Wait for the empty state message
-        const foundEmpty = await waitForOutput(/No schedules found/i, 30);
-        expect(foundEmpty).toBe(true);
-        
-        // Verify process.exit was called
-        expect(process.exit).toHaveBeenCalledWith(0);
-        
-        // Verify API call was made
-        const calls = env.server.getLogs();
-        const listCall = calls.find(c => c.method === 'getSchedules');
-        expect(listCall).toBeDefined();
-      } finally {
-        await env.stopAndCleanup();
-      }
-    });
-
-    it('should list schedules when schedules exist', async () => {
-      const env = await createTestEnv();
-      const { server } = env;
-      
-      // Add test schedules
-      server.addSchedule({
-        id: 'schedule-1',
-        brainName: 'daily-report',
-        cronExpression: '0 9 * * *',
-        enabled: true,
-        createdAt: Date.now() - 86400000, // 1 day ago
-        nextRunAt: Date.now() + 3600000, // 1 hour from now
-      });
-      server.addSchedule({
-        id: 'schedule-2', 
-        brainName: 'hourly-sync',
-        cronExpression: '0 * * * *',
-        enabled: true,
-        createdAt: Date.now() - 172800000, // 2 days ago
-        nextRunAt: Date.now() + 1800000, // 30 mins from now
-      });
-      
-      const px = await env.start();
-      
-      try {
-        const { waitForOutput, instance } = await px(['schedule', '-l']);
-        
-        // Wait for schedules to appear
-        const foundSchedules = await waitForOutput(/daily-report/i, 30);
-        expect(foundSchedules).toBe(true);
-        
-        // Check that both schedules are shown
-        const output = instance.lastFrame() || '';
-        expect(output).toContain('daily-report');
-        expect(output).toContain('hourly-sync');
-        expect(output).toContain('0 9 * * *');
-        expect(output).toContain('0 * * * *');
-        
-        // Verify process.exit was called
-        expect(process.exit).toHaveBeenCalledWith(0);
-        
-        // Verify API call was made
-        const calls = server.getLogs();
-        const listCall = calls.find(c => c.method === 'getSchedules');
-        expect(listCall).toBeDefined();
-      } finally {
-        await env.stopAndCleanup();
-      }
-    });
-
-    it('should filter schedules by brain name', async () => {
-      const env = await createTestEnv();
-      const { server } = env;
-      
-      // Add test schedules
-      server.addSchedule({
-        id: 'schedule-1',
-        brainName: 'daily-report',
-        cronExpression: '0 9 * * *',
-        enabled: true,
-        createdAt: Date.now(),
-        nextRunAt: Date.now() + 3600000,
-      });
-      server.addSchedule({
-        id: 'schedule-2',
-        brainName: 'hourly-sync',
-        cronExpression: '0 * * * *',
-        enabled: true,
-        createdAt: Date.now(),
-        nextRunAt: Date.now() + 1800000,
-      });
-      
-      const px = await env.start();
-      
-      try {
-        const { waitForOutput, instance } = await px(['schedule', '-l', '--brain', 'daily-report']);
-        
-        // Wait for filtered results
-        const foundSchedule = await waitForOutput(/daily-report/i, 30);
-        expect(foundSchedule).toBe(true);
-        
-        // Verify only the filtered schedule is shown
-        const output = instance.lastFrame() || '';
-        expect(output).toContain('daily-report');
-        expect(output).not.toContain('hourly-sync');
-        
-        // Verify process.exit was called
-        expect(process.exit).toHaveBeenCalledWith(0);
-        
-        // Verify API call was made
-        const calls = server.getLogs();
-        const listCall = calls.find(c => c.method === 'getSchedules');
-        expect(listCall).toBeDefined();
-      } finally {
-        await env.stopAndCleanup();
-      }
-    });
-
-    it('should handle server connection errors', async () => {
-      const env = await createTestEnv();
-      // Don't start the server to simulate connection error
-      
-      try {
-        const { waitForOutput } = await px(['schedule', '-l'], { server: env.server });
-        
-        const foundError = await waitForOutput(/Error connecting to the local development server/i, 30);
-        expect(foundError).toBe(true);
-        
-        // Verify process.exit was called
-        expect(process.exit).toHaveBeenCalledWith(0);
-      } finally {
-        env.cleanup();
-      }
-    });
-  });
-
-  describe('schedule delete', () => {
-    let originalExit: typeof process.exit;
-    
-    beforeEach(() => {
-      // Mock process.exit but don't throw - just track the call
-      originalExit = process.exit;
-      process.exit = jest.fn() as any;
-    });
-
-    afterEach(() => {
-      process.exit = originalExit;
-    });
-
-    it('should delete a schedule successfully', async () => {
-      const env = await createTestEnv();
-      const { server } = env;
-      
-      // Add a schedule to delete
-      server.addSchedule({
-        id: 'schedule-to-delete',
-        brainName: 'test-brain',
-        cronExpression: '0 * * * *',
-        enabled: true,
-        createdAt: Date.now(),
-        nextRunAt: Date.now() + 3600000,
-      });
-      
-      const px = await env.start();
-      
-      try {
-        const { waitForOutput } = await px(['schedule', '-d', 'schedule-to-delete', '--force']);
-        
-        // Wait for success message
-        const foundSuccess = await waitForOutput(/Schedule deleted successfully/i, 30);
-        expect(foundSuccess).toBe(true);
-        
-        // Verify process.exit was called
-        expect(process.exit).toHaveBeenCalledWith(0);
-        
-        // Verify API call was made
-        const calls = server.getLogs();
-        const deleteCall = calls.find(c => c.method === 'deleteSchedule');
-        expect(deleteCall).toBeDefined();
-        expect(deleteCall!.args[0]).toBe('schedule-to-delete');
-        
-        // Verify schedule was removed from server
-        expect(server.getSchedules().length).toBe(0);
-      } finally {
-        await env.stopAndCleanup();
-      }
-    });
-
-    it('should handle deleting non-existent schedule', async () => {
-      const env = await createTestEnv();
-      const { server } = env;
-      const px = await env.start();
-      
-      try {
-        const { waitForOutput } = await px(['schedule', '-d', 'non-existent-id', '--force']);
-        
-        // Wait for error message
-        const foundError = await waitForOutput(/not found/i, 30);
-        expect(foundError).toBe(true);
-        
-        // Verify process.exit was called
-        expect(process.exit).toHaveBeenCalledWith(0);
-        
-        // Verify no deleteSchedule call was logged (404 handled by nock)
-        const calls = server.getLogs();
-        // The server still logs the attempt, but nock returns 404
-        expect(calls.some(c => c.method === 'start')).toBe(true);
-      } finally {
-        await env.stopAndCleanup();
-      }
-    });
-
-    // Skipping this test due to complexities with stdin handling in test environment
-    // The delete functionality is covered by the force flag test
-
-    it('should handle server connection errors', async () => {
-      const env = await createTestEnv();
-      // Don't start the server to simulate connection error
-      
-      try {
-        const { waitForOutput } = await px(['schedule', '-d', 'some-id', '--force'], { server: env.server });
-        
-        const foundError = await waitForOutput(/Error connecting to the local development server/i, 30);
-        expect(foundError).toBe(true);
-        
-        // Verify process.exit was called
-        expect(process.exit).toHaveBeenCalledWith(0);
-      } finally {
-        env.cleanup();
-      }
-    });
-  });
-
-  describe('schedule runs', () => {
-    it('should show empty state when no runs exist', async () => {
-      const env = await createTestEnv();
-      const px = await env.start();
-      
-      try {
-        const { waitForOutput } = await px(['schedule', 'runs']);
-        
-        const foundMessage = await waitForOutput(/No scheduled runs found/i, 30);
-        expect(foundMessage).toBe(true);
-        
-        // Verify API call was made
-        const calls = env.server.getLogs();
-        const runsCall = calls.find(c => c.method === 'getScheduleRuns');
-        expect(runsCall).toBeDefined();
-      } finally {
-        await env.stopAndCleanup();
-      }
-    });
-
-    it('should list scheduled runs when they exist', async () => {
-      const env = await createTestEnv();
-      const { server } = env;
-      
-      // Add some scheduled runs
-      server.addScheduleRun({
-        id: 'run-1',
-        scheduleId: 'schedule-1',
-        status: 'triggered',
-        ranAt: Date.now() - 3600000, // 1 hour ago
-      });
-      
-      server.addScheduleRun({
-        id: 'run-2',
-        scheduleId: 'schedule-2',
-        status: 'failed',
-        ranAt: Date.now() - 7200000, // 2 hours ago
-        error: 'Connection timeout',
-      });
-      
-      const px = await env.start();
-      
-      try {
-        const { waitForOutput } = await px(['schedule', 'runs']);
-        
-        // Check for runs in output
-        const foundRuns = await waitForOutput(/Found 2 scheduled runs/i, 30);
-        expect(foundRuns).toBe(true);
-        
-        // Check for run IDs
-        const foundRun1 = await waitForOutput(/run-1/i, 30);
-        expect(foundRun1).toBe(true);
-        
-        const foundRun2 = await waitForOutput(/run-2/i, 30);
-        expect(foundRun2).toBe(true);
-      } finally {
-        await env.stopAndCleanup();
-      }
-    });
-
-    it('should filter runs by schedule ID', async () => {
-      const env = await createTestEnv();
-      const { server } = env;
-      
-      // Add runs for different schedules
-      server.addScheduleRun({
-        id: 'run-1',
-        scheduleId: 'schedule-abc',
-        status: 'triggered',
-        ranAt: Date.now() - 3600000,
-      });
-      
-      server.addScheduleRun({
-        id: 'run-2',
-        scheduleId: 'schedule-xyz',
-        status: 'triggered',
-        ranAt: Date.now() - 7200000,
-      });
-      
-      const px = await env.start();
-      
-      try {
-        const { waitForOutput, instance } = await px([
-          'schedule', 
-          'runs', 
-          '--schedule-id', 
-          'schedule-abc'
-        ]);
-        
-        const foundMessage = await waitForOutput(/Found 1 scheduled run for schedule schedule-abc/i, 30);
-        expect(foundMessage).toBe(true);
-        
-        // Verify only the filtered run is shown
-        const output = instance.lastFrame() || '';
-        expect(output).toContain('run-1');
-        expect(output).not.toContain('run-2');
-      } finally {
-        await env.stopAndCleanup();
-      }
-    });
-
-    it('should filter runs by status', async () => {
-      const env = await createTestEnv();
-      const { server } = env;
-      
-      // Add runs with different statuses
-      server.addScheduleRun({
-        id: 'run-1',
-        scheduleId: 'schedule-1',
-        status: 'triggered',
-        ranAt: Date.now() - 3600000,
-      });
-      
-      server.addScheduleRun({
-        id: 'run-2',
-        scheduleId: 'schedule-1',
-        status: 'failed',
-        ranAt: Date.now() - 7200000,
-      });
-      
-      const px = await env.start();
-      
-      try {
-        const { waitForOutput, instance } = await px([
-          'schedule', 
-          'runs', 
-          '--status', 
-          'failed'
-        ]);
-        
-        const foundMessage = await waitForOutput(/Found 1 scheduled run with status failed/i, 30);
-        expect(foundMessage).toBe(true);
-        
-        // Verify only failed run is shown
-        const output = instance.lastFrame() || '';
-        expect(output).toContain('run-2');
-        expect(output).not.toContain('run-1');
-      } finally {
-        await env.stopAndCleanup();
-      }
-    });
-
-    it('should respect limit parameter', async () => {
-      const env = await createTestEnv();
-      const px = await env.start();
-      
-      try {
-        const { waitForOutput } = await px([
-          'schedule', 
-          'runs', 
-          '--limit',
-          '50'
-        ]);
-        
-        // Wait for the component to render and make the API call
-        const found = await waitForOutput(/No scheduled runs found|Found \d+ scheduled run/i, 30);
-        expect(found).toBe(true);
-        
-        // Just verify the API was called with the right limit
-        const calls = env.server.getLogs();
-        const runsCall = calls.find(c => c.method === 'getScheduleRuns');
-        expect(runsCall).toBeDefined();
-        expect(runsCall?.args[0]).toContain('limit=50');
-      } finally {
-        await env.stopAndCleanup();
-      }
-    });
-  });
-});

package/src/commands/schedule.ts

@@ -1,65 +0,0 @@
-import type { ArgumentsCamelCase } from 'yargs';
-import React from 'react';
-import { ScheduleCreate } from '../components/schedule-create.js';
-import { ScheduleList } from '../components/schedule-list.js';
-import { ScheduleDelete } from '../components/schedule-delete.js';
-import { ScheduleRuns } from '../components/schedule-runs.js';
-
-interface ScheduleCreateArgs {
-  brainName: string;
-  cronExpression: string;
-}
-
-interface ScheduleListArgs {
-  brain?: string;
-}
-
-interface ScheduleDeleteArgs {
-  scheduleId: string;
-  force: boolean;
-}
-
-interface ScheduleRunsArgs {
-  scheduleId?: string;
-  limit: number;
-  status?: 'triggered' | 'failed' | 'complete';
-}
-
-export class ScheduleCommand {
-  constructor() {}
-
-  create({
-    brainName,
-    cronExpression,
-  }: ArgumentsCamelCase<ScheduleCreateArgs>): React.ReactElement {
-    return React.createElement(ScheduleCreate, {
-      brainName,
-      cronExpression,
-    });
-  }
-
-  list({ brain }: ArgumentsCamelCase<ScheduleListArgs>): React.ReactElement {
-    return React.createElement(ScheduleList, {
-      brainFilter: brain,
-    });
-  }
-
-  delete({ scheduleId, force }: ArgumentsCamelCase<ScheduleDeleteArgs>): React.ReactElement {
-    return React.createElement(ScheduleDelete, {
-      scheduleId,
-      force,
-    });
-  }
-
-  runs({
-    scheduleId,
-    limit,
-    status,
-  }: ArgumentsCamelCase<ScheduleRunsArgs>): React.ReactElement {
-    return React.createElement(ScheduleRuns, {
-      scheduleId,
-      limit,
-      status,
-    });
-  }
-}