@kithinji/pod 1.0.22 → 1.0.23

package/dist/main.js

@@ -4266,7 +4266,7 @@ build
 `;
 }
 function genEnv() {
-  return `host=localhost
+  return `HOST=localhost
 `;
 }
 function genIndexHtml(name) {
@@ -4546,100 +4546,123 @@ async function createDeployfile(cwd, projectName) {
   const deployFile = `name: ${projectName}
 version: 1.0.0
 
+vars:
+  deploy_path: &deploy_path "/home/ubuntu/${projectName}"
+  backup_path: &backup_path "/home/ubuntu/backups"
+  user: &user "ubuntu"
+
+shared_operations:
+  install_docker: &install_docker
+    type: ensure
+    ensure:
+      docker:
+        version: "28.5.2"
+        addUserToGroup: true
+
+  stop_containers: &stop_containers
+    type: action
+    action:
+      command: docker compose down --remove-orphans 2>/dev/null || true
+
+  pull_images: &pull_images
+    type: action
+    action:
+      command: docker compose pull --quiet
+
+  build_and_start: &build_and_start
+    type: action
+    action:
+      command: docker compose up -d --build --remove-orphans --wait
+
+  cleanup_docker: &cleanup_docker
+    type: action
+    action:
+      command: docker system prune -f --volumes --filter "until=168h"
+
 targets:
+  localhost:
+    type: local
+    operations:
+      #- name: "Environment Setup"
+      #  <<: *install_docker
+      - name: "Refresh Stack"
+        <<: *build_and_start
+
   ec2:
+    type: ssh
     host: ec2-xx-xx-xxx-xxx.xx-xxxx-x.compute.amazonaws.com
-    user: ubuntu
+    user: *user
     keyPath: ~/xxxx.pem
     port: 22
-    deployPath: /home/\${user}/app
+    deployPath: *deploy_path
 
     operations:
-      - name: "Setup swap space"
+      - name: "Provision Directories and Swap"
         type: ensure
         ensure:
           swap:
             size: 4G
 
       - name: "Install Docker"
-        type: ensure
-        ensure:
-          docker:
-            version: "28.5.2"
-            addUserToGroup: true
+        <<: *install_docker
 
       - name: "Create application directories"
         type: ensure
         ensure:
           directory:
-            path: \${deployPath}
-            owner: \${user}
+            path: *deploy_path
+            owner: *user
 
       - name: "Create backup directory"
         type: ensure
         ensure:
           directory:
-            path: /home/\${user}/backups
-            owner: \${user}
-
-      - name: "Stop running containers"
-        type: action
-        action:
-          command: cd \${deployPath} && docker compose down 2>/dev/null || true
+            path: *backup_path
+            owner: *user
 
-      - name: "Sync application files"
+      - name: "Sync Source Files"
         type: action
         action:
           rsync:
             source: ./
-            destination: \${deployPath}/
+            destination: *deploy_path
+            delete: true
             exclude:
-              - node_modules/
               - .git/
-              - "*.log"
+              - node_modules/
               - .env.local
-              - dist/
-              - public/
+              - "*.log"
 
-      - name: "Pull Docker images"
+      - name: "Navigate to Deploy Path"
         type: action
         action:
-          command: cd \${deployPath} && docker compose pull
+          command: cd *deploy_path
 
-      - name: "Build and start containers"
+      - name: "Create Pre-deployment Backup"
         type: action
         action:
-          command: cd \${deployPath} && docker compose up -d --build --remove-orphans
+          command: tar -czf *backup_path/backup-$(date +%Y%m%d-%H%M%S).tar.gz .
 
-      - name: "Wait for services to start"
-        type: action
-        action:
-          command: sleep 10
+      - name: "Pull Latest Images"
+        <<: *pull_images
 
-      - name: "Show container status"
-        type: action
-        action:
-          command: cd \${deployPath} && docker compose ps
+      - name: "Stop Existing Stack"
+        <<: *stop_containers
 
-      - name: "Show recent logs"
-        type: action
-        action:
-          command: cd \${deployPath} && docker compose logs --tail=30
+      - name: "Build and Launch"
+        <<: *build_and_start
 
-      - name: "Cleanup old backups"
-        type: action
-        action:
-          command: find /home/\${user}/backups -name "backup-*.tar.gz" -mtime +7 -delete
+      - name: "Verify Health Status"
+        type: verify
+        verify:
+          command: ! "[ $(docker compose ps --format json | grep -qv 'running\\|healthy') ]"
 
-      - name: "Cleanup Docker resources"
+      - name: "Maintenance: Cleanup"
         type: action
         action:
-          command: docker system prune -f --volumes
-
-      - name: "Verify containers are running"
-        type: verify
-        verify:
-          command: cd \${deployPath} && docker compose ps | grep -q "Up"
+          command: |
+            find *backup_path -name "backup-*.tar.gz" -mtime +7 -delete
+            docker image prune -af --filter "until=24h"
 `;
   const deployFilePath = path12.join(cwd, "pod.deploy.yml");
   await fs9.writeFile(deployFilePath, deployFile);
@@ -4944,6 +4967,9 @@ import path13 from "path";
 import os from "os";
 import { NodeSSH } from "node-ssh";
 import chalk from "chalk";
+import { exec } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(exec);
 function interpolate(str, context2) {
   if (!str) return "";
   return str.replace(/\${([^}]+)}/g, (match, key) => {
@@ -5142,19 +5168,42 @@ if [ "${addToGroup}" = "true" ]; then
 fi
 `
 };
-var RemoteShell = class {
-  constructor(ssh) {
-    this.ssh = ssh;
+var SSHStrategy = class {
+  constructor(target) {
+    this.ssh = new NodeSSH();
+    this.target = target;
+    this.currentDir = target.deployPath || ".";
+  }
+  async connect() {
+    await this.ssh.connect({
+      host: this.target.host,
+      username: this.target.user,
+      privateKeyPath: this.target.keyPath,
+      port: this.target.port || 22
+    });
   }
-  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 disconnect() {
+    this.ssh.dispose();
+  }
+  async runCommand(cmd, silent = false) {
+    const trimmed = cmd.trim();
+    if (trimmed.startsWith("cd ")) {
+      const newPath = trimmed.replace("cd ", "").trim();
+      this.currentDir = path13.posix.resolve(this.currentDir, newPath);
+      if (!silent) console.log(chalk.gray(` [SSH Path: ${this.currentDir}]`));
+      return { stdout: "", stderr: "", code: 0 };
     }
+    const result = await this.ssh.execCommand(trimmed, {
+      cwd: this.currentDir
+    });
+    if (result.code !== 0 && result.code !== null) {
+      throw new Error(`Execution failed: ${trimmed}
+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 runScript(name, content, context2) {
     const interpolated = interpolate(content, context2);
@@ -5162,22 +5211,20 @@ var RemoteShell = class {
     await this.uploadContent(remotePath, interpolated);
     try {
       await this.ssh.execCommand(`chmod +x ${remotePath}`);
-      return await this.run(remotePath, context2);
+      await this.runCommand(remotePath);
     } 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: ", "")}`)));
+  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);
     }
-    return result;
   }
   async readJson(remotePath) {
     const res = await this.ssh.execCommand(`cat ${remotePath}`);
@@ -5187,211 +5234,354 @@ STDERR: ${result.stderr}`);
       return null;
     }
   }
+  async syncDirectory(source, destination, exclude) {
+    const putOptions = { recursive: true, concurrency: 10 };
+    if (exclude?.length) {
+      putOptions.validate = (filePath) => {
+        const relative = path13.relative(source, filePath);
+        if (relative === "") return true;
+        return !exclude.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 ${source} \u2192 ${destination}`));
+    await this.ssh.putDirectory(source, destination, putOptions);
+  }
 };
-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));
+var LocalStrategy = class {
+  constructor(target, cwd) {
+    this.target = target;
+    this.currentDir = cwd;
+  }
+  async connect() {
+  }
+  async disconnect() {
+  }
+  async runCommand(cmd, silent = false) {
+    const trimmed = cmd.trim();
+    if (trimmed.startsWith("cd ")) {
+      const newPath = trimmed.replace("cd ", "").trim();
+      this.currentDir = path13.resolve(this.currentDir, newPath);
+      if (!silent) console.log(chalk.gray(` [Local Path: ${this.currentDir}]`));
+      return { stdout: "", stderr: "", code: 0 };
     }
-    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);
+    try {
+      const { stdout, stderr } = await execAsync(trimmed, {
+        cwd: this.currentDir
+      });
+      if (!silent && stdout) {
+        stdout.split("\n").filter((l) => l.startsWith("LOG:")).forEach(
+          (l) => console.log(chalk.gray(` ${l.replace("LOG: ", "")}`))
+        );
+      }
+      return { stdout, stderr, code: 0 };
+    } catch (err) {
+      throw new Error(
+        `Execution failed: ${trimmed}
+STDERR: ${err.stderr || err.message}`
+      );
+    }
+  }
+  async runScript(name, content, context2) {
+    const interpolated = interpolate(content, context2);
+    const scriptPath = path13.join(
+      os.tmpdir(),
+      `pod_script_${name}_${Date.now()}.sh`
+    );
+    fs10.writeFileSync(scriptPath, interpolated);
+    fs10.chmodSync(scriptPath, "755");
+    try {
+      await this.runCommand(scriptPath);
+    } finally {
+      if (fs10.existsSync(scriptPath)) fs10.unlinkSync(scriptPath);
+    }
+  }
+  async uploadContent(localPath, content) {
+    const dir = path13.dirname(localPath);
+    if (!fs10.existsSync(dir)) {
+      fs10.mkdirSync(dir, { recursive: true });
+    }
+    fs10.writeFileSync(localPath, content);
+  }
+  async readJson(localPath) {
+    try {
+      if (!fs10.existsSync(localPath)) return null;
+      const content = fs10.readFileSync(localPath, "utf8");
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+  async syncDirectory(source, destination, exclude) {
+    console.log(chalk.gray(` Copying ${source} \u2192 ${destination}`));
+    if (!fs10.existsSync(destination)) {
+      fs10.mkdirSync(destination, { recursive: true });
+    }
+    const shouldExclude = (relativePath) => {
+      if (!exclude?.length) return false;
+      return exclude.some((pattern) => {
+        if (pattern.endsWith("/")) {
+          const dir = pattern.slice(0, -1);
+          const segment = "/" + dir + "/";
+          return relativePath === dir || relativePath.startsWith(dir + "/") || relativePath.includes(segment);
+        }
+        if (pattern.startsWith("*.")) {
+          return relativePath.endsWith(pattern.slice(1));
+        }
+        return relativePath === pattern;
+      });
+    };
+    const copyRecursive = (src, dest) => {
+      const entries = fs10.readdirSync(src, { withFileTypes: true });
+      for (const entry of entries) {
+        const srcPath = path13.join(src, entry.name);
+        const destPath = path13.join(dest, entry.name);
+        const relativePath = path13.relative(source, srcPath);
+        if (shouldExclude(relativePath)) continue;
+        if (entry.isDirectory()) {
+          if (!fs10.existsSync(destPath)) {
+            fs10.mkdirSync(destPath, { recursive: true });
+          }
+          copyRecursive(srcPath, destPath);
         } else {
-          throw new Error(`Unknown operation type: ${op.type}`);
+          fs10.copyFileSync(srcPath, destPath);
         }
-      } catch (err) {
-        throw new Error(`Failed at operation "${op.name}": ${err.message}`);
       }
+    };
+    copyRecursive(source, destination);
+  }
+};
+var StrategyFactory = class {
+  static create(target, cwd) {
+    const targetType = target.type || (target.host ? "ssh" : "local");
+    switch (targetType) {
+      case "ssh":
+        return new SSHStrategy(target);
+      case "local":
+        return new LocalStrategy(target, cwd);
+      default:
+        throw new Error(`Unknown target type: ${targetType}`);
     }
-    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`);
+};
+var OperationHandler = class {
+  constructor(strategy, target, lock, lockPath) {
+    this.strategy = strategy;
+    this.target = target;
+    this.lock = lock;
+    this.lockPath = lockPath;
+  }
+  async handleEnsure(op, options) {
+    if (!op.ensure) {
+      throw new Error(`Ensure operation "${op.name}" missing ensure config`);
+    }
+    if (op.ensure.swap) {
+      await this.ensureSwap(op, options);
+    }
+    if (op.ensure.docker) {
+      await this.ensureDocker(op, options);
+    }
+    if (op.ensure.directory) {
+      await this.ensureDirectory(op, options);
+    }
   }
-  if (op.ensure.swap) {
+  async ensureSwap(op, options) {
     const key = "swap";
-    const locked = lock.ensures[key];
+    const locked = this.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] = {
+      await this.strategy.runScript(key, script, this.target);
+      this.lock.ensures[key] = {
         version: currentConfig.size,
         config: currentConfig
       };
-      await shell.uploadContent(lockPath, JSON.stringify(lock, null, 2));
+      await this.saveLock();
     } else {
       console.log(chalk.gray(`\u2713 ${op.name} (already satisfied)`));
     }
   }
-  if (op.ensure.docker) {
+  async ensureDocker(op, options) {
     const key = "docker";
-    const locked = lock.ensures[key];
+    const locked = this.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,
+        this.target.user || os.userInfo().username,
         !!currentConfig.addUserToGroup
       );
-      await shell.runScript(key, script, target);
-      lock.ensures[key] = {
+      await this.strategy.runScript(key, script, this.target);
+      this.lock.ensures[key] = {
         version: currentConfig.version,
         config: currentConfig
       };
-      await shell.uploadContent(lockPath, JSON.stringify(lock, null, 2));
+      await this.saveLock();
     } else {
       console.log(chalk.gray(`\u2713 ${op.name} (already satisfied)`));
     }
   }
-  if (op.ensure.directory) {
+  async ensureDirectory(op, options) {
     const key = `directory_${op.ensure.directory.path}`;
-    const locked = lock.ensures[key];
+    const locked = this.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] = {
+      const dirPath = interpolate(currentConfig.path, this.target);
+      const owner = currentConfig.owner ? interpolate(currentConfig.owner, this.target) : this.target.user || os.userInfo().username;
+      await this.strategy.runCommand(`mkdir -p ${dirPath}`, true);
+      if (this.target.user) {
+        await this.strategy.runCommand(
+          `sudo chown -R ${owner}:${owner} ${dirPath}`,
+          true
+        );
+      }
+      this.lock.ensures[key] = {
         version: dirPath,
         config: currentConfig
       };
-      await shell.uploadContent(lockPath, JSON.stringify(lock, null, 2));
+      await this.saveLock();
     } 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;
-        });
-      };
+  async handleAction(op) {
+    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" && this.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 || ".", this.target);
+      await this.strategy.syncDirectory(src, dest, op.action.rsync.exclude);
+    }
+    if (op.action.command) {
+      const cmd = interpolate(op.action.command, this.target);
+      await this.strategy.runCommand(cmd);
+    }
+    if (when === "once") {
+      this.lock.once_actions.push(actionId);
+      await this.saveLock();
     }
-    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`);
+  async handleVerify(op) {
+    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, this.target);
+      const timeout = op.verify.http.timeout || "30s";
+      await this.strategy.runCommand(
+        `curl -f --max-time ${timeout} ${url}`,
+        true
+      );
+    }
+    if (op.verify.command) {
+      const cmd = interpolate(op.verify.command, this.target);
+      await this.strategy.runCommand(cmd, true);
+    }
   }
-  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);
+  async saveLock() {
+    await this.strategy.uploadContent(
+      this.lockPath,
+      JSON.stringify(this.lock, null, 2)
+    );
   }
-  if (op.verify.command) {
-    await shell.run(op.verify.command, target, true);
+};
+async function deploy(targetName, options) {
+  const cwd = process.cwd();
+  const rawConfig = yaml2.load(
+    fs10.readFileSync(path13.join(cwd, "pod.deploy.yml"), "utf8"),
+    { schema: yaml2.DEFAULT_SCHEMA }
+  );
+  const rawTarget = rawConfig.targets?.[targetName];
+  if (!rawTarget) throw new Error(`Target ${targetName} not found.`);
+  console.log(
+    chalk.blue.bold(
+      `
+Pod Deploy: ${rawConfig.name} v${rawConfig.version} \u2192 ${targetName}
+`
+    )
+  );
+  let target = deepInterpolate(rawTarget, {
+    ...rawConfig,
+    ...rawTarget
+  });
+  target = resolveLocalPaths(target, cwd);
+  const strategy = StrategyFactory.create(target, cwd);
+  try {
+    await strategy.connect();
+    const lockPath = target.deployPath ? path13.posix.join(target.deployPath, "pod-lock.json") : path13.join(cwd, "pod-lock.json");
+    let lock = await strategy.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 strategy.uploadContent(lockPath, JSON.stringify(lock, null, 2));
+    }
+    const handler = new OperationHandler(strategy, target, lock, lockPath);
+    for (const op of target.operations) {
+      try {
+        if (op.type === "ensure") {
+          await handler.handleEnsure(op, options);
+        } else if (op.type === "action") {
+          await handler.handleAction(op);
+        } else if (op.type === "verify") {
+          await handler.handleVerify(op);
+        } 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(`
+Deployment successful!
+`));
+  } catch (err) {
+    console.error(chalk.red.bold(`
+Deployment Failed: ${err.message}`));
+    throw err;
+  } finally {
+    await strategy.disconnect();
   }
 }
 
 // src/main.ts
 import chalk2 from "chalk";
 var program = new Command();
-program.name("pod").description("Pod cli tool").version("1.0.22");
+program.name("pod").description("Pod cli tool").version("1.0.23");
 program.command("new <name>").description("Start a new Orca Project").action(async (name) => {
   await addNew(name);
-  const appDir = path14.resolve(process.cwd(), name);
+  const appDir = path14.resolve(process.cwd());
   const shell = process.platform === "win32" ? process.env.ComSpec || "cmd.exe" : "/bin/sh";
   console.log("Installing dependencies...");
   execSync("npm install", { stdio: "inherit", cwd: appDir, shell });