ima2-gen 1.1.6 → 1.1.8

package/routes/generate.js

@@ -4,7 +4,7 @@ import { randomBytes } from "crypto";
 import { validateAndNormalizeRefs } from "../lib/refs.js";
 import { classifyUpstreamError } from "../lib/errorClassify.js";
 import { normalizeOAuthParams } from "../lib/oauthNormalize.js";
-import { normalizeImageModel } from "../lib/imageModels.js";
+import { normalizeImageModel, normalizeReasoningEffort } from "../lib/imageModels.js";
 import { generateViaOAuth } from "../lib/oauthProxy.js";
 import { isNonRetryableGenerationError, normalizeGenerationFailure } from "../lib/generationErrors.js";
 import { startJob, finishJob } from "../lib/inflight.js";
@@ -39,6 +39,8 @@ export function registerGenerateRoutes(app, ctx) {
         references = [],
         mode: promptMode = "auto",
         model: rawModel,
+        reasoningEffort: rawReasoningEffort,
+        webSearchEnabled: rawWebSearchEnabled = true,
       } = req.body;
       const { quality, warnings: qualityWarnings } = normalizeOAuthParams({ provider, quality: rawQuality });
       const modelCheck = normalizeImageModel(ctx, rawModel);
@@ -49,6 +51,15 @@ export function registerGenerateRoutes(app, ctx) {
         return res.status(modelCheck.status).json({ error: modelCheck.error, code: modelCheck.code });
       }
       const imageModel = modelCheck.model;
+      const reasoningCheck = normalizeReasoningEffort(ctx, rawReasoningEffort);
+      if (reasoningCheck.error) {
+        finishStatus = "error";
+        finishHttpStatus = reasoningCheck.status;
+        finishErrorCode = reasoningCheck.code;
+        return res.status(reasoningCheck.status).json({ error: reasoningCheck.error, code: reasoningCheck.code });
+      }
+      const reasoningEffort = reasoningCheck.effort;
+      const webSearchEnabled = rawWebSearchEnabled !== false;
       const normalizedPromptMode = promptMode === "direct" ? "direct" : "auto";
 
       if (!prompt) return res.status(400).json({ error: "Prompt is required" });
@@ -106,6 +117,7 @@ export function registerGenerateRoutes(app, ctx) {
         clientNodeId,
         promptChars: typeof prompt === "string" ? prompt.length : 0,
         promptMode: normalizedPromptMode,
+        webSearchEnabled,
       });
       const startTime = Date.now();
 
@@ -127,7 +139,7 @@ export function registerGenerateRoutes(app, ctx) {
               requestId,
               normalizedPromptMode,
               ctx,
-              { model: imageModel },
+              { model: imageModel, reasoningEffort, webSearchEnabled },
             );
             if (r.b64) return r;
             lastErr = new Error("Empty response (safety refusal)");
@@ -170,6 +182,7 @@ export function registerGenerateRoutes(app, ctx) {
             createdAt: Date.now(),
             usage: r.value.usage || null,
             webSearchCalls: r.value.webSearchCalls || 0,
+            webSearchEnabled,
             refsCount: refCheck.refs.length,
           };
           const rawBuffer = Buffer.from(r.value.b64, "base64");
