@_davideast/jules-env 0.1.2 → 0.2.1

package/dist/cli.mjs

@@ -6029,9 +6029,10 @@ import { spawn } from "node:child_process";
 import { mkdir, writeFile, appendFile } from "node:fs/promises";
 import { resolve, dirname } from "node:path";
 import { homedir } from "node:os";
-async function executePlan(plan, dryRun) {
+var SHELLENV_SOURCE = ". $HOME/.jules/shellenv 2>/dev/null; ";
+async function executePlan(plan, dryRun, label) {
   if (dryRun) {
-    console.log("--- DRY RUN: Execution Plan ---");
+    console.log(`--- DRY RUN: ${label ?? "Execution Plan"} ---`);
   }
   for (const step of plan.installSteps) {
     if (dryRun) {
@@ -6044,7 +6045,8 @@ async function executePlan(plan, dryRun) {
       console.log(`[${step.id}] ${step.label}...`);
       let skip = false;
       if (step.checkCmd) {
-        const check = spawn("sh", ["-c", step.checkCmd], {
+        const fullCheckCmd = `${SHELLENV_SOURCE}${step.checkCmd}`;
+        const check = spawn("sh", ["-c", fullCheckCmd], {
           stdio: "ignore"
         });
         const exitCode = await new Promise((res) => check.on("close", (code) => res(code ?? 1)));
@@ -6054,7 +6056,8 @@ async function executePlan(plan, dryRun) {
         }
       }
       if (!skip) {
-        const proc = spawn("sh", ["-c", step.cmd], {
+        const fullCmd = `${SHELLENV_SOURCE}${step.cmd}`;
+        const proc = spawn("sh", ["-c", fullCmd], {
           stdio: "inherit"
         });
         const exitCode = await new Promise((res) => proc.on("close", (code) => res(code ?? 1)));
@@ -6099,6 +6102,54 @@ async function executePlan(plan, dryRun) {
   }
 }
 
+// src/core/resolver.ts
+class CircularDependencyError extends Error {
+  chain;
+  constructor(chain) {
+    super(`Circular dependency detected: ${chain.join(" -> ")}`);
+    this.chain = chain;
+    this.name = "CircularDependencyError";
+  }
+}
+
+class MissingDependencyError extends Error {
+  from;
+  missing;
+  constructor(from, missing) {
+    super(`Recipe '${from}' depends on missing recipe '${missing}'`);
+    this.from = from;
+    this.missing = missing;
+    this.name = "MissingDependencyError";
+  }
+}
+function resolveDependencies(recipeName, registry) {
+  const result = [];
+  const visited = new Set;
+  const visiting = new Set;
+  function walk(name, chain) {
+    if (visited.has(name))
+      return;
+    if (visiting.has(name))
+      throw new CircularDependencyError([...chain, name]);
+    const recipe = registry[name];
+    if (!recipe) {
+      if (chain.length > 0) {
+        throw new MissingDependencyError(chain[chain.length - 1], name);
+      }
+      throw new Error(`Recipe '${name}' not found`);
+    }
+    visiting.add(name);
+    for (const dep of recipe.depends ?? []) {
+      walk(dep, [...chain, name]);
+    }
+    visiting.delete(name);
+    visited.add(name);
+    result.push(name);
+  }
+  walk(recipeName, []);
+  return result;
+}
+
 // src/recipes/dart.ts
 import { spawnSync } from "node:child_process";
 async function resolveDarwin() {
@@ -6176,6 +6227,304 @@ var DartRecipe = {
   }
 };
 
+// src/recipes/flutter.ts
+import { spawnSync as spawnSync2 } from "node:child_process";
+async function resolveDarwin2() {
+  const installSteps = [
+    {
+      id: "install-flutter",
+      label: "Install Flutter SDK",
+      cmd: "brew install --cask flutter",
+      checkCmd: "brew list --cask flutter"
+    },
+    {
+      id: "precache-web",
+      label: "Precache Flutter web artifacts",
+      cmd: "flutter precache --web",
+      checkCmd: 'test -d "$(brew --cask --room 2>/dev/null || echo /usr/local/Caskroom)/flutter"/*/flutter/bin/cache/flutter_web_sdk'
+    }
+  ];
+  let flutterRoot = "";
+  try {
+    const result = spawnSync2("brew", ["--cask", "--room"], { encoding: "utf-8" });
+    if (result.status === 0) {
+      const caskroom = result.stdout.trim();
+      const ls = spawnSync2("ls", [caskroom + "/flutter"], { encoding: "utf-8" });
+      if (ls.status === 0) {
+        const version = ls.stdout.trim().split(`
+`)[0];
+        if (version) {
+          flutterRoot = `${caskroom}/flutter/${version}/flutter`;
+        }
+      }
+    }
+  } catch (e) {}
+  if (!flutterRoot) {
+    flutterRoot = "/usr/local/Caskroom/flutter/latest/flutter";
+  }
+  installSteps[1].checkCmd = `test -d ${flutterRoot}/bin/cache/flutter_web_sdk`;
+  const env = {
+    FLUTTER_ROOT: flutterRoot
+  };
+  const paths = [
+    `${flutterRoot}/bin`
+  ];
+  return ExecutionPlanSchema.parse({ installSteps, env, paths });
+}
+async function resolveLinux2() {
+  const installSteps = [
+    {
+      id: "install-flutter-prereqs",
+      label: "Install prerequisites",
+      cmd: "sudo apt-get update && sudo apt-get install -y curl git unzip xz-utils",
+      checkCmd: "dpkg -s curl && dpkg -s git && dpkg -s unzip && dpkg -s xz-utils"
+    },
+    {
+      id: "clone-flutter",
+      label: "Clone Flutter SDK",
+      cmd: "sudo git clone -b stable https://github.com/flutter/flutter.git /usr/local/flutter && sudo chown -R $(id -u):$(id -g) /usr/local/flutter",
+      checkCmd: "test -d /usr/local/flutter"
+    },
+    {
+      id: "precache-web",
+      label: "Precache Flutter web artifacts",
+      cmd: "/usr/local/flutter/bin/flutter precache --web",
+      checkCmd: "test -d /usr/local/flutter/bin/cache/flutter_web_sdk"
+    }
+  ];
+  const env = {
+    FLUTTER_ROOT: "/usr/local/flutter"
+  };
+  const paths = [
+    "/usr/local/flutter/bin"
+  ];
+  return ExecutionPlanSchema.parse({ installSteps, env, paths });
+}
+var FlutterRecipe = {
+  name: "flutter",
+  description: "Flutter SDK (web)",
+  resolve: async (ctx) => {
+    switch (process.platform) {
+      case "darwin":
+        return resolveDarwin2();
+      case "linux":
+        return resolveLinux2();
+      default:
+        throw new Error(`Unsupported platform: ${process.platform}`);
+    }
+  }
+};
+
+// src/recipes/ruby.ts
+import { spawnSync as spawnSync3 } from "node:child_process";
+async function resolveDarwin3() {
+  const installSteps = [{
+    id: "install-ruby",
+    label: "Install Ruby",
+    cmd: "brew install ruby",
+    checkCmd: "brew list --versions ruby"
+  }];
+  let rubyPrefix = "";
+  try {
+    const result = spawnSync3("brew", ["--prefix", "ruby"], { encoding: "utf-8" });
+    if (result.status === 0) {
+      rubyPrefix = result.stdout.trim();
+    }
+  } catch (e) {}
+  if (!rubyPrefix) {
+    rubyPrefix = "/usr/local/opt/ruby";
+  }
+  const env = {
+    GEM_HOME: "$HOME/.gem/ruby"
+  };
+  const paths = [
+    `${rubyPrefix}/bin`,
+    "$HOME/.gem/ruby/bin"
+  ];
+  return ExecutionPlanSchema.parse({ installSteps, env, paths });
+}
+async function resolveLinux3() {
+  const installSteps = [
+    {
+      id: "install-ruby-prereqs",
+      label: "Install build prerequisites",
+      cmd: "sudo apt-get update && sudo apt-get install -y build-essential",
+      checkCmd: "dpkg -s build-essential"
+    },
+    {
+      id: "install-ruby",
+      label: "Install Ruby",
+      cmd: "sudo apt-get install -y ruby-full",
+      checkCmd: "dpkg -s ruby-full"
+    }
+  ];
+  const env = {
+    GEM_HOME: "$HOME/.gem/ruby"
+  };
+  const paths = [
+    "$HOME/.gem/ruby/bin"
+  ];
+  return ExecutionPlanSchema.parse({ installSteps, env, paths });
+}
+var RubyRecipe = {
+  name: "ruby",
+  description: "Ruby programming language",
+  resolve: async (ctx) => {
+    switch (process.platform) {
+      case "darwin":
+        return resolveDarwin3();
+      case "linux":
+        return resolveLinux3();
+      default:
+        throw new Error(`Unsupported platform: ${process.platform}`);
+    }
+  }
+};
+
+// src/recipes/php.ts
+import { spawnSync as spawnSync4 } from "node:child_process";
+async function resolveDarwin4() {
+  const installSteps = [
+    {
+      id: "install-php",
+      label: "Install PHP",
+      cmd: "brew install php",
+      checkCmd: "brew list --versions php"
+    },
+    {
+      id: "install-composer",
+      label: "Install Composer",
+      cmd: "brew install composer",
+      checkCmd: "brew list --versions composer"
+    }
+  ];
+  let phpPrefix = "";
+  try {
+    const result = spawnSync4("brew", ["--prefix", "php"], { encoding: "utf-8" });
+    if (result.status === 0) {
+      phpPrefix = result.stdout.trim();
+    }
+  } catch (e) {}
+  if (!phpPrefix) {
+    phpPrefix = "/usr/local/opt/php";
+  }
+  const env = {
+    COMPOSER_HOME: "$HOME/.config/composer"
+  };
+  const paths = [
+    `${phpPrefix}/bin`,
+    "$HOME/.config/composer/vendor/bin"
+  ];
+  return ExecutionPlanSchema.parse({ installSteps, env, paths });
+}
+async function resolveLinux4() {
+  const installSteps = [
+    {
+      id: "install-php",
+      label: "Install PHP",
+      cmd: "sudo apt-get update && sudo apt-get install -y php-cli php-common php-mbstring php-xml php-curl php-zip unzip",
+      checkCmd: "dpkg -s php-cli"
+    },
+    {
+      id: "install-composer",
+      label: "Install Composer",
+      cmd: "curl -sS https://getcomposer.org/installer | sudo php -- --install-dir=/usr/local/bin --filename=composer",
+      checkCmd: "which composer"
+    }
+  ];
+  const env = {
+    COMPOSER_HOME: "$HOME/.config/composer"
+  };
+  const paths = [
+    "$HOME/.config/composer/vendor/bin"
+  ];
+  return ExecutionPlanSchema.parse({ installSteps, env, paths });
+}
+var PhpRecipe = {
+  name: "php",
+  description: "PHP programming language with Composer",
+  resolve: async (ctx) => {
+    switch (process.platform) {
+      case "darwin":
+        return resolveDarwin4();
+      case "linux":
+        return resolveLinux4();
+      default:
+        throw new Error(`Unsupported platform: ${process.platform}`);
+    }
+  }
+};
+
+// src/recipes/php-sqlite.ts
+async function resolveDarwin5() {
+  return ExecutionPlanSchema.parse({ installSteps: [], env: {}, paths: [] });
+}
+async function resolveLinux5() {
+  const installSteps = [
+    {
+      id: "install-php-sqlite",
+      label: "Install PHP SQLite extension",
+      cmd: "sudo apt-get update && sudo apt-get install -y php-sqlite3",
+      checkCmd: "dpkg -s php-sqlite3"
+    }
+  ];
+  return ExecutionPlanSchema.parse({ installSteps, env: {}, paths: [] });
+}
+var PhpSqliteRecipe = {
+  name: "php-sqlite",
+  description: "PHP SQLite extension",
+  depends: ["php"],
+  resolve: async (ctx) => {
+    switch (process.platform) {
+      case "darwin":
+        return resolveDarwin5();
+      case "linux":
+        return resolveLinux5();
+      default:
+        throw new Error(`Unsupported platform: ${process.platform}`);
+    }
+  }
+};
+
+// src/recipes/laravel.ts
+async function resolveDarwin6() {
+  const installSteps = [
+    {
+      id: "install-laravel-installer",
+      label: "Install Laravel installer",
+      cmd: "composer global require laravel/installer",
+      checkCmd: "laravel --version"
+    }
+  ];
+  return ExecutionPlanSchema.parse({ installSteps, env: {}, paths: [] });
+}
+async function resolveLinux6() {
+  const installSteps = [
+    {
+      id: "install-laravel-installer",
+      label: "Install Laravel installer",
+      cmd: "composer global require laravel/installer",
+      checkCmd: "laravel --version"
+    }
+  ];
+  return ExecutionPlanSchema.parse({ installSteps, env: {}, paths: [] });
+}
+var LaravelRecipe = {
+  name: "laravel",
+  description: "Laravel PHP framework installer",
+  depends: ["php-sqlite"],
+  resolve: async (ctx) => {
+    switch (process.platform) {
+      case "darwin":
+        return resolveDarwin6();
+      case "linux":
+        return resolveLinux6();
+      default:
+        throw new Error(`Unsupported platform: ${process.platform}`);
+    }
+  }
+};
+
 // src/core/loader.ts
 function substituteVars(str, vars) {
   return str.replace(/\{\{(\w+)\}\}/g, (_, key) => {
@@ -6232,13 +6581,13 @@ var ollama_default = {
     {
       id: "enable-ollama",
       label: "Enable Ollama service",
-      cmd: "sudo systemctl daemon-reload && sudo systemctl enable --now ollama",
-      checkCmd: "systemctl is-active ollama"
+      cmd: "if command -v systemctl >/dev/null 2>&1; then sudo systemctl daemon-reload && sudo systemctl enable --now ollama; else nohup ollama serve > /tmp/ollama.log 2>&1 & fi",
+      checkCmd: "curl -sf http://localhost:11434/ >/dev/null 2>&1"
     },
     {
       id: "wait-for-ollama",
       label: "Wait for Ollama to initialize",
-      cmd: "sleep 5"
+      cmd: "for i in 1 2 3 4 5 6 7 8 9 10; do curl -sf http://localhost:11434/ >/dev/null 2>&1 && exit 0; sleep 1; done; echo 'Ollama server did not start'; exit 1"
     },
     {
       id: "pull-model",
@@ -6255,7 +6604,7 @@ var ollama_default = {
 // package.json
 var package_default = {
   name: "@_davideast/jules-env",
-  version: "0.1.2",
+  version: "0.2.1",
   description: "Configure ephemeral development environments",
   license: "Apache-2.0",
   type: "module",
@@ -6288,7 +6637,12 @@ var package_default = {
     test: "bun test",
     typecheck: "tsc --noEmit",
     "check:all": "bun run scripts/prepublish-checks.ts",
-    prepack: "bun run scripts/prepublish-checks.ts"
+    prepack: "bun run scripts/prepublish-checks.ts",
+    docker: "docker build -t jules-env . && docker run --rm -it jules-env",
+    "test:install": "./scripts/test-install.sh"
+  },
+  np: {
+    "2fa": false
   }
 };
 
@@ -6296,28 +6650,38 @@ var package_default = {
 var program2 = new Command;
 var recipes = {
   dart: DartRecipe,
+  flutter: FlutterRecipe,
+  ruby: RubyRecipe,
+  php: PhpRecipe,
+  "php-sqlite": PhpSqliteRecipe,
+  laravel: LaravelRecipe,
   ollama: loadDataRecipe(ollama_default)
 };
 program2.name("jules-env").description("Configure ephemeral development environments").version(package_default.version);
 program2.command("use <runtime>").description("Setup a runtime environment").option("--version <v>", "Version to install", "latest").option("--dry-run", "Simulate execution", false).option("--preset <p>", "Configuration preset").action(async (runtime, options) => {
   try {
-    const recipe = recipes[runtime];
-    if (!recipe) {
-      console.error(`Error: Recipe for '${runtime}' not found.`);
-      process.exit(1);
-    }
     const context = UseContextSchema.parse({
       runtime,
       version: options.version,
       preset: options.preset,
       dryRun: options.dryRun
     });
-    console.log(`[jules-env] Resolving plan for ${runtime}...`);
-    const plan = await recipe.resolve(context);
-    await executePlan(plan, context.dryRun);
+    const order = resolveDependencies(runtime, recipes);
+    if (order.length > 1) {
+      console.log(`[jules-env] Resolving dependencies: ${order.join(" -> ")}`);
+    }
+    for (const recipeName of order) {
+      const recipe = recipes[recipeName];
+      const depContext = recipeName === runtime ? context : UseContextSchema.parse({ runtime: recipeName, dryRun: context.dryRun });
+      console.log(`[jules-env] Resolving plan for ${recipeName}...`);
+      const plan = await recipe.resolve(depContext);
+      await executePlan(plan, context.dryRun, recipeName);
+    }
   } catch (err) {
     if (err instanceof z.ZodError) {
       console.error("Validation Error:", err.errors);
+    } else if (err instanceof CircularDependencyError || err instanceof MissingDependencyError) {
+      console.error("Dependency Error:", err.message);
     } else {
       console.error("Error:", err);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@_davideast/jules-env",
-  "version": "0.1.2",
+  "version": "0.2.1",
   "description": "Configure ephemeral development environments",
   "license": "Apache-2.0",
   "type": "module",
@@ -33,6 +33,11 @@
     "test": "bun test",
     "typecheck": "tsc --noEmit",
     "check:all": "bun run scripts/prepublish-checks.ts",
-    "prepack": "bun run scripts/prepublish-checks.ts"
+    "prepack": "bun run scripts/prepublish-checks.ts",
+    "docker": "docker build -t jules-env . && docker run --rm -it jules-env",
+    "test:install": "./scripts/test-install.sh"
+  },
+  "np": {
+    "2fa": false
   }
 }