@stagepass/cli 1.0.0 → 1.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stagepass/cli",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Local Development Orchestrator for Webflow",
   "type": "module",
   "main": "bin/index.js",
@@ -12,7 +12,10 @@
     "src"
   ],
   "scripts": {
-    "start": "node bin/index.js"
+    "start": "node bin/index.js",
+    "build": "echo 'No build step required for CLI package'",
+    "test": "vitest run",
+    "test:watch": "vitest"
   },
   "keywords": [
     "webflow",
@@ -38,6 +41,9 @@
     "ora": "^7.0.1",
     "sudo-prompt": "^9.2.1"
   },
+  "devDependencies": {
+    "vitest": "^2.1.0"
+  },
   "engines": {
     "node": ">=18.0.0"
   }

package/src/commands/__tests__/link.test.js

@@ -0,0 +1,113 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { link } from '../link.js';
+import fs from 'fs-extra';
+import { execa } from 'execa';
+import os from 'os';
+import path from 'path';
+
+// Mock dependencies
+vi.mock('fs-extra');
+vi.mock('execa');
+vi.mock('ora', () => ({
+  default: vi.fn(() => ({
+    start: vi.fn(() => ({
+      succeed: vi.fn(),
+      fail: vi.fn(),
+      warn: vi.fn(),
+    })),
+  })),
+}));
+
+describe('link command', () => {
+  const mockCaddyDir = path.join(os.homedir(), '.stagepass');
+  const mockCaddyFile = path.join(mockCaddyDir, 'Caddyfile');
+  const originalCwd = process.cwd;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    process.cwd = vi.fn(() => '/test/project');
+  });
+
+  afterEach(() => {
+    process.cwd = originalCwd;
+  });
+
+  it('should use current directory name as domain if not provided', async () => {
+    fs.pathExists.mockResolvedValue(false);
+    fs.ensureDir.mockResolvedValue();
+    fs.writeFile.mockResolvedValue();
+    execa.mockResolvedValue({});
+
+    await link(undefined, {});
+
+    expect(fs.writeFile).toHaveBeenCalled();
+    const writtenContent = fs.writeFile.mock.calls[0][1];
+    expect(writtenContent).toContain('project.sp');
+  });
+
+  it('should add .sp extension if missing', async () => {
+    fs.pathExists.mockResolvedValue(false);
+    fs.ensureDir.mockResolvedValue();
+    fs.writeFile.mockResolvedValue();
+    execa.mockResolvedValue({});
+
+    await link('my-domain', {});
+
+    const writtenContent = fs.writeFile.mock.calls[0][1];
+    expect(writtenContent).toContain('my-domain.sp');
+  });
+
+  it('should replace existing domain block if already linked', async () => {
+    const existingContent = `
+# START: test.sp
+test.sp {
+    root * "/old/path"
+}
+# END: test.sp
+`;
+
+    fs.pathExists.mockResolvedValue(true);
+    fs.readFile.mockResolvedValue(existingContent);
+    fs.ensureDir.mockResolvedValue();
+    fs.writeFile.mockResolvedValue();
+    execa.mockResolvedValue({});
+
+    await link('test', {});
+
+    expect(fs.writeFile).toHaveBeenCalled();
+    const writtenContent = fs.writeFile.mock.calls[0][1];
+    expect(writtenContent).toContain('test.sp');
+    expect(writtenContent).toContain('/test/project');
+    // Should not contain old path
+    expect(writtenContent).not.toContain('/old/path');
+  });
+
+  it('should append new domain block if not exists', async () => {
+    const existingContent = '# Some existing config';
+    
+    fs.pathExists.mockResolvedValue(true);
+    fs.readFile.mockResolvedValue(existingContent);
+    fs.ensureDir.mockResolvedValue();
+    fs.writeFile.mockResolvedValue();
+    execa.mockResolvedValue({});
+
+    await link('new-domain', {});
+
+    expect(fs.writeFile).toHaveBeenCalled();
+    const writtenContent = fs.writeFile.mock.calls[0][1];
+    expect(writtenContent).toContain('Some existing config');
+    expect(writtenContent).toContain('new-domain.sp');
+  });
+
+  it('should handle Caddy reload failure gracefully', async () => {
+    fs.pathExists.mockResolvedValue(false);
+    fs.ensureDir.mockResolvedValue();
+    fs.writeFile.mockResolvedValue();
+    execa.mockRejectedValue(new Error('Caddy not running'));
+
+    await link('test', {});
+
+    // Should still write config even if reload fails
+    expect(fs.writeFile).toHaveBeenCalled();
+  });
+});

package/src/commands/__tests__/reload.test.js

@@ -0,0 +1,72 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { reload } from '../reload.js';
+import fs from 'fs-extra';
+import { execa } from 'execa';
+import os from 'os';
+import path from 'path';
+
+// Mock dependencies
+vi.mock('fs-extra');
+vi.mock('execa');
+vi.mock('ora', () => ({
+  default: vi.fn(() => ({
+    start: vi.fn(() => ({
+      succeed: vi.fn(),
+      fail: vi.fn(),
+    })),
+  })),
+}));
+
+describe('reload command', () => {
+  const mockCaddyDir = path.join(os.homedir(), '.stagepass');
+  const mockCaddyFile = path.join(mockCaddyDir, 'Caddyfile');
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should reload Caddy when Caddyfile exists', async () => {
+    fs.pathExists.mockResolvedValue(true);
+    execa.mockResolvedValue({});
+
+    await reload({});
+
+    expect(execa).toHaveBeenCalledWith(
+      'caddy',
+      ['reload', '--config', mockCaddyFile],
+      expect.any(Object)
+    );
+  });
+
+  it('should fail if Caddyfile does not exist', async () => {
+    fs.pathExists.mockResolvedValue(false);
+
+    await reload({});
+
+    expect(execa).not.toHaveBeenCalled();
+  });
+
+  it('should fail if Caddy is not installed', async () => {
+    fs.pathExists.mockResolvedValue(true);
+    execa.mockRejectedValueOnce(new Error('caddy: command not found'));
+
+    await reload({});
+
+    // Should not attempt reload if version check fails
+    expect(execa).toHaveBeenCalledTimes(1);
+    expect(execa).toHaveBeenCalledWith('caddy', ['version'], expect.any(Object));
+  });
+
+  it('should use verbose stdio when verbose option is set', async () => {
+    fs.pathExists.mockResolvedValue(true);
+    execa.mockResolvedValue({});
+
+    await reload({ verbose: true });
+
+    expect(execa).toHaveBeenCalledWith(
+      'caddy',
+      ['reload', '--config', mockCaddyFile],
+      expect.objectContaining({ stdio: 'inherit' })
+    );
+  });
+});

package/src/commands/__tests__/unlink.test.js

@@ -0,0 +1,90 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { unlink } from '../unlink.js';
+import fs from 'fs-extra';
+import { execa } from 'execa';
+import os from 'os';
+import path from 'path';
+
+// Mock dependencies
+vi.mock('fs-extra');
+vi.mock('execa');
+vi.mock('ora', () => ({
+  default: vi.fn(() => ({
+    start: vi.fn(() => ({
+      succeed: vi.fn(),
+      fail: vi.fn(),
+      warn: vi.fn(),
+    })),
+  })),
+}));
+
+describe('unlink command', () => {
+  const mockCaddyDir = path.join(os.homedir(), '.stagepass');
+  const mockCaddyFile = path.join(mockCaddyDir, 'Caddyfile');
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should remove domain block from Caddyfile', async () => {
+    const existingContent = `
+# START: test.sp
+test.sp {
+    root * "/some/path"
+}
+# END: test.sp
+
+# START: other.sp
+other.sp {
+    root * "/other/path"
+}
+# END: other.sp
+`;
+
+    fs.pathExists.mockResolvedValue(true);
+    fs.readFile.mockResolvedValue(existingContent);
+    fs.writeFile.mockResolvedValue();
+    execa.mockResolvedValue({});
+
+    await unlink('test', {});
+
+    expect(fs.writeFile).toHaveBeenCalled();
+    const writtenContent = fs.writeFile.mock.calls[0][1];
+    expect(writtenContent).not.toContain('test.sp');
+    expect(writtenContent).toContain('other.sp');
+  });
+
+  it('should use current directory name if domain not provided', async () => {
+    const originalCwd = process.cwd;
+    process.cwd = vi.fn(() => '/test/my-project');
+
+    const existingContent = `
+# START: my-project.sp
+my-project.sp {
+    root * "/test/my-project"
+}
+# END: my-project.sp
+`;
+
+    fs.pathExists.mockResolvedValue(true);
+    fs.readFile.mockResolvedValue(existingContent);
+    fs.writeFile.mockResolvedValue();
+    execa.mockResolvedValue({});
+
+    await unlink(undefined, {});
+
+    const writtenContent = fs.writeFile.mock.calls[0][1];
+    expect(writtenContent).not.toContain('my-project.sp');
+
+    process.cwd = originalCwd;
+  });
+
+  it('should fail if Caddyfile does not exist', async () => {
+    fs.pathExists.mockResolvedValue(false);
+
+    await unlink('test', {});
+
+    expect(fs.writeFile).not.toHaveBeenCalled();
+    expect(execa).not.toHaveBeenCalled();
+  });
+});

package/src/commands/link.js

@@ -36,11 +36,22 @@ export async function link(domain, options = {}) {
       const newBlock = `
 ${blockStart}
 ${targetDomain} {
+    @options method OPTIONS
+    handle @options {
+        header Access-Control-Allow-Origin *
+        header Access-Control-Allow-Methods *
+        header Access-Control-Allow-Headers *
+        header Access-Control-Max-Age 86400
+        respond 204
+    }
+
     root * "${currentDir}"
     php_fastcgi 127.0.0.1:9000
     file_server
     tls internal
     header Access-Control-Allow-Origin *
+    header Access-Control-Allow-Methods *
+    header Access-Control-Allow-Headers *
 }
 ${blockEnd}`;