V3.1.2 beta.rc4

.pre-commit-config.yaml

@@ -0,0 +1,44 @@
+# Pre-commit hooks: formatter + linter for the TS frontend and Python backends.
+# Install once with:  pre-commit install
+# Run on all files :  pre-commit run --all-files
+#
+# Python (service/, home-agent/) is handled by Ruff (matches the Ruff CI check).
+# WebUI is handled by ESLint + Prettier via the existing npm scripts (matches the
+# "Lint TS" CI check). ESLint resolves its flat config from WebUI/, not the repo
+# root, so the eslint hook runs against the whole WebUI workspace.
+#
+# Formatters (ruff-format, prettier) reformat in place and then `git add` what they
+# changed, so they never abort the commit just because formatting was applied — the
+# reformatted files are restaged and included in the same commit. The linters still
+# fail on genuine, unfixable problems.
+repos:
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.15.20
+    hooks:
+      # Linter (auto-fix what it safely can)
+      - id: ruff
+        name: ruff lint (Python)
+        args: [--fix]
+        files: ^(service|home-agent)/.*\.py$
+
+  - repo: local
+    hooks:
+      # Formatter (Ruff) — format in place, restage, never fail on reformat
+      - id: ruff-format
+        name: ruff format (Python)
+        language: system
+        entry: bash -c 'uvx ruff@0.15.20 format "$@" && git add -- "$@"' --
+        files: ^(service|home-agent)/.*\.py$
+      # Linter (ESLint with auto-fix)
+      - id: eslint
+        name: eslint (WebUI)
+        language: system
+        entry: bash -c 'cd WebUI && npm run lint:eslint'
+        files: ^WebUI/.*\.(ts|tsx|mts|cts|js|jsx|mjs|cjs|vue)$
+        pass_filenames: false
+      # Formatter (Prettier) — format in place, restage, never fail on reformat
+      - id: prettier
+        name: prettier (WebUI)
+        language: system
+        entry: bash -c 'cd WebUI && files=(); for f in "$@"; do files+=("${f#WebUI/}"); done && npx prettier --write "${files[@]}" && cd .. && git add -- "$@"' --
+        files: ^WebUI/.*\.(ts|tsx|mts|cts|js|jsx|mjs|cjs|vue|json|css|scss|html|md|ya?ml)$

WebUI/build/scripts/ensure-precommit-hook.mjs

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+/**
+ * ensure-precommit-hook.mjs
+ *
+ * Install the git pre-commit hook defined by <repo-root>/.pre-commit-config.yaml
+ * (Ruff for the Python backends, ESLint + Prettier for the WebUI). Run as part of
+ * `npm run setup` so a fresh clone is ready to commit without a manual step.
+ *
+ * Best effort and idempotent:
+ *   - No-op if this is not a git checkout (e.g. a source tarball).
+ *   - No-op if the hook is already installed.
+ *   - Uses `pre-commit` from PATH, else falls back to `uvx pre-commit`
+ *     (uv ships with this repo's toolchain). If neither is available it prints
+ *     how to install it and exits 0 — never blocks setup.
+ */
+import { spawnSync } from 'node:child_process'
+import { existsSync, readFileSync } from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const webuiDir = path.resolve(fileURLToPath(new URL('../../', import.meta.url)))
+const repoRoot = path.resolve(webuiDir, '..')
+
+function log(msg) {
+  console.log(`[ensure-precommit-hook] ${msg}`)
+}
+
+// Resolve a path relative to the git dir (handles worktrees and `.git` files).
+function gitPath(relative) {
+  const res = spawnSync('git', ['rev-parse', '--git-path', relative], {
+    cwd: repoRoot,
+    encoding: 'utf-8',
+  })
+  if (res.status !== 0) return undefined
+  const out = res.stdout.trim()
+  return path.isAbsolute(out) ? out : path.join(repoRoot, out)
+}
+
+// Skip cleanly when this is not a git working tree.
+if (
+  spawnSync('git', ['rev-parse', '--is-inside-work-tree'], { cwd: repoRoot, stdio: 'ignore' })
+    .status !== 0
+) {
+  log('Not a git checkout — skipping pre-commit hook install.')
+  process.exit(0)
+}
+
+const configPath = path.join(repoRoot, '.pre-commit-config.yaml')
+if (!existsSync(configPath)) {
+  log(`No .pre-commit-config.yaml at ${configPath} — skipping.`)
+  process.exit(0)
+}
+
+// Already installed? The shim pre-commit writes carries a recognizable marker.
+const hookPath = gitPath('hooks/pre-commit')
+if (hookPath && existsSync(hookPath)) {
+  try {
+    if (readFileSync(hookPath, 'utf-8').includes('File generated by pre-commit')) {
+      log('pre-commit hook already installed — nothing to do.')
+      process.exit(0)
+    }
+  } catch {
+    /* fall through and (re)install */
+  }
+}
+
+function commandAvailable(cmd, args = ['--version']) {
+  return spawnSync(cmd, args, { stdio: 'ignore' }).status === 0
+}
+
+// Prefer a `pre-commit` on PATH; otherwise run it through uv's `uvx`.
+let runner
+if (commandAvailable('pre-commit')) {
+  runner = ['pre-commit']
+} else if (commandAvailable('uvx')) {
+  runner = ['uvx', 'pre-commit']
+} else {
+  log('`pre-commit` is not installed and `uvx` is unavailable, so the hook was not installed.')
+  log('Install it once with either of:')
+  log('    uv tool install pre-commit')
+  log('    pipx install pre-commit')
+  log('then re-run `npm run setup` (or `pre-commit install`).')
+  process.exit(0)
+}
+
+log(`Installing git pre-commit hook with: ${runner.join(' ')} install`)
+const res = spawnSync(runner[0], [...runner.slice(1), 'install'], {
+  cwd: repoRoot,
+  stdio: 'inherit',
+})
+if (res.status !== 0) {
+  log('Could not install the pre-commit hook (continuing anyway).')
+  log('You can install it manually later with `pre-commit install`.')
+  process.exit(0)
+}
+
+log('pre-commit hook installed.')