@@ -242,6 +255,7 @@ export function registerGenerateRoutes(app, ctx) {
         warnings: qualityWarnings,
         revisedPrompt: firstRevised,
         promptMode: normalizedPromptMode,
+        webSearchEnabled,
       };
 
       if (count === 1) {

package/routes/imageImport.js

@@ -0,0 +1,33 @@
+import express from "express";
+import { createLocalImport } from "../lib/localImportStore.js";
+
+function decodeHeader(value) {
+  if (typeof value !== "string" || !value) return null;
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+
+export function registerImageImportRoutes(app, ctx) {
+  const rawImage = express.raw({
+    type: ["image/png", "image/jpeg", "image/webp"],
+    limit: ctx.config.server.bodyLimit,
+  });
+
+  app.post("/api/history/import-local", rawImage, async (req, res) => {
+    try {
+      const item = await createLocalImport(ctx, {
+        buffer: Buffer.isBuffer(req.body) ? req.body : Buffer.alloc(0),
+        originalFilename: decodeHeader(req.headers["x-ima2-original-filename"]),
+      });
+      res.status(201).json({ item });
+    } catch (err) {
+      res.status(err.status || 500).json({
+        error: err.message,
+        code: err.code || "IMPORT_FAILED",
+      });
+    }
+  });
+}

package/routes/index.js

@@ -9,12 +9,21 @@ import { registerStorageRoutes } from "./storage.js";
 import { registerCardNewsRoutes } from "./cardNews.js";
 import { registerMetadataRoutes } from "./metadata.js";
 import { registerPromptRoutes } from "./prompts.js";
+import { registerPromptImportRoutes } from "./promptImport.js";
+import { registerAnnotationRoutes } from "./annotations.js";
+import { registerCanvasVersionRoutes } from "./canvasVersions.js";
+import { registerComfyRoutes } from "./comfy.js";
+import { registerImageImportRoutes } from "./imageImport.js";
 
 export function configureRoutes(app, ctx) {
   registerHealthRoutes(app, ctx);
   registerStorageRoutes(app, ctx);
   registerMetadataRoutes(app, ctx);
   registerHistoryRoutes(app, ctx);
+  registerAnnotationRoutes(app, ctx);
+  registerCanvasVersionRoutes(app, ctx);
+  registerImageImportRoutes(app, ctx);
+  registerComfyRoutes(app, ctx);
   registerSessionRoutes(app, ctx);
   registerEditRoutes(app, ctx);
   registerNodeRoutes(app, ctx);
@@ -22,4 +31,5 @@ export function configureRoutes(app, ctx) {
   registerMultimodeRoutes(app, ctx);
   registerGenerateRoutes(app, ctx);
   registerPromptRoutes(app, ctx);
+  registerPromptImportRoutes(app, ctx);
 }

package/routes/multimode.js

@@ -4,7 +4,7 @@ import { randomBytes } from "crypto";
 import { validateAndNormalizeRefs } from "../lib/refs.js";
 import { classifyUpstreamError } from "../lib/errorClassify.js";
 import { normalizeOAuthParams } from "../lib/oauthNormalize.js";
-import { normalizeImageModel } from "../lib/imageModels.js";
+import { normalizeImageModel, normalizeReasoningEffort } from "../lib/imageModels.js";
 import { generateMultimodeViaOAuth } from "../lib/oauthProxy.js";
 import { startJob, finishJob } from "../lib/inflight.js";
 import { logEvent, logError } from "../lib/logger.js";
@@ -56,6 +56,8 @@ export function registerMultimodeRoutes(app, ctx) {
         references = [],
         mode: promptMode = "auto",
         model: rawModel,
+        reasoningEffort: rawReasoningEffort,
+        webSearchEnabled: rawWebSearchEnabled = true,
       } = req.body;
       const maxImages = normalizeMaxImages(req.body?.maxImages);
       const normalizedPromptMode = promptMode === "direct" ? "direct" : "auto";
@@ -69,6 +71,16 @@ export function registerMultimodeRoutes(app, ctx) {
         return;
       }
       const imageModel = modelCheck.model;
+      const reasoningCheck = normalizeReasoningEffort(ctx, rawReasoningEffort);
+      if (reasoningCheck.error) {
+        finishStatus = "error";
+        finishHttpStatus = reasoningCheck.status;
+        finishErrorCode = reasoningCheck.code;
+        sendSse(res, "error", { error: reasoningCheck.error, code: reasoningCheck.code, status: reasoningCheck.status, requestId });
+        return;
+      }
+      const reasoningEffort = reasoningCheck.effort;
+      const webSearchEnabled = rawWebSearchEnabled !== false;
       if (!prompt) {
         finishStatus = "error";
         finishHttpStatus = 400;
@@ -122,6 +134,7 @@ export function registerMultimodeRoutes(app, ctx) {
         maxImages,
         refs: refCheck.refs.length,
         promptChars: typeof prompt === "string" ? prompt.length : 0,
+        webSearchEnabled,
       });
 
       const startTime = Date.now();
@@ -143,6 +156,8 @@ export function registerMultimodeRoutes(app, ctx) {
         {
           model: imageModel,
           maxImages,
+          reasoningEffort,
+          webSearchEnabled,
           onPartialImage: (partial) =>
             sendSse(res, "partial", {
               image: `data:${mime};base64,${partial.b64}`,
@@ -184,6 +199,7 @@ export function registerMultimodeRoutes(app, ctx) {
           createdAt: Date.now(),
           usage: generated.usage || null,
           webSearchCalls: generated.webSearchCalls || 0,
+          webSearchEnabled,
           refsCount: refCheck.refs.length,
         };
         const rawBuffer = Buffer.from(image.b64, "base64");
@@ -224,6 +240,7 @@ export function registerMultimodeRoutes(app, ctx) {
         model: imageModel,
         usage: generated.usage || null,
         webSearchCalls: generated.webSearchCalls || 0,
+        webSearchEnabled,
         warnings: qualityWarnings,
         extraIgnored: generated.extraIgnored || 0,
         promptMode: normalizedPromptMode,

package/routes/nodes.js

@@ -10,7 +10,7 @@ import { startJob, finishJob } from "../lib/inflight.js";
 import { validateAndNormalizeRefs } from "../lib/refs.js";
 import { classifyUpstreamError } from "../lib/errorClassify.js";
 import { normalizeOAuthParams } from "../lib/oauthNormalize.js";
-import { normalizeImageModel } from "../lib/imageModels.js";
+import { normalizeImageModel, normalizeReasoningEffort } from "../lib/imageModels.js";
 import { generateViaOAuth, editViaOAuth } from "../lib/oauthProxy.js";
 import { isNonRetryableGenerationError, normalizeGenerationFailure } from "../lib/generationErrors.js";
 import { logEvent, logError } from "../lib/logger.js";
@@ -87,6 +87,7 @@ export function registerNodeRoutes(app, ctx) {
         contextMode: rawContextMode = "parent-plus-refs",
         searchMode: rawSearchMode = "on",
         model: rawModel,
+        reasoningEffort: rawReasoningEffort,
       } = body;
       const { provider = "oauth" } = body;
       const { quality, warnings: qualityWarnings } = normalizeOAuthParams({ provider, quality: rawQuality });
@@ -101,11 +102,23 @@ export function registerNodeRoutes(app, ctx) {
         });
       }
       const imageModel = modelCheck.model;
+      const reasoningCheck = normalizeReasoningEffort(ctx, rawReasoningEffort);
+      if (reasoningCheck.error) {
+        finishStatus = "error";
+        finishHttpStatus = reasoningCheck.status;
+        finishErrorCode = reasoningCheck.code;
+        return res.status(reasoningCheck.status).json({
+          error: { code: reasoningCheck.code, message: reasoningCheck.error },
+          parentNodeId,
+        });
+      }
+      const reasoningEffort = reasoningCheck.effort;
       const normalizedPromptMode = promptMode === "direct" ? "direct" : "auto";
       const contextMode = ["parent-plus-refs", "parent-only", "ancestry"].includes(rawContextMode)
         ? rawContextMode
         : "parent-plus-refs";
       const searchMode = ["off", "auto", "on"].includes(rawSearchMode) ? rawSearchMode : "on";
+      const webSearchEnabled = body.webSearchEnabled !== false && searchMode !== "off";
       if (contextMode === "ancestry") {
         finishStatus = "error";
         finishHttpStatus = 400;
@@ -168,7 +181,6 @@ export function registerNodeRoutes(app, ctx) {
       const generateReferenceDiagnostics = operation === "generate" ? referenceDiagnostics : [];
       const referenceMismatchCount = generateReferenceDiagnostics.filter((ref) => ref.warnings?.includes("mime_mismatch")).length;
       const refsForRequest = contextMode === "parent-only" ? [] : (refCheck.refDetails || refCheck.refs);
-      const webSearchEnabled = true;
       const parentImagePresent = !!parentB64;
       const inputImageCount = (parentImagePresent ? 1 : 0) + refsForRequest.length;
       logEvent("node", "request", {
@@ -227,7 +239,13 @@ export function registerNodeRoutes(app, ctx) {
             webSearchEnabled,
           });
           const r = parentB64
-            ? await editViaOAuth(prompt, parentB64, quality, size, moderation, normalizedPromptMode, ctx, requestId, { model: imageModel, references: refsForRequest, searchMode: "on" })
+            ? await editViaOAuth(prompt, parentB64, quality, size, moderation, normalizedPromptMode, ctx, requestId, {
+                model: imageModel,
+                references: refsForRequest,
+                searchMode,
+                reasoningEffort,
+                webSearchEnabled,
+              })
             : await generateViaOAuth(
                 prompt,
                 quality,
@@ -239,6 +257,8 @@ export function registerNodeRoutes(app, ctx) {
                 ctx,
                 {
                   model: imageModel,
+                  reasoningEffort,
+                  webSearchEnabled,
                   partialImages: streamResponse ? 2 : 0,
                   onPartialImage: streamResponse
                     ? (partial) =>
@@ -336,6 +356,7 @@ export function registerNodeRoutes(app, ctx) {
         elapsed,
         usage: usage || null,
         webSearchCalls,
+        webSearchEnabled,
         contextMode,
         searchMode,
         provider: "oauth",
@@ -375,6 +396,7 @@ export function registerNodeRoutes(app, ctx) {
         elapsed,
         usage,
         webSearchCalls,
+        webSearchEnabled,
         provider: "oauth",
         model: imageModel,
         size,

package/routes/promptImport.js

@@ -0,0 +1,354 @@
+import { getDb } from "../lib/db.js";
+import { logError, logEvent } from "../lib/logger.js";
+import { isPromptImportError, promptImportError } from "../lib/promptImport/errors.js";
+import {
+  fetchGitHubSourceText,
+  isSupportedPromptFileName,
+  normalizeGitHubSource,
+} from "../lib/promptImport/githubSource.js";
+import {
+  fetchGitHubFolderFiles,
+  fetchSelectedGitHubFolderFiles,
+  normalizeGitHubFolderSource,
+} from "../lib/promptImport/githubFolder.js";
+import { parsePromptCandidates } from "../lib/promptImport/parsePromptCandidates.js";
+import {
+  getPromptImportSources,
+  refreshCuratedSource,
+  searchCuratedPrompts,
+} from "../lib/promptImport/promptIndex.js";
+import { searchGitHubDiscovery } from "../lib/promptImport/githubDiscovery.js";
+import {
+  listDiscoveryCandidates,
+  reviewDiscoveryCandidate,
+} from "../lib/promptImport/discoveryRegistry.js";
+
+function promptImportLimits(ctx) {
+  return {
+    maxFileBytesForPreview: ctx.config.limits.promptImportMaxFileBytes,
+    maxPromptCandidatesPerFile: ctx.config.limits.promptImportMaxCandidatesPerFile,
+    maxPromptCandidatesPerImport: ctx.config.limits.promptImportMaxCandidatesPerImport,
+    fetchTimeoutMs: ctx.config.limits.promptImportFetchTimeoutMs,
+    maxCandidateChars: ctx.config.limits.promptImportMaxCandidateChars,
+    minCandidateChars: ctx.config.limits.promptImportMinCandidateChars,
+    maxSourceCharsScanned: ctx.config.limits.promptImportMaxSourceCharsScanned,
+    maxRepoIndexFiles: ctx.config.limits.promptImportMaxRepoIndexFiles,
+    curatedSearchLimit: ctx.config.limits.promptImportCuratedSearchLimit,
+    indexCacheTtlMs: ctx.config.limits.promptImportIndexCacheTtlMs,
+    maxFolderFiles: ctx.config.limits.promptImportMaxFolderFiles,
+    maxFolderPreviewFiles: ctx.config.limits.promptImportMaxFolderPreviewFiles,
+    discoverySearchLimit: ctx.config.limits.promptImportDiscoverySearchLimit,
+    discoveryMaxQueries: ctx.config.limits.promptImportDiscoveryMaxQueries,
+  };
+}
+
+function sendPromptImportError(res, error) {
+  const status = isPromptImportError(error) ? error.status : 500;
+  const code = isPromptImportError(error) ? error.code : "PROMPT_IMPORT_FAILED";
+  const message = error?.message || "Prompt import failed";
+  res.status(status).json({ error: { code, message } });
+}
+
+function generateId() {
+  return `${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+
+function sourceFilename(source) {
+  if (source.kind === "local") return source.filename;
+  return source.path.split("/").pop();
+}
+
+function normalizeLocalSource(source) {
+  const filename = typeof source?.filename === "string" ? source.filename.trim() : "";
+  const text = typeof source?.text === "string" ? source.text : "";
+  if (!filename || !isSupportedPromptFileName(filename)) {
+    throw promptImportError("UNSUPPORTED_EXTENSION", "Only .md, .markdown, and .txt files are supported");
+  }
+  if (!text.trim()) {
+    throw promptImportError("PROMPT_IMPORT_EMPTY", "Prompt source is empty", 422);
+  }
+  return {
+    kind: "local",
+    filename,
+    extension: filename.split(".").pop().toLowerCase(),
+    text,
+    tags: [`file:${filename}`, `ext:${filename.split(".").pop().toLowerCase()}`],
+  };
+}
+
+async function buildPreview(req, ctx) {
+  const body = req.body || {};
+  const rawSource = body.source || body;
+  const kind = rawSource.kind === "github" ? "github" : "local";
+  const limits = promptImportLimits(ctx);
+  let source;
+  let text;
+
+  if (kind === "github") {
+    source = normalizeGitHubSource(rawSource.input);
+    text = await fetchGitHubSourceText(source, limits);
+  } else {
+    source = normalizeLocalSource(rawSource);
+    text = source.text;
+  }
+
+  if (text.length > limits.maxSourceCharsScanned) {
+    text = text.slice(0, limits.maxSourceCharsScanned);
+  }
+
+  const candidates = parsePromptCandidates({
+    text,
+    filename: sourceFilename(source),
+    source: {
+      kind: source.kind,
+      owner: source.owner,
+      repo: source.repo,
+      ref: source.ref,
+      path: source.path,
+      htmlUrl: source.htmlUrl,
+      filename: source.filename,
+    },
+    tags: source.tags,
+    limits,
+  });
+
+  if (candidates.length === 0) {
+    throw promptImportError("PROMPT_IMPORT_EMPTY", "No prompt candidates were found", 422);
+  }
+  return { source, candidates, warnings: [] };
+}
+
+function normalizeFolderInput(body) {
+  const input = typeof body?.source?.input === "string" ? body.source.input : body?.input;
+  return normalizeGitHubFolderSource(input);
+}
+
+async function buildFolderFiles(req, ctx) {
+  const limits = promptImportLimits(ctx);
+  const source = normalizeFolderInput(req.body || {});
+  return fetchGitHubFolderFiles(source, limits);
+}
+
+async function buildFolderPreview(req, ctx) {
+  const limits = promptImportLimits(ctx);
+  const source = normalizeFolderInput(req.body || {});
+  const paths = Array.isArray(req.body?.paths) ? req.body.paths : [];
+  const selected = await fetchSelectedGitHubFolderFiles(source, paths, limits);
+  const candidates = [];
+  const warnings = [...selected.warnings];
+
+  for (const file of selected.files) {
+    const text = file.text.length > limits.maxSourceCharsScanned
+      ? file.text.slice(0, limits.maxSourceCharsScanned)
+      : file.text;
+    const parsed = parsePromptCandidates({
+      text,
+      filename: file.path,
+      source: {
+        kind: "github",
+        owner: source.owner,
+        repo: source.repo,
+        ref: source.ref,
+        path: file.path,
+        htmlUrl: file.htmlUrl,
+      },
+      tags: [...source.tags, `file:${file.name}`, `ext:${file.extension}`],
+      limits,
+    });
+    if (parsed.length === 0) warnings.push(`${file.path}: no prompt candidates`);
+    candidates.push(...parsed);
+  }
+
+  if (candidates.length === 0) {
+    throw promptImportError("PROMPT_IMPORT_EMPTY", "No prompt candidates were found", 422);
+  }
+  return {
+    source,
+    files: selected.files.map(({ text, contentHash, ...file }) => file),
+    candidates: candidates.slice(0, limits.maxPromptCandidatesPerImport),
+    warnings,
+  };
+}
+
+function assertCommitCandidateText(text, limits) {
+  if (text.length < limits.minCandidateChars) {
+    throw promptImportError("PROMPT_IMPORT_EMPTY", "Prompt candidate is too short", 422);
+  }
+  if (text.length > limits.maxCandidateChars) {
+    throw promptImportError("PROMPT_IMPORT_TOO_MANY_CANDIDATES", "Prompt candidate is too large", 413);
+  }
+}
+
+function commitCandidates(candidates, folderId, limits) {
+  const db = getDb();
+  const result = { foldersCreated: 0, promptsImported: 0, duplicatesSkipped: 0 };
+  const now = Math.floor(Date.now() / 1000);
+  const targetFolder = typeof folderId === "string" && folderId ? folderId : "__root__";
+  const folderExists = db.prepare("SELECT 1 FROM prompt_folders WHERE id = ? LIMIT 1").get(targetFolder);
+  const resolvedFolderId = folderExists ? targetFolder : "__root__";
+
+  for (const candidate of candidates) {
+    if (!candidate?.text || typeof candidate.text !== "string") continue;
+    const text = candidate.text.trim();
+    if (!text) continue;
+    assertCommitCandidateText(text, limits);
+    const dup = db.prepare("SELECT 1 FROM prompts WHERE text = ? AND folder_id = ? LIMIT 1").get(text, resolvedFolderId);
+    if (dup) {
+      result.duplicatesSkipped++;
+      continue;
+    }
+    const tagsJson = Array.isArray(candidate.tags) ? JSON.stringify([...new Set(candidate.tags)]) : null;
+    db.prepare(
+      `INSERT INTO prompts (id, folder_id, name, text, tags, mode, is_favorite, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      generateId(),
+      resolvedFolderId,
+      typeof candidate.name === "string" && candidate.name.trim() ? candidate.name.trim() : text.slice(0, 30),
+      text,
+      tagsJson,
+      candidate.mode === "direct" || candidate.mode === "auto" ? candidate.mode : null,
+      0,
+      now,
+      now,
+    );
+    result.promptsImported++;
+  }
+  return result;
+}
+
+export function registerPromptImportRoutes(app, ctx) {
+  app.get("/api/prompts/import/curated-sources", async (req, res) => {
+    try {
+      res.json(await getPromptImportSources(ctx));
+    } catch (error) {
+      logError("promptImport", "curated_sources_error", error);
+      sendPromptImportError(res, error);
+    }
+  });
+
+  app.get("/api/prompts/import/discovery", async (req, res) => {
+    try {
+      const candidates = await listDiscoveryCandidates(ctx, {
+        status: typeof req.query?.status === "string" ? req.query.status : undefined,
+      });
+      res.json({ candidates, warnings: [] });
+    } catch (error) {
+      logError("promptImport", "discovery_list_error", error);
+      sendPromptImportError(res, error);
+    }
+  });
+
+  app.post("/api/prompts/import/discovery-search", async (req, res) => {
+    try {
+      const limits = promptImportLimits(ctx);
+      const seeds = Array.isArray(req.body?.seeds) ? req.body.seeds : [];
+      if (seeds.length > limits.discoveryMaxQueries) {
+        throw promptImportError("GITHUB_DISCOVERY_TOO_MANY_QUERIES", "Too many discovery queries", 413);
+      }
+      const result = await searchGitHubDiscovery(ctx, {
+        q: req.body?.q,
+        seeds,
+        limit: req.body?.limit,
+        maxQueries: limits.discoveryMaxQueries,
+      });
+      res.json(result);
+    } catch (error) {
+      logError("promptImport", "discovery_search_error", error);
+      sendPromptImportError(res, error);
+    }
+  });
+
+  app.post("/api/prompts/import/discovery-review", async (req, res) => {
+    try {
+      const result = await reviewDiscoveryCandidate(ctx, {
+        repo: req.body?.repo,
+        status: req.body?.status,
+        reviewNotes: req.body?.reviewNotes,
+        allowedPaths: req.body?.allowedPaths,
+        defaultSearch: req.body?.defaultSearch,
+      });
+      res.json(result);
+    } catch (error) {
+      logError("promptImport", "discovery_review_error", error);
+      sendPromptImportError(res, error);
+    }
+  });
+
+  app.post("/api/prompts/import/curated-search", async (req, res) => {
+    try {
+      const result = await searchCuratedPrompts(ctx, {
+        q: req.body?.q,
+        sourceIds: req.body?.sourceIds,
+        limit: req.body?.limit,
+      });
+      res.json(result);
+    } catch (error) {
+      logError("promptImport", "curated_search_error", error);
+      sendPromptImportError(res, error);
+    }
+  });
+
+  app.post("/api/prompts/import/curated-refresh", async (req, res) => {
+    try {
+      const sourceId = typeof req.body?.sourceId === "string" ? req.body.sourceId : "";
+      if (!sourceId) {
+        throw promptImportError("INVALID_GITHUB_SOURCE", "Curated source is required", 400);
+      }
+      const result = await refreshCuratedSource(ctx, sourceId);
+      res.json(result);
+    } catch (error) {
+      logError("promptImport", "curated_refresh_error", error);
+      sendPromptImportError(res, error);
+    }
+  });
+
+  app.post("/api/prompts/import/folder-files", async (req, res) => {
+    try {
+      const result = await buildFolderFiles(req, ctx);
+      res.json(result);
+    } catch (error) {
+      logError("promptImport", "folder_files_error", error);
+      sendPromptImportError(res, error);
+    }
+  });
+
+  app.post("/api/prompts/import/folder-preview", async (req, res) => {
+    try {
+      const result = await buildFolderPreview(req, ctx);
+      res.json(result);
+    } catch (error) {
+      logError("promptImport", "folder_preview_error", error);
+      sendPromptImportError(res, error);
+    }
+  });
+
+  app.post("/api/prompts/import/preview", async (req, res) => {
+    try {
+      const preview = await buildPreview(req, ctx);
+      res.json(preview);
+    } catch (error) {
+      logError("promptImport", "preview_error", error);
+      sendPromptImportError(res, error);
+    }
+  });
+
+  app.post("/api/prompts/import/commit", async (req, res) => {
+    try {
+      const limits = promptImportLimits(ctx);
+      const candidates = Array.isArray(req.body?.candidates) ? req.body.candidates : [];
+      if (candidates.length === 0) {
+        throw promptImportError("PROMPT_IMPORT_EMPTY", "Select at least one prompt to import", 422);
+      }
+      if (candidates.length > limits.maxPromptCandidatesPerImport) {
+        throw promptImportError("PROMPT_IMPORT_TOO_MANY_CANDIDATES", "Too many prompt candidates", 413);
+      }
+      const result = commitCandidates(candidates, req.body?.folderId, limits);
+      logEvent("promptImport", "committed", result);
+      res.json(result);
+    } catch (error) {
+      logError("promptImport", "commit_error", error);
+      sendPromptImportError(res, error);
+    }
+  });
+}