machinaos 0.0.81 → 0.0.83

package/client/package.json

@@ -1,7 +1,7 @@
 {
   "name": "react-flow-client",
   "private": true,
-  "version": "0.0.81",
+  "version": "0.0.83",
   "type": "module",
   "scripts": {
     "start": "vite --host 0.0.0.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "machinaos",
-  "version": "0.0.81",
+  "version": "0.0.83",
   "description": "Open source workflow automation platform with AI agents, React Flow, and n8n-inspired architecture",
   "type": "module",
   "keywords": [
@@ -53,6 +53,7 @@
     "!**/node_modules/",
     "!**/.vite/",
     ".env.template",
+    "pyproject.toml",
     "README.md",
     "install.sh",
     "install.ps1"

package/pyproject.toml

@@ -0,0 +1,57 @@
+[project]
+name = "machinaos-cli"
+version = "0.1.0"
+description = "MachinaOS project supervisor CLI (machina)."
+requires-python = ">=3.12"
+dependencies = [
+    "typer>=0.12",
+    "rich>=13",
+    "anyio>=4",
+    "psutil>=6",
+    # OS-native user data / cache / config / log dirs. Soft dependency
+    # in the CLI (``cli/platform_.py`` imports it inside a try/except
+    # and falls back to a stdlib implementation if the wheel isn't
+    # available) so ``machina clean`` / ``machina build`` still work
+    # immediately after a wipe, before ``pip install`` has had a
+    # chance to materialise it.
+    "platformdirs>=4.0",
+    # Required on Windows for the supervisor's Job Object (cli/tree.py).
+    # Without it, child processes survive abnormal supervisor exit
+    # (SIGKILL, BSOD, console close) and accumulate as orphans across
+    # dev restarts. Floor 308 is the first release shipping prebuilt
+    # wheels for Python 3.13.
+    "pywin32>=308; platform_system == 'Windows'",
+]
+
+[project.scripts]
+machina = "cli.cli:app"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["cli"]
+
+# The CLI runs under the user's global / pipx-managed Python — it is
+# NOT a uv-managed project. ``managed = false`` tells ``uv`` to leave
+# this project alone: ``uv sync`` at the repo root is a no-op, no
+# ``<repo>/.venv/`` is created, ``python`` on PATH resolves to the
+# user's global interpreter instead of being shadowed by a workspace
+# venv. The server is the only uv-managed project (``server/.venv``).
+[tool.uv]
+managed = false
+
+[dependency-groups]
+dev = []
+
+# ``machinaos-cli`` is a standalone Python CLI package -- installable
+# via ``pipx install .`` / ``pip install .`` against any Python >=3.12
+# without involving uv. It depends on nothing from ``server/``. The
+# server has its own uv-managed venv at ``server/.venv``; the CLI
+# invokes server-side commands by shelling out via ``cli.run.uv_run``
+# (which runs ``uv run --no-sync ...`` with ``cwd=server/`` so uv
+# discovers ``server/pyproject.toml`` and activates ``server/.venv``).
+# Keeping the CLI independent of the uv workspace means contributors
+# can install / run / debug ``machina`` on whatever interpreter is on
+# PATH -- no per-checkout venv activation required.

package/scripts/install.js

@@ -23,12 +23,20 @@ const ROOT = resolve(__dirname, '..');
 process.env.PYTHONUTF8 = '1';
 
 function run(cmd, cwd = ROOT, timeoutMs = 300000) {
+  // Strip VIRTUAL_ENV from the spawned env. When the user runs
+  // ``npm install -g machinaos`` from a shell that has activated a
+  // venv (very common during dev), uv emits a noisy ``VIRTUAL_ENV
+  // ... does not match the project environment path`` warning per
+  // invocation. uv only honours VIRTUAL_ENV with ``--active``, which
+  // we never pass, so dropping it at the source is the documented
+  // workaround. Same fix applied to cli/supervisor.py's _full_env.
+  const { VIRTUAL_ENV, ...cleanEnv } = process.env;
   execSync(cmd, {
     cwd,
     stdio: 'inherit',
     shell: true,
     timeout: timeoutMs,
-    env: { ...process.env, MACHINAOS_INSTALLING: 'true' }
+    env: { ...cleanEnv, MACHINAOS_INSTALLING: 'true' }
   });
 }
 
@@ -118,16 +126,20 @@ if (uvVersion) {
   }
 }
 
-// Temporal binary: downloaded on first backend boot by
-// server/services/temporal/_install.py via pooch (~90 MB tarball
-// cached under platformdirs.user_cache). No global npm install.
-// User-installed `temporal` on PATH (brew / scoop / cargo) is still
-// honoured by the Python supervisor's shutil.which fallback.
+// Temporal binary: downloaded eagerly during install (step [6/6])
+// by ``python -m services.temporal._install``, same call ``machina
+// build`` already makes. The pooch cache (~/.cache/MachinaOs/...)
+// makes re-runs sub-second. Done eagerly because
+// ``TemporalServerRuntime._pre_spawn`` unconditionally calls
+// ``ensure_temporal_binaries`` -- the runtime always uses the
+// pooch-downloaded binary regardless of any system ``temporal`` on
+// PATH -- so pre-fetching here eliminates a 30-90 s stall on the
+// user's first ``machina start``.
 let temporalVersion = getVersion('temporal --version');
 console.log(
   temporalVersion
-    ? `  temporal: ${temporalVersion} (system install, will be reused)`
-    : '  temporal: managed by Python backend (pooch download on first boot)',
+    ? `  temporal: ${temporalVersion} (system install, pooch copy installed below)`
+    : '  temporal: not on PATH, pooch copy installed below',
 );
 
 // agent-browser is managed by the Python backend
@@ -148,7 +160,7 @@ try {
   // Calculate total steps
   let totalSteps = 1;  // .env always
   if (!clientDistExists) totalSteps += 2;  // client deps + build
-  totalSteps += 3;  // Python deps + bytecode compile + CLI venv
+  totalSteps += 4;  // Python deps + bytecode compile + CLI venv + Temporal binary
   let step = 0;
 
   // Create .env if needed
@@ -220,6 +232,18 @@ try {
   }
   run(`uv pip install --python "${cliVenvPython}" --quiet -e .`, ROOT);
 
+  // Eagerly fetch the official Temporal CLI binary (~90 MB tarball
+  // from temporal.download/cli/archive/latest). Same call ``machina
+  // build`` step [6/6] makes. The runtime supervisor unconditionally
+  // uses this pooch-cached copy via
+  // ``TemporalServerRuntime._pre_spawn`` -- it ignores any system
+  // ``temporal`` on PATH -- so pre-fetching at install time turns a
+  // 30-90 s stall on first ``machina start`` into a sub-second
+  // cache hit. Idempotent on re-install (pooch cache).
+  step++;
+  console.log(`[${step}/${totalSteps}] Installing Temporal binaries...`);
+  run('uv run python -m services.temporal._install', serverDir, 600000);
+
   // WhatsApp RPC is now an npm dependency - binary downloaded via postinstall
   console.log('');
   console.log('Done!');