@cat-factory/app 0.34.0 → 0.35.0

package/app/components/layout/IntegrationsHub.vue

@@ -8,6 +8,7 @@
 // Sections gate on the same `available` probes the navbar used, so a system that
 // the backend has turned off simply doesn't appear here.
 const ui = useUiStore()
+const auth = useAuthStore()
 const github = useGitHubStore()
 const slack = useSlackStore()
 const documents = useDocumentsStore()
@@ -256,6 +257,18 @@ const groups = computed<IntegrationGroup[]>(() => {
       onClick: () => go(() => ui.openProviderConnection('runner-pool')),
     })
   }
+  // Local-mode-only: the warm-container pool + checkout reuse for the local runner. Shown
+  // only on the local-mode service (the controller 503s elsewhere, and `auth.localMode`
+  // is set from /auth/config).
+  if (auth.localMode?.enabled) {
+    infra.push({
+      key: 'local-mode',
+      icon: 'i-lucide-container',
+      label: 'Local mode',
+      description: 'Warm container pool + per-repo checkout reuse for the local runner.',
+      onClick: () => go(ui.openLocalModeSettings),
+    })
+  }
   if (infra.length) out.push({ title: 'Infrastructure', items: infra })
 
   return out

package/app/components/settings/LocalModeSettingsPanel.vue

