@kithinji/pod 1.0.27 → 1.0.28

package/dist/main.js

@@ -406,17 +406,17 @@ var MacroDependencyGraph = class {
     const visited = /* @__PURE__ */ new Set();
     const inProgress = /* @__PURE__ */ new Set();
     const sorted = [];
-    const visit = (key, path15 = []) => {
+    const visit = (key, path16 = []) => {
       if (visited.has(key)) return;
       if (inProgress.has(key)) {
-        const cycle = [...path15, key].join(" -> ");
+        const cycle = [...path16, 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, [...path15, key]);
+        visit(depKey, [...path16, key]);
       }
       inProgress.delete(key);
       visited.add(key);
@@ -1798,22 +1798,22 @@ var ElementTransformer = class {
     this.jsxUtils = jsxUtils;
     this.observableManager = observableManager;
   }
-  transformElement(path15, scope, context2) {
-    if (this.t.isJSXFragment(path15.node)) {
+  transformElement(path16, scope, context2) {
+    if (this.t.isJSXFragment(path16.node)) {
       return this.transformFragment(
-        path15,
+        path16,
         scope,
         context2
       );
     }
     return this.transformJSXElement(
-      path15,
+      path16,
       scope,
       context2
     );
   }
-  transformJSXElement(path15, scope, context2) {
-    const jsxElement = path15.node;
+  transformJSXElement(path16, scope, context2) {
+    const jsxElement = path16.node;
     const tag = this.jsxUtils.getComponentName(jsxElement.openingElement.name);
     const isComponent = this.jsxUtils.isComponentTag(tag);
     if (isComponent && tag) {
@@ -1928,7 +1928,7 @@ var ElementTransformer = class {
     }
     return { id: elId, statements };
   }
-  transformFragment(path15, scope, context2) {
+  transformFragment(path16, scope, context2) {
     const fragId = scope.generateUidIdentifier("frag");
     const statements = [];
     statements.push(
@@ -1946,7 +1946,7 @@ var ElementTransformer = class {
       ])
     );
     this.processDOMChildren(
-      path15.node.children,
+      path16.node.children,
       fragId,
       statements,
       scope,
@@ -2335,7 +2335,7 @@ function j2d({ types: t }) {
     name: "jsx-to-dom",
     visitor: {
       Program: {
-        exit(path15, state) {
+        exit(path16, state) {
           if (state.helpersImported) return;
           const helpers = [
             { local: "$insert", imported: "insert" },
@@ -2346,7 +2346,7 @@ function j2d({ types: t }) {
             { local: "$effect", imported: "effect" }
           ];
           for (const helper of helpers) {
-            path15.unshiftContainer(
+            path16.unshiftContainer(
               "body",
               t.importDeclaration(
                 [
@@ -2362,10 +2362,10 @@ function j2d({ types: t }) {
           state.helpersImported = true;
         }
       },
-      ClassMethod(path15) {
-        if (path15.getData("processed")) return;
+      ClassMethod(path16) {
+        if (path16.getData("processed")) return;
         let hasJSX = false;
-        path15.traverse({
+        path16.traverse({
           JSXElement() {
             hasJSX = true;
           },
@@ -2374,11 +2374,11 @@ function j2d({ types: t }) {
           }
         });
         if (!hasJSX) return;
-        path15.setData("processed", true);
-        const body = path15.node.body;
+        path16.setData("processed", true);
+        const body = path16.node.body;
         if (!t.isBlockStatement(body)) return;
         const observables = /* @__PURE__ */ new Map();
-        path15.traverse({
+        path16.traverse({
           JSXElement(jsxPath) {
             observableManager.collectObservables(
               jsxPath.node,
@@ -2402,7 +2402,7 @@ function j2d({ types: t }) {
         const observableSignals = /* @__PURE__ */ new Map();
         const signalDeclarations = [];
         for (const [key, observable] of observables) {
-          const signalId = path15.scope.generateUidIdentifier("sig");
+          const signalId = path16.scope.generateUidIdentifier("sig");
           observableSignals.set(key, signalId);
           signalDeclarations.push(
             t.variableDeclaration("const", [
@@ -2420,7 +2420,7 @@ function j2d({ types: t }) {
           astUtils.insertBeforeReturn(body.body, signalDeclarations);
         }
         const context2 = { observables, observableSignals };
-        path15.traverse({
+        path16.traverse({
           JSXElement(jsxPath) {
             if (jsxPath.getData("processed")) return;
             jsxPath.setData("processed", true);
@@ -2953,8 +2953,8 @@ async function swcTransform(source, pathStr, tsx = false, react) {
     resolveDir
   };
 }
-function parseFileMetadata(source, path15) {
-  const isTsx = path15.endsWith(".tsx");
+function parseFileMetadata(source, path16) {
+  const isTsx = path16.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;
@@ -2962,7 +2962,7 @@ function parseFileMetadata(source, path15) {
   else if (isPublicFile) directive = "public";
   return {
     source,
-    path: path15,
+    path: path16,
     isTsx,
     directive,
     isPublicFile,
@@ -2970,58 +2970,58 @@ function parseFileMetadata(source, path15) {
   };
 }
 var ServerBuildTransformer = class {
-  async transformPublicFile(source, path15) {
-    const controllerCode = generateController(path15, source);
+  async transformPublicFile(source, path16) {
+    const controllerCode = generateController(path16, source);
     if (controllerCode) {
       source = `${source}
 
 ${controllerCode}
 `;
     }
-    return swcTransform(source, path15);
+    return swcTransform(source, path16);
   }
-  async transformRegularTypeScript(source, path15, isPublic) {
+  async transformRegularTypeScript(source, path16, isPublic) {
     if (isPublic) {
-      return this.transformPublicFile(source, path15);
+      return this.transformPublicFile(source, path16);
     }
-    return swcTransform(source, path15);
+    return swcTransform(source, path16);
   }
-  async transformServerTsx(source, path15) {
-    return swcTransform(source, path15, true, {
+  async transformServerTsx(source, path16) {
+    return swcTransform(source, path16, true, {
       runtime: "automatic",
       importSource: "@kithinji/orca"
     });
   }
-  async transformInteractiveTsxStub(source, path15) {
-    const stubSource = generateServerStub(path15, source);
-    return swcTransform(stubSource, path15);
+  async transformInteractiveTsxStub(source, path16) {
+    const stubSource = generateServerStub(path16, source);
+    return swcTransform(stubSource, path16);
   }
   async process(metadata, onClientFound) {
     const expandedSource = await expandMacros(metadata.source, metadata.path);
     const expandedMetadata = { ...metadata, source: expandedSource };
-    const { source, path: path15, isTsx, isInteractiveFile, isPublicFile } = expandedMetadata;
+    const { source, path: path16, isTsx, isInteractiveFile, isPublicFile } = expandedMetadata;
     if (isTsx) {
       if (isInteractiveFile) {
-        onClientFound(path15);
-        const clientCode = await this.transformInteractiveTsxStub(source, path15);
+        onClientFound(path16);
+        const clientCode = await this.transformInteractiveTsxStub(source, path16);
         const store = Store.getInstance();
-        store.set(path15, clientCode.contents);
+        store.set(path16, clientCode.contents);
         return clientCode;
       }
-      return this.transformServerTsx(source, path15);
+      return this.transformServerTsx(source, path16);
     }
-    return this.transformRegularTypeScript(source, path15, isPublicFile);
+    return this.transformRegularTypeScript(source, path16, isPublicFile);
   }
 };
 var ClientBuildTransformer = class {
-  async transformInteractiveTsx(source, path15) {
-    const swcResult = await swcTransform(source, path15, true, {
+  async transformInteractiveTsx(source, path16) {
+    const swcResult = await swcTransform(source, path16, true, {
       runtime: "preserve"
     });
     const babelResult = await babel.transformAsync(
       swcResult.contents,
       {
-        filename: path15,
+        filename: path16,
         sourceType: "module",
         plugins: [j2d],
         parserOpts: {
@@ -3037,37 +3037,37 @@ var ClientBuildTransformer = class {
       resolveDir: swcResult.resolveDir
     };
   }
-  async transformServerComponent(node, source, path15) {
-    const scSource = generateServerComponent(path15, source);
-    return swcTransform(scSource, path15);
+  async transformServerComponent(node, source, path16) {
+    const scSource = generateServerComponent(path16, source);
+    return swcTransform(scSource, path16);
   }
-  async transformPublicFileRpc(node, source, path15) {
-    const stubSource = generateRpcStub(path15, source);
-    return swcTransform(stubSource, path15);
+  async transformPublicFileRpc(node, source, path16) {
+    const stubSource = generateRpcStub(path16, source);
+    return swcTransform(stubSource, path16);
   }
-  async transformSharedCode(source, path15) {
-    return swcTransform(source, path15);
+  async transformSharedCode(source, path16) {
+    return swcTransform(source, path16);
   }
   async process(node, metadata) {
     const expandedSource = await expandMacros(metadata.source, metadata.path);
     const expandedMetadata = { ...metadata, source: expandedSource };
-    const { source, path: path15, isTsx, directive } = expandedMetadata;
+    const { source, path: path16, isTsx, directive } = expandedMetadata;
     if (isTsx) {
       if (directive === "interactive") {
-        return this.transformInteractiveTsx(source, path15);
+        return this.transformInteractiveTsx(source, path16);
       } else if (directive === null) {
-        return this.transformServerComponent(node, source, path15);
+        return this.transformServerComponent(node, source, path16);
       } else {
         throw new Error(
-          `Unexpected directive "${directive}" for TSX file: ${path15}`
+          `Unexpected directive "${directive}" for TSX file: ${path16}`
         );
       }
     }
     if (directive === "public") {
-      return this.transformPublicFileRpc(node, source, path15);
+      return this.transformPublicFileRpc(node, source, path16);
     }
     if (directive === null) {
-      return this.transformSharedCode(source, path15);
+      return this.transformSharedCode(source, path16);
     }
     return {
       contents: source,
@@ -4815,18 +4815,398 @@ bootstrap();
 `;
 }
 
+// src/add/ts/index.ts
+import path12 from "path";
+import prompts from "prompts";
+async function addTs(name) {
+  const baseDir = path12.join(process.cwd(), name);
+  const response = await prompts({
+    type: "select",
+    name: "target",
+    message: "Where will this project run?",
+    choices: [
+      { title: "Browser", value: "browser" },
+      { title: "Node.js", value: "node" },
+      { title: "Both (Browser & Node.js)", value: "both" }
+    ],
+    initial: 2
+  });
+  if (!response.target) {
+    console.log("Project creation cancelled");
+    process.exit(0);
+  }
+  const target = response.target;
+  const structure = {
+    files: [
+      { name: "package.json", content: genPackageJson2(name, target) },
+      { name: "tsconfig.json", content: genTsConfig(target) },
+      { name: "build.js", content: genBuildConfig(name, target) },
+      { name: "README.md", content: genReadMe2(name, target) },
+      { name: ".gitignore", content: genGitIgnore2() },
+      { name: ".env", content: genEnv2() }
+    ],
+    dirs: [
+      {
+        name: "src",
+        files: getSrcFiles(target)
+      }
+    ]
+  };
+  createStructure(baseDir, structure);
+  console.log(`TypeScript project created for ${target} environment`);
+}
+function getSrcFiles(target) {
+  switch (target) {
+    case "both":
+      return [
+        { name: "index.ts", content: genIndexTs() },
+        { name: "index.browser.ts", content: genBrowserIndexTs() },
+        { name: "index.node.ts", content: genNodeIndexTs() }
+      ];
+    case "browser":
+      return [{ name: "index.ts", content: genBrowserIndexTs() }];
+    case "node":
+      return [{ name: "index.ts", content: genNodeIndexTs() }];
+  }
+}
+function genPackageJson2(name, target) {
+  const pkg = {
+    name,
+    version: "1.0.0",
+    type: "module",
+    scripts: {
+      build: "node build.js",
+      dev: "node build.js --watch",
+      clean: "rm -rf dist"
+    },
+    devDependencies: {
+      typescript: "^5.9.3",
+      esbuild: "^0.27.2"
+    }
+  };
+  if (target === "node") {
+    pkg.main = "dist/index.mjs";
+    pkg.types = "./dist/types/index.d.ts";
+  } else if (target === "browser") {
+    pkg.main = "dist/index.mjs";
+    pkg.types = "./dist/types/index.d.ts";
+  } else if (target === "both") {
+    pkg.exports = {
+      ".": {
+        browser: {
+          import: "./dist/browser/index.mjs"
+        },
+        node: {
+          import: "./dist/node/index.mjs"
+        },
+        types: "./dist/types/index.d.ts"
+      }
+    };
+  }
+  return JSON.stringify(pkg, null, 2);
+}
+function genTsConfig(target) {
+  const config = {
+    compilerOptions: {
+      target: "ES2020",
+      module: "ESNext",
+      moduleResolution: "bundler",
+      declaration: true,
+      declarationMap: true,
+      emitDeclarationOnly: true,
+      outDir: "./dist/types",
+      rootDir: "./src",
+      strict: true,
+      esModuleInterop: true,
+      skipLibCheck: true,
+      forceConsistentCasingInFileNames: true,
+      baseUrl: ".",
+      paths: {
+        "@/*": ["./src/*"]
+      }
+    },
+    include: ["src/**/*"],
+    exclude: ["node_modules", "dist"]
+  };
+  if (target === "browser" || target === "both") {
+    config.compilerOptions.lib = ["ES2020", "DOM"];
+  } else {
+    config.compilerOptions.lib = ["ES2020"];
+  }
+  return JSON.stringify(config, null, 2);
+}
+function genBuildConfig(name, target) {
+  return `const esbuild = require('esbuild');
+const { execSync } = require('child_process');
+const path = require('path');
+
+const isWatch = process.argv.includes('--watch');
+
+
+const aliasPlugin = {
+  name: 'alias',
+  setup(build) {
+    build.onResolve({ filter: /^@\\
+      return {
+        path: path.resolve(__dirname, 'src', args.path.slice(2))
+      };
+    });
+  }
+};
+
+
+const buildConfigs = ${JSON.stringify(getBuildConfigs(target), null, 2).replace(
+    /"plugins": null/g,
+    '"plugins": [aliasPlugin]'
+  )};
+
+async function build() {
+  try {
+    execSync('rm -rf dist', { stdio: 'inherit' });
+    
+    
+    for (const config of buildConfigs) {
+      console.log(\`Building \${config.outfile}...\`);
+      
+      if (isWatch) {
+        const ctx = await esbuild.context(config);
+        await ctx.watch();
+        console.log(\`Watching \${config.outfile}...\`);
+      } else {
+        await esbuild.build(config);
+      }
+    }
+
+    console.log('Generating TypeScript declarations...');
+    execSync("npx tsc", {
+        stdio: "inherit",
+    });
+
+    if (!isWatch) {
+      console.log('Build successful!');
+    } else {
+      console.log('Initial build complete. Watching for changes...');
+    }
+  } catch (error) {
+    console.error('Build failed:', error.message);
+    process.exit(1);
+  }
+}
+
+build();
+`;
+}
+function getBuildConfigs(target) {
+  const baseConfig = {
+    bundle: true,
+    sourcemap: true,
+    minify: false,
+    plugins: null
+  };
+  switch (target) {
+    case "browser":
+      return [
+        {
+          ...baseConfig,
+          entryPoints: ["src/index.ts"],
+          outfile: "dist/index.mjs",
+          platform: "browser",
+          format: "esm",
+          target: ["es2020"],
+          external: []
+        }
+      ];
+    case "node":
+      return [
+        {
+          ...baseConfig,
+          entryPoints: ["src/index.ts"],
+          outfile: "dist/index.mjs",
+          platform: "node",
+          format: "esm",
+          target: ["node18"],
+          packages: "external"
+        }
+      ];
+    case "both":
+      return [
+        {
+          ...baseConfig,
+          entryPoints: ["src/index.browser.ts"],
+          outfile: "dist/browser/index.mjs",
+          platform: "browser",
+          format: "esm",
+          target: ["es2020"],
+          external: []
+        },
+        {
+          ...baseConfig,
+          entryPoints: ["src/index.node.ts"],
+          outfile: "dist/node/index.mjs",
+          platform: "node",
+          format: "esm",
+          target: ["node18"],
+          packages: "external"
+        }
+      ];
+  }
+}
+function genReadMe2(name, target) {
+  return `# ${name}
+
+TypeScript project configured for **${target}** environment(s).
+
+## Features
+
+- Fast builds with esbuild
+- Proper bundling for ${target}
+- Source maps for debugging
+- TypeScript declarations
+- Watch mode for development
+
+## Installation
+
+\`\`\`bash
+npm install
+\`\`\`
+
+## Development
+
+\`\`\`bash
+npm run dev
+\`\`\`
+
+Watch mode will automatically rebuild when you change files.
+
+## Build
+
+\`\`\`bash
+npm run build
+\`\`\`
+
+This will:
+1. Bundle your code with esbuild
+2. Generate TypeScript declarations
+3. Create source maps
+
+## Clean
+
+\`\`\`bash
+npm run clean
+\`\`\`
+
+${target === "both" ? `
+## Usage
+
+This package builds separate bundles for browser and Node.js:
+
+### In Browser
+\`\`\`javascript
+import { platform } from '${name}';
+
+console.log(platform); 
+\`\`\`
+
+### In Node.js
+\`\`\`javascript
+import { platform } from '${name}';
+
+console.log(platform); 
+\`\`\`
+` : target === "browser" ? `
+## Usage
+
+\`\`\`javascript
+import { platform } from '${name}';
+console.log(platform); 
+\`\`\`
+
+Include \`dist/index.mjs\` in your HTML or bundle with your favorite bundler.
+` : `
+## Usage
+
+\`\`\`javascript
+import { platform } from '${name}';
+console.log(platform); 
+\`\`\`
+`}
+
+## Build Output
+
+- \`dist/*.mjs\` - Bundled JavaScript (ESM)
+- \`dist/types/*.d.ts\` - TypeScript declarations
+- \`dist/*.map\` - Source maps
+`;
+}
+function genGitIgnore2() {
+  return `node_modules/
+dist/
+.env
+*.log
+.DS_Store
+coverage/
+.vscode/
+.idea/
+*.tsbuildinfo
+`;
+}
+function genEnv2() {
+  return `# Environment variables
+`;
+}
+function genIndexTs() {
+  return `
+export * from './index.browser.js';
+export * from './index.node.js';
+`;
+}
+function genBrowserIndexTs() {
+  return `
+export const platform = 'browser' as const;
+
+export function getBrowserInfo() {
+  if (typeof window !== 'undefined') {
+    return {
+      userAgent: navigator.userAgent,
+      language: navigator.language,
+    };
+  }
+  return null;
+}
+
+console.log('Running in browser environment');
+`;
+}
+function genNodeIndexTs() {
+  return `
+import { platform as osPlatform, arch } from 'os';
+
+export const platform = 'node' as const;
+
+export function getNodeInfo() {
+  return {
+    platform: osPlatform(),
+    arch: arch(),
+    nodeVersion: process.version,
+  };
+}
+
+console.log('Running in Node.js environment');
+`;
+}
+
 // src/main.ts
-import path14 from "path";
+import path15 from "path";
 import { execSync } from "child_process";
 
 // src/docker/docker.ts
 import fs10 from "fs-extra";
-import path12 from "path";
-import prompts from "prompts";
+import path13 from "path";
+import prompts2 from "prompts";
 import yaml from "js-yaml";
 async function dockerize(env = "prod") {
   const cwd = process.cwd();
-  const packageJsonPath = path12.join(cwd, "package.json");
+  const packageJsonPath = path13.join(cwd, "package.json");
   if (!fs10.existsSync(packageJsonPath)) {
     throw new Error("package.json not found. Are you in a Pod project?");
   }
@@ -4856,7 +5236,7 @@ function detectServices(packageJson) {
 }
 async function selectServices(detected) {
   if (detected.length === 0) return [];
-  const response = await prompts({
+  const response = await prompts2({
     type: "multiselect",
     name: "services",
     message: "Select services to include:",
@@ -4870,7 +5250,7 @@ async function selectServices(detected) {
   return detected.filter((s) => response.services.includes(s.name));
 }
 async function restructureProject(cwd, projectName) {
-  const nestedDir = path12.join(cwd, projectName);
+  const nestedDir = path13.join(cwd, projectName);
   if (fs10.existsSync(nestedDir)) {
     console.log("\u26A0\uFE0F  Project already restructured, skipping...");
     return;
@@ -4879,18 +5259,18 @@ async function restructureProject(cwd, projectName) {
   const items = await fs10.readdir(cwd);
   const toMove = items.filter((item) => item !== projectName);
   for (const item of toMove) {
-    const src = path12.join(cwd, item);
-    const dest = path12.join(nestedDir, item);
+    const src = path13.join(cwd, item);
+    const dest = path13.join(nestedDir, item);
     await fs10.move(src, dest, { overwrite: true });
   }
-  const envSrc = path12.join(nestedDir, ".env");
-  const envDest = path12.join(cwd, ".env");
+  const envSrc = path13.join(nestedDir, ".env");
+  const envDest = path13.join(cwd, ".env");
   if (fs10.existsSync(envSrc)) {
     await fs10.move(envSrc, envDest, { overwrite: true });
   }
 }
 async function writeEnvVars(cwd, services, env) {
-  const envPath = path12.join(cwd, ".env");
+  const envPath = path13.join(cwd, ".env");
   let existingEnv = {};
   let existingContent = "";
   if (fs10.existsSync(envPath)) {
@@ -4947,8 +5327,8 @@ function parseEnvFile(content) {
   return env;
 }
 async function createDockerfile(cwd, projectName) {
-  const dockerfilePath = path12.join(cwd, projectName, "Dockerfile");
-  const dockerignorePath = path12.join(cwd, projectName, ".dockerignore");
+  const dockerfilePath = path13.join(cwd, projectName, "Dockerfile");
+  const dockerignorePath = path13.join(cwd, projectName, ".dockerignore");
   const dockerfile = `FROM node:18-alpine
 
 WORKDIR /app
@@ -5138,7 +5518,7 @@ targets:
             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");
+  const deployFilePath = path13.join(cwd, "pod.deploy.yml");
   await fs10.writeFile(deployFilePath, deployFile);
 }
 async function setupProduction(cwd, projectName, services) {
@@ -5209,14 +5589,14 @@ async function setupProduction(cwd, projectName, services) {
     }
     compose.services[projectName].depends_on.push(service.name);
   }
-  const composePath = path12.join(cwd, "docker-compose.yml");
+  const composePath = path13.join(cwd, "docker-compose.yml");
   await fs10.writeFile(
     composePath,
     yaml.dump(compose, { indent: 2, lineWidth: -1 })
   );
 }
 async function setupDevelopment(cwd, projectName, services) {
-  const existingCompose = path12.join(cwd, "docker-compose.yml");
+  const existingCompose = path13.join(cwd, "docker-compose.yml");
   let existingServices = [];
   if (fs10.existsSync(existingCompose)) {
     const content = await fs10.readFile(existingCompose, "utf8");
@@ -5227,14 +5607,14 @@ async function setupDevelopment(cwd, projectName, services) {
   }
   const servicesToTunnel = [];
   if (existingServices.length > 0) {
-    const { tunnel } = await prompts({
+    const { tunnel } = await prompts2({
       type: "confirm",
       name: "tunnel",
       message: "Tunnel to remote database services?",
       initial: false
     });
     if (tunnel) {
-      const { selected } = await prompts({
+      const { selected } = await prompts2({
         type: "multiselect",
         name: "selected",
         message: "Select services to tunnel:",
@@ -5288,14 +5668,14 @@ async function setupDevelopment(cwd, projectName, services) {
     };
     compose.services[projectName].depends_on.push(tunnelName);
   }
-  const devComposePath = path12.join(cwd, "docker-compose.dev.yml");
+  const devComposePath = path13.join(cwd, "docker-compose.dev.yml");
   await fs10.writeFile(
     devComposePath,
     yaml.dump(compose, { indent: 2, lineWidth: -1 })
   );
 }
 async function createTunnelService(projectDir, serviceName) {
-  const tunnelDir = path12.join(projectDir, `${serviceName}-tunnel`);
+  const tunnelDir = path13.join(projectDir, `${serviceName}-tunnel`);
   await fs10.ensureDir(tunnelDir);
   const dockerfile = `FROM alpine:latest
 
@@ -5324,8 +5704,8 @@ ssh -i $SSH_KEY \\
     -o ServerAliveInterval=60 \\
     $REMOTE_HOST
 `;
-  await fs10.writeFile(path12.join(tunnelDir, "Dockerfile"), dockerfile);
-  await fs10.writeFile(path12.join(tunnelDir, "tunnel.sh"), tunnelScript);
+  await fs10.writeFile(path13.join(tunnelDir, "Dockerfile"), dockerfile);
+  await fs10.writeFile(path13.join(tunnelDir, "tunnel.sh"), tunnelScript);
 }
 function getServiceConfig(serviceName) {
   const configs = {
@@ -5437,7 +5817,7 @@ function printNextSteps(projectName, env, services) {
 // src/deploy/deploy.ts
 import fs11 from "fs-extra";
 import yaml2 from "js-yaml";
-import path13 from "path";
+import path14 from "path";
 import os from "os";
 import { NodeSSH } from "node-ssh";
 import chalk from "chalk";
@@ -5468,7 +5848,7 @@ function deepInterpolate(obj, context2) {
 }
 function expandTilde(fp) {
   if (!fp || typeof fp !== "string") return fp;
-  return fp.startsWith("~/") ? path13.join(os.homedir(), fp.slice(2)) : fp;
+  return fp.startsWith("~/") ? path14.join(os.homedir(), fp.slice(2)) : fp;
 }
 function resolveLocalPaths(obj, cwd) {
   if (Array.isArray(obj)) {
@@ -5480,7 +5860,7 @@ function resolveLocalPaths(obj, cwd) {
       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);
+        result[key] = path14.isAbsolute(expanded) ? expanded : path14.resolve(cwd, expanded);
       } else {
         result[key] = resolveLocalPaths(value, cwd);
       }
@@ -5663,7 +6043,7 @@ var SSHStrategy = class {
     const trimmed = cmd.trim();
     if (trimmed.startsWith("cd ")) {
       const newPath = trimmed.replace("cd ", "").trim();
-      this.currentDir = path13.posix.resolve(this.currentDir, newPath);
+      this.currentDir = path14.posix.resolve(this.currentDir, newPath);
       if (!silent) console.log(chalk.gray(` [SSH Path: ${this.currentDir}]`));
       return { stdout: "", stderr: "", code: 0 };
     }
@@ -5691,7 +6071,7 @@ STDERR: ${result.stderr}`);
     }
   }
   async uploadContent(remotePath, content) {
-    const localTmp = path13.join(os.tmpdir(), `pod_tmp_${Date.now()}`);
+    const localTmp = path14.join(os.tmpdir(), `pod_tmp_${Date.now()}`);
     fs11.writeFileSync(localTmp, content);
     try {
       await this.ssh.execCommand(`mkdir -p $(dirname ${remotePath})`);
@@ -5712,7 +6092,7 @@ STDERR: ${result.stderr}`);
     const putOptions = { recursive: true, concurrency: 10 };
     if (exclude?.length) {
       putOptions.validate = (filePath) => {
-        const relative = path13.relative(source, filePath);
+        const relative = path14.relative(source, filePath);
         if (relative === "") return true;
         return !exclude.some((pattern) => {
           if (pattern.endsWith("/")) {
@@ -5744,7 +6124,7 @@ var LocalStrategy = class {
     const trimmed = cmd.trim();
     if (trimmed.startsWith("cd ")) {
       const newPath = trimmed.replace("cd ", "").trim();
-      this.currentDir = path13.resolve(this.currentDir, newPath);
+      this.currentDir = path14.resolve(this.currentDir, newPath);
       if (!silent) console.log(chalk.gray(` [Local Path: ${this.currentDir}]`));
       return { stdout: "", stderr: "", code: 0 };
     }
@@ -5767,7 +6147,7 @@ STDERR: ${err.stderr || err.message}`
   }
   async runScript(name, content, context2) {
     const interpolated = interpolate(content, context2);
-    const scriptPath = path13.join(
+    const scriptPath = path14.join(
       os.tmpdir(),
       `pod_script_${name}_${Date.now()}.sh`
     );
@@ -5780,7 +6160,7 @@ STDERR: ${err.stderr || err.message}`
     }
   }
   async uploadContent(localPath, content) {
-    const dir = path13.dirname(localPath);
+    const dir = path14.dirname(localPath);
     if (!fs11.existsSync(dir)) {
       fs11.mkdirSync(dir, { recursive: true });
     }
@@ -5817,9 +6197,9 @@ STDERR: ${err.stderr || err.message}`
     const copyRecursive = (src, dest) => {
       const entries = fs11.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);
+        const srcPath = path14.join(src, entry.name);
+        const destPath = path14.join(dest, entry.name);
+        const relativePath = path14.relative(source, srcPath);
         if (shouldExclude(relativePath)) continue;
         if (entry.isDirectory()) {
           if (!fs11.existsSync(destPath)) {
@@ -5990,7 +6370,7 @@ var OperationHandler = class {
 async function deploy(targetName, options) {
   const cwd = process.cwd();
   const rawConfig = yaml2.load(
-    fs11.readFileSync(path13.join(cwd, "pod.deploy.yml"), "utf8"),
+    fs11.readFileSync(path14.join(cwd, "pod.deploy.yml"), "utf8"),
     { schema: yaml2.DEFAULT_SCHEMA }
   );
   const rawTarget = rawConfig.targets?.[targetName];
@@ -6010,7 +6390,7 @@ Pod Deploy: ${rawConfig.name} v${rawConfig.version} \u2192 ${targetName}
   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");
+    const lockPath = target.deployPath ? path14.posix.join(target.deployPath, "pod-lock.json") : path14.join(cwd, "pod-lock.json");
     let lock = await strategy.readJson(lockPath) || {
       ensures: {},
       once_actions: []
@@ -6052,16 +6432,31 @@ Deployment Failed: ${err.message}`));
 // src/main.ts
 import chalk2 from "chalk";
 var program = new Command();
-program.name("pod").description("Pod cli tool").version("1.0.27");
-program.command("new <name>").description("Start a new Orca Project").action(async (name) => {
-  await addNew(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 });
-  console.log("Starting development server...");
-  execSync("npm run dev", { stdio: "inherit", cwd: appDir, shell });
-  console.log(`All done! Your app "${name}" is running in development mode.`);
+program.name("pod").description("Pod cli tool").version("1.0.28");
+program.command("new <name> [type]").description("Start a new Orca Project").action(async (name, type) => {
+  const orca = async () => {
+    await addNew(name);
+    const appDir = path15.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 });
+    console.log("Starting development server...");
+    execSync("npm run dev", { stdio: "inherit", cwd: appDir, shell });
+    console.log(
+      `All done! Your app "${name}" is running in development mode.`
+    );
+  };
+  const ts4 = () => {
+    addTs(name);
+  };
+  switch (type) {
+    case "orca":
+      return await orca();
+    case "ts":
+      return await ts4();
+    default:
+      return await orca();
+  }
 });
 program.command("dev").description("Start Pod development server").action(async (opts) => {
   await startDevServer();