hostfn 0.1.5 → 0.1.7

package/README.md

@@ -178,7 +178,7 @@ Create `hostfn.config.json` in your project root:
   "build": {
     "command": "npm run build",
     "directory": "dist",
-    "nodeModules": "production"
+    "nodeModules": "all"
   },
   "start": {
     "command": "npm start",
@@ -1133,4 +1133,3 @@ MIT
 
 
 
-

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "hostfn",
-  "version": "0.1.5",
-  "license": "Apache-2.0",
+  "version": "0.1.7",
+  "license": "MIT",
   "description": "Universal application deployment CLI",
   "type": "module",
   "bin": {
@@ -21,12 +21,14 @@
     "chalk": "^5.3.0",
     "ora": "^7.0.1",
     "inquirer": "^9.2.12",
+    "semver": "^7.7.2",
     "zod": "^3.22.4",
     "ssh2": "^1.15.0",
     "dotenv": "^16.3.1",
     "execa": "^8.0.1"
   },
   "devDependencies": {
+    "@types/semver": "^7.7.1",
     "@types/node": "^20.10.0",
     "@types/ssh2": "^1.15.0",
     "@types/inquirer": "^9.0.7",
@@ -39,7 +41,8 @@
   "author": "21n",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/21nCo/super-functions.git"
+    "url": "git+https://github.com/21nCo/super-functions.git",
+    "directory": "hostfn/cli"
   },
   "bugs": {
     "url": "https://github.com/21nCo/super-functions/issues"
@@ -50,5 +53,13 @@
   ],
   "engines": {
     "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "superfunctions": {
+    "initFunction": "hostFn",
+    "schemaVersion": 1,
+    "namespace": "hostfn"
   }
 }

package/src/__tests__/core/sync.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, it, vi, beforeEach } from 'vitest';
+import { FileSync } from '../../core/sync.js';
+
+const { execaMock } = vi.hoisted(() => ({
+  execaMock: vi.fn(),
+}));
+
+vi.mock('execa', () => ({
+  execa: execaMock,
+}));
+
+describe('FileSync.syncLocal', () => {
+  beforeEach(() => {
+    execaMock.mockReset();
+    execaMock.mockResolvedValue({
+      exitCode: 0,
+      stdout: '',
+      stderr: '',
+    });
+  });
+
+  it('applies include filters before exclude filters so rsync overrides work', async () => {
+    await FileSync.syncLocal('/tmp/source', '/tmp/destination', {
+      include: ['.env.production'],
+      exclude: ['.env.*'],
+    });
+
+    expect(execaMock).toHaveBeenCalledWith(
+      'rsync',
+      expect.arrayContaining([
+        '--include',
+        '.env.production',
+        '--exclude',
+        '.env.*',
+      ]),
+      expect.any(Object),
+    );
+
+    const args = execaMock.mock.calls[0][1] as string[];
+    expect(args.indexOf('--include')).toBeLessThan(args.indexOf('--exclude'));
+  });
+});

package/src/__tests__/core/workspace.test.ts

