@worca/ui 0.43.0 → 0.44.0

package/app/styles.css

@@ -8170,6 +8170,60 @@ sl-dialog.markdown-dialog::part(body) {
   color: var(--fg);
 }
 
+.template-action-dialog .dialog-collisions {
+  border-left: 3px solid var(--sl-color-warning-500, #f59e0b);
+  padding: 10px 12px;
+  background: var(--sl-color-warning-50, rgba(245, 158, 11, 0.05));
+  border-radius: 4px;
+  min-width: 0;
+}
+.template-action-dialog .dialog-collisions-header {
+  margin-bottom: 6px;
+}
+.template-action-dialog .dialog-collision-list {
+  list-style: none;
+  margin: 10px 0 0;
+  padding: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+.template-action-dialog .dialog-collision-row {
+  display: grid;
+  grid-template-columns: minmax(90px, 140px) minmax(0, 1fr) minmax(0, 1fr);
+  align-items: center;
+  gap: 8px;
+  min-width: 0;
+}
+.template-action-dialog .dialog-collision-alias {
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.template-action-dialog .dialog-collision-alias code {
+  font-family: var(--sl-font-mono);
+  font-size: 13px;
+  color: var(--fg);
+}
+.template-action-dialog .collision-action-select,
+.template-action-dialog .collision-rename-input {
+  width: 100%;
+  min-width: 0;
+}
+.template-action-dialog .dialog-collision-row[data-rename="false"] .collision-action-select {
+  grid-column: 2 / span 2;
+}
+.template-action-dialog .dialog-new-aliases-hint {
+  margin-top: 8px;
+}
+.template-action-dialog .dialog-new-aliases-hint code {
+  font-family: var(--sl-font-mono);
+  font-size: 12px;
+  color: var(--fg);
+  margin-right: 4px;
+}
+
 .editor-content {
   flex: 1;
   overflow-y: auto;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@worca/ui",
-  "version": "0.43.0",
+  "version": "0.44.0",
   "description": "Pipeline monitoring UI for worca-cc",
   "license": "MIT",
   "author": "Sinisha Djukic",

package/server/paths.js

@@ -23,6 +23,17 @@ export function worcaHome() {
   return join(homedir(), '.worca');
 }
 
+/**
+ * @returns {string} Absolute path to the user-global settings.json
+ * (`~/.worca/settings.json` by default, $WORCA_HOME-aware). The Python
+ * runtime reads this layer first and deep-merges project settings on top,
+ * so any UI surface that needs to mirror runtime resolution (e.g. model
+ * alias dropdowns) must layer this in.
+ */
+export function globalSettingsPath() {
+  return join(worcaHome(), 'settings.json');
+}
+
 /**
  * @param {string=} override Caller-supplied path that wins over $WORCA_HOME.
  * @returns {string} Absolute path to the fleet-runs directory.

package/server/project-routes.js

@@ -29,7 +29,7 @@ import { getDefaultBranch } from './git-helpers.js';
 import { extractAndStripGlobalKeys } from './global-keys.js';
 import { LaunchLock } from './launch-lock.js';
 import { createModelEnvRouter } from './model-env-routes.js';
-import { preferencesPath } from './paths.js';
+import { globalSettingsPath, preferencesPath } from './paths.js';
 import { readPreferences } from './preferences.js';
 import { ProcessManager } from './process-manager.js';
 import { countRunningPipelinesAcrossProjects } from './process-registry.js';
@@ -45,6 +45,7 @@ import {
 import {
   deepMerge,
   localPathFor,
+  readEffectiveSettings,
   readLocalSettings,
   readMergedSettings,
 } from './settings-merge.js';
@@ -488,6 +489,28 @@ export function createProjectScopedRoutes({
     }
   });
 
+  // GET /api/projects/:projectId/effective-settings
+  //
+  // Returns the fully-layered settings the Python runtime sees: user-global
+  // base → user-global .local → project base → project .local. Used by UI
+  // surfaces that must mirror runtime alias resolution (e.g. the per-agent
+  // model dropdown in the template editor — without this, aliases that live
+  // only in user-global ~/.worca/settings.json are invisible to projects).
+  router.get('/effective-settings', (req, res) => {
+    const { settingsPath } = req.project;
+    try {
+      const merged = readEffectiveSettings(settingsPath, globalSettingsPath());
+      res.json({
+        worca: merged.worca || {},
+        permissions: merged.permissions || {},
+      });
+    } catch (err) {
+      res
+        .status(500)
+        .json({ error: { code: 'read_error', message: err.message } });
+    }
+  });
+
   // POST /api/projects/:projectId/settings
   router.post('/settings', async (req, res) => {
     const { settingsPath } = req.project;

package/server/settings-merge.js

@@ -81,3 +81,48 @@ export function readLocalSettings(settingsPath) {
     return {};
   }
 }
+
+/**
+ * Read the full effective settings stack the way the Python runtime resolves
+ * it: user-global base → user-global .local → project base → project .local.
+ * Each layer deep-merges over the previous. Missing files are treated as
+ * empty objects. Used by UI surfaces (model alias dropdowns, etc.) that must
+ * mirror what `worca.utils.settings.resolve_model` sees at run time.
+ *
+ * `globalSettingsPath` is passed in so callers can substitute it during
+ * tests; production callers thread the result of `paths.globalSettingsPath()`.
+ */
+export function readEffectiveSettings(projectSettingsPath, globalSettingsPath) {
+  const layers = [];
+  if (globalSettingsPath) {
+    try {
+      layers.push(JSON.parse(readFileSync(globalSettingsPath, 'utf8')));
+    } catch {
+      /* missing or invalid — treat as empty */
+    }
+    const globalLocal = localPathFor(globalSettingsPath);
+    if (existsSync(globalLocal)) {
+      try {
+        layers.push(JSON.parse(readFileSync(globalLocal, 'utf8')));
+      } catch {
+        /* invalid — skip */
+      }
+    }
+  }
+  if (projectSettingsPath) {
+    try {
+      layers.push(JSON.parse(readFileSync(projectSettingsPath, 'utf8')));
+    } catch {
+      /* missing or invalid — treat as empty */
+    }
+    const projectLocal = localPathFor(projectSettingsPath);
+    if (existsSync(projectLocal)) {
+      try {
+        layers.push(JSON.parse(readFileSync(projectLocal, 'utf8')));
+      } catch {
+        /* invalid — skip */
+      }
+    }
+  }
+  return layers.reduce((acc, layer) => deepMerge(acc, layer), {});
+}

package/server/templates-routes.js

@@ -378,6 +378,50 @@ function exportGist(projectRoot, id) {
   return match ? match[0] : null;
 }
 
+function _parseResolutionsHeader(req) {
+  const raw = req.headers['x-resolutions'];
+  if (!raw) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+      return parsed;
+    }
+  } catch {
+    /* fall through */
+  }
+  return null;
+}
+
+function _writeResolutionsFile(dir, resolutions) {
+  if (!resolutions || Object.keys(resolutions).length === 0) return null;
+  const path = join(dir, 'resolutions.json');
+  writeFileSync(path, JSON.stringify(resolutions), 'utf8');
+  return path;
+}
+
+function _baseImportArgs(
+  bundlePath,
+  dstTier,
+  resolutionsPath,
+  onModelConflict,
+) {
+  const args = [
+    'import',
+    '--from',
+    bundlePath,
+    '--scope',
+    dstTier,
+    '--non-interactive',
+  ];
+  if (resolutionsPath) {
+    args.push('--resolutions', resolutionsPath);
+  }
+  if (onModelConflict) {
+    args.push('--on-model-conflict', onModelConflict);
+  }
+  return args;
+}
+
 function handleZipImport(req, res) {
   const dstTier = req.query.dst_tier;
   if (!isValidTier(dstTier)) {
@@ -389,18 +433,18 @@ function handleZipImport(req, res) {
   if (rejectBuiltinWrite(res, dstTier, 'import to')) return;
 
   const zipBuffer = req.body;
-  const tmpPath = join(
-    tmpdir(),
-    `worca-import-${Math.random().toString(36).slice(2)}.zip`,
-  );
+  const resolutions = _parseResolutionsHeader(req);
+  const onModelConflict = req.query.on_model_conflict || null;
+  const dir = mkdtempSync(join(tmpdir(), 'worca-import-'));
+  const tmpPath = join(dir, 'bundle.zip');
   try {
     writeFileSync(tmpPath, zipBuffer);
+    const resolutionsPath = _writeResolutionsFile(dir, resolutions);
     const stdout = runWorcaTemplates(
       req.project.projectRoot,
-      ['import', '--from', tmpPath, '--scope', dstTier, '--non-interactive'],
+      _baseImportArgs(tmpPath, dstTier, resolutionsPath, onModelConflict),
       { timeout: 60000 },
     );
-    // Best-effort summary: the CLI may print imported template ids to stdout
     const imported = [];
     for (const line of (stdout || '').split('\n')) {
       const m = line.match(/imported[:\s]+([a-z0-9_-]+)/i);
@@ -412,16 +456,76 @@ function handleZipImport(req, res) {
       .status(statusForCliCode(err.cliCode))
       .json({ ok: false, error: err.message, code: err.cliCode });
   } finally {
+    cleanupTemp(dir);
+  }
+}
+
+function handleImportPreview(req, res) {
+  const dstTier = req.query.dst_tier;
+  if (!isValidTier(dstTier)) {
+    return res.status(400).json({
+      ok: false,
+      error: `dst_tier must be one of: ${TIERS.join(', ')}`,
+    });
+  }
+  if (rejectBuiltinWrite(res, dstTier, 'import to')) return;
+
+  const ctype = req.headers['content-type'] || '';
+  const dir = mkdtempSync(join(tmpdir(), 'worca-import-preview-'));
+  try {
+    let bundlePath;
+    if (ctype.startsWith('application/zip')) {
+      bundlePath = join(dir, 'bundle.zip');
+      writeFileSync(bundlePath, req.body);
+    } else {
+      const { bundle } = req.body || {};
+      if (!bundle || typeof bundle !== 'object') {
+        return res
+          .status(400)
+          .json({ ok: false, error: 'bundle must be a JSON object' });
+      }
+      bundlePath = join(dir, 'bundle.json');
+      writeFileSync(bundlePath, JSON.stringify(bundle), 'utf8');
+    }
+    const stdout = runWorcaTemplates(
+      req.project.projectRoot,
+      [
+        'import',
+        '--from',
+        bundlePath,
+        '--scope',
+        dstTier,
+        '--non-interactive',
+        '--preview',
+      ],
+      { timeout: 30000 },
+    );
     try {
-      rmSync(tmpPath, { force: true });
+      const payload = JSON.parse(stdout);
+      res.json({ ok: true, ...payload });
     } catch {
-      /* ignore cleanup errors */
+      res.status(500).json({
+        ok: false,
+        error: 'CLI preview output was not valid JSON',
+        raw: stdout,
+      });
     }
+  } catch (err) {
+    res
+      .status(statusForCliCode(err.cliCode))
+      .json({ ok: false, error: err.message, code: err.cliCode });
+  } finally {
+    cleanupTemp(dir);
   }
 }
 
 function handleJsonImport(req, res) {
-  const { bundle, dst_tier: dstTier } = req.body || {};
+  const {
+    bundle,
+    dst_tier: dstTier,
+    resolutions,
+    on_model_conflict: onModelConflict,
+  } = req.body || {};
   if (!bundle || typeof bundle !== 'object') {
     return res
       .status(400)
@@ -435,7 +539,10 @@ function handleJsonImport(req, res) {
   }
   if (rejectBuiltinWrite(res, dstTier, 'import to')) return;
   try {
-    const result = importBundle(req.project.projectRoot, bundle, dstTier);
+    const result = importBundle(req.project.projectRoot, bundle, dstTier, {
+      resolutions,
+      onModelConflict,
+    });
     res.json({ ok: true, ...result });
   } catch (err) {
     res
@@ -444,17 +551,19 @@ function handleJsonImport(req, res) {
   }
 }
 
-function importBundle(projectRoot, bundle, tier) {
+function importBundle(projectRoot, bundle, tier, opts = {}) {
   if (!bundle || !Array.isArray(bundle.templates)) {
     throw new Error('Bundle must contain a "templates" array');
   }
+  const { resolutions, onModelConflict } = opts;
   const dir = mkdtempSync(join(tmpdir(), 'worca-import-'));
   const bundlePath = join(dir, 'bundle.json');
   try {
     writeFileSync(bundlePath, JSON.stringify(bundle), 'utf8');
+    const resolutionsPath = _writeResolutionsFile(dir, resolutions);
     runWorcaTemplates(
       projectRoot,
-      ['import', '--from', bundlePath, '--scope', tier, '--non-interactive'],
+      _baseImportArgs(bundlePath, tier, resolutionsPath, onModelConflict),
       { timeout: 60000 },
     );
     const targetDir = dirForTier(projectRoot, tier);
@@ -593,6 +702,12 @@ export function createTemplatesRoutes() {
     },
   );
 
+  router.post(
+    '/templates/import/preview',
+    expressRaw({ type: 'application/zip', limit: '1mb' }),
+    (req, res) => handleImportPreview(req, res),
+  );
+
   /**
    * POST /api/projects/:projectId/templates/validate
    * Body: { config }