@positronic/cli 0.0.3 → 0.0.5

package/src/commands/server.ts

@@ -1,353 +0,0 @@
-import * as path from 'path';
-import * as fs from 'fs';
-import { spawn } from 'child_process';
-import chokidar, { type FSWatcher } from 'chokidar';
-import type { ArgumentsCamelCase } from 'yargs';
-import { syncResources, generateTypes } from './helpers.js';
-import type { PositronicDevServer, ServerHandle } from '@positronic/spec';
-
-export class ServerCommand {
-  constructor(private server: PositronicDevServer) {}
-
-  async handle(argv: ArgumentsCamelCase<any>) {
-    // Handle kill option
-    if (argv.k) {
-      return this.handleKill(argv);
-    }
-
-    // Validate arguments
-    if (argv.port && argv.d && !argv.logFile) {
-      throw new Error(
-        'When using --port with -d, you must also specify --log-file'
-      );
-    }
-
-    // Check for existing PID file (skip if we're a detached child process)
-    const pidFile = this.getPidFilePath(argv.port);
-    if (!process.env.POSITRONIC_DETACHED_CHILD && fs.existsSync(pidFile)) {
-      const existingPid = parseInt(fs.readFileSync(pidFile, 'utf8').trim());
-      if (this.isProcessRunning(existingPid)) {
-        throw new Error(
-          `Server already running (PID: ${existingPid}). Stop it with: px server -k`
-        );
-      } else {
-        console.log('WARNING: Removing stale PID file');
-        fs.unlinkSync(pidFile);
-      }
-    }
-
-    // If -d flag is set, spawn a detached process
-    if (argv.d) {
-      return this.handleDetached(argv);
-    }
-
-    // Write PID file for foreground process too
-    fs.writeFileSync(pidFile, String(process.pid));
-
-    const brainsDir = path.join(this.server.projectRootDir, 'brains');
-    const resourcesDir = path.join(this.server.projectRootDir, 'resources');
-
-    let serverHandle: ServerHandle | null = null;
-    let watcher: FSWatcher | null = null;
-    let logStream: fs.WriteStream | null = null;
-
-    // Always create a log file (use default if not specified)
-    const logFilePath = argv.logFile
-      ? path.resolve(argv.logFile)
-      : path.join(this.server.projectRootDir, '.positronic-server.log');
-
-    // Ensure directory exists
-    const logDir = path.dirname(logFilePath);
-    if (!fs.existsSync(logDir)) {
-      fs.mkdirSync(logDir, { recursive: true });
-    }
-
-    // Create log stream (append mode)
-    logStream = fs.createWriteStream(logFilePath, { flags: 'a' });
-
-    // Helper function to log to both console and file
-    const logBoth = (level: string, message: string) => {
-      const timestamp = new Date().toISOString();
-      const logLine = `[${timestamp}] [${level}] ${message}\n`;
-      if (logStream && !logStream.destroyed) {
-        logStream.write(logLine);
-      }
-
-      // Console output is handled by the dev server's direct forwarding
-      // to avoid duplication
-    };
-
-    // Always register log callbacks to capture server logs
-    // The server is responsible for generating logs through these callbacks
-    this.server.onLog((message) => logBoth('INFO', message));
-    this.server.onError((message) => logBoth('ERROR', message));
-    this.server.onWarning((message) => logBoth('WARN', message));
-
-    const cleanup = async () => {
-      if (watcher) {
-        await watcher.close();
-        watcher = null;
-      }
-      if (serverHandle && !serverHandle.killed) {
-        serverHandle.kill();
-        serverHandle = null;
-      }
-
-      // Close log stream
-      if (logStream) {
-        logStream.end();
-        logStream = null;
-      }
-
-      // Remove PID file
-      if (fs.existsSync(pidFile)) {
-        fs.unlinkSync(pidFile);
-      }
-
-      process.exit(0);
-    };
-
-    process.on('SIGINT', cleanup); // Catches Ctrl+C
-    process.on('SIGTERM', cleanup); // Catches kill commands
-
-    try {
-      // Use the dev server's setup method
-      await this.server.setup(argv.force);
-
-      // Use the dev server's start method
-      serverHandle = await this.server.start(argv.port);
-
-      serverHandle.onClose((code?: number | null) => {
-        if (watcher) {
-          watcher.close();
-          watcher = null;
-        }
-        process.exit(code ?? 1); // Exit with server's code or 1 if null
-      });
-
-      serverHandle.onError((err: Error) => {
-        console.error('Failed to start dev server:', err);
-        if (watcher) {
-          watcher.close();
-          watcher = null;
-        }
-        process.exit(1);
-      });
-      // Wait for the server to be ready before syncing resources
-      const isReady = await serverHandle.waitUntilReady(15000);
-
-      if (!isReady) {
-        console.error(
-          '⚠️  Server startup timeout: The server is taking longer than expected to initialize.'
-        );
-
-        // Clean up and exit
-        if (serverHandle && !serverHandle.killed) {
-          serverHandle.kill();
-        }
-        process.exit(1);
-      }
-
-      // Initial resource sync and type generation
-      try {
-        const syncResult = await syncResources(this.server.projectRootDir);
-        if (syncResult.errorCount > 0) {
-          console.log(
-            `⚠️  Resource sync completed with ${syncResult.errorCount} errors:`
-          );
-          syncResult.errors.forEach((error) => {
-            console.log(`   • ${error.file}: ${error.message}`);
-          });
-        } else {
-          console.log(
-            `✅ Synced ${syncResult.uploadCount} resources (${syncResult.skipCount} up to date, ${syncResult.deleteCount} deleted)`
-          );
-        }
-        await generateTypes(this.server.projectRootDir);
-      } catch (error) {
-        console.error(
-          '❌ Error during resource synchronization:',
-          error instanceof Error ? error.message : String(error)
-        );
-        console.error(
-          '\nThe server is running, but resources may not be available to your brains.'
-        );
-        console.error(
-          '\nYou can manually sync resources by running: px resources sync'
-        );
-        // Don't exit here - let the server continue running
-      }
-
-      // Watcher setup - target the user's brains and resources directories
-      const watchPaths = [
-        path.join(brainsDir, '*.ts'),
-        path.join(resourcesDir, '**/*'),
-      ];
-
-      watcher = chokidar.watch(watchPaths, {
-        ignored: [/(^|[\/\\])\../, '**/node_modules/**'],
-        persistent: true,
-        ignoreInitial: true,
-        awaitWriteFinish: {
-          stabilityThreshold: 200,
-          pollInterval: 100,
-        },
-      });
-
-      const handleResourceChange = async () => {
-        await syncResources(this.server.projectRootDir);
-        await generateTypes(this.server.projectRootDir);
-      };
-
-      watcher
-        .on('add', async (filePath) => {
-          if (filePath.startsWith(resourcesDir)) {
-            await handleResourceChange();
-          } else if (filePath.startsWith(brainsDir)) {
-            // Call the dev server's watch method if it exists
-            if (this.server.watch) {
-              await this.server.watch(filePath, 'add');
-            }
-          }
-        })
-        .on('change', async (filePath) => {
-          if (filePath.startsWith(resourcesDir)) {
-            await handleResourceChange();
-          } else if (filePath.startsWith(brainsDir)) {
-            // Call the dev server's watch method if it exists
-            if (this.server.watch) {
-              await this.server.watch(filePath, 'change');
-            }
-          }
-        })
-        .on('unlink', async (filePath) => {
-          if (filePath.startsWith(resourcesDir)) {
-            await handleResourceChange();
-          } else if (filePath.startsWith(brainsDir)) {
-            // Call the dev server's watch method if it exists
-            if (this.server.watch) {
-              await this.server.watch(filePath, 'unlink');
-            }
-          }
-        })
-        .on('error', (error) => console.error(`Watcher error: ${error}`));
-    } catch (error) {
-      console.error('An error occurred during server startup:', error);
-      await cleanup(); // Attempt cleanup on error
-    }
-  }
-
-  private async handleDetached(argv: ArgumentsCamelCase<any>) {
-    // Get the path to the current CLI executable
-    const cliPath = process.argv[1];
-
-    // Build the command arguments
-    const args = ['server'];
-
-    // Add optional arguments if they were provided
-    if (argv.force) args.push('--force');
-    if (argv.port) args.push('--port', String(argv.port));
-    if (argv.logFile) args.push('--log-file', argv.logFile);
-
-    // Determine output file for logs
-    const logFile =
-      argv.logFile ||
-      path.join(this.server.projectRootDir, '.positronic-server.log');
-
-    // Open log file in append mode
-    const out = fs.openSync(logFile, 'a');
-    const err = fs.openSync(logFile, 'a');
-
-    // Spawn the detached process with a special environment variable to skip PID check
-    const child = spawn(process.execPath, [cliPath, ...args], {
-      detached: true,
-      stdio: ['ignore', out, err],
-      cwd: this.server.projectRootDir,
-      env: { ...process.env, POSITRONIC_DETACHED_CHILD: 'true' },
-    });
-
-    // Write the PID to a file for later reference
-    const pidFile = this.getPidFilePath(argv.port);
-    fs.writeFileSync(pidFile, String(child.pid));
-
-    // Detach from the child process
-    child.unref();
-
-    console.log(`✅ Server started in background (PID: ${child.pid})`);
-    console.log(`   Logs: ${logFile}`);
-    console.log(`   To stop: px server -k`);
-
-    // Exit the parent process
-    process.exit(0);
-  }
-
-  private getPidFilePath(port?: number): string {
-    if (port) {
-      return path.join(
-        this.server.projectRootDir,
-        `.positronic-server-${port}.pid`
-      );
-    }
-    return path.join(this.server.projectRootDir, '.positronic-server.pid');
-  }
-
-  private isProcessRunning(pid: number): boolean {
-    try {
-      // This sends signal 0 which doesn't kill the process, just checks if it exists
-      process.kill(pid, 0);
-      return true;
-    } catch (e) {
-      return false;
-    }
-  }
-
-  private async handleKill(argv: ArgumentsCamelCase<any>) {
-    const pidFile = path.join(this.server.projectRootDir, '.positronic-server.pid');
-    
-    if (!fs.existsSync(pidFile)) {
-      console.error(`❌ No default server is running`);
-      console.error(`   PID file not found: ${pidFile}`);
-      process.exit(1);
-    }
-
-    try {
-      const pid = parseInt(fs.readFileSync(pidFile, 'utf8').trim());
-      
-      if (!this.isProcessRunning(pid)) {
-        console.log('⚠️  Server process not found, removing stale PID file');
-        fs.unlinkSync(pidFile);
-        process.exit(0);
-      }
-
-      // Kill the process
-      process.kill(pid, 'SIGTERM');
-      
-      // Wait a moment to see if the process stops
-      let killed = false;
-      for (let i = 0; i < 10; i++) {
-        await new Promise(resolve => setTimeout(resolve, 100));
-        if (!this.isProcessRunning(pid)) {
-          killed = true;
-          break;
-        }
-      }
-
-      if (!killed) {
-        // Force kill if SIGTERM didn't work
-        console.log('⚠️  Server did not stop gracefully, forcing shutdown');
-        process.kill(pid, 'SIGKILL');
-      }
-
-      // Clean up PID file
-      if (fs.existsSync(pidFile)) {
-        fs.unlinkSync(pidFile);
-      }
-
-      console.log(`✅ Server stopped (PID: ${pid})`);
-      process.exit(0);
-    } catch (error) {
-      console.error('❌ Failed to kill server:', error instanceof Error ? error.message : String(error));
-      process.exit(1);
-    }
-  }
-}