WebUI/electron/remoteUpdates.ts

@@ -162,6 +162,42 @@ export function getBundledComfyUiGitRefSync(): string {
   }
 }
 
+const bundledBackendVersionCache: Partial<Record<keyof BackendVersions, BackendVersion>> = {}
+
+/**
+ * Backend version/releaseTag from the **shipped** `external/backend-versions.json`
+ * (not a remote resolve). Used as the build-time default before the UI applies a
+ * resolved/overridden version via updateSettings, so the version lives in exactly
+ * one place (the JSON) rather than being duplicated in service source.
+ */
+export function getBundledBackendVersionSync(
+  serviceName: keyof BackendVersions,
+): BackendVersion | undefined {
+  if (bundledBackendVersionCache[serviceName]) {
+    return bundledBackendVersionCache[serviceName]
+  }
+  const versionsFilePath = path.join(externalResourcesDir(), 'backend-versions.json')
+  try {
+    const raw = fs.readFileSync(versionsFilePath, 'utf-8')
+    const parsed = BackendVersionsSchema.parse(JSON.parse(raw))
+    const v = parsed[serviceName]
+    if (v) {
+      bundledBackendVersionCache[serviceName] = v
+      appLoggerInstance.info(
+        `Bundled ${serviceName} version from local JSON: ${JSON.stringify(v)}`,
+        'backend-version',
+      )
+    }
+    return v
+  } catch (e) {
+    appLoggerInstance.error(
+      `Failed to read bundled ${serviceName} version from ${versionsFilePath}: ${e}`,
+      'backend-version',
+    )
+    return undefined
+  }
+}
+
 const loadLocalModels = async () => {
   const modelsFilePath = path.join(externalResourcesDir(), 'models.json')
   try {

WebUI/electron/subprocesses/comfyUIBackendService.ts

@@ -4,6 +4,7 @@ import path from 'node:path'
 import fs from 'fs'
 import * as filesystem from 'fs-extra'
 import { spawnProcessAsync } from './osProcessHelper.ts'
+import { restoreTreeWritePermissions } from './tools.ts'
 import {
   LongLivedPythonApiService,
   GitService,
@@ -816,6 +817,10 @@ export class ComfyUiBackendService extends LongLivedPythonApiService {
       // directory handles. Surface a clear, actionable error if it ultimately
       // cannot be removed rather than letting `git clone` fail later with a
       // confusing "destination path already exists" message.
+      // On Linux/macOS a read-only directory in the tree fails removal with EACCES
+      // (unlink/rmdir needs write permission on the parent); strip the read-only
+      // bit up front, and again on EACCES, so the wipe-and-reclone path works.
+      await restoreTreeWritePermissions(this.serviceDir)
       let lastError: unknown
       for (let attempt = 0; attempt < 5; attempt++) {
         try {
@@ -824,6 +829,9 @@ export class ComfyUiBackendService extends LongLivedPythonApiService {
           break
         } catch (removeError) {
           lastError = removeError
+          if ((removeError as NodeJS.ErrnoException)?.code === 'EACCES') {
+            await restoreTreeWritePermissions(this.serviceDir)
+          }
           await new Promise((resolve) => setTimeout(resolve, 1000))
         }
       }

WebUI/electron/subprocesses/llamaCppBackendService.ts

@@ -14,7 +14,7 @@ import {
 } from './deviceDetection.ts'
 import type { LocalSettings } from '../main.ts'
 import getPort, { portNumbers } from 'get-port'
-import { binary, extract } from './tools.ts'
+import { binary, extract, restoreTreeWritePermissions } from './tools.ts'
 import * as llamaCppPhison from './llamaCppPhison.ts'
 import type { LlamaCppBuildVariant } from './llamaCppPhison.ts'
 
@@ -990,6 +990,12 @@ export class LlamaCppBackendService implements ApiService {
   private async removeDirectoryWithRetries(targetDir: string): Promise<void> {
     const maxAttempts = 5
 
+    // On Linux/macOS, unlink()/rmdir() need write permission on the parent dir,
+    // so a read-only directory in an extracted release tarball would otherwise
+    // fail every attempt with EACCES (retries don't change permissions). Strip
+    // the read-only bit up front, and again before each retry, so reinstall works.
+    await restoreTreeWritePermissions(targetDir)
+
     for (let attempt = 1; attempt <= maxAttempts; attempt++) {
       try {
         filesystem.removeSync(targetDir)
@@ -1004,6 +1010,9 @@ export class LlamaCppBackendService implements ApiService {
           `Failed to remove ${targetDir} on attempt ${attempt}/${maxAttempts}: ${message}`,
           this.name,
         )
+        if ((error as NodeJS.ErrnoException)?.code === 'EACCES') {
+          await restoreTreeWritePermissions(targetDir)
+        }
         await new Promise((resolve) => setTimeout(resolve, 1000))
       }
     }