@positronic/cli 0.0.2

package/src/commands/server.ts

@@ -0,0 +1,353 @@
+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

@@ -0,0 +1,324 @@
+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;
+    }
+  }
+}