@@ -0,0 +1,180 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { WorkspaceManager } from '../../core/workspace.js';
+
+const execSyncMock = vi.fn();
+
+vi.mock('child_process', () => ({
+  execSync: execSyncMock,
+}));
+
+describe('WorkspaceManager.generateLockfile', () => {
+  let rootDir: string;
+  let serviceDir: string;
+  let targetDir: string;
+
+  beforeEach(() => {
+    execSyncMock.mockReset();
+    rootDir = mkdtempSync(join(tmpdir(), 'hostfn-workspace-root-'));
+    serviceDir = join(rootDir, 'services', 'api');
+    targetDir = mkdtempSync(join(tmpdir(), 'hostfn-workspace-target-'));
+
+    mkdirSync(serviceDir, { recursive: true });
+
+    writeFileSync(
+      join(rootDir, 'package.json'),
+      JSON.stringify({
+        private: true,
+        workspaces: ['services/*'],
+      }, null, 2),
+    );
+
+    writeFileSync(
+      join(serviceDir, 'package.json'),
+      JSON.stringify({
+        name: '@hostfn/api',
+        dependencies: {
+          commander: '^12.0.0',
+          chalk: '^5.0.0',
+          'zero-lib': '^0.2.3',
+        },
+      }, null, 2),
+    );
+
+    writeFileSync(
+      join(rootDir, 'package-lock.json'),
+      JSON.stringify({
+        name: 'workspace-root',
+        lockfileVersion: 3,
+        packages: {
+          '': { name: 'workspace-root' },
+          'node_modules/commander': { version: '4.1.1', name: 'commander' },
+          'services/api/node_modules/commander': { version: '12.1.0', name: 'commander' },
+          'node_modules/chalk': { version: '5.3.0', name: 'chalk' },
+          'node_modules/zero-lib': { version: '0.5.0', name: 'zero-lib' },
+          'services/api/node_modules/zero-lib': { version: '0.2.8', name: 'zero-lib' },
+        },
+      }, null, 2),
+    );
+
+    writeFileSync(
+      join(targetDir, 'package.json'),
+      JSON.stringify({
+        name: '@hostfn/api',
+        dependencies: {
+          commander: '^12.0.0',
+          chalk: '^5.0.0',
+          'zero-lib': '^0.2.3',
+        },
+      }, null, 2),
+    );
+  });
+
+  afterEach(() => {
+    rmSync(rootDir, { recursive: true, force: true });
+    rmSync(targetDir, { recursive: true, force: true });
+  });
+
+  it('pins package.json to the exact workspace-scoped versions used for lockfile generation', async () => {
+    execSyncMock.mockImplementation(() => {
+      const pinnedPackageJson = JSON.parse(readFileSync(join(targetDir, 'package.json'), 'utf-8'));
+      expect(pinnedPackageJson.dependencies.commander).toBe('12.1.0');
+      expect(pinnedPackageJson.dependencies.chalk).toBe('5.3.0');
+      expect(pinnedPackageJson.dependencies['zero-lib']).toBe('0.2.8');
+    });
+
+    const manager = new WorkspaceManager();
+    await manager.detectWorkspace(serviceDir);
+    await manager.generateLockfile(targetDir, serviceDir);
+
+    expect(execSyncMock).toHaveBeenCalledWith(
+      'npm install --package-lock-only --ignore-scripts',
+      expect.objectContaining({
+        cwd: targetDir,
+        stdio: 'ignore',
+      }),
+    );
+
+    const deployedPackageJson = JSON.parse(readFileSync(join(targetDir, 'package.json'), 'utf-8'));
+    expect(deployedPackageJson.dependencies.commander).toBe('12.1.0');
+    expect(deployedPackageJson.dependencies.chalk).toBe('5.3.0');
+    expect(deployedPackageJson.dependencies['zero-lib']).toBe('0.2.8');
+  });
+});
+
+describe('WorkspaceManager.rewritePackageJson', () => {
+  let rootDir: string;
+  let serviceDir: string;
+  let toolingDir: string;
+  let targetDir: string;
+
+  beforeEach(async () => {
+    rootDir = mkdtempSync(join(tmpdir(), 'hostfn-workspace-root-'));
+    serviceDir = join(rootDir, 'services', 'api');
+    toolingDir = join(rootDir, 'services', 'tooling');
+    targetDir = mkdtempSync(join(tmpdir(), 'hostfn-workspace-target-'));
+
+    mkdirSync(serviceDir, { recursive: true });
+    mkdirSync(toolingDir, { recursive: true });
+
+    writeFileSync(
+      join(rootDir, 'package.json'),
+      JSON.stringify({
+        private: true,
+        workspaces: ['services/*'],
+      }, null, 2),
+    );
+
+    writeFileSync(
+      join(toolingDir, 'package.json'),
+      JSON.stringify({
+        name: '@hostfn/tooling',
+        version: '1.0.0',
+      }, null, 2),
+    );
+
+    writeFileSync(
+      join(serviceDir, 'package.json'),
+      JSON.stringify({
+        name: '@hostfn/api',
+        dependencies: {
+          '@hostfn/tooling': 'workspace:*',
+        },
+        devDependencies: {
+          '@hostfn/tooling': 'workspace:*',
+        },
+      }, null, 2),
+    );
+
+    writeFileSync(
+      join(targetDir, 'package.json'),
+      JSON.stringify({
+        name: '@hostfn/api',
+        dependencies: {
+          '@hostfn/tooling': 'workspace:*',
+        },
+        devDependencies: {
+          '@hostfn/tooling': 'workspace:*',
+        },
+      }, null, 2),
+    );
+  });
+
+  afterEach(() => {
+    rmSync(rootDir, { recursive: true, force: true });
+    rmSync(targetDir, { recursive: true, force: true });
+  });
+
+  it('preserves workspace devDependencies as file references in the deployment bundle', async () => {
+    const manager = new WorkspaceManager();
+    await manager.detectWorkspace(serviceDir);
+
+    manager.rewritePackageJson(serviceDir, targetDir);
+
+    const rewrittenPackageJson = JSON.parse(readFileSync(join(targetDir, 'package.json'), 'utf-8'));
+    expect(rewrittenPackageJson.dependencies['@hostfn/tooling']).toBe('file:./__workspace__/@hostfn/tooling');
+    expect(rewrittenPackageJson.devDependencies['@hostfn/tooling']).toBe('file:./__workspace__/@hostfn/tooling');
+  });
+});