@@ -0,0 +1,159 @@
+<script setup lang="ts">
+// Local-mode-only settings: the warm-container pool + per-repo checkout reuse. These are
+// a per-DEPLOYMENT singleton stored in the DB (they replaced the LOCAL_POOL_* / HARNESS_*
+// env vars), so a developer tunes them here instead of editing .env. The warm pool keeps
+// idle harness containers ready and re-leases one (preferring repo affinity) to each run —
+// far faster startup than a cold container per run. Saving applies the new sizing to the
+// running service immediately (the pool is resized live — no restart needed); in-flight
+// runs keep the container they already hold, and the checkout config applies to containers
+// started after the save.
+import { reactive, ref, watch } from 'vue'
+
+const ui = useUiStore()
+const store = useLocalSettingsStore()
+const toast = useToast()
+
+const open = computed({
+  get: () => ui.localModeSettingsOpen,
+  set: (v: boolean) => (v ? ui.openLocalModeSettings() : ui.closeLocalModeSettings()),
+})
+
+const saving = ref(false)
+
+// Editable draft. `idleMinutes` and `cleanKeep` are friendlier renderings of the stored
+// `pool.idleTtlMs` (ms) and `checkout.cleanKeep` (string[]).
+const draft = reactive({
+  size: 0,
+  minWarm: 0,
+  max: null as number | null,
+  idleMinutes: 10,
+  workspaceRoot: '/workspace',
+  cleanKeep: 'node_modules,.venv,target,.gradle,.pnpm-store',
+})
+
+function syncDraft() {
+  const s = store.settings
+  if (!s) return
+  draft.size = s.pool.size
+  draft.minWarm = s.pool.minWarm
+  draft.max = s.pool.max
+  draft.idleMinutes = Math.round(s.pool.idleTtlMs / 60_000)
+  draft.workspaceRoot = s.checkout.workspaceRoot
+  draft.cleanKeep = s.checkout.cleanKeep.join(',')
+}
+
+// Load + hydrate the draft whenever the panel opens.
+watch(open, (isOpen) => {
+  if (isOpen) void store.load().then(syncDraft)
+})
+watch(() => store.settings, syncDraft)
+
+async function save() {
+  const cleanKeep = draft.cleanKeep
+    .split(',')
+    .map((s) => s.trim())
+    .filter(Boolean)
+  saving.value = true
+  try {
+    await store.save({
+      pool: {
+        size: Math.max(0, Math.floor(draft.size)),
+        minWarm: Math.max(0, Math.floor(draft.minWarm)),
+        max: draft.max == null ? null : Math.max(0, Math.floor(draft.max)),
+        idleTtlMs: Math.max(0, Math.floor(draft.idleMinutes * 60_000)),
+      },
+      checkout: { workspaceRoot: draft.workspaceRoot.trim() || '/workspace', cleanKeep },
+    })
+    toast.add({ title: 'Local settings saved', icon: 'i-lucide-check', color: 'success' })
+  } catch (e) {
+    toast.add({
+      title: 'Could not save local settings',
+      description: e instanceof Error ? e.message : String(e),
+      icon: 'i-lucide-triangle-alert',
+      color: 'error',
+    })
+  } finally {
+    saving.value = false
+  }
+}
+</script>
+
+<template>
+  <UModal v-model:open="open" title="Local mode" :ui="{ content: 'max-w-2xl' }">
+    <template #body>
+      <div class="space-y-6">
+        <p class="text-xs text-slate-400">
+          Tuning for the local container runner — stored on this machine's deployment (it replaced
+          the <code>LOCAL_POOL_*</code> / <code>HARNESS_*</code> env vars). Saving resizes the warm
+          pool live — no restart needed; in-flight runs keep the container they already hold.
+        </p>
+
+        <!-- Warm container pool -->
+        <section class="space-y-3">
+          <div>
+            <h4 class="text-sm font-semibold text-slate-200">Warm container pool</h4>
+            <p class="text-[11px] text-slate-400">
+              Keep idle harness containers ready and re-lease one (preferring a container that
+              already holds the run's repo) instead of cold-starting per run. Pool size 0 disables
+              it. Requires a Docker-family runtime (Docker/Podman/OrbStack/Colima); ignored on Apple
+              <code>container</code>.
+            </p>
+          </div>
+          <div class="grid grid-cols-1 gap-3 sm:grid-cols-2">
+            <UFormField label="Pool size" help="Max idle warm containers. 0 = pooling off.">
+              <UInput v-model.number="draft.size" type="number" :min="0" size="sm" />
+            </UFormField>
+            <UFormField label="Pre-warm at boot" help="Containers started when the service boots.">
+              <UInput v-model.number="draft.minWarm" type="number" :min="0" size="sm" />
+            </UFormField>
+            <UFormField label="Max containers" help="Hard cap (leased + idle). Blank = pool size.">
+              <UInput
+                v-model.number="draft.max"
+                type="number"
+                :min="0"
+                size="sm"
+                placeholder="(pool size)"
+              />
+            </UFormField>
+            <UFormField label="Idle timeout (minutes)" help="Evict an idle pooled container after.">
+              <UInput v-model.number="draft.idleMinutes" type="number" :min="0" size="sm" />
+            </UFormField>
+          </div>
+        </section>
+
+        <!-- Checkout reuse -->
+        <section class="space-y-3 border-t border-slate-800 pt-6">
+          <div>
+            <h4 class="text-sm font-semibold text-slate-200">Checkout reuse</h4>
+            <p class="text-[11px] text-slate-400">
+              When a warm container already holds the run's repo, the harness reuses its per-repo
+              checkout (clean sweep + fetch + switch branch) instead of cloning fresh.
+            </p>
+          </div>
+          <UFormField
+            label="Workspace root"
+            help="Absolute in-container directory the reused checkout lives under."
+          >
+            <UInput v-model="draft.workspaceRoot" size="sm" placeholder="/workspace" />
+          </UFormField>
+          <UFormField
+            label="Keep on clean (comma-separated)"
+            help="Dependency-cache directories the per-run clean sweep preserves."
+          >
+            <UInput
+              v-model="draft.cleanKeep"
+              size="sm"
+              placeholder="node_modules,.venv,target,.gradle,.pnpm-store"
+            />
+          </UFormField>
+        </section>
+
+        <div class="flex justify-end">
+          <UButton color="primary" icon="i-lucide-save" :loading="saving" @click="save">
+            Save
+          </UButton>
+        </div>
+      </div>
+    </template>
+  </UModal>
+</template>

package/app/composables/api/localSettings.ts

@@ -0,0 +1,17 @@
+import type { LocalSettings, UpdateLocalSettingsInput } from '~/types/localSettings'
+import type { ApiContext } from './context'
+
+/**
+ * Local-mode operational settings (warm-container-pool sizing + per-repo checkout reuse) —
+ * a per-deployment singleton. Wired only on the local-mode service; both calls 503 on the
+ * Worker / stock Node facades (the store hides the panel then). No secrets, so the read view
+ * is the plain config and the write replaces it wholesale.
+ */
+export function localSettingsApi({ http }: ApiContext) {
+  return {
+    getLocalSettings: () => http<LocalSettings>('/local-settings'),
+
+    updateLocalSettings: (body: UpdateLocalSettingsInput) =>
+      http<LocalSettings>('/local-settings', { method: 'PUT', body }),
+  }
+}

package/app/composables/useApi.ts

@@ -11,6 +11,7 @@ import { fragmentsApi } from './api/fragments'
 import { githubApi } from './api/github'
 import { humanTestApi } from './api/humanTest'
 import { kaizenApi } from './api/kaizen'
+import { localSettingsApi } from './api/localSettings'
 import { modelsApi } from './api/models'
 import { notificationsApi } from './api/notifications'
 import { presetsApi } from './api/presets'
@@ -89,6 +90,7 @@ export function useApi() {
     ...followUpsApi(ctx),
     ...humanTestApi(ctx),
     ...kaizenApi(ctx),
+    ...localSettingsApi(ctx),
     ...specApi(ctx),
     ...notificationsApi(ctx),
     ...presetsApi(ctx),

package/app/pages/index.vue

@@ -35,6 +35,7 @@ import ProviderConnectionPanel from '~/components/settings/ProviderConnectionPan
 import ProviderConfigBanner from '~/components/layout/ProviderConfigBanner.vue'
 import ModelConfigurationPanel from '~/components/settings/ModelConfigurationPanel.vue'
 import LocalModelEndpointsPanel from '~/components/settings/LocalModelEndpointsPanel.vue'
+import LocalModeSettingsPanel from '~/components/settings/LocalModeSettingsPanel.vue'
 import SandboxPanel from '~/components/sandbox/SandboxPanel.vue'
 import UserSecretsSection from '~/components/settings/UserSecretsSection.vue'
 import OpenRouterCatalogPanel from '~/components/settings/OpenRouterCatalogPanel.vue'
@@ -194,6 +195,7 @@ watch(
       <ProviderConnectionPanel />
       <ModelConfigurationPanel />
       <LocalModelEndpointsPanel />
+      <LocalModeSettingsPanel />
       <SandboxPanel />
       <UserSecretsSection />
       <OpenRouterCatalogPanel />

package/app/stores/localSettings.ts

@@ -0,0 +1,48 @@
+import { defineStore } from 'pinia'
+import { ref } from 'vue'
+import type { LocalSettings, UpdateLocalSettingsInput } from '~/types/localSettings'
+
+/**
+ * Local-mode operational settings (warm-container-pool sizing + per-repo checkout reuse) —
+ * a per-deployment singleton that replaced the old LOCAL_POOL_* / HARNESS_* env vars. No
+ * secrets, so the store holds the full config. `available` mirrors the backend opt-in: a 503
+ * (not the local-mode service) hides the panel. Loaded on demand from the settings panel.
+ */
+export const useLocalSettingsStore = defineStore('localSettings', () => {
+  const api = useApi()
+
+  const settings = ref<LocalSettings | null>(null)
+  const loading = ref(false)
+  const available = ref<boolean | null>(null)
+
+  async function load() {
+    loading.value = true
+    try {
+      settings.value = await api.getLocalSettings()
+      available.value = true
+    } catch (e) {
+      // 503 ⇒ not the local-mode service ⇒ hide the panel.
+      if (
+        e &&
+        typeof e === 'object' &&
+        'statusCode' in e &&
+        (e as { statusCode?: number }).statusCode === 503
+      ) {
+        available.value = false
+        settings.value = null
+      } else {
+        throw e
+      }
+    } finally {
+      loading.value = false
+    }
+  }
+
+  async function save(input: UpdateLocalSettingsInput) {
+    settings.value = await api.updateLocalSettings(input)
+    available.value = true
+    return settings.value
+  }
+
+  return { settings, loading, available, load, save }
+})

package/app/stores/ui.ts

@@ -116,6 +116,9 @@ export const useUiStore = defineStore('ui', () => {
   const vendorCredentialsOpen = ref(false)
   // Per-user settings panel: the signed-in user's own-machine local model runners.
   const localModelsOpen = ref(false)
+  // Local-mode-only settings panel: the warm-container pool sizing + per-repo checkout reuse
+  // (a per-deployment singleton that replaced the LOCAL_POOL_* / HARNESS_* env vars).
+  const localModeSettingsOpen = ref(false)
   // The Sandbox (parallel prompt/model testing) surface — an opt-in, on-demand window.
   const sandboxOpen = ref(false)
   const userSecretsOpen = ref(false)
@@ -432,6 +435,13 @@ export const useUiStore = defineStore('ui', () => {
   function closeLocalModels() {
     localModelsOpen.value = false
   }
+  function openLocalModeSettings() {
+    cameFromIntegrations.value = false
+    localModeSettingsOpen.value = true
+  }
+  function closeLocalModeSettings() {
+    localModeSettingsOpen.value = false
+  }
   function openSandbox() {
     sandboxOpen.value = true
   }
@@ -580,6 +590,7 @@ export const useUiStore = defineStore('ui', () => {
     modelConfigOpen,
     vendorCredentialsOpen,
     localModelsOpen,
+    localModeSettingsOpen,
     sandboxOpen,
     userSecretsOpen,
     openRouterOpen,
@@ -650,6 +661,8 @@ export const useUiStore = defineStore('ui', () => {
     closeVendorCredentials,
     openLocalModels,
     closeLocalModels,
+    openLocalModeSettings,
+    closeLocalModeSettings,
     openSandbox,
     closeSandbox,
     openUserSecrets,

package/app/types/localSettings.ts

@@ -0,0 +1,31 @@
+// Local-mode operational settings (warm-container-pool sizing + per-repo checkout reuse).
+// Mirrors `@cat-factory/contracts` localSettings. A per-deployment singleton, edited in the
+// dedicated local-mode settings panel — these replaced the old LOCAL_POOL_* / HARNESS_* env
+// vars. There are no secrets, so the read view is the plain config. Local-mode-only (the
+// warm pool is the local Docker-family runner's differentiator).
+
+export interface LocalPoolSettings {
+  /** Max idle warm containers kept for re-lease. 0 disables pooling (cold-start per run). */
+  size: number
+  /** Containers pre-warmed when the service starts. */
+  minWarm: number
+  /** Hard cap on total containers (leased + idle). `null` ⇒ defaults to `size`. */
+  max: number | null
+  /** How long an idle pooled container is kept before eviction (ms). */
+  idleTtlMs: number
+}
+
+export interface LocalCheckoutSettings {
+  /** Absolute in-container dir the reused per-repo checkout lives under. */
+  workspaceRoot: string
+  /** Dep-cache directories the per-run clean sweep keeps (so deps aren't reinstalled). */
+  cleanKeep: string[]
+}
+
+export interface LocalSettings {
+  pool: LocalPoolSettings
+  checkout: LocalCheckoutSettings
+}
+
+/** Admin write: the full settings blob fully replaces the stored config. */
+export type UpdateLocalSettingsInput = LocalSettings

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cat-factory/app",
-  "version": "0.34.0",
+  "version": "0.35.0",
   "description": "Reusable Nuxt layer for the Agent Architecture Board SPA (components, stores, composables, pages). Consume it from a thin deployment app via `extends: ['@cat-factory/app']` and point it at your backend with NUXT_PUBLIC_API_BASE. See deploy/frontend for an example.",
   "repository": {
     "type": "git",