package/src/commands/test-utils.ts

@@ -1,324 +0,0 @@
-import React from 'react';
-import { render } from 'ink-testing-library';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-import { fileURLToPath } from 'url';
-import process from 'process';
-import type { TestServerHandle } from '../test/test-dev-server.js';
-import { TestDevServer } from '../test/test-dev-server.js';
-import { buildCli } from '../cli.js';
-import type { PositronicDevServer } from '@positronic/spec';
-import caz from 'caz';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-// Singleton cache for the template to avoid repeated npm installs
-// This is shared across all tests in a test run and should NOT be deleted
-// by individual test cleanup. It's cleaned up automatically when the process exits.
-let cachedTemplatePath: string | null = null;
-
-async function getCachedTemplate(): Promise<string> {
-  // Check if cached template exists and is valid
-  if (cachedTemplatePath && fs.existsSync(cachedTemplatePath)) {
-    return cachedTemplatePath;
-  }
-  
-  // Create cache only once per test run
-  const devPath = path.resolve(__dirname, '../../../');
-  const originalTemplate = path.resolve(devPath, 'template-new-project');
-
-  // First, copy template to temp location so caz can mess with that copy
-  const tempCopyDir = fs.mkdtempSync(
-    path.join(os.tmpdir(), 'positronic-template-copy-')
-  );
-  fs.cpSync(originalTemplate, tempCopyDir, { recursive: true });
-
-  // Now generate the actual cached template in another temp directory
-  cachedTemplatePath = fs.mkdtempSync(
-    path.join(os.tmpdir(), 'positronic-cached-template-')
-  );
-
-  // Run caz once to generate a clean template
-  const cazOptions = {
-    name: 'test-project',
-    backend: 'none',
-    install: false,
-    claudemd: false, // Add the new claudemd option
-    force: true,
-  };
-
-  // Temporarily hijack all output streams to suppress caz output
-  const originalStdoutWrite = process.stdout.write;
-  const originalStderrWrite = process.stderr.write;
-  const originalConsoleLog = console.log;
-  const originalConsoleError = console.error;
-
-  process.stdout.write = () => true;
-  process.stderr.write = () => true;
-  console.log = () => {};
-  console.error = () => {};
-
-  try {
-    await caz.default(tempCopyDir, cachedTemplatePath, cazOptions);
-  } finally {
-    // Restore original output streams
-    process.stdout.write = originalStdoutWrite;
-    process.stderr.write = originalStderrWrite;
-    console.log = originalConsoleLog;
-    console.error = originalConsoleError;
-  }
-
-  // Clean up the temp copy directory
-  fs.rmSync(tempCopyDir, { recursive: true, force: true });
-
-  return cachedTemplatePath;
-}
-
-// Helper function to copy test resources from test data directory
-function copyTestResources(targetDir: string) {
-  const testDataPath = path.join(__dirname, '../test/data/resources');
-  const targetResourcesPath = path.join(targetDir, 'resources');
-
-  // Remove existing resources directory if it exists
-  if (fs.existsSync(targetResourcesPath)) {
-    fs.rmSync(targetResourcesPath, { recursive: true, force: true });
-  }
-
-  // Copy the test data resources
-  fs.cpSync(testDataPath, targetResourcesPath, { recursive: true });
-}
-
-// Helper function to create a minimal Positronic project structure
-export async function createMinimalProject(dir: string) {
-  // Get or create the cached template
-  const cachedTemplate = await getCachedTemplate();
-
-  // Copy the cached template to the target directory
-  fs.cpSync(cachedTemplate, dir, { recursive: true });
-  copyTestResources(dir);
-  // Update positronic.config.json with the correct project name if it exists
-  const configPath = path.join(dir, 'positronic.config.json');
-  if (fs.existsSync(configPath)) {
-    const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
-    config.name = 'test-project';
-    fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
-  }
-}
-
-export class TestEnv {
-  private serverHandle: TestServerHandle | null = null;
-  constructor(public server: TestDevServer) {}
-  get projectRootDir() {
-    return this.server.projectRootDir;
-  }
-
-  setup(setup: (tempDir: string) => void | Promise<void>) {
-    setup(this.projectRootDir);
-    return this;
-  }
-
-  async start() {
-    if (this.serverHandle) {
-      throw new Error('Server already started');
-    }
-    this.serverHandle = await this.server.start();
-    return async (argv: string[]) => {
-      if (!this.serverHandle) {
-        throw new Error('Server not started');
-      }
-      return px(argv, {
-        server: this.server,
-        projectRootDir: this.projectRootDir,
-      });
-    };
-  }
-
-  cleanup() {
-    fs.rmSync(this.projectRootDir, { recursive: true, force: true });
-  }
-
-  async stop() {
-    if (!this.serverHandle) {
-      throw new Error('Server not started');
-    }
-    this.serverHandle.kill();
-    this.serverHandle = null;
-    await this.server.stop();
-  }
-
-  async stopAndCleanup() {
-    await this.stop();
-    this.cleanup();
-  }
-}
-
-export async function createTestEnv(): Promise<TestEnv> {
-  const tempDir = fs.mkdtempSync(
-    path.join(os.tmpdir(), 'positronic-server-test-')
-  );
-  await createMinimalProject(tempDir);
-
-  // Create test dev server instance
-  const devServer = new TestDevServer(tempDir);
-
-  return new TestEnv(devServer);
-}
-
-// Helper function to wait for types file to contain specific content
-export async function waitForTypesFile(
-  typesPath: string,
-  expectedContent: string | string[],
-  maxWaitMs = 5000
-): Promise<string> {
-  const startTime = Date.now();
-  const contentToCheck = Array.isArray(expectedContent)
-    ? expectedContent
-    : [expectedContent];
-
-  while (Date.now() - startTime < maxWaitMs) {
-    if (fs.existsSync(typesPath)) {
-      const content = fs.readFileSync(typesPath, 'utf-8');
-      // Check if all expected content is present
-      if (contentToCheck.every((expected) => content.includes(expected))) {
-        return content;
-      }
-    }
-    await new Promise((resolve) => setTimeout(resolve, 100));
-  }
-
-  return '';
-}
-
-interface PxResult {
-  waitForOutput: (regex?: RegExp, maxTries?: number) => Promise<boolean>;
-  waitForTypesFile: (types: string | string[]) => Promise<string>;
-  instance: {
-    lastFrame: () => string | undefined;
-    rerender: (element: React.ReactElement) => void;
-    unmount: () => void;
-    frames: string[];
-    stdin: {
-      write: (data: string) => void;
-    };
-    stdout: {
-      lastFrame: () => string | undefined;
-      frames: string[];
-    };
-    stderr: {
-      lastFrame: () => string | undefined;
-      frames: string[];
-    };
-  };
-}
-
-export async function px(
-  argv: string[],
-  options: {
-    server?: PositronicDevServer;
-    projectRootDir?: string;
-    configDir?: string;
-  } = {}
-): Promise<PxResult> {
-  const { server, projectRootDir, configDir } = options;
-  let instance: ReturnType<typeof render> | null = null;
-  instance = await runCli(argv, {
-    server,
-    configDir,
-  });
-
-  // const { lastFrame, rerender, unmount, frames, stdin, stdout, stderr } = instance!;
-
-  return {
-    waitForOutput: async (regex?: RegExp, maxTries = 10) => {
-      if (!instance && !regex) {
-        return true;
-      }
-      if (!instance && regex) {
-        console.error('waitForOutput failed, instance is null');
-        return false;
-      }
-
-      let tries = 0;
-      while (tries < maxTries) {
-        const lastFrame = instance!.lastFrame() ?? '';
-        if (regex!.test(lastFrame)) {
-          return true;
-        }
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        tries++;
-      }
-      console.error('waitForOutput failed, last frame:', instance!.lastFrame());
-      return false;
-    },
-    waitForTypesFile: async (types: string | string[]) => {
-      if (projectRootDir) {
-        const typesPath = path.join(projectRootDir, 'resources.d.ts');
-        return waitForTypesFile(typesPath, types, 1000);
-      }
-      console.warn(
-        "waitForTypesFile didn't wait for anything, projectRootDir is not set"
-      );
-      return '';
-    },
-    instance: instance
-      ? {
-          lastFrame: instance.lastFrame,
-          rerender: instance.rerender,
-          unmount: instance.unmount,
-          frames: instance.frames,
-          stdin: instance.stdin,
-          stdout: instance.stdout,
-          stderr: instance.stderr,
-        }
-      : {
-          lastFrame: () => undefined,
-          rerender: () => {},
-          unmount: () => {},
-          frames: [],
-          stdin: { write: () => {} },
-          stdout: { lastFrame: () => undefined, frames: [] },
-          stderr: { lastFrame: () => undefined, frames: [] },
-        },
-  };
-}
-
-// Helper function to test CLI commands with ink-testing-library
-async function runCli(
-  argv: string[],
-  options: {
-    server?: PositronicDevServer;
-    configDir?: string;
-  } = {}
-): Promise<ReturnType<typeof render> | null> {
-  let capturedElement: ReturnType<typeof render> | null = null;
-  const { configDir, server } = options;
-  const mockRenderFn = (element: React.ReactElement) => {
-    capturedElement = render(element);
-    return capturedElement;
-  };
-
-  // Setup project-specific environment if configDir is provided
-  if (configDir) {
-    process.env.POSITRONIC_CONFIG_DIR = configDir;
-  }
-
-  try {
-    const testCli = buildCli({
-      argv,
-      server,
-      exitProcess: false,
-      render: mockRenderFn,
-    });
-
-    await testCli.parse();
-
-    return capturedElement;
-  } finally {
-    // Cleanup project-specific environment if configDir was provided
-    if (configDir) {
-      delete process.env.POSITRONIC_CONFIG_DIR;
-    }
-  }
-}