package/src/commands/deploy.ts

@@ -1,7 +1,7 @@
 import ora from 'ora';
 import { tmpdir } from 'os';
 import { join } from 'path';
-import { mkdtempSync, rmSync, cpSync } from 'fs';
+import { mkdtempSync, rmSync, cpSync, existsSync } from 'fs';
 import { Logger } from '../utils/logger.js';
 import { ConfigLoader } from '../config/loader.js';
 import { createSSHConnection, SSHConnection } from '../core/ssh.js';
@@ -25,6 +25,37 @@ interface DeployOptions {
   all?: boolean;
 }
 
+interface InstallPlan {
+  nodeModulesMode: 'all' | 'production' | 'none';
+  useCi: boolean;
+  installCmd: string | null;
+}
+
+function computeInstallPlan(
+  config: HostfnConfig,
+  hasLockFile: boolean,
+): InstallPlan {
+  const nodeModulesMode =
+    config.build?.nodeModules ?? (config.build?.command ? 'all' : 'production');
+
+  const installCmd =
+    nodeModulesMode === 'none'
+      ? null
+      : hasLockFile
+        ? (nodeModulesMode === 'all'
+            ? 'npm ci --install-links'
+            : 'npm ci --production --install-links')
+        : (nodeModulesMode === 'all'
+            ? 'npm install --install-links'
+            : 'npm install --production --install-links');
+
+  return {
+    nodeModulesMode,
+    useCi: hasLockFile,
+    installCmd,
+  };
+}
+
 export async function deployCommand(
   environment: string,
   options: DeployOptions
@@ -310,8 +341,16 @@ async function deploySingleService(
     Logger.section('Pre-flight Checks');
     Logger.br();
 
-    // For local mode, skip rsync and SSH connection
+    // Local mode still relies on rsync so include the same pre-flight check.
     if (options.local) {
+      const rsyncSpinner = ora('Checking rsync availability...').start();
+      const hasRsync = await FileSync.isRsyncAvailable();
+      if (!hasRsync) {
+        rsyncSpinner.fail('rsync not installed');
+        throw new Error('rsync is required for deployment. Please install it first.');
+      }
+      rsyncSpinner.succeed('rsync available');
+
       const localSpinner = ora('Initializing local deployment...').start();
       ssh = new LocalExecutor();
       localSpinner.succeed('Local mode ready');
@@ -404,6 +443,19 @@ async function deploySingleService(
         bundleSpinner.text = 'Bundling workspace dependencies...';
         await workspaceManager.bundleWorkspaceDependencies(sourceDir, bundleDir);
         
+        // Rewrite package.json to use file: references for workspace deps
+        workspaceManager.rewritePackageJson(sourceDir, bundleDir);
+
+        const { nodeModulesMode } = computeInstallPlan(
+          config,
+          existsSync(join(bundleDir, 'package-lock.json')),
+        );
+
+        if (nodeModulesMode !== 'none') {
+          bundleSpinner.text = 'Generating lockfile...';
+          await workspaceManager.generateLockfile(bundleDir, sourceDir);
+        }
+        
         bundleSpinner.succeed('Workspace dependencies bundled');
         Logger.br();
         
@@ -416,84 +468,58 @@ async function deploySingleService(
     Logger.br();
 
     if (options.local) {
-      // Local mode: copy files directly
+      // Local mode: use rsync locally so include/exclude behavior stays aligned
+      // with the remote deploy path.
       const syncSpinner = ora('Copying files locally...').start();
-      
-      cpSync(actualSourceDir, remoteDir, {
-        recursive: true,
-        filter: (src) => {
-          const relativePath = src.replace(actualSourceDir, '');
-          const excludePatterns = config.sync?.exclude || [
-            'node_modules',
-            '.git',
-            'dist',
-            '.env',
-            '*.log',
-          ];
-          return !excludePatterns.some(pattern => relativePath.includes(pattern));
-        },
+      const rawExcludes = config.sync?.exclude || [
+        'node_modules',
+        '.git',
+        '.github',
+        'dist',
+        'build',
+        '.env',
+        '.env.*',
+        '*.log',
+        '.turbo',
+        '.wrangler',
+      ];
+      const localExcludes = bundleDir
+        ? rawExcludes.map((pattern) => (pattern === 'dist' || pattern === 'build') ? `/${pattern}` : pattern)
+        : rawExcludes;
+
+      await FileSync.syncLocal(actualSourceDir, remoteDir, {
+        exclude: localExcludes,
+        include: config.sync?.include,
+        verbose: false,
       });
       
       syncSpinner.succeed('Files copied successfully');
-      
-      // Copy workspace dependencies if they exist
-      if (bundleDir) {
-        const bundledNodeModules = join(bundleDir, 'node_modules');
-        const { existsSync } = await import('fs');
-        
-        if (existsSync(bundledNodeModules)) {
-          const uploadSpinner = ora('Copying workspace dependencies...').start();
-          cpSync(bundledNodeModules, join(remoteDir, 'node_modules'), { recursive: true });
-          uploadSpinner.succeed('Workspace dependencies copied');
-        }
-      }
     } else {
       // Remote mode: use rsync
       const syncSpinner = ora('Syncing files to server...').start();
+
+      // When syncing a workspace bundle, anchor 'dist' to root (/dist) so it only
+      // excludes the service's own dist folder and not workspace deps' compiled output
+      // (e.g. __workspace__/@21n/email/dist which is needed for type declarations).
+      const rawExcludes = config.sync?.exclude || [
+        'node_modules', '.git', '.github', 'dist', 'build', '.env', '.env.*', '*.log', '.turbo', '.wrangler',
+      ];
+      const syncExcludes = bundleDir
+        ? rawExcludes.map(p => (p === 'dist' || p === 'build') ? `/${p}` : p)
+        : rawExcludes;
       
       await FileSync.sync(
         actualSourceDir,
         remoteDir,
         host,
         {
-          exclude: config.sync?.exclude || [
-            'node_modules',
-            '.git',
-            'dist',
-            '.env',
-            '*.log',
-          ],
+          exclude: syncExcludes,
+          include: config.sync?.include,
           verbose: false,
         }
       );
 
       syncSpinner.succeed('Files synced successfully');
-      
-      // Upload bundled workspace dependencies if they exist (before npm install)
-      if (bundleDir) {
-        const bundledNodeModules = join(bundleDir, 'node_modules');
-        const { existsSync } = await import('fs');
-        
-        if (existsSync(bundledNodeModules)) {
-          Logger.section('Uploading Workspace Dependencies');
-          Logger.br();
-          
-          const uploadSpinner = ora('Uploading bundled workspace dependencies...').start();
-          
-          await FileSync.sync(
-            bundledNodeModules,
-            join(remoteDir, 'node_modules'),
-            host,
-            {
-              exclude: [],
-              verbose: false,
-            }
-          );
-          
-          uploadSpinner.succeed('Workspace dependencies uploaded');
-          Logger.br();
-        }
-      }
     }
     
     Logger.br();
@@ -504,30 +530,31 @@ async function deploySingleService(
 
     // Install dependencies
     const installSpinner = ora('Installing dependencies...').start();
-    
+
     // Check if package-lock.json exists, use npm ci if available, otherwise npm install
     const lockFileCheck = await ssh.exec(
       'test -f package-lock.json && echo "exists"',
       { cwd: remoteDir, streaming: false }
     );
     const hasLockFile = lockFileCheck.stdout.trim() === 'exists';
-    
-    // If build command exists, install all dependencies (including dev); otherwise production only
-    const needsDevDeps = !!config.build?.command;
-    const installCmd = hasLockFile 
-      ? (needsDevDeps ? 'npm ci --install-links' : 'npm ci --production --install-links')
-      : (needsDevDeps ? 'npm install --install-links' : 'npm install --production --install-links');
-    
-    const installResult = await ssh.exec(
-      installCmd,
-      { cwd: remoteDir, streaming: false }
-    );
-    
-    if (installResult.exitCode !== 0) {
-      installSpinner.fail('Dependency installation failed');
-      throw new Error(`${installCmd} failed: ${installResult.stderr}`);
+
+    const { installCmd } = computeInstallPlan(config, hasLockFile);
+
+    if (installCmd) {
+      const installResult = await ssh.exec(
+        installCmd,
+        { cwd: remoteDir, streaming: false }
+      );
+
+      if (installResult.exitCode !== 0) {
+        installSpinner.fail('Dependency installation failed');
+        const errorOutput = installResult.stderr || installResult.stdout;
+        throw new Error(`${installCmd} failed: ${errorOutput}`);
+      }
+      installSpinner.succeed('Dependencies installed');
+    } else {
+      installSpinner.info('Skipping dependency installation (build.nodeModules=none)');
     }
-    installSpinner.succeed('Dependencies installed');
 
     // Build application
     if (config.build?.command) {
@@ -684,8 +711,9 @@ EOF`);
 
     const healthSpinner = ora('Waiting for service to be ready...').start();
     const healthPath = config.health?.path || '/health';
+    const timeout = config.health?.timeout || 60;
     const retries = config.health?.retries || 10;
-    const interval = config.health?.interval || 3000;
+    const interval = config.health?.interval || 3;
     
     let healthy = false;
     for (let i = 0; i < retries; i++) {
@@ -693,7 +721,7 @@ EOF`);
       
       // Check health via SSH using curl on localhost
       const healthCheckResult = await ssh.exec(
-        `curl -sf http://localhost:${envConfig.port}${healthPath}`,
+        `curl --max-time ${timeout} -sf http://localhost:${envConfig.port}${healthPath}`,
         { cwd: remoteDir, streaming: false }
       );
       
@@ -704,7 +732,7 @@ EOF`);
       }
       
       if (i < retries - 1) {
-        await new Promise(resolve => setTimeout(resolve, interval));
+        await new Promise(resolve => setTimeout(resolve, interval * 1000));
       }
     }
     
@@ -804,8 +832,19 @@ async function dryRunDeploy(
   Logger.log(`   → Exclude: ${config.sync?.exclude?.join(', ')}`);
   Logger.br();
   
+  const hasLocalLockFile = existsSync(join(process.cwd(), 'package-lock.json'));
+  const workspaceManager = new WorkspaceManager();
+  const isWorkspace = await workspaceManager.detectWorkspace(process.cwd());
+  const hasBundledWorkspaceDeps =
+    isWorkspace && workspaceManager.getWorkspaceDependencies(process.cwd()).length > 0;
+  const { installCmd } = computeInstallPlan(config, hasLocalLockFile || hasBundledWorkspaceDeps);
+
   Logger.log('3. Remote Build');
-  Logger.log('   → npm ci --production');
+  if (installCmd) {
+    Logger.log(`   → ${installCmd}`);
+  } else {
+    Logger.log('   → Skip dependency installation (build.nodeModules=none)');
+  }
   if (config.build?.command) {
     Logger.log(`   → ${config.build.command}`);
   }

package/src/commands/init.ts

@@ -134,7 +134,7 @@ export async function initCommand(): Promise<void> {
     build: {
       command: buildAnswers.buildCommand,
       directory: 'dist',
-      nodeModules: 'production',
+      nodeModules: 'all',
     },
     start: {
       command: buildAnswers.startCommand,

package/src/config/loader.ts

@@ -37,7 +37,7 @@ export class ConfigLoader {
     const result = HostfnConfigSchema.safeParse(config);
 
     if (!result.success) {
-      const errors = result.error.errors
+      const errors = result.error.issues
         .map(err => `  - ${err.path.join('.')}: ${err.message}`)
         .join('\n');
       

package/src/config/schema.ts

@@ -19,7 +19,7 @@ export type EnvironmentConfig = z.infer<typeof EnvironmentConfigSchema>;
 export const BuildConfigSchema = z.object({
   command: z.string().describe('Build command to run'),
   directory: z.string().default('dist').describe('Output directory'),
-  nodeModules: z.enum(['all', 'production', 'none']).default('production'),
+  nodeModules: z.enum(['all', 'production', 'none']).optional(),
 }).optional();
 
 export type BuildConfig = z.infer<typeof BuildConfigSchema>;

package/src/core/ssh.ts

@@ -35,6 +35,8 @@ export class SSHConnection {
       host: options.host,
       port: options.port || 22,
       username: options.username,
+      keepaliveInterval: 30000,  // Send keepalive every 30s to survive long npm installs
+      keepaliveCountMax: 10,
     };
 
     // Add authentication method