@kithinji/pod 1.0.22 → 1.0.24

package/dist/main.js

@@ -928,79 +928,144 @@ async function expandMacros(source, filePath, projectRoot = process.cwd()) {
 import * as path4 from "path";
 import { parseSync } from "@swc/core";
 function generateController(filePath, code) {
-  const ast = parseSync(code, {
-    syntax: "typescript",
-    tsx: filePath.endsWith("x"),
-    decorators: true
-  });
-  const serviceInfo = extractServiceInfo(ast);
-  if (!serviceInfo || !serviceInfo.hasInjectable) return null;
-  return generateControllerCode(serviceInfo, filePath);
+  try {
+    const ast = parseSync(code, {
+      syntax: "typescript",
+      tsx: filePath.endsWith("x") || filePath.endsWith(".tsx"),
+      decorators: true
+    });
+    const serviceInfo = extractServiceInfo(ast, filePath);
+    if (!serviceInfo || !serviceInfo.hasInjectable) {
+      return null;
+    }
+    validateServiceInfo(serviceInfo, filePath);
+    return generateControllerCode(serviceInfo, filePath);
+  } catch (error) {
+    if (error.type) {
+      throw error;
+    }
+    throw {
+      type: "parse",
+      message: `Failed to parse TypeScript file: ${error.message}`,
+      filePath,
+      details: error
+    };
+  }
 }
-function extractServiceInfo(ast) {
+function extractServiceInfo(ast, filePath) {
   let serviceClass = null;
   let hasInjectable = false;
   const importMap = {};
-  for (const item of ast.body) {
-    if (item.type === "ImportDeclaration") {
-      const decl = item;
-      const source = decl.source.value;
-      decl.specifiers.forEach((spec) => {
-        if (spec.type === "ImportSpecifier" || spec.type === "ImportDefaultSpecifier" || spec.type === "ImportNamespaceSpecifier") {
-          importMap[spec.local.value] = source;
+  try {
+    for (const item of ast.body) {
+      if (item.type === "ImportDeclaration") {
+        const decl = item;
+        const source = decl.source.value;
+        decl.specifiers.forEach((spec) => {
+          if (spec.type === "ImportSpecifier" || spec.type === "ImportDefaultSpecifier" || spec.type === "ImportNamespaceSpecifier") {
+            importMap[spec.local.value] = source;
+          }
+        });
+      }
+      if (item.type === "ExportDeclaration" && item.declaration?.type === "ClassDeclaration") {
+        const classDecl = item.declaration;
+        if (hasInjectableDecorator(classDecl.decorators)) {
+          serviceClass = classDecl;
+          hasInjectable = true;
         }
-      });
-    }
-    if (item.type === "ExportDeclaration" && item.declaration.type === "ClassDeclaration") {
-      const classDecl = item.declaration;
-      if (hasInjectableDecorator(classDecl.decorators)) {
-        serviceClass = classDecl;
-        hasInjectable = true;
       }
     }
+    if (!serviceClass?.identifier) {
+      return null;
+    }
+    return {
+      className: serviceClass.identifier.value,
+      methods: extractMethods(serviceClass, filePath),
+      hasInjectable,
+      importMap
+    };
+  } catch (error) {
+    throw {
+      type: "parse",
+      message: `Failed to extract service info: ${error.message}`,
+      filePath,
+      details: error
+    };
   }
-  if (!serviceClass || !serviceClass.identifier) return null;
-  return {
-    className: serviceClass.identifier.value,
-    methods: extractMethods(serviceClass),
-    hasInjectable,
-    importMap
-  };
 }
 function hasInjectableDecorator(decorators) {
-  return decorators?.some((d) => {
+  if (!decorators) return false;
+  return decorators.some((d) => {
     const expr = d.expression;
     return expr.type === "Identifier" && expr.value === "Injectable" || expr.type === "CallExpression" && expr.callee.type === "Identifier" && expr.callee.value === "Injectable";
-  }) ?? false;
+  });
 }
-function extractMethods(classDecl) {
+function extractMethods(classDecl, filePath) {
   const methods = [];
+  const className = classDecl.identifier?.value || "UnknownClass";
   for (const member of classDecl.body) {
-    if (member.type === "ClassMethod" && member.accessibility === "public") {
-      const method = member;
-      const methodName = method.key.type === "Identifier" ? method.key.value : "";
-      if (!methodName) continue;
-      if (!method.function.async) {
-        throw new Error(
-          `Server action ${classDecl.identifier.value}.${methodName} must be async.`
-        );
-      }
-      const { paramSchemas, returnSchema } = extractSignature(
-        method.function.decorators,
-        method.function.params.length
-      );
-      methods.push({
-        name: methodName,
-        params: extractMethodParams(method.function.params),
-        returnType: extractReturnType(method.function.returnType),
-        isAsync: true,
-        paramSchemas,
-        returnSchema
-      });
+    if (!isPublicMethod(member)) continue;
+    const method = member;
+    const methodName = getMethodName(method);
+    if (!methodName) continue;
+    const returnTypeInfo = analyzeReturnType(method);
+    if (!returnTypeInfo.isObservable && !method.function.async) {
+      throw {
+        type: "validation",
+        message: `Method ${className}.${methodName} must be async or return an Observable`,
+        filePath,
+        details: { className, methodName }
+      };
     }
+    const { paramSchemas, returnSchema } = extractSignature(
+      method.function.decorators,
+      method.function.params.length
+    );
+    methods.push({
+      name: methodName,
+      params: extractMethodParams(method.function.params),
+      returnType: returnTypeInfo.type,
+      isAsync: method.function.async,
+      isObservable: returnTypeInfo.isObservable,
+      paramSchemas,
+      returnSchema
+    });
   }
   return methods;
 }
+function isPublicMethod(member) {
+  return member.type === "ClassMethod" && (member.accessibility === "public" || !member.accessibility);
+}
+function getMethodName(method) {
+  if (method.key.type === "Identifier") {
+    return method.key.value;
+  }
+  return null;
+}
+function analyzeReturnType(method) {
+  const returnType = method.function.returnType?.typeAnnotation;
+  if (!returnType) {
+    return { type: "any", isObservable: false };
+  }
+  if (returnType.type === "TsTypeReference" && returnType.typeName.type === "Identifier" && returnType.typeName.value === "Observable") {
+    const innerType = returnType.typeParams?.params[0];
+    return {
+      type: innerType ? stringifyType(innerType) : "any",
+      isObservable: true
+    };
+  }
+  if (returnType.type === "TsTypeReference" && returnType.typeName.type === "Identifier" && returnType.typeName.value === "Promise") {
+    const innerType = returnType.typeParams?.params[0];
+    return {
+      type: innerType ? stringifyType(innerType) : "any",
+      isObservable: false
+    };
+  }
+  return {
+    type: stringifyType(returnType),
+    isObservable: false
+  };
+}
 function extractSignature(decorators, paramCount) {
   if (!decorators) return { paramSchemas: [] };
   for (const decorator of decorators) {
@@ -1023,9 +1088,14 @@ function extractSignature(decorators, paramCount) {
   return { paramSchemas: [] };
 }
 function stringifyExpression(expr) {
-  if (expr.type === "Identifier") return expr.value;
+  if (!expr) return "any";
+  if (expr.type === "Identifier") {
+    return expr.value;
+  }
   if (expr.type === "MemberExpression") {
-    return `${stringifyExpression(expr.object)}.${expr.property.value || ""}`;
+    const object = stringifyExpression(expr.object);
+    const property = expr.property.value || stringifyExpression(expr.property);
+    return `${object}.${property}`;
   }
   if (expr.type === "CallExpression") {
     const args = expr.arguments.map((a) => stringifyExpression(a.expression)).join(", ");
@@ -1036,6 +1106,13 @@ function stringifyExpression(expr) {
 function extractMethodParams(params) {
   return params.map((p) => {
     const pat = p.pat;
+    if (pat.type !== "Identifier") {
+      return {
+        name: "param",
+        type: "any",
+        decorators: []
+      };
+    }
     return {
       name: pat.value,
       type: pat.typeAnnotation ? stringifyType(pat.typeAnnotation.typeAnnotation) : "any",
@@ -1043,97 +1120,191 @@ function extractMethodParams(params) {
     };
   });
 }
-function extractReturnType(node) {
-  if (!node?.typeAnnotation) return "any";
-  const type = node.typeAnnotation;
-  if (type.type === "TsTypeReference" && type.typeName.value === "Promise") {
-    return stringifyType(type.typeParams?.params[0]);
-  }
-  return stringifyType(type);
-}
 function stringifyType(node) {
   if (!node) return "any";
   switch (node.type) {
     case "TsKeywordType":
       return node.kind;
     case "TsTypeReference":
+      if (node.typeName.type !== "Identifier") return "any";
       const base = node.typeName.value;
-      const args = node.typeParams ? `<${node.typeParams.params.map(stringifyType).join(", ")}>` : "";
+      const args = node.typeParams?.params ? `<${node.typeParams.params.map(stringifyType).join(", ")}>` : "";
       return base + args;
     case "TsArrayType":
       return `${stringifyType(node.elemType)}[]`;
+    case "TsUnionType":
+      return node.types.map(stringifyType).join(" | ");
+    case "TsIntersectionType":
+      return node.types.map(stringifyType).join(" & ");
     default:
       return "any";
   }
 }
+function validateServiceInfo(serviceInfo, filePath) {
+  if (!serviceInfo.className) {
+    throw {
+      type: "validation",
+      message: "Service class must have a valid name",
+      filePath
+    };
+  }
+  if (serviceInfo.methods.length === 0) {
+    console.warn(
+      `Warning: Service ${serviceInfo.className} has no public methods`
+    );
+  }
+  serviceInfo.methods.forEach((method) => {
+    if (method.params.length > 0 && method.paramSchemas.length === 0) {
+      console.warn(
+        `Warning: Method ${serviceInfo.className}.${method.name} has parameters but no @Signature validation`
+      );
+    }
+  });
+}
 function generateControllerCode(serviceInfo, filePath) {
   const serviceName = serviceInfo.className;
-  const controllerName = serviceName.replace(/Service$/, "AutoController");
-  const serviceImportPath = `./${path4.basename(filePath).replace(/\.ts$/, "")}`;
+  const controllerName = serviceName.replace(/Service$/, "GenController");
+  const serviceImportPath = getImportPath(filePath);
+  const controllerPath = serviceNameToPath(serviceName);
+  const imports = generateImports(serviceInfo, serviceName, serviceImportPath);
+  const methods = generateMethods(serviceInfo);
+  const serviceInstance = toInstanceName(serviceName);
+  return `${imports}
+
+@Controller("/${controllerPath}", {
+  providedIn: "root",
+})
+export class ${controllerName} {
+  constructor(private readonly ${serviceInstance}: ${serviceName}) {}
+
+${methods}
+}`;
+}
+function getImportPath(filePath) {
+  const basename3 = path4.basename(filePath);
+  return `./${basename3.replace(/\.tsx?$/, "")}`;
+}
+function serviceNameToPath(serviceName) {
+  return serviceName.replace(/Service$/, "").replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+}
+function toInstanceName(className) {
+  return className.charAt(0).toLowerCase() + className.slice(1);
+}
+function generateImports(serviceInfo, serviceName, serviceImportPath) {
   const importGroups = /* @__PURE__ */ new Map();
   const registerIdentifier = (id) => {
     const source = serviceInfo.importMap[id] || serviceImportPath;
-    if (!importGroups.has(source)) importGroups.set(source, /* @__PURE__ */ new Set());
+    if (!importGroups.has(source)) {
+      importGroups.set(source, /* @__PURE__ */ new Set());
+    }
     importGroups.get(source).add(id);
   };
   serviceInfo.methods.forEach((m) => {
     [...m.paramSchemas, m.returnSchema].filter(Boolean).forEach((s) => {
       const matches = s.match(/[A-Z][a-zA-Z0-9]*/g);
       matches?.forEach(registerIdentifier);
-      if (s.includes("z.")) registerIdentifier("z");
+      if (s.includes("z.")) {
+        registerIdentifier("z");
+      }
     });
   });
-  let importStrings = `import { Controller, Post, Get, Body } from "@kithinji/orca";
+  const hasPost = serviceInfo.methods.some(
+    (m) => !m.isObservable && m.params.length > 0
+  );
+  const hasGet = serviceInfo.methods.some(
+    (m) => !m.isObservable && m.params.length === 0
+  );
+  const hasSse = serviceInfo.methods.some((m) => m.isObservable);
+  const hasSseWithParams = serviceInfo.methods.some(
+    (m) => m.isObservable && m.params.length > 0
+  );
+  const decorators = ["Controller"];
+  if (hasPost) decorators.push("Post");
+  if (hasGet) decorators.push("Get");
+  if (hasPost) decorators.push("Body");
+  if (hasSse) decorators.push("Sse");
+  if (hasSseWithParams) decorators.push("Query");
+  let importStrings = `import { ${decorators.join(
+    ", "
+  )} } from "@kithinji/orca";
 `;
   importGroups.forEach((ids, source) => {
     const filteredIds = Array.from(ids).filter((id) => id !== serviceName);
     if (filteredIds.length > 0) {
-      importStrings += `
-import { ${filteredIds.join(
+      importStrings += `import { ${filteredIds.join(
         ", "
-      )} } from "${source}";`;
-    }
-  });
-  const methods = serviceInfo.methods.map((m) => {
-    const hasParams = m.params.length > 0;
-    const bodyParam = hasParams ? `@Body() body: any` : "";
-    let body = "";
-    if (hasParams) {
-      if (m.paramSchemas.length > 0) {
-        body += `    const b = typeof body === 'object' && body !== null ? body : {};
-`;
-        m.params.forEach((p, i) => {
-          body += `    const ${p.name} = ${m.paramSchemas[i]}.parse(b.${p.name});
+      )} } from "${source}";
 `;
-        });
-      } else {
-        body += `    const { ${m.params.map((p) => p.name).join(", ")} } = body;
-`;
-      }
     }
-    const callArgs = m.params.map((p) => p.name).join(", ");
-    const serviceCall = `this.${serviceName.charAt(0).toLowerCase() + serviceName.slice(1)}.${m.name}(${callArgs})`;
-    if (m.returnSchema) {
-      body += `    const res = await ${serviceCall};
-    return ${m.returnSchema}.parse(res);`;
-    } else {
-      body += `    return ${serviceCall};`;
-    }
-    return `  @${hasParams ? "Post" : "Get"}("${m.name}")
-  async ${m.name}(${bodyParam}): Promise<${m.returnType}> {
+  });
+  return importStrings;
+}
+function generateMethods(serviceInfo) {
+  return serviceInfo.methods.map((m) => generateMethod(m, serviceInfo.className)).join("\n\n");
+}
+function generateMethod(method, serviceName) {
+  const hasParams = method.params.length > 0;
+  const serviceInstance = toInstanceName(serviceName);
+  if (method.isObservable) {
+    const queryParams = hasParams ? method.params.map((p) => `@Query('${p.name}') ${p.name}: ${p.type}`).join(", ") : "";
+    const body2 = generateMethodBody(method, serviceInstance, false);
+    return `  @Sse("${method.name}")
+  ${method.name}(${queryParams}): Observable<${method.returnType}> {
+${body2}
+  }`;
+  }
+  const decorator = hasParams ? "Post" : "Get";
+  const bodyParam = hasParams ? `@Body() body: any` : "";
+  const body = generateMethodBody(method, serviceInstance, true);
+  return `  @${decorator}("${method.name}")
+  async ${method.name}(${bodyParam}): Promise<${method.returnType}> {
 ${body}
   }`;
-  }).join("\n\n");
-  return `${importStrings}
-
-@Controller("/${serviceName}", {
-  providedIn: "root",
-})
-export class ${controllerName} {
-  constructor(private readonly ${serviceName.charAt(0).toLowerCase() + serviceName.slice(1)}: ${serviceName}) {}
-
-${methods}
-}`;
+}
+function generateMethodBody(method, serviceInstance, isAsync) {
+  const lines = [];
+  const hasParams = method.params.length > 0;
+  if (hasParams && method.isObservable && method.paramSchemas.length > 0) {
+    method.params.forEach((p, i) => {
+      lines.push(
+        `    const validated${capitalize(p.name)} = ${method.paramSchemas[i]}.parse(${p.name});`
+      );
+    });
+  }
+  if (hasParams && !method.isObservable) {
+    if (method.paramSchemas.length > 0) {
+      lines.push(
+        `    const b = typeof body === 'object' && body !== null ? body : {};`
+      );
+      method.params.forEach((p, i) => {
+        lines.push(
+          `    const ${p.name} = ${method.paramSchemas[i]}.parse(b.${p.name});`
+        );
+      });
+    } else {
+      const paramNames = method.params.map((p) => p.name).join(", ");
+      lines.push(`    const { ${paramNames} } = body || {};`);
+    }
+  }
+  let callArgs;
+  if (hasParams && method.isObservable && method.paramSchemas.length > 0) {
+    callArgs = method.params.map((p) => `validated${capitalize(p.name)}`).join(", ");
+  } else {
+    callArgs = method.params.map((p) => p.name).join(", ");
+  }
+  const serviceCall = `${serviceInstance}.${method.name}(${callArgs})`;
+  if (method.returnSchema && isAsync) {
+    lines.push(`    const res = await this.${serviceCall};`);
+    lines.push(`    return ${method.returnSchema}.parse(res);`);
+  } else if (isAsync) {
+    lines.push(`    return this.${serviceCall};`);
+  } else {
+    lines.push(`    return this.${serviceCall};`);
+  }
+  return lines.join("\n");
+}
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
 }
 
 // src/plugins/generators/tsx_server_stub.ts
@@ -2378,7 +2549,7 @@ function extractMethods2(classDecl) {
         continue;
       }
       const params = extractMethodParams2(method.function.params || []);
-      const returnType = extractReturnType2(method.function.returnType);
+      const returnType = extractReturnType(method.function.returnType);
       const isAsync = method.function.async || false;
       methods.push({
         name: methodName,
@@ -2407,7 +2578,7 @@ function extractMethodParams2(params) {
   }
   return result;
 }
-function extractReturnType2(returnType) {
+function extractReturnType(returnType) {
   if (!returnType || !returnType.typeAnnotation) {
     return "any";
   }
@@ -2526,37 +2697,66 @@ ${decoratorsStr}export class ${className} extends _OrcaComponent {
 }`;
 }
 
-// src/plugins/generators/generate_rsc.ts
+// src/plugins/generators/generate_rpc.ts
 import { parseSync as parseSync4 } from "@swc/core";
-function generateRscStub(filePath, code) {
-  const ast = parseSync4(code, {
-    syntax: "typescript",
-    tsx: filePath.endsWith("x"),
-    decorators: true
-  });
-  const serviceInfo = extractServiceInfo2(ast);
-  return generateStubCode2(serviceInfo);
+function generateRpcStub(filePath, code) {
+  try {
+    const ast = parseSync4(code, {
+      syntax: "typescript",
+      tsx: filePath.endsWith("x") || filePath.endsWith(".tsx"),
+      decorators: true
+    });
+    const serviceInfo = extractServiceInfo2(ast, filePath);
+    validateServiceInfo2(serviceInfo, filePath);
+    return generateStubCode2(serviceInfo);
+  } catch (error) {
+    if (error.type) {
+      throw error;
+    }
+    throw {
+      type: "parse",
+      message: `Failed to parse TypeScript file: ${error.message}`,
+      filePath,
+      details: error
+    };
+  }
 }
-function extractServiceInfo2(ast) {
+function extractServiceInfo2(ast, filePath) {
   let serviceClass = null;
-  for (const item of ast.body) {
-    if (item.type === "ExportDeclaration" && item.declaration.type === "ClassDeclaration") {
-      const classDecl = item.declaration;
-      if (hasInjectableDecorator2(classDecl.decorators)) {
-        serviceClass = classDecl;
-        break;
+  try {
+    for (const item of ast.body) {
+      if (item.type === "ExportDeclaration" && item.declaration?.type === "ClassDeclaration") {
+        const classDecl = item.declaration;
+        if (hasInjectableDecorator2(classDecl.decorators)) {
+          serviceClass = classDecl;
+          break;
+        }
       }
     }
+    if (!serviceClass?.identifier) {
+      throw {
+        type: "validation",
+        message: "No exported class with @Injectable decorator found",
+        filePath
+      };
+    }
+    const className = serviceClass.identifier.value;
+    const methods = extractMethods3(serviceClass, className, filePath);
+    return {
+      className,
+      methods
+    };
+  } catch (error) {
+    if (error.type) {
+      throw error;
+    }
+    throw {
+      type: "parse",
+      message: `Failed to extract service info: ${error.message}`,
+      filePath,
+      details: error
+    };
   }
-  if (!serviceClass || !serviceClass.identifier) {
-    throw new Error("Service class is undefined");
-  }
-  const className = serviceClass.identifier.value;
-  const methods = extractMethods3(serviceClass);
-  return {
-    className,
-    methods
-  };
 }
 function hasInjectableDecorator2(decorators) {
   if (!decorators) return false;
@@ -2573,65 +2773,81 @@ function hasInjectableDecorator2(decorators) {
     return false;
   });
 }
-function extractMethods3(classDecl) {
+function extractMethods3(classDecl, className, filePath) {
   const methods = [];
   for (const member of classDecl.body) {
-    if (member.type === "ClassMethod" && member.accessibility === "public") {
-      const method = member;
-      const methodName = method.key.type === "Identifier" ? method.key.value : "";
-      if (!methodName) {
-        continue;
-      }
-      if (!method.function.async) {
-        throw new Error(
-          `Server action ${classDecl.identifier.value}.${methodName} must be async.`
-        );
-      }
-      const params = extractMethodParams3(method.function.params || []);
-      const returnType = extractReturnType3(method.function.returnType);
-      const isAsync = method.function.async || false;
-      methods.push({
-        name: methodName,
-        params,
-        returnType,
-        isAsync
-      });
+    if (!isPublicMethod2(member)) continue;
+    const method = member;
+    const methodName = getMethodName2(method);
+    if (!methodName) continue;
+    const returnTypeInfo = analyzeReturnType2(method);
+    if (!returnTypeInfo.isObservable && !method.function.async) {
+      throw {
+        type: "validation",
+        message: `Method ${className}.${methodName} must be async or return an Observable`,
+        filePath,
+        details: { className, methodName }
+      };
     }
+    const params = extractMethodParams3(method.function.params || []);
+    methods.push({
+      name: methodName,
+      params,
+      returnType: returnTypeInfo.type,
+      isAsync: method.function.async,
+      isObservable: returnTypeInfo.isObservable
+    });
   }
   return methods;
 }
+function isPublicMethod2(member) {
+  return member.type === "ClassMethod" && (member.accessibility === "public" || !member.accessibility);
+}
+function getMethodName2(method) {
+  if (method.key.type === "Identifier") {
+    return method.key.value;
+  }
+  return null;
+}
+function analyzeReturnType2(method) {
+  const returnType = method.function.returnType?.typeAnnotation;
+  if (!returnType) {
+    return { type: "any", isObservable: false };
+  }
+  if (returnType.type === "TsTypeReference" && returnType.typeName.type === "Identifier" && returnType.typeName.value === "Observable") {
+    const innerType = returnType.typeParams?.params[0];
+    return {
+      type: innerType ? stringifyType4(innerType) : "any",
+      isObservable: true
+    };
+  }
+  if (returnType.type === "TsTypeReference" && returnType.typeName.type === "Identifier" && returnType.typeName.value === "Promise") {
+    const innerType = returnType.typeParams?.params[0];
+    return {
+      type: innerType ? stringifyType4(innerType) : "any",
+      isObservable: false
+    };
+  }
+  return {
+    type: stringifyType4(returnType),
+    isObservable: false
+  };
+}
 function extractMethodParams3(params) {
   const result = [];
   for (const param of params) {
-    if (param.type === "Parameter") {
-      const pat = param.pat;
-      if (pat.type === "Identifier") {
-        const name = pat.value;
-        const type = pat.typeAnnotation?.typeAnnotation ? stringifyType4(pat.typeAnnotation.typeAnnotation) : "any";
-        result.push({
-          name,
-          type
-        });
-      }
+    const pat = param.pat;
+    if (pat.type === "Identifier") {
+      const name = pat.value;
+      const type = pat.typeAnnotation?.typeAnnotation ? stringifyType4(pat.typeAnnotation.typeAnnotation) : "any";
+      result.push({
+        name,
+        type
+      });
     }
   }
   return result;
 }
-function extractReturnType3(returnType) {
-  if (!returnType || !returnType.typeAnnotation) {
-    return "any";
-  }
-  const type = returnType.typeAnnotation;
-  if (type.type === "TsTypeReference") {
-    const typeName = type.typeName;
-    if (typeName.type === "Identifier" && typeName.value === "Promise") {
-      if (type.typeParams && type.typeParams.params.length > 0) {
-        return stringifyType4(type.typeParams.params[0]);
-      }
-    }
-  }
-  return stringifyType4(type);
-}
 function stringifyType4(typeNode) {
   if (!typeNode) return "any";
   switch (typeNode.type) {
@@ -2640,7 +2856,7 @@ function stringifyType4(typeNode) {
     case "TsTypeReference":
       if (typeNode.typeName.type === "Identifier") {
         const baseName = typeNode.typeName.value;
-        if (typeNode.typeParams && typeNode.typeParams.params.length > 0) {
+        if (typeNode.typeParams?.params.length) {
           const params = typeNode.typeParams.params.map(stringifyType4).join(", ");
           return `${baseName}<${params}>`;
         }
@@ -2667,18 +2883,87 @@ function stringifyType4(typeNode) {
       return "any";
   }
 }
+function validateServiceInfo2(serviceInfo, filePath) {
+  if (!serviceInfo.className) {
+    throw {
+      type: "validation",
+      message: "Service class must have a valid name",
+      filePath
+    };
+  }
+  if (serviceInfo.methods.length === 0) {
+    console.warn(
+      `Warning: Service ${serviceInfo.className} has no public methods`
+    );
+  }
+}
 function generateStubCode2(serviceInfo) {
   const className = serviceInfo.className;
-  const methods = serviceInfo.methods.map((method) => {
-    const params = method.params.map((p) => `${p.name}: ${p.type}`).join(", ");
-    const paramNames = method.params.map((p) => p.name).join(", ");
-    const asyncKeyword = method.isAsync ? "async " : "";
-    const returnType = method.isAsync ? `Promise<${method.returnType}>` : method.returnType;
-    const hasParams = method.params.length > 0;
-    const bodyParam = hasParams ? `{ ${paramNames} }` : "{}";
-    if (!hasParams) {
-      return `  ${asyncKeyword}${method.name}(${params}): ${returnType} {
-    const response = await fetch(\`/${className}/${method.name}\`, {
+  const basePath = serviceNameToPath2(className);
+  const methods = serviceInfo.methods.map((method) => generateMethod2(method, basePath)).join("\n\n");
+  const hasObservable = serviceInfo.methods.some((m) => m.isObservable);
+  const observableImport = hasObservable ? `import { Observable } from "@kithinji/orca";
+` : "";
+  return `${observableImport}import { Injectable } from "@kithinji/orca";
+
+@Injectable()
+export class ${className} {
+${methods}
+}`;
+}
+function serviceNameToPath2(serviceName) {
+  return serviceName.replace(/Service$/, "").replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+}
+function generateMethod2(method, basePath) {
+  if (method.isObservable) {
+    return generateSseMethod(method, basePath);
+  }
+  const params = method.params.map((p) => `${p.name}: ${p.type}`).join(", ");
+  const hasParams = method.params.length > 0;
+  if (!hasParams) {
+    return generateGetMethod(method, basePath);
+  }
+  return generatePostMethod(method, basePath, params);
+}
+function generateSseMethod(method, basePath) {
+  const params = method.params.map((p) => `${p.name}: ${p.type}`).join(", ");
+  const hasParams = method.params.length > 0;
+  let urlBuilder;
+  if (hasParams) {
+    const queryParams = method.params.map((p) => `${p.name}=\${encodeURIComponent(${p.name})}`).join("&");
+    urlBuilder = `\`/${basePath}/${method.name}?${queryParams}\``;
+  } else {
+    urlBuilder = `\`/${basePath}/${method.name}\``;
+  }
+  return `  ${method.name}(${params}): Observable<${method.returnType}> {
+    return new Observable((observer) => {
+      const eventSource = new EventSource(${urlBuilder});
+
+      eventSource.onmessage = (event) => {
+        try {
+          const data = JSON.parse(event.data);
+          observer.next(data);
+        } catch (error) {
+          observer.error?.(error);
+        }
+      };
+
+      eventSource.onerror = (error) => {
+        observer.error?.(error);
+        eventSource.close();
+      };
+
+      return () => {
+        eventSource.close();
+      };
+    });
+  }`;
+}
+function generateGetMethod(method, basePath) {
+  const params = method.params.map((p) => `${p.name}: ${p.type}`).join(", ");
+  const returnType = `Promise<${method.returnType}>`;
+  return `  async ${method.name}(${params}): ${returnType} {
+    const response = await fetch(\`/${basePath}/${method.name}\`, {
       method: 'GET',
       headers: {
         'Content-Type': 'application/json',
@@ -2691,14 +2976,17 @@ function generateStubCode2(serviceInfo) {
 
     return response.json();
   }`;
-    }
-    return `  ${asyncKeyword}${method.name}(${params}): ${returnType} {
-    const response = await fetch(\`/${className}/${method.name}\`, {
+}
+function generatePostMethod(method, basePath, params) {
+  const paramNames = method.params.map((p) => p.name).join(", ");
+  const returnType = `Promise<${method.returnType}>`;
+  return `  async ${method.name}(${params}): ${returnType} {
+    const response = await fetch(\`/${basePath}/${method.name}\`, {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
       },
-      body: JSON.stringify(${bodyParam}),
+      body: JSON.stringify({ ${paramNames} }),
     });
 
     if (!response.ok) {
@@ -2707,13 +2995,6 @@ function generateStubCode2(serviceInfo) {
 
     return response.json();
   }`;
-  }).join("\n\n");
-  return `import { Injectable } from "@kithinji/orca";
-
-@Injectable()
-export class ${className} {
-${methods}
-}`;
 }
 
 // src/plugins/my.ts
@@ -2830,8 +3111,8 @@ var ClientBuildTransformer = class {
     const scSource = generateServerComponent(path15, source);
     return swcTransform(scSource, path15);
   }
-  async transformPublicFileRsc(node, source, path15) {
-    const stubSource = generateRscStub(path15, source);
+  async transformPublicFileRpc(node, source, path15) {
+    const stubSource = generateRpcStub(path15, source);
     return swcTransform(stubSource, path15);
   }
   async transformSharedCode(source, path15) {
@@ -2853,7 +3134,7 @@ var ClientBuildTransformer = class {
       }
     }
     if (directive === "public") {
-      return this.transformPublicFileRsc(node, source, path15);
+      return this.transformPublicFileRpc(node, source, path15);
     }
     if (directive === null) {
       return this.transformSharedCode(source, path15);
@@ -3484,7 +3765,7 @@ Processing dependencies for "${name}": [${component.dependencies.join(
   }
 }
 function updateModuleWithComponent(moduleContent, componentName) {
-  const className = capitalize(componentName);
+  const className = capitalize2(componentName);
   const importPath = `./component/${componentName}.component`;
   const sourceFile = ts2.createSourceFile(
     "component.module.ts",
@@ -3640,7 +3921,7 @@ function ensureComponentModuleImported(appModuleContent) {
 function ensureInImportsArray(content, sourceFile) {
   return addToDecoratorArray(content, sourceFile, "imports", "ComponentModule");
 }
-function capitalize(str) {
+function capitalize2(str) {
   return str.charAt(0).toUpperCase() + str.slice(1);
 }
 function createModule() {
@@ -4266,7 +4547,7 @@ build
 `;
 }
 function genEnv() {
-  return `host=localhost
+  return `HOST=localhost
 `;
 }
 function genIndexHtml(name) {
@@ -4546,100 +4827,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}
+            path: *backup_path
+            owner: *user
 
-      - name: "Stop running containers"
-        type: action
-        action:
-          command: cd \${deployPath} && docker compose down 2>/dev/null || true
-
-      - 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 +5248,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 +5449,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 +5492,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 +5515,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;
   }
-  if (op.ensure.swap) {
+  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);
+    }
+  }
+  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.24");
 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 });