-
Manage Subscription
+
+ {isCancelAtPeriodEnd ? 'Restore Subscription' : 'Manage Subscription'}
+
{isCancelAtPeriodEnd && (
You'll keep access until {formatDate(periodEndDate)}
@@ -217,10 +226,12 @@ export function CancelSubscription({ subscription, subscriptionData }: CancelSub
'h-8 rounded-[8px] font-medium text-xs transition-all duration-200',
error
? 'border-red-500 text-red-500 dark:border-red-500 dark:text-red-500'
- : 'text-muted-foreground hover:border-red-500 hover:bg-red-500 hover:text-white dark:hover:border-red-500 dark:hover:bg-red-500'
+ : isCancelAtPeriodEnd
+ ? 'text-muted-foreground hover:border-green-500 hover:bg-green-500 hover:text-white dark:hover:border-green-500 dark:hover:bg-green-500'
+ : 'text-muted-foreground hover:border-red-500 hover:bg-red-500 hover:text-white dark:hover:border-red-500 dark:hover:bg-red-500'
)}
>
- {error ? 'Error' : 'Manage'}
+ {error ? 'Error' : isCancelAtPeriodEnd ? 'Restore' : 'Manage'}
@@ -228,11 +239,11 @@ export function CancelSubscription({ subscription, subscriptionData }: CancelSub
- {isCancelAtPeriodEnd ? 'Manage' : 'Cancel'} {subscription.plan} subscription?
+ {isCancelAtPeriodEnd ? 'Restore' : 'Cancel'} {subscription.plan} subscription?
{isCancelAtPeriodEnd
- ? 'Your subscription is set to cancel at the end of the billing period. You can reactivate it or manage other settings.'
+ ? 'Your subscription is set to cancel at the end of the billing period. Would you like to keep your subscription active?'
: `You'll be redirected to Stripe to manage your subscription. You'll keep access until ${formatDate(
periodEndDate
)}, then downgrade to free plan.`}{' '}
@@ -260,38 +271,23 @@ export function CancelSubscription({ subscription, subscriptionData }: CancelSub
setIsDialogOpen(false) : handleKeep}
disabled={isLoading}
>
- Keep Subscription
+ {isCancelAtPeriodEnd ? 'Cancel' : 'Keep Subscription'}
{(() => {
const subscriptionStatus = getSubscriptionStatus()
- if (
- subscriptionStatus.isPaid &&
- (activeOrganization?.id
- ? useOrganizationStore.getState().subscriptionData?.cancelAtPeriodEnd
- : false)
- ) {
+ if (subscriptionStatus.isPaid && isCancelAtPeriodEnd) {
return (
-
-
-
-
-
-
- Subscription will be cancelled at end of billing period
-
-
-
+
+ {isLoading ? 'Restoring...' : 'Restore Subscription'}
+
)
}
return (
diff --git a/apps/sim/app/workspace/[workspaceId]/w/components/sidebar/components/settings-modal/components/subscription/subscription.tsx b/apps/sim/app/workspace/[workspaceId]/w/components/sidebar/components/settings-modal/components/subscription/subscription.tsx
index 9ac78581ef..b69b499aff 100644
--- a/apps/sim/app/workspace/[workspaceId]/w/components/sidebar/components/settings-modal/components/subscription/subscription.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/w/components/sidebar/components/settings-modal/components/subscription/subscription.tsx
@@ -523,6 +523,7 @@ export function Subscription({ onOpenChange }: SubscriptionProps) {
}}
subscriptionData={{
periodEnd: subscriptionData?.periodEnd || null,
+ cancelAtPeriodEnd: subscriptionData?.cancelAtPeriodEnd,
}}
/>
diff --git a/apps/sim/lib/billing/core/billing.ts b/apps/sim/lib/billing/core/billing.ts
index 48085eb821..55b6a207f7 100644
--- a/apps/sim/lib/billing/core/billing.ts
+++ b/apps/sim/lib/billing/core/billing.ts
@@ -220,6 +220,7 @@ export async function getSimplifiedBillingSummary(
metadata: any
stripeSubscriptionId: string | null
periodEnd: Date | string | null
+ cancelAtPeriodEnd?: boolean
// Usage details
usage: {
current: number
@@ -318,6 +319,7 @@ export async function getSimplifiedBillingSummary(
metadata: subscription.metadata || null,
stripeSubscriptionId: subscription.stripeSubscriptionId || null,
periodEnd: subscription.periodEnd || null,
+ cancelAtPeriodEnd: subscription.cancelAtPeriodEnd || undefined,
// Usage details
usage: {
current: usageData.currentUsage,
@@ -393,6 +395,7 @@ export async function getSimplifiedBillingSummary(
metadata: subscription?.metadata || null,
stripeSubscriptionId: subscription?.stripeSubscriptionId || null,
periodEnd: subscription?.periodEnd || null,
+ cancelAtPeriodEnd: subscription?.cancelAtPeriodEnd || undefined,
// Usage details
usage: {
current: currentUsage,
@@ -450,5 +453,14 @@ function getDefaultBillingSummary(type: 'individual' | 'organization') {
lastPeriodCost: 0,
daysRemaining: 0,
},
+ ...(type === 'organization' && {
+ organizationData: {
+ seatCount: 0,
+ memberCount: 0,
+ totalBasePrice: 0,
+ totalCurrentUsage: 0,
+ totalOverage: 0,
+ },
+ }),
}
}
diff --git a/apps/sim/stores/subscription/types.ts b/apps/sim/stores/subscription/types.ts
index c0de147d45..643694b795 100644
--- a/apps/sim/stores/subscription/types.ts
+++ b/apps/sim/stores/subscription/types.ts
@@ -29,6 +29,7 @@ export interface SubscriptionData {
metadata: any | null
stripeSubscriptionId: string | null
periodEnd: Date | null
+ cancelAtPeriodEnd?: boolean
usage: UsageData
billingBlocked?: boolean
}
diff --git a/packages/cli/__tests__/__mocks__/chalk.ts b/packages/cli/__tests__/__mocks__/chalk.ts
new file mode 100644
index 0000000000..49ec13fa17
--- /dev/null
+++ b/packages/cli/__tests__/__mocks__/chalk.ts
@@ -0,0 +1,9 @@
+const chalk = {
+ blue: (str: string) => str,
+ green: (str: string) => str,
+ red: (str: string) => str,
+ yellow: (str: string) => str,
+ bold: (str: string) => str,
+};
+
+export default chalk;
diff --git a/packages/cli/__tests__/index.test.ts b/packages/cli/__tests__/index.test.ts
new file mode 100644
index 0000000000..b446f73008
--- /dev/null
+++ b/packages/cli/__tests__/index.test.ts
@@ -0,0 +1,429 @@
+import { execSync, spawn } from 'child_process';
+import { existsSync, mkdirSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import * as indexModule from '../src/index';
+
+jest.mock('child_process');
+jest.mock('fs');
+jest.mock('os');
+jest.mock('path');
+jest.mock('readline');
+
+const mockExecSync = execSync as jest.MockedFunction < typeof execSync > ;
+const mockSpawn = spawn as jest.MockedFunction < typeof spawn > ;
+const mockExistsSync = existsSync as jest.MockedFunction < typeof existsSync > ;
+const mockMkdirSync = mkdirSync as jest.MockedFunction < typeof mkdirSync > ;
+const mockHomedir = homedir as jest.MockedFunction < typeof homedir > ;
+const mockJoin = join as jest.MockedFunction < typeof join > ;
+
+describe('SimStudio CLI', () => {
+ let config: indexModule.Config;
+ let mockSpawnProcess: any;
+ let consoleLogSpy: jest.SpyInstance;
+ let consoleErrorSpy: jest.SpyInstance;
+
+ beforeEach(() => {
+ jest.clearAllMocks();
+
+ config = {
+ port: 3000,
+ pullImages: true,
+ yes: false,
+ dataDir: '/home/user/.simstudio/data',
+ networkName: 'simstudio-network',
+ dbContainer: 'simstudio-db',
+ migrationsContainer: 'simstudio-migrations',
+ realtimeContainer: 'simstudio-realtime',
+ appContainer: 'simstudio-app',
+ dbImage: 'pgvector/pgvector:pg17',
+ migrationsImage: 'ghcr.io/simstudioai/migrations:latest',
+ realtimeImage: 'ghcr.io/simstudioai/realtime:latest',
+ appImage: 'ghcr.io/simstudioai/simstudio:latest',
+ postgresUser: 'postgres',
+ postgresPassword: 'postgres',
+ postgresDb: 'simstudio',
+ realtimePort: 3002,
+ betterAuthSecret: 'test-secret-32chars-long-enough-1234567890',
+ encryptionKey: 'test-encryption-32chars-long-1234567890abcd',
+ } as indexModule.Config;
+
+ mockHomedir.mockReturnValue('/home/user');
+ mockJoin.mockImplementation((...args) => args.join('/'));
+
+ consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
+ consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
+
+ // Mock spawn return value
+ mockSpawnProcess = {
+ on: jest.fn().mockImplementation((event: string, cb: Function) => {
+ if (event === 'close') cb(0);
+ return mockSpawnProcess;
+ }),
+ };
+ mockSpawn.mockReturnValue(mockSpawnProcess);
+ });
+
+ afterEach(() => {
+ consoleLogSpy.mockRestore();
+ consoleErrorSpy.mockRestore();
+ });
+
+ describe('generateSecret', () => {
+ it('should generate a secret of specified length', () => {
+ const secret = indexModule.generateSecret(16);
+ expect(secret).toHaveLength(16);
+ expect(secret).toMatch(/^[a-zA-Z0-9]+$/);
+ });
+
+ it('should default to 32 characters', () => {
+ const secret = indexModule.generateSecret();
+ expect(secret).toHaveLength(32);
+ });
+ });
+
+ describe('isPortAvailable', () => {
+ let net: any;
+
+ beforeEach(() => {
+ net = require('net');
+ });
+
+ it('should return true if port is available', async () => {
+ jest.spyOn(net, 'createServer').mockImplementation(() => {
+ return {
+ once: jest.fn().mockImplementation((event: string, cb: () => void) => {
+ if (event === 'listening') setImmediate(cb);
+ }),
+ listen: jest.fn(),
+ close: jest.fn().mockImplementation((cb: () => void) => cb && cb()),
+ } as any;
+ });
+
+ const available = await indexModule.isPortAvailable(3000);
+ expect(available).toBe(true);
+ });
+
+ it('should return false if port is in use (EADDRINUSE)', async () => {
+ jest.spyOn(net, 'createServer').mockImplementation(() => {
+ return {
+ once: jest.fn().mockImplementation((event: string, cb: (err?: any) => void) => {
+ if (event === 'error') setImmediate(() => cb({ code: 'EADDRINUSE' }));
+ }),
+ listen: jest.fn(),
+ close: jest.fn(),
+ } as any;
+ });
+
+ const available = await indexModule.isPortAvailable(3000);
+ expect(available).toBe(false);
+ });
+
+ it('should return true on any other error (cannot determine)', async () => {
+ jest.spyOn(net, 'createServer').mockImplementation(() => {
+ return {
+ once: jest.fn().mockImplementation((event: string, cb: (err?: any) => void) => {
+ if (event === 'error') setImmediate(() => cb({ code: 'EPERM' }));
+ }),
+ listen: jest.fn(),
+ close: jest.fn(),
+ } as any;
+ });
+
+ const available = await indexModule.isPortAvailable(3000);
+ expect(available).toBe(true);
+ });
+ });
+
+ describe('isDockerRunning', () => {
+ it('should resolve true if Docker info succeeds', async () => {
+ mockSpawnProcess.on.mockImplementation((event: string, cb: Function) => {
+ if (event === 'close') cb(0);
+ return mockSpawnProcess;
+ });
+
+ const running = await indexModule.isDockerRunning();
+ expect(running).toBe(true);
+ expect(mockSpawn).toHaveBeenCalledWith('docker', ['info'], {
+ stdio: 'ignore'
+ });
+ });
+
+ it('should resolve false if Docker info fails', async () => {
+ mockSpawnProcess.on.mockImplementation((event: string, cb: Function) => {
+ if (event === 'close') cb(1);
+ return mockSpawnProcess;
+ });
+
+ const running = await indexModule.isDockerRunning();
+ expect(running).toBe(false);
+ });
+
+ it('should resolve false on spawn error', async () => {
+ const errorProcess: any = {
+ on: jest.fn((event: string, cb: Function) => {
+ if (event === 'error') cb(new Error('spawn error'));
+ return errorProcess;
+ }),
+ };
+ mockSpawn.mockReturnValueOnce(errorProcess as any);
+
+ const running = await indexModule.isDockerRunning();
+ expect(running).toBe(false);
+ });
+ });
+
+ describe('runCommand', () => {
+ it('should resolve true if command succeeds (code 0)', async () => {
+ mockSpawnProcess.on.mockImplementation((event: string, cb: Function) => {
+ if (event === 'close') cb(0);
+ return mockSpawnProcess;
+ });
+
+ const success = await indexModule.runCommand(['docker', 'ps']);
+ expect(success).toBe(true);
+ expect(mockSpawn).toHaveBeenCalledWith('docker', ['ps'], {
+ stdio: 'inherit'
+ });
+ });
+
+ it('should resolve false if command fails (code 1)', async () => {
+ mockSpawnProcess.on.mockImplementation((event: string, cb: Function) => {
+ if (event === 'close') cb(1);
+ return mockSpawnProcess;
+ });
+
+ const success = await indexModule.runCommand(['docker', 'ps']);
+ expect(success).toBe(false);
+ });
+
+ it('should resolve false on spawn error', async () => {
+ const errorProcess: any = {
+ on: jest.fn((event: string, cb: Function) => {
+ if (event === 'error') cb(new Error('error'));
+ return errorProcess;
+ }),
+ };
+ mockSpawn.mockReturnValueOnce(errorProcess as any);
+
+ const success = await indexModule.runCommand(['docker', 'ps']);
+ expect(success).toBe(false);
+ });
+ });
+
+ describe('pullImage', () => {
+ it('should return true if pull succeeds', async () => {
+ const success = await indexModule.pullImage('test:image');
+ expect(success).toBe(true);
+ expect(mockSpawn).toHaveBeenCalledWith('docker', ['pull', 'test:image'], {
+ stdio: 'inherit'
+ });
+ });
+
+ it('should return false if pull fails', async () => {
+ mockSpawnProcess.on.mockImplementation((event: string, cb: Function) => {
+ if (event === 'close') cb(1);
+ return mockSpawnProcess;
+ });
+
+ const success = await indexModule.pullImage('test:image');
+ expect(success).toBe(false);
+ });
+ });
+
+ describe('stopAndRemoveContainer', () => {
+ it('should stop and remove container successfully', async () => {
+ await indexModule.stopAndRemoveContainer('test-container');
+ expect(mockSpawn).toHaveBeenCalledWith('docker', ['stop', 'test-container'], {
+ stdio: 'inherit'
+ });
+ expect(mockSpawn).toHaveBeenCalledWith('docker', ['rm', 'test-container'], {
+ stdio: 'inherit'
+ });
+ });
+ });
+
+ describe('cleanupExistingContainers', () => {
+ it('should call stopAndRemove for all containers', async () => {
+ await indexModule.cleanupExistingContainers(config);
+ expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('Cleaning up'));
+ });
+ });
+
+ describe('ensureDataDir', () => {
+ it('should create directory if it does not exist', () => {
+ mockExistsSync.mockReturnValueOnce(false);
+
+ const success = indexModule.ensureDataDir('/test/dir');
+ expect(success).toBe(true);
+ expect(mockMkdirSync).toHaveBeenCalledWith('/test/dir', {
+ recursive: true
+ });
+ });
+
+ it('should return true if directory exists', () => {
+ mockExistsSync.mockReturnValueOnce(true);
+
+ const success = indexModule.ensureDataDir('/test/dir');
+ expect(success).toBe(true);
+ expect(mockMkdirSync).not.toHaveBeenCalled();
+ });
+
+ it('should return false on mkdir error', () => {
+ mockExistsSync.mockReturnValueOnce(false);
+ mockMkdirSync.mockImplementation(() => {
+ throw new Error('mkdir error');
+ });
+
+ const success = indexModule.ensureDataDir('/test/dir');
+ expect(success).toBe(false);
+ expect(consoleErrorSpy).toHaveBeenCalled();
+ });
+ });
+
+ describe('startDatabase', () => {
+ it('should construct and run DB start command successfully', async () => {
+ const success = await indexModule.startDatabase(config);
+ expect(success).toBe(true);
+ expect(mockSpawn).toHaveBeenCalledWith('docker', expect.arrayContaining([
+ 'run', '-d', '--name', config.dbContainer,
+ '--network', config.networkName,
+ ]), {
+ stdio: 'inherit'
+ });
+ });
+
+ it('should return false if command fails', async () => {
+ mockSpawnProcess.on.mockImplementation((event: string, cb: Function) => {
+ if (event === 'close') cb(1);
+ return mockSpawnProcess;
+ });
+
+ const success = await indexModule.startDatabase(config);
+ expect(success).toBe(false);
+ });
+ });
+
+ describe('waitForPgReady', () => {
+ it('should resolve true if PG becomes ready', async () => {
+ let attempts = 0;
+ mockExecSync.mockImplementation(() => {
+ attempts++;
+ if (attempts === 2) return Buffer.from('ready');
+ throw new Error('not ready');
+ });
+
+ const ready = await indexModule.waitForPgReady('test-db', 5000);
+ expect(ready).toBe(true);
+ });
+
+ it('should resolve false after timeout and print correct message', async () => {
+ mockExecSync.mockImplementation(() => {
+ throw new Error('not ready');
+ });
+
+ const ready = await indexModule.waitForPgReady('test-db', 200);
+ expect(ready).toBe(false);
+ expect(consoleErrorSpy).toHaveBeenCalledWith(
+ expect.stringContaining('failed to become ready within 0m0.2s')
+ );
+ });
+ });
+
+ describe('runMigrations', () => {
+ it('should construct and run migrations command successfully', async () => {
+ const success = await indexModule.runMigrations(config);
+ expect(success).toBe(true);
+ expect(mockSpawn).toHaveBeenCalledWith('docker', expect.arrayContaining([
+ 'run', '--rm', '--name', config.migrationsContainer,
+ '--network', config.networkName,
+ ]), {
+ stdio: 'inherit'
+ });
+ });
+
+ it('should return false if command fails', async () => {
+ mockSpawnProcess.on.mockImplementation((event: string, cb: Function) => {
+ if (event === 'close') cb(1);
+ return mockSpawnProcess;
+ });
+
+ const success = await indexModule.runMigrations(config);
+ expect(success).toBe(false);
+ });
+ });
+
+ describe('startRealtime', () => {
+ it('should construct and run Realtime start command successfully', async () => {
+ const success = await indexModule.startRealtime(config);
+ expect(success).toBe(true);
+ expect(mockSpawn).toHaveBeenCalledWith('docker', expect.arrayContaining([
+ 'run', '-d', '--name', config.realtimeContainer,
+ '--network', config.networkName,
+ ]), {
+ stdio: 'inherit'
+ });
+ });
+
+ it('should return false if command fails', async () => {
+ mockSpawnProcess.on.mockImplementation((event: string, cb: Function) => {
+ if (event === 'close') cb(1);
+ return mockSpawnProcess;
+ });
+
+ const success = await indexModule.startRealtime(config);
+ expect(success).toBe(false);
+ });
+ });
+
+ describe('startApp', () => {
+ it('should construct and run App start command successfully', async () => {
+ const success = await indexModule.startApp(config);
+ expect(success).toBe(true);
+ expect(mockSpawn).toHaveBeenCalledWith('docker', expect.arrayContaining([
+ 'run', '-d', '--name', config.appContainer,
+ '--network', config.networkName,
+ ]), {
+ stdio: 'inherit'
+ });
+ });
+
+ it('should return false if command fails', async () => {
+ mockSpawnProcess.on.mockImplementation((event: string, cb: Function) => {
+ if (event === 'close') cb(1);
+ return mockSpawnProcess;
+ });
+
+ const success = await indexModule.startApp(config);
+ expect(success).toBe(false);
+ });
+ });
+
+ describe('printSuccess', () => {
+ it('should log success messages and stop command', () => {
+ indexModule.printSuccess(config);
+ expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('Sim is now running'));
+ });
+ });
+
+ describe('setupShutdownHandlers', () => {
+ it('should set up shutdown handlers', () => {
+ const mockRl = {
+ on: jest.fn(),
+ close: jest.fn(),
+ };
+ const mockCreateInterface = require('readline').createInterface;
+ mockCreateInterface.mockReturnValue(mockRl);
+
+ const processOnSpy = jest.spyOn(process, 'on');
+
+ indexModule.setupShutdownHandlers(config);
+
+ expect(mockCreateInterface).toHaveBeenCalled();
+ expect(processOnSpy).toHaveBeenCalledWith('SIGTERM', expect.any(Function));
+ expect(processOnSpy).toHaveBeenCalledWith('uncaughtException', expect.any(Function));
+
+ processOnSpy.mockRestore();
+ });
+ });
+});
diff --git a/packages/cli/__tests__/setup.ts b/packages/cli/__tests__/setup.ts
new file mode 100644
index 0000000000..707010b9e0
--- /dev/null
+++ b/packages/cli/__tests__/setup.ts
@@ -0,0 +1,8 @@
+import { TextEncoder, TextDecoder } from 'util';
+
+// Set NODE_ENV to test
+process.env.NODE_ENV = 'test';
+
+// Mock global TextEncoder and TextDecoder for Node.js < 11
+global.TextEncoder = TextEncoder as any;
+global.TextDecoder = TextDecoder as any;
diff --git a/packages/cli/package.json b/packages/cli/package.json
index bc1ca47962..4a3806d262 100644
--- a/packages/cli/package.json
+++ b/packages/cli/package.json
@@ -10,7 +10,11 @@
"scripts": {
"build": "bun run build:tsc",
"build:tsc": "tsc",
- "prepublishOnly": "bun run build"
+ "prepublishOnly": "bun run build",
+ "dev": "bun --watch index.ts",
+ "test": "jest",
+ "test:watch": "jest --watch",
+ "test:coverage": "jest --coverage"
},
"files": [
"dist"
@@ -31,19 +35,25 @@
"author": "Sim",
"license": "Apache-2.0",
"dependencies": {
- "chalk": "^4.1.2",
- "commander": "^11.1.0",
- "dotenv": "^16.3.1",
- "inquirer": "^8.2.6",
- "listr2": "^6.6.1"
+ "chalk": "^5.3.0",
+ "commander": "^12.1.0",
+ "dotenv": "^16.4.5",
+ "inquirer": "^10.0.6",
+ "listr2": "^8.0.1"
},
"devDependencies": {
+ "@types/chalk": "^2.2.2",
+ "@types/commander": "^2.12.2",
"@types/inquirer": "^8.2.6",
- "@types/node": "^20.5.1",
- "typescript": "^5.1.6"
+ "@types/jest": "^29.5.12",
+ "@types/node": "^22.5.0",
+ "jest": "^29.7.0",
+ "ts-jest": "^29.2.5",
+ "ts-node": "^10.9.2",
+ "typescript": "^5.6.3"
},
"engines": {
- "node": ">=16"
+ "node": ">=18"
},
"turbo": {
"tasks": {
@@ -53,5 +63,51 @@
]
}
}
+ },
+ "jest": {
+ "preset": "ts-jest",
+ "testEnvironment": "node",
+ "moduleFileExtensions": [
+ "ts",
+ "js"
+ ],
+ "testMatch": [
+ "**/__tests__/**/*.test.ts"
+ ],
+ "collectCoverageFrom": [
+ "src/**/*.ts",
+ "!src/**/*.d.ts"
+ ],
+ "coverageThreshold": {
+ "global": {
+ "branches": 8,
+ "functions": 70,
+ "lines": 55,
+ "statements": 55
+ }
+ },
+ "setupFilesAfterEnv": [
+ "