@kithinji/pod 1.0.18 → 1.0.20

package/dist/main.js

@@ -405,17 +405,17 @@ var MacroDependencyGraph = class {
     const visited = /* @__PURE__ */ new Set();
     const inProgress = /* @__PURE__ */ new Set();
     const sorted = [];
-    const visit = (key, path14 = []) => {
+    const visit = (key, path15 = []) => {
       if (visited.has(key)) return;
       if (inProgress.has(key)) {
-        const cycle = [...path14, key].join(" -> ");
+        const cycle = [...path15, key].join(" -> ");
         throw new Error(`Circular macro dependency detected: ${cycle}`);
       }
       const node = this.nodes.get(key);
       if (!node) return;
       inProgress.add(key);
       for (const depKey of node.dependencies) {
-        visit(depKey, [...path14, key]);
+        visit(depKey, [...path15, key]);
       }
       inProgress.delete(key);
       visited.add(key);
@@ -1573,22 +1573,22 @@ var ElementTransformer = class {
     this.jsxUtils = jsxUtils;
     this.observableManager = observableManager;
   }
-  transformElement(path14, scope, context2) {
-    if (this.t.isJSXFragment(path14.node)) {
+  transformElement(path15, scope, context2) {
+    if (this.t.isJSXFragment(path15.node)) {
       return this.transformFragment(
-        path14,
+        path15,
         scope,
         context2
       );
     }
     return this.transformJSXElement(
-      path14,
+      path15,
       scope,
       context2
     );
   }
-  transformJSXElement(path14, scope, context2) {
-    const jsxElement = path14.node;
+  transformJSXElement(path15, scope, context2) {
+    const jsxElement = path15.node;
     const tag = this.jsxUtils.getComponentName(jsxElement.openingElement.name);
     const isComponent = this.jsxUtils.isComponentTag(tag);
     if (isComponent && tag) {
@@ -1702,7 +1702,7 @@ var ElementTransformer = class {
     }
     return { id: elId, statements };
   }
-  transformFragment(path14, scope, context2) {
+  transformFragment(path15, scope, context2) {
     const fragId = scope.generateUidIdentifier("frag");
     const statements = [];
     statements.push(
@@ -1720,7 +1720,7 @@ var ElementTransformer = class {
       ])
     );
     this.processDOMChildren(
-      path14.node.children,
+      path15.node.children,
       fragId,
       statements,
       scope,
@@ -2065,7 +2065,7 @@ function j2d({ types: t }) {
     name: "jsx-to-dom",
     visitor: {
       Program: {
-        exit(path14, state) {
+        exit(path15, state) {
           if (state.helpersImported) return;
           const helpers = [
             { local: "$insert", imported: "insert" },
@@ -2076,7 +2076,7 @@ function j2d({ types: t }) {
             { local: "$effect", imported: "effect" }
           ];
           for (const helper of helpers) {
-            path14.unshiftContainer(
+            path15.unshiftContainer(
               "body",
               t.importDeclaration(
                 [
@@ -2092,10 +2092,10 @@ function j2d({ types: t }) {
           state.helpersImported = true;
         }
       },
-      ClassMethod(path14) {
-        if (path14.getData("processed")) return;
+      ClassMethod(path15) {
+        if (path15.getData("processed")) return;
         let hasJSX = false;
-        path14.traverse({
+        path15.traverse({
           JSXElement() {
             hasJSX = true;
           },
@@ -2104,11 +2104,11 @@ function j2d({ types: t }) {
           }
         });
         if (!hasJSX) return;
-        path14.setData("processed", true);
-        const body = path14.node.body;
+        path15.setData("processed", true);
+        const body = path15.node.body;
         if (!t.isBlockStatement(body)) return;
         const observables = /* @__PURE__ */ new Map();
-        path14.traverse({
+        path15.traverse({
           JSXElement(jsxPath) {
             observableManager.collectObservables(
               jsxPath.node,
@@ -2132,7 +2132,7 @@ function j2d({ types: t }) {
         const observableSignals = /* @__PURE__ */ new Map();
         const signalDeclarations = [];
         for (const [key, observable] of observables) {
-          const signalId = path14.scope.generateUidIdentifier("sig");
+          const signalId = path15.scope.generateUidIdentifier("sig");
           observableSignals.set(key, signalId);
           signalDeclarations.push(
             t.variableDeclaration("const", [
@@ -2150,7 +2150,7 @@ function j2d({ types: t }) {
           astUtils.insertBeforeReturn(body.body, signalDeclarations);
         }
         const context2 = { observables, observableSignals };
-        path14.traverse({
+        path15.traverse({
           JSXElement(jsxPath) {
             if (jsxPath.getData("processed")) return;
             jsxPath.setData("processed", true);
@@ -2742,8 +2742,8 @@ async function swcTransform(source, pathStr, tsx = false, react) {
     resolveDir
   };
 }
-function parseFileMetadata(source, path14) {
-  const isTsx = path14.endsWith(".tsx");
+function parseFileMetadata(source, path15) {
+  const isTsx = path15.endsWith(".tsx");
   const isInteractiveFile = source.startsWith('"use interactive"') || source.startsWith("'use interactive'");
   const isPublicFile = source.startsWith('"use public"') || source.startsWith("'use public'");
   let directive = null;
@@ -2751,7 +2751,7 @@ function parseFileMetadata(source, path14) {
   else if (isPublicFile) directive = "public";
   return {
     source,
-    path: path14,
+    path: path15,
     isTsx,
     directive,
     isPublicFile,
@@ -2759,58 +2759,58 @@ function parseFileMetadata(source, path14) {
   };
 }
 var ServerBuildTransformer = class {
-  async transformPublicFile(source, path14) {
-    const controllerCode = generateController(path14, source);
+  async transformPublicFile(source, path15) {
+    const controllerCode = generateController(path15, source);
     if (controllerCode) {
       source = `${source}
 
 ${controllerCode}
 `;
     }
-    return swcTransform(source, path14);
+    return swcTransform(source, path15);
   }
-  async transformRegularTypeScript(source, path14, isPublic) {
+  async transformRegularTypeScript(source, path15, isPublic) {
     if (isPublic) {
-      return this.transformPublicFile(source, path14);
+      return this.transformPublicFile(source, path15);
     }
-    return swcTransform(source, path14);
+    return swcTransform(source, path15);
   }
-  async transformServerTsx(source, path14) {
-    return swcTransform(source, path14, true, {
+  async transformServerTsx(source, path15) {
+    return swcTransform(source, path15, true, {
       runtime: "automatic",
       importSource: "@kithinji/orca"
     });
   }
-  async transformInteractiveTsxStub(source, path14) {
-    const stubSource = generateServerStub(path14, source);
-    return swcTransform(stubSource, path14);
+  async transformInteractiveTsxStub(source, path15) {
+    const stubSource = generateServerStub(path15, source);
+    return swcTransform(stubSource, path15);
   }
   async process(metadata, onClientFound) {
     const expandedSource = await expandMacros(metadata.source, metadata.path);
     const expandedMetadata = { ...metadata, source: expandedSource };
-    const { source, path: path14, isTsx, isInteractiveFile, isPublicFile } = expandedMetadata;
+    const { source, path: path15, isTsx, isInteractiveFile, isPublicFile } = expandedMetadata;
     if (isTsx) {
       if (isInteractiveFile) {
-        onClientFound(path14);
-        const clientCode = await this.transformInteractiveTsxStub(source, path14);
+        onClientFound(path15);
+        const clientCode = await this.transformInteractiveTsxStub(source, path15);
         const store = Store.getInstance();
-        store.set(path14, clientCode.contents);
+        store.set(path15, clientCode.contents);
         return clientCode;
       }
-      return this.transformServerTsx(source, path14);
+      return this.transformServerTsx(source, path15);
     }
-    return this.transformRegularTypeScript(source, path14, isPublicFile);
+    return this.transformRegularTypeScript(source, path15, isPublicFile);
   }
 };
 var ClientBuildTransformer = class {
-  async transformInteractiveTsx(source, path14) {
-    const swcResult = await swcTransform(source, path14, true, {
+  async transformInteractiveTsx(source, path15) {
+    const swcResult = await swcTransform(source, path15, true, {
       runtime: "preserve"
     });
     const babelResult = await babel.transformAsync(
       swcResult.contents,
       {
-        filename: path14,
+        filename: path15,
         sourceType: "module",
         plugins: [j2d],
         parserOpts: {
@@ -2826,37 +2826,37 @@ var ClientBuildTransformer = class {
       resolveDir: swcResult.resolveDir
     };
   }
-  async transformServerComponent(node, source, path14) {
-    const scSource = generateServerComponent(path14, source);
-    return swcTransform(scSource, path14);
+  async transformServerComponent(node, source, path15) {
+    const scSource = generateServerComponent(path15, source);
+    return swcTransform(scSource, path15);
   }
-  async transformPublicFileRsc(node, source, path14) {
-    const stubSource = generateRscStub(path14, source);
-    return swcTransform(stubSource, path14);
+  async transformPublicFileRsc(node, source, path15) {
+    const stubSource = generateRscStub(path15, source);
+    return swcTransform(stubSource, path15);
   }
-  async transformSharedCode(source, path14) {
-    return swcTransform(source, path14);
+  async transformSharedCode(source, path15) {
+    return swcTransform(source, path15);
   }
   async process(node, metadata) {
     const expandedSource = await expandMacros(metadata.source, metadata.path);
     const expandedMetadata = { ...metadata, source: expandedSource };
-    const { source, path: path14, isTsx, directive } = expandedMetadata;
+    const { source, path: path15, isTsx, directive } = expandedMetadata;
     if (isTsx) {
       if (directive === "interactive") {
-        return this.transformInteractiveTsx(source, path14);
+        return this.transformInteractiveTsx(source, path15);
       } else if (directive === null) {
-        return this.transformServerComponent(node, source, path14);
+        return this.transformServerComponent(node, source, path15);
       } else {
         throw new Error(
-          `Unexpected directive "${directive}" for TSX file: ${path14}`
+          `Unexpected directive "${directive}" for TSX file: ${path15}`
         );
       }
     }
     if (directive === "public") {
-      return this.transformPublicFileRsc(node, source, path14);
+      return this.transformPublicFileRsc(node, source, path15);
     }
     if (directive === null) {
-      return this.transformSharedCode(source, path14);
+      return this.transformSharedCode(source, path15);
     }
     return {
       contents: source,
@@ -3185,7 +3185,7 @@ async function startDevServer() {
         format: "esm",
         sourcemap: config.build?.sourcemap ?? true,
         splitting: true,
-        minify: config.build?.minify ?? false,
+        minify: config.build?.minify ?? true,
         plugins: [
           ...config.plugins?.map((cb) => cb(store)) || [],
           ...config.client_plugins?.map((cb) => cb(store)) || [],
@@ -4336,7 +4336,7 @@ bootstrap();
 }
 
 // src/main.ts
-import path13 from "path";
+import path14 from "path";
 import { execSync } from "child_process";
 
 // src/docker/docker.ts
@@ -4361,6 +4361,7 @@ async function dockerize(env = "prod") {
   } else {
     await setupDevelopment(cwd, projectName, selectedServices);
   }
+  await writeEnvVars(cwd, selectedServices, env);
   printNextSteps(projectName, env, selectedServices);
 }
 function detectServices(packageJson) {
@@ -4407,8 +4408,66 @@ async function restructureProject(cwd, projectName) {
     await fs9.move(envSrc, envDest, { overwrite: true });
   }
 }
+async function writeEnvVars(cwd, services, env) {
+  const envPath = path12.join(cwd, ".env");
+  let existingEnv = {};
+  let existingContent = "";
+  if (fs9.existsSync(envPath)) {
+    existingContent = await fs9.readFile(envPath, "utf8");
+    existingEnv = parseEnvFile(existingContent);
+  }
+  const newVars = [];
+  if (env === "prod" && !existingEnv.HOST) {
+    newVars.push("HOST=example.com");
+  }
+  for (const service of services) {
+    const serviceVars = getEnvVars(service.name);
+    for (const varLine of serviceVars) {
+      const [key] = varLine.split("=");
+      if (!existingEnv[key]) {
+        newVars.push(varLine);
+      }
+    }
+    if (env === "dev" && service.needsTunnel) {
+      const remoteHostKey = `${service.name.toUpperCase()}_REMOTE_HOST`;
+      const remotePortKey = `${service.name.toUpperCase()}_REMOTE_PORT`;
+      if (!existingEnv[remoteHostKey]) {
+        newVars.push(`${remoteHostKey}=user@remote-server.com`);
+      }
+      if (!existingEnv[remotePortKey]) {
+        newVars.push(`${remotePortKey}=${getDefaultPort(service.name)}`);
+      }
+    }
+  }
+  if (newVars.length > 0) {
+    const separator = existingContent && !existingContent.endsWith("\n") ? "\n" : "";
+    const newContent = existingContent + separator + (existingContent ? "\n" : "") + newVars.join("\n") + "\n";
+    await fs9.writeFile(envPath, newContent);
+    console.log(
+      `\u2705 Added ${newVars.length} new environment variable(s) to .env`
+    );
+  } else {
+    console.log("\u2705 All required environment variables already exist in .env");
+  }
+}
+function parseEnvFile(content) {
+  const env = {};
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const equalIndex = trimmed.indexOf("=");
+    if (equalIndex > 0) {
+      const key = trimmed.substring(0, equalIndex).trim();
+      const value = trimmed.substring(equalIndex + 1).trim();
+      env[key] = value;
+    }
+  }
+  return env;
+}
 async function createDockerfile(cwd, projectName) {
   const dockerfilePath = path12.join(cwd, projectName, "Dockerfile");
+  const dockerignorePath = path12.join(cwd, projectName, ".dockerignore");
   const dockerfile = `FROM node:18-alpine
 
 WORKDIR /app
@@ -4422,8 +4481,65 @@ COPY . .
 EXPOSE 8080
 
 CMD ["npm", "run", "dev"]
+`;
+  const dockerignore = `# Dependencies
+node_modules
+npm-debug.log
+yarn-error.log
+package-lock.json
+yarn.lock
+
+# Environment files
+.env
+.env.*
+
+# Git
+.git
+.gitignore
+
+# IDE
+.vscode
+.idea
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Testing
+coverage
+.nyc_output
+*.test.js
+*.spec.js
+__tests__
+
+# Build files
+dist
+public
+
+# Logs
+logs
+*.log
+
+# Documentation
+README.md
+docs
+*.md
+
+# Docker
+Dockerfile
+.dockerignore
+docker-compose*.yml
+
+# Misc
+.cache
+tmp
+temp
 `;
   await fs9.writeFile(dockerfilePath, dockerfile);
+  await fs9.writeFile(dockerignorePath, dockerignore);
 }
 async function setupProduction(cwd, projectName, services) {
   const compose = {
@@ -4454,7 +4570,6 @@ async function setupProduction(cwd, projectName, services) {
         ],
         networks: ["web"],
         env_file: [".env"]
-        // Fixed: Added env_file to read HOST variable
       },
       [projectName]: {
         build: {
@@ -4463,19 +4578,16 @@ async function setupProduction(cwd, projectName, services) {
         },
         labels: [
           "traefik.enable=true",
-          "traefik.http.routers.app.rule=Host(`${HOST}`)",
-          // Fixed: Changed from app.${HOST} to ${HOST}
+          "traefik.http.routers.app.rule=Host(`app.${HOST}`)",
           "traefik.http.routers.app.entrypoints=websecure",
           "traefik.http.routers.app.tls.certresolver=myresolver",
           "traefik.http.services.app.loadbalancer.server.port=8080"
         ],
         env_file: [".env"],
         networks: ["web"],
-        volumes: [`./${projectName}:/app`],
-        // Fixed: Changed from ./web to ./${projectName}
+        volumes: [`./${projectName}:/app`, `/app/node_modules`],
         command: "npm run dev",
         depends_on: []
-        // Fixed: Added missing depends_on array
       }
     },
     networks: {
@@ -4484,7 +4596,6 @@ async function setupProduction(cwd, projectName, services) {
       }
     },
     volumes: {}
-    // Fixed: Added missing volumes object
   };
   for (const service of services) {
     const config = getServiceConfig(service.name);
@@ -4548,7 +4659,6 @@ async function setupDevelopment(cwd, projectName, services) {
         ports: ["8080:8080"],
         env_file: [".env"],
         volumes: [`./${projectName}:/app`, `/app/node_modules`],
-        // Fixed: Changed from . to ./${projectName}
         command: "npm run dev",
         depends_on: []
       }
@@ -4665,6 +4775,33 @@ function getServiceConfig(serviceName) {
   };
   return configs[serviceName];
 }
+function getEnvVars(serviceName) {
+  const vars = {
+    postgres: [
+      "DB_HOST=postgres",
+      "DB_PORT=5432",
+      "DB_USER=myuser",
+      "DB_PASSWORD=mypassword",
+      "DB_NAME=mydb"
+    ],
+    mysql: [
+      "DB_HOST=mysql",
+      "DB_PORT=3306",
+      "DB_USER=myuser",
+      "DB_PASSWORD=mypassword",
+      "DB_NAME=mydb",
+      "DB_ROOT_PASSWORD=rootpassword"
+    ],
+    redis: ["REDIS_HOST=redis", "REDIS_PORT=6379"],
+    mongodb: [
+      "MONGO_HOST=mongodb",
+      "MONGO_PORT=27017",
+      "MONGO_USER=myuser",
+      "MONGO_PASSWORD=mypassword"
+    ]
+  };
+  return vars[serviceName] || [];
+}
 function getDefaultPort(service) {
   const ports = {
     postgres: 5432,
@@ -4679,12 +4816,12 @@ function printNextSteps(projectName, env, services) {
 \u2705 Done! Next steps:
 `);
   if (env === "prod") {
-    console.log(`  # Edit .env with your settings`);
+    console.log(`  # Review and edit .env with your settings`);
     console.log(`  docker-compose up -d`);
-    console.log(`  # Access at https://\${HOST}
+    console.log(`  # Access at https://app.\${HOST}
 `);
   } else {
-    console.log(`  # Edit .env with your settings`);
+    console.log(`  # Review and edit .env with your settings`);
     if (services.some((s) => s.needsTunnel)) {
       console.log(`  # Add SSH keys: {service}.pem`);
     }
@@ -4693,12 +4830,461 @@ function printNextSteps(projectName, env, services) {
   }
 }
 
+// src/deploy/deploy.ts
+import fs10 from "fs-extra";
+import yaml2 from "js-yaml";
+import path13 from "path";
+import os from "os";
+import { NodeSSH } from "node-ssh";
+import chalk from "chalk";
+function interpolate(str, context2) {
+  if (!str) return "";
+  return str.replace(/\${([^}]+)}/g, (match, key) => {
+    return context2[key] !== void 0 ? String(context2[key]) : match;
+  });
+}
+function deepInterpolate(obj, context2) {
+  if (typeof obj === "string") {
+    return interpolate(obj, context2);
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => deepInterpolate(item, context2));
+  }
+  if (obj && typeof obj === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[key] = deepInterpolate(value, context2);
+    }
+    return result;
+  }
+  return obj;
+}
+function expandTilde(fp) {
+  if (!fp || typeof fp !== "string") return fp;
+  return fp.startsWith("~/") ? path13.join(os.homedir(), fp.slice(2)) : fp;
+}
+function resolveLocalPaths(obj, cwd) {
+  if (Array.isArray(obj)) {
+    return obj.map((item) => resolveLocalPaths(item, cwd));
+  }
+  if (obj && typeof obj === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      const isLocalPathKey = key === "keyPath" || key === "source";
+      if (isLocalPathKey && typeof value === "string") {
+        const expanded = expandTilde(value);
+        result[key] = path13.isAbsolute(expanded) ? expanded : path13.resolve(cwd, expanded);
+      } else {
+        result[key] = resolveLocalPaths(value, cwd);
+      }
+    }
+    return result;
+  }
+  return obj;
+}
+var SCRIPTS = {
+  SWAP: (size) => `#!/bin/bash
+set -euo pipefail
+
+# Check if swap file exists
+if [ -f /swapfile ]; then
+  CURRENT_SIZE=$(stat -c%s /swapfile 2>/dev/null || echo "0")
+  CURRENT_SIZE_GB=$((CURRENT_SIZE / 1024 / 1024 / 1024))
+  REQ_SIZE=$(echo "${size}" | tr -d 'G' | tr -d 'g')
+  
+  if [ "$CURRENT_SIZE_GB" -ge "$REQ_SIZE" ]; then
+    echo "LOG: Swap of sufficient size exists. Skipping."
+    exit 0
+  fi
+  
+  # Remove old swap if size doesn't match
+  sudo swapoff /swapfile || true
+  sudo rm /swapfile
+fi
+
+echo "LOG: Creating ${size} swap file..."
+sudo fallocate -l ${size} /swapfile || \\
+  sudo dd if=/dev/zero of=/swapfile bs=1M count=$(($(echo ${size} | tr -d 'G' | tr -d 'g') * 1024))
+
+sudo chmod 600 /swapfile
+sudo mkswap /swapfile
+sudo swapon /swapfile
+
+# Add to fstab if not already there
+grep -q "/swapfile" /etc/fstab || echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab
+
+echo "LOG: Swap file configured successfully"
+`,
+  DOCKER: (version, user, addToGroup) => `#!/bin/bash
+set -euo pipefail
+
+echo "LOG: Target Docker version: ${version}"
+
+# Check current Docker installation
+INSTALLED_VER=$(docker --version 2>/dev/null | awk '{print $3}' | tr -d ',' || echo "none")
+echo "LOG: Currently installed: $INSTALLED_VER"
+
+# Determine if we need to install/reinstall
+NEEDS_INSTALL=false
+
+if [ "$INSTALLED_VER" = "none" ]; then
+  echo "LOG: Docker not installed"
+  NEEDS_INSTALL=true
+elif [ "${version}" = "latest" ]; then
+  echo "LOG: Latest version requested"
+  NEEDS_INSTALL=true
+elif [[ "$INSTALLED_VER" != *"${version}"* ]]; then
+  echo "LOG: Version mismatch detected (need ${version}, have $INSTALLED_VER)"
+  echo "LOG: Uninstalling current Docker..."
+  
+  # Stop Docker services
+  sudo systemctl stop docker.socket 2>/dev/null || true
+  sudo systemctl stop docker 2>/dev/null || true
+  sudo systemctl stop containerd 2>/dev/null || true
+  
+  # Remove Docker packages (data is preserved)
+  sudo apt-get purge -y \\
+    docker-ce \\
+    docker-ce-cli \\
+    containerd.io \\
+    docker-buildx-plugin \\
+    docker-compose-plugin \\
+    docker-ce-rootless-extras \\
+    2>/dev/null || true
+  
+  sudo apt-get purge -y docker docker-engine docker.io runc 2>/dev/null || true
+  sudo apt-get autoremove -y
+  
+  echo "LOG: Uninstall complete"
+  NEEDS_INSTALL=true
+else
+  echo "LOG: Correct version already installed"
+fi
+
+if [ "$NEEDS_INSTALL" = true ]; then
+  echo "LOG: Installing Docker ${version}..."
+  
+  # Update and install prerequisites
+  sudo apt-get update -y
+  sudo apt-get install -y ca-certificates curl gnupg lsb-release
+  
+  # Add Docker GPG key
+  sudo install -m 0755 -d /etc/apt/keyrings
+  curl -fsSL https://download.docker.com/linux/ubuntu/gpg | \\
+    sudo gpg --dearmor --batch --yes -o /etc/apt/keyrings/docker.gpg
+  sudo chmod a+r /etc/apt/keyrings/docker.gpg
+  
+  # Add Docker repository
+  ARCH="$(dpkg --print-architecture)"
+  RELEASE="$(lsb_release -cs)"
+  echo "deb [arch=\${ARCH} signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \${RELEASE} stable" | \\
+    sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
+  
+  sudo apt-get update -y
+  
+  # Install Docker
+  if [ "${version}" = "latest" ]; then
+    echo "LOG: Installing latest Docker version"
+    sudo apt-get install -y \\
+      docker-ce \\
+      docker-ce-cli \\
+      containerd.io \\
+      docker-buildx-plugin \\
+      docker-compose-plugin
+  else
+    echo "LOG: Finding version ${version}..."
+    VERSION_STRING=$(apt-cache madison docker-ce | grep "${version}" | head -1 | awk '{print $3}')
+    
+    if [ -z "$VERSION_STRING" ]; then
+      echo "LOG: ERROR - Version ${version} not found!"
+      echo "LOG: Available versions:"
+      apt-cache madison docker-ce | head -10
+      exit 1
+    fi
+    
+    echo "LOG: Installing Docker CE version: $VERSION_STRING"
+    sudo apt-get install -y \\
+      docker-ce=$VERSION_STRING \\
+      docker-ce-cli=$VERSION_STRING \\
+      containerd.io \\
+      docker-buildx-plugin \\
+      docker-compose-plugin
+  fi
+  
+  # Enable and start Docker
+  sudo systemctl enable docker
+  sudo systemctl start docker
+  
+  FINAL_VER=$(docker --version | awk '{print $3}' | tr -d ',')
+  echo "LOG: Docker installed successfully - $FINAL_VER"
+fi
+
+# Configure docker group
+if [ "${addToGroup}" = "true" ]; then
+  if ! getent group docker >/dev/null 2>&1; then
+    sudo groupadd docker
+    echo "LOG: Created docker group"
+  fi
+  
+  if groups ${user} | grep -q '\\bdocker\\b'; then
+    echo "LOG: User ${user} already in docker group"
+  else
+    sudo usermod -aG docker ${user}
+    echo "LOG: Added ${user} to docker group (logout required)"
+  fi
+fi
+`
+};
+var RemoteShell = class {
+  constructor(ssh) {
+    this.ssh = ssh;
+  }
+  async uploadContent(remotePath, content) {
+    const localTmp = path13.join(os.tmpdir(), `pod_tmp_${Date.now()}`);
+    fs10.writeFileSync(localTmp, content);
+    try {
+      await this.ssh.execCommand(`mkdir -p $(dirname ${remotePath})`);
+      await this.ssh.putFile(localTmp, remotePath);
+    } finally {
+      if (fs10.existsSync(localTmp)) fs10.unlinkSync(localTmp);
+    }
+  }
+  async runScript(name, content, context2) {
+    const interpolated = interpolate(content, context2);
+    const remotePath = `/tmp/pod_script_${name}_${Date.now()}.sh`;
+    await this.uploadContent(remotePath, interpolated);
+    try {
+      await this.ssh.execCommand(`chmod +x ${remotePath}`);
+      return await this.run(remotePath, context2);
+    } finally {
+      await this.ssh.execCommand(`rm -f ${remotePath}`);
+    }
+  }
+  async run(cmd, context2, silent = false) {
+    const interpolated = interpolate(cmd, context2);
+    const result = await this.ssh.execCommand(interpolated);
+    if (result.code !== 0 && result.code !== null) {
+      throw new Error(`Execution failed: ${cmd}
+STDERR: ${result.stderr}`);
+    }
+    if (!silent && result.stdout) {
+      result.stdout.split("\n").filter((l) => l.startsWith("LOG:")).forEach((l) => console.log(chalk.gray(` ${l.replace("LOG: ", "")}`)));
+    }
+    return result;
+  }
+  async readJson(remotePath) {
+    const res = await this.ssh.execCommand(`cat ${remotePath}`);
+    try {
+      return res.code === 0 ? JSON.parse(res.stdout) : null;
+    } catch {
+      return null;
+    }
+  }
+};
+async function deploy(targetName, options) {
+  const cwd = process.cwd();
+  const rawConfig = yaml2.load(
+    fs10.readFileSync(path13.join(cwd, "pod.deploy.yml"), "utf8")
+  );
+  const rawTarget = rawConfig.targets?.[targetName];
+  if (!rawTarget) throw new Error(`Target ${targetName} not found.`);
+  console.log(
+    chalk.blue.bold(
+      `
+\u{1F680} Pod Deploy: ${rawConfig.name} v${rawConfig.version} \u2192 ${targetName}
+`
+    )
+  );
+  let target = deepInterpolate(rawTarget, {
+    ...rawConfig,
+    ...rawTarget
+  });
+  target = resolveLocalPaths(target, cwd);
+  const ssh = new NodeSSH();
+  const shell = new RemoteShell(ssh);
+  try {
+    await ssh.connect({
+      host: target.host,
+      username: target.user,
+      privateKeyPath: target.keyPath,
+      port: target.port || 22
+    });
+    const lockPath = path13.posix.join(target.deployPath, "pod-lock.json");
+    let lock = await shell.readJson(lockPath) || {
+      ensures: {},
+      once_actions: []
+    };
+    if (lock.deployment_version !== rawConfig.version) {
+      console.log(chalk.magenta(`\u2192 Version change: ${rawConfig.version}`));
+      lock.deployment_version = rawConfig.version;
+      lock.once_actions = [];
+      await shell.uploadContent(lockPath, JSON.stringify(lock, null, 2));
+    }
+    for (const op of target.operations) {
+      try {
+        if (op.type === "ensure") {
+          await handleEnsure(op, shell, target, lock, lockPath, options);
+        } else if (op.type === "action") {
+          await handleAction(op, shell, target, lock, lockPath);
+        } else if (op.type === "verify") {
+          await handleVerify(op, shell, target);
+        } else {
+          throw new Error(`Unknown operation type: ${op.type}`);
+        }
+      } catch (err) {
+        throw new Error(`Failed at operation "${op.name}": ${err.message}`);
+      }
+    }
+    console.log(chalk.green.bold(`
+\u2705 Deployment successful!
+`));
+  } catch (err) {
+    console.error(chalk.red.bold(`
+\u274C Deployment Failed: ${err.message}`));
+    throw err;
+  } finally {
+    ssh.dispose();
+  }
+}
+async function handleEnsure(op, shell, target, lock, lockPath, options) {
+  if (!op.ensure) {
+    throw new Error(`Ensure operation "${op.name}" missing ensure config`);
+  }
+  if (op.ensure.swap) {
+    const key = "swap";
+    const locked = lock.ensures[key];
+    const currentConfig = op.ensure.swap;
+    const configChanged = JSON.stringify(locked?.config) !== JSON.stringify(currentConfig);
+    if (options?.forceEnsure || !locked || locked.version !== currentConfig.size || configChanged) {
+      console.log(chalk.yellow(`\u2192 Ensuring: ${op.name}`));
+      const script = SCRIPTS.SWAP(currentConfig.size);
+      await shell.runScript(key, script, target);
+      lock.ensures[key] = {
+        version: currentConfig.size,
+        config: currentConfig
+      };
+      await shell.uploadContent(lockPath, JSON.stringify(lock, null, 2));
+    } else {
+      console.log(chalk.gray(`\u2713 ${op.name} (already satisfied)`));
+    }
+  }
+  if (op.ensure.docker) {
+    const key = "docker";
+    const locked = lock.ensures[key];
+    const currentConfig = op.ensure.docker;
+    const configChanged = JSON.stringify(locked?.config) !== JSON.stringify(currentConfig);
+    if (options?.forceEnsure || !locked || locked.version !== currentConfig.version || configChanged) {
+      console.log(chalk.yellow(`\u2192 Ensuring: ${op.name}`));
+      const script = SCRIPTS.DOCKER(
+        currentConfig.version,
+        target.user,
+        !!currentConfig.addUserToGroup
+      );
+      await shell.runScript(key, script, target);
+      lock.ensures[key] = {
+        version: currentConfig.version,
+        config: currentConfig
+      };
+      await shell.uploadContent(lockPath, JSON.stringify(lock, null, 2));
+    } else {
+      console.log(chalk.gray(`\u2713 ${op.name} (already satisfied)`));
+    }
+  }
+  if (op.ensure.directory) {
+    const key = `directory_${op.ensure.directory.path}`;
+    const locked = lock.ensures[key];
+    const currentConfig = op.ensure.directory;
+    const configChanged = JSON.stringify(locked?.config) !== JSON.stringify(currentConfig);
+    if (options?.forceEnsure || !locked || configChanged) {
+      console.log(chalk.yellow(`\u2192 Ensuring: ${op.name}`));
+      const dirPath = interpolate(currentConfig.path, target);
+      const owner = currentConfig.owner ? interpolate(currentConfig.owner, target) : target.user;
+      await shell.run(`mkdir -p ${dirPath}`, target, true);
+      await shell.run(
+        `sudo chown -R ${owner}:${owner} ${dirPath}`,
+        target,
+        true
+      );
+      lock.ensures[key] = {
+        version: dirPath,
+        config: currentConfig
+      };
+      await shell.uploadContent(lockPath, JSON.stringify(lock, null, 2));
+    } else {
+      console.log(chalk.gray(`\u2713 ${op.name} (already satisfied)`));
+    }
+  }
+}
+async function handleAction(op, shell, target, lock, lockPath) {
+  if (!op.action) {
+    throw new Error(`Action operation "${op.name}" missing action config`);
+  }
+  const when = op.when || "always";
+  if (when === "never") {
+    console.log(chalk.gray(`\u2298 ${op.name} (disabled)`));
+    return;
+  }
+  const actionId = `action_${op.name}`;
+  if (when === "once" && lock.once_actions.includes(actionId)) {
+    console.log(chalk.gray(`\u2713 ${op.name} (already completed)`));
+    return;
+  }
+  console.log(chalk.cyan(`\u2192 Running: ${op.name}`));
+  if (op.action.rsync) {
+    const src = op.action.rsync.source;
+    const dest = interpolate(op.action.rsync.destination || ".", target);
+    const putOptions = { recursive: true, concurrency: 10 };
+    if (op.action.rsync.exclude?.length) {
+      const excludePatterns = op.action.rsync.exclude;
+      putOptions.validate = (filePath) => {
+        const relative = path13.relative(src, filePath);
+        if (relative === "") return true;
+        return !excludePatterns.some((pattern) => {
+          if (pattern.endsWith("/")) {
+            const dir = pattern.slice(0, -1);
+            const segment = "/" + dir + "/";
+            return relative === dir || relative.startsWith(dir + "/") || relative.includes(segment);
+          }
+          if (pattern.startsWith("*.")) {
+            return relative.endsWith(pattern.slice(1));
+          }
+          return relative === pattern;
+        });
+      };
+    }
+    console.log(chalk.gray(` Syncing ${src} \u2192 ${dest}`));
+    await shell.ssh.putDirectory(src, dest, putOptions);
+  }
+  if (op.action.command) {
+    await shell.run(op.action.command, target);
+  }
+  if (when === "once") {
+    lock.once_actions.push(actionId);
+    await shell.uploadContent(lockPath, JSON.stringify(lock, null, 2));
+  }
+}
+async function handleVerify(op, shell, target) {
+  if (!op.verify) {
+    throw new Error(`Verify operation "${op.name}" missing verify config`);
+  }
+  console.log(chalk.cyan(`\u2192 Verifying: ${op.name}`));
+  if (op.verify.http) {
+    const url = interpolate(op.verify.http.url, target);
+    const timeout = op.verify.http.timeout || "30s";
+    await shell.run(`curl -f --max-time ${timeout} ${url}`, target, true);
+  }
+  if (op.verify.command) {
+    await shell.run(op.verify.command, target, true);
+  }
+}
+
 // src/main.ts
+import chalk2 from "chalk";
 var program = new Command();
-program.name("pod").description("Pod cli tool").version("1.0.18");
+program.name("pod").description("Pod cli tool").version("1.0.20");
 program.command("new <name>").description("Start a new Pod Project").action(async (name) => {
   await addNew(name);
-  const appDir = path13.resolve(process.cwd(), name);
+  const appDir = path14.resolve(process.cwd(), name);
   const shell = process.platform === "win32" ? process.env.ComSpec || "cmd.exe" : "/bin/sh";
   console.log("Installing dependencies...");
   execSync("npm install", { stdio: "inherit", cwd: appDir, shell });
@@ -4729,10 +5315,12 @@ program.command("dockerize <env>").description("Dockerize a pod project.").actio
     console.error("\u274C Error:", err.message);
   }
 });
-program.command("deploy <type> <options>").description("Deploy a Pod Project").action(async (type, name) => {
+program.command("deploy").description("Deploy to a target environment").argument("<target>", "Target environment (e.g., ec2)").option("--force-install", "Force reinstallation even if already installed").action(async (target, options) => {
   try {
-  } catch (err) {
-    console.error("\u274C Error:", err.message);
+    await deploy(target, options);
+  } catch (error) {
+    console.error(chalk2.red(error.message));
+    process.exit(1);
   }
 });
 program.parse(process.argv);