@shawnstack/quickforge 1.3.25 → 1.3.26

package/server/plugins/manifest.mjs

@@ -0,0 +1,174 @@
+import path from 'node:path'
+
+export const PLUGIN_API_VERSION = 1
+
+const pluginNamePattern = /^[a-z0-9][a-z0-9_-]{0,63}$/
+const toolNamePattern = /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/
+
+function isPlainObject(value) {
+  return Boolean(value && typeof value === 'object' && !Array.isArray(value))
+}
+
+function asString(value, fallback = '') {
+  return typeof value === 'string' ? value.trim() : fallback
+}
+
+function normalizeStringArray(value) {
+  if (!Array.isArray(value)) return []
+  const result = []
+  const seen = new Set()
+  for (const item of value) {
+    const text = asString(item)
+    if (!text || seen.has(text)) continue
+    seen.add(text)
+    result.push(text)
+  }
+  return result
+}
+
+function addPermission(result, seen, value) {
+  const text = asString(value)
+  if (!text || seen.has(text)) return
+  seen.add(text)
+  result.push(text)
+}
+
+function normalizePermissions(value) {
+  if (Array.isArray(value)) return normalizeStringArray(value)
+  if (!isPlainObject(value)) return []
+
+  const result = []
+  const seen = new Set()
+  for (const [key, item] of Object.entries(value)) {
+    if (!key) continue
+    if (Array.isArray(item)) {
+      for (const permission of item) addPermission(result, seen, `${key}:${permission}`)
+    } else if (isPlainObject(item)) {
+      addPermission(result, seen, `${key}:${JSON.stringify(item)}`)
+    } else {
+      addPermission(result, seen, `${key}:${item}`)
+    }
+  }
+  return result
+}
+
+function normalizeSchema(value) {
+  return isPlainObject(value) ? value : { type: 'object', properties: {} }
+}
+
+function isPathInside(root, target) {
+  const relative = path.relative(root, target)
+  return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative))
+}
+
+function normalizeRelativePath(value, fieldName, pluginName, pluginDir) {
+  const rawPath = asString(value).replace(/\\/g, '/')
+  if (!rawPath) throw new Error(`Plugin ${pluginName} ${fieldName} contribution path is required.`)
+  if (rawPath.includes('\0')) throw new Error(`Plugin ${pluginName} ${fieldName} contribution path contains invalid characters.`)
+  if (path.isAbsolute(rawPath)) throw new Error(`Plugin ${pluginName} ${fieldName} contribution path must be relative: ${rawPath}`)
+
+  const resolvedPath = path.resolve(pluginDir, rawPath)
+  if (!isPathInside(pluginDir, resolvedPath)) {
+    throw new Error(`Plugin ${pluginName} ${fieldName} contribution path is outside the plugin directory: ${rawPath}`)
+  }
+
+  return {
+    path: rawPath.replace(/^\.\//, ''),
+    resolvedPath,
+  }
+}
+
+function normalizePathContributions(value, fieldName, pluginName, pluginDir) {
+  const entries = typeof value === 'string' ? [value] : Array.isArray(value) ? value : isPlainObject(value) ? [value] : []
+  const result = []
+  const seen = new Set()
+
+  for (const entry of entries) {
+    const rawPath = typeof entry === 'string'
+      ? entry
+      : isPlainObject(entry)
+        ? entry.path || entry.dir || entry.file
+        : ''
+    const normalized = normalizeRelativePath(rawPath, fieldName, pluginName, pluginDir)
+    const key = normalized.path.toLowerCase()
+    if (seen.has(key)) continue
+    seen.add(key)
+    result.push(normalized)
+  }
+
+  return result
+}
+
+function normalizeTool(tool, pluginName) {
+  if (!isPlainObject(tool)) throw new Error(`Plugin ${pluginName} tool entry must be an object.`)
+  const name = asString(tool.name)
+  if (!toolNamePattern.test(name)) {
+    throw new Error(`Plugin ${pluginName} has invalid tool name: ${name || '(empty)'}. Use letters, numbers, underscore, or hyphen.`)
+  }
+  return {
+    name,
+    label: asString(tool.label || tool.title, name),
+    description: asString(tool.description, name),
+    parameters: normalizeSchema(tool.parameters || tool.inputSchema),
+    executionMode: asString(tool.executionMode) || undefined,
+  }
+}
+
+export function quickForgePluginToolName(pluginName, toolName) {
+  return `plugin__${pluginName}__${toolName.replace(/[^A-Za-z0-9_-]/g, '_')}`
+}
+
+export function parseQuickForgePluginToolName(value) {
+  const name = String(value || '')
+  if (!name.startsWith('plugin__')) return null
+  const rest = name.slice('plugin__'.length)
+  const index = rest.indexOf('__')
+  if (index <= 0 || index >= rest.length - 2) return null
+  return {
+    pluginName: rest.slice(0, index),
+    toolName: rest.slice(index + 2),
+  }
+}
+
+export function isPluginToolName(name) {
+  return Boolean(parseQuickForgePluginToolName(name))
+}
+
+export function normalizePluginManifest(raw, pluginDir) {
+  if (!isPlainObject(raw)) throw new Error('plugin.json must contain an object.')
+
+  const name = asString(raw.name)
+  if (!pluginNamePattern.test(name)) {
+    throw new Error(`Invalid plugin name: ${name || '(empty)'}. Use lowercase letters, numbers, underscore, or hyphen.`)
+  }
+
+  const apiVersion = Number(raw.apiVersion || PLUGIN_API_VERSION)
+  if (apiVersion !== PLUGIN_API_VERSION) {
+    throw new Error(`Unsupported plugin apiVersion ${apiVersion}. Current QuickForge plugin API is ${PLUGIN_API_VERSION}.`)
+  }
+
+  const contributes = isPlainObject(raw.contributes) ? raw.contributes : {}
+  const tools = Array.isArray(contributes.tools)
+    ? contributes.tools.map((tool) => normalizeTool(tool, name))
+    : []
+
+  return {
+    name,
+    displayName: asString(raw.displayName || raw.title, name),
+    version: asString(raw.version, '0.0.0'),
+    description: asString(raw.description),
+    apiVersion,
+    quickforgeVersion: asString(raw.quickforgeVersion),
+    enabledByDefault: raw.enabledByDefault === true,
+    main: asString(raw.main, 'index.mjs'),
+    permissions: normalizePermissions(raw.permissions),
+    contributes: {
+      tools,
+      skills: normalizePathContributions(contributes.skills, 'skills', name, pluginDir),
+      commands: normalizePathContributions(contributes.commands, 'commands', name, pluginDir),
+      settings: isPlainObject(contributes.settings) ? contributes.settings : null,
+    },
+    dir: pluginDir,
+    manifestPath: path.join(pluginDir, 'plugin.json'),
+  }
+}

package/server/plugins/registry.mjs

@@ -0,0 +1,304 @@
+import { promises as fs } from 'node:fs'
+import path from 'node:path'
+import os from 'node:os'
+import { fileURLToPath } from 'node:url'
+import { dataDir, readStore, atomicUpdate } from '../storage.mjs'
+import { logger } from '../utils/logger.mjs'
+import { loadPlugin } from './loader.mjs'
+import {
+  isPluginToolName,
+  normalizePluginManifest,
+  parseQuickForgePluginToolName,
+  quickForgePluginToolName,
+} from './manifest.mjs'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const bundledPluginDir = path.resolve(__dirname, '..', '..', 'plugins')
+const globalPluginDir = path.join(dataDir, 'plugins')
+const legacyGlobalPluginDir = path.join(os.homedir(), '.agents', 'plugins')
+let cachedCatalog = null
+let cachedCatalogKey = null
+let refreshPromise = null
+
+function catalogKey(projectContext = null) {
+  return projectContext?.workspaceRoot ? path.resolve(projectContext.workspaceRoot) : ''
+}
+
+function isPlainObject(value) {
+  return Boolean(value && typeof value === 'object' && !Array.isArray(value))
+}
+
+async function exists(filePath) {
+  try {
+    await fs.access(filePath)
+    return true
+  } catch {
+    return false
+  }
+}
+
+async function readJsonFile(filePath) {
+  const text = await fs.readFile(filePath, 'utf8')
+  return JSON.parse(text.trimStart())
+}
+
+async function listPluginDirs(root) {
+  let entries = []
+  try {
+    entries = await fs.readdir(root, { withFileTypes: true })
+  } catch (error) {
+    if (error?.code === 'ENOENT') return []
+    throw error
+  }
+  return entries.filter((entry) => entry.isDirectory()).map((entry) => path.join(root, entry.name))
+}
+
+function normalizePluginStore(store) {
+  const source = isPlainObject(store) ? store : {}
+  return {
+    enabled: isPlainObject(source.enabled) ? source.enabled : {},
+    config: isPlainObject(source.config) ? source.config : {},
+  }
+}
+
+async function readPluginStore() {
+  return normalizePluginStore(await readStore('plugins'))
+}
+
+function contributionSummary(contribution) {
+  return {
+    path: contribution.path,
+    resolvedPath: contribution.resolvedPath,
+  }
+}
+
+async function discoverManifests(projectContext) {
+  const roots = [bundledPluginDir, globalPluginDir, legacyGlobalPluginDir]
+  if (projectContext?.workspaceRoot) roots.push(path.join(projectContext.workspaceRoot, '.quickforge', 'plugins'))
+
+  const manifests = new Map()
+  const errors = []
+  for (const root of roots) {
+    const dirs = await listPluginDirs(root)
+    for (const dir of dirs) {
+      const manifestPath = path.join(dir, 'plugin.json')
+      if (!(await exists(manifestPath))) continue
+      try {
+        const manifest = normalizePluginManifest(await readJsonFile(manifestPath), dir)
+        if (!manifests.has(manifest.name) || root !== legacyGlobalPluginDir) {
+          manifests.set(manifest.name, { manifest, sourceRoot: root })
+        }
+      } catch (error) {
+        errors.push({ dir, sourceRoot: root, error: error?.message || 'Failed to read plugin manifest' })
+      }
+    }
+  }
+  return { manifests, errors, roots }
+}
+
+async function loadEnabledPlugins(projectContext) {
+  const store = await readPluginStore()
+  const { manifests, errors, roots } = await discoverManifests(projectContext)
+  const plugins = []
+  const handlers = new Map()
+
+  for (const { manifest, sourceRoot } of manifests.values()) {
+    const enabled = store.enabled[manifest.name] === true || (manifest.enabledByDefault && store.enabled[manifest.name] !== false)
+    const config = isPlainObject(store.config[manifest.name]) ? store.config[manifest.name] : {}
+    const entry = {
+      ...manifest,
+      enabled,
+      config,
+      sourceRoot,
+      status: enabled ? 'loaded' : 'disabled',
+      error: null,
+      tools: manifest.contributes.tools.map((tool) => ({
+        ...tool,
+        quickForgeName: quickForgePluginToolName(manifest.name, tool.name),
+      })),
+      skills: manifest.contributes.skills.map(contributionSummary),
+      commands: manifest.contributes.commands.map(contributionSummary),
+    }
+
+    if (enabled && entry.tools.length > 0) {
+      try {
+        const loaded = await loadPlugin(manifest, { config, projectContext })
+        handlers.set(manifest.name, loaded)
+      } catch (error) {
+        logger.error(`Failed to load plugin ${manifest.name}:`, error)
+        entry.status = 'error'
+        entry.error = error?.message || 'Failed to load plugin'
+      }
+    }
+
+    plugins.push(entry)
+  }
+
+  plugins.sort((a, b) => a.name.localeCompare(b.name))
+  return { plugins, handlers, errors, roots }
+}
+
+export async function refreshPlugins(projectContext = null) {
+  const key = catalogKey(projectContext)
+  if (!refreshPromise) {
+    refreshPromise = loadEnabledPlugins(projectContext).then((catalog) => {
+      cachedCatalog = catalog
+      cachedCatalogKey = key
+      return catalog
+    }).finally(() => {
+      refreshPromise = null
+    })
+  }
+  return refreshPromise
+}
+
+async function getCatalog(projectContext = null) {
+  const key = catalogKey(projectContext)
+  if (!cachedCatalog || cachedCatalogKey !== key) return refreshPlugins(projectContext)
+  return cachedCatalog
+}
+
+function enabledLoadedPlugins(catalog) {
+  return catalog.plugins.filter((plugin) => plugin.enabled && plugin.status === 'loaded')
+}
+
+export async function getEnabledPluginSkillSources(projectContext = null) {
+  const catalog = await getCatalog(projectContext)
+  return enabledLoadedPlugins(catalog).flatMap((plugin) => plugin.skills.map((skill) => ({
+    pluginName: plugin.name,
+    source: `plugin:${plugin.name}`,
+    dir: skill.resolvedPath,
+    path: skill.path,
+  })))
+}
+
+export async function getEnabledPluginCommandSources(projectContext = null) {
+  const catalog = await getCatalog(projectContext)
+  return enabledLoadedPlugins(catalog).flatMap((plugin) => plugin.commands.map((command) => ({
+    pluginName: plugin.name,
+    source: `plugin:${plugin.name}`,
+    path: command.resolvedPath,
+    relativePath: command.path,
+  })))
+}
+
+export async function getPluginStatus(projectContext = null) {
+  const catalog = await refreshPlugins(projectContext)
+  return {
+    searchPaths: catalog.roots,
+    errors: catalog.errors,
+    plugins: catalog.plugins.map((plugin) => ({
+      name: plugin.name,
+      displayName: plugin.displayName,
+      version: plugin.version,
+      description: plugin.description,
+      apiVersion: plugin.apiVersion,
+      quickforgeVersion: plugin.quickforgeVersion,
+      enabledByDefault: plugin.enabledByDefault,
+      dir: plugin.dir,
+      sourceRoot: plugin.sourceRoot,
+      enabled: plugin.enabled,
+      status: plugin.status,
+      error: plugin.error,
+      permissions: plugin.permissions,
+      tools: plugin.tools.map((tool) => ({
+        name: tool.name,
+        quickForgeName: tool.quickForgeName,
+        label: tool.label,
+        description: tool.description,
+      })),
+      skills: plugin.skills.map((skill) => ({ path: skill.path })),
+      commands: plugin.commands.map((command) => ({ path: command.path })),
+      settings: plugin.contributes.settings,
+      config: plugin.config,
+    })),
+  }
+}
+
+export async function setPluginEnabled(name, enabled) {
+  await atomicUpdate('plugins', (store) => {
+    const next = normalizePluginStore(store)
+    next.enabled[name] = enabled === true
+    return next
+  })
+  cachedCatalog = null
+  cachedCatalogKey = null
+}
+
+export async function setPluginConfig(name, config) {
+  await atomicUpdate('plugins', (store) => {
+    const next = normalizePluginStore(store)
+    next.config[name] = isPlainObject(config) ? config : {}
+    return next
+  })
+  cachedCatalog = null
+  cachedCatalogKey = null
+}
+
+export async function createPluginToolDefinitions(projectContext = null) {
+  const catalog = await getCatalog(projectContext)
+  const definitions = []
+  for (const plugin of catalog.plugins) {
+    if (!plugin.enabled || plugin.status !== 'loaded') continue
+    for (const tool of plugin.tools) {
+      definitions.push({
+        name: tool.quickForgeName,
+        label: tool.label,
+        description: `[Plugin:${plugin.name}] ${tool.description || tool.name}`,
+        parameters: tool.parameters,
+        executionMode: tool.executionMode,
+        plugin: { name: plugin.name, toolName: tool.name },
+      })
+    }
+  }
+  return definitions
+}
+
+export { isPluginToolName }
+
+export async function callPluginTool(toolName, params = {}, toolContext = {}) {
+  const parsed = parseQuickForgePluginToolName(toolName)
+  if (!parsed) {
+    const error = new Error(`Invalid plugin tool name: ${toolName}`)
+    error.statusCode = 400
+    throw error
+  }
+
+  const catalog = await getCatalog(toolContext)
+  const plugin = catalog.plugins.find((item) => item.name === parsed.pluginName)
+  if (!plugin || !plugin.enabled || plugin.status !== 'loaded') {
+    const error = new Error(`Plugin is not loaded: ${parsed.pluginName}`)
+    error.statusCode = 503
+    throw error
+  }
+
+  const tool = plugin.tools.find((item) => item.name === parsed.toolName || item.quickForgeName === toolName)
+  if (!tool) {
+    const error = new Error(`Unknown plugin tool: ${toolName}`)
+    error.statusCode = 404
+    throw error
+  }
+
+  const handler = catalog.handlers.get(parsed.pluginName)
+  if (!handler) {
+    const error = new Error(`Missing plugin handler: ${parsed.pluginName}`)
+    error.statusCode = 503
+    throw error
+  }
+
+  const result = await handler.callTool(tool.name, params, {
+    ...toolContext,
+    plugin: { name: plugin.name, dir: plugin.dir, config: plugin.config },
+  })
+
+  return {
+    isError: Boolean(result.isError),
+    content: result.content,
+    details: {
+      ...(isPlainObject(result.details) ? result.details : {}),
+      plugin: true,
+      pluginName: plugin.name,
+      tool: tool.name,
+    },
+  }
+}

package/server/project-config.mjs

@@ -298,24 +298,71 @@ export async function readInstructionsFile(filePath) {
   return null
 }
 
+async function readInstructionSources(candidates) {
+  const sources = []
+  const seen = new Set()
+
+  for (const candidate of candidates) {
+    const file = path.resolve(candidate.file)
+    if (seen.has(file)) continue
+    seen.add(file)
+
+    try {
+      const content = await fs.readFile(file, 'utf8')
+      const trimmed = content.trim()
+      if (trimmed) sources.push({ source: candidate.source, content: trimmed })
+    } catch {
+      // optional compatibility source
+    }
+  }
+
+  return sources
+}
+
+function combineInstructionSources(sources) {
+  return sources.map((source) => source.content).join('\n\n') || null
+}
+
+function globalInstructionCandidates() {
+  const home = os.homedir()
+  return [
+    { file: path.join(home, '.claude', 'CLAUDE.md'), source: '~/.claude/CLAUDE.md' },
+    { file: path.join(home, '.opencode', 'AGENTS.md'), source: '~/.opencode/AGENTS.md' },
+    { file: path.join(dataDir, 'AGENTS.md'), source: '~/.quickforge/AGENTS.md' },
+    { file: path.join(dataDir, 'agents.md'), source: '~/.quickforge/agents.md' },
+  ]
+}
+
+function projectInstructionCandidates(workspaceRoot) {
+  return [
+    { file: path.join(workspaceRoot, 'CLAUDE.md'), source: 'CLAUDE.md' },
+    { file: path.join(workspaceRoot, 'AGENTS.md'), source: 'AGENTS.md' },
+    { file: path.join(workspaceRoot, 'agents.md'), source: 'agents.md' },
+    { file: path.join(workspaceRoot, '.opencode', 'AGENTS.md'), source: '.opencode/AGENTS.md' },
+    { file: path.join(workspaceRoot, '.quickforge', 'AGENTS.md'), source: '.quickforge/AGENTS.md' },
+  ]
+}
+
 export async function buildInstructionsPayload(projectId) {
   const config = await readProjectConfig()
-  let projectInstructions = null
+  let projectInstructionSources = []
   let project = projectId ? config.projects.find((item) => item.id === projectId) ?? null : null
 
   if (projectId) {
     try {
       const context = await projectContextFromId(projectId)
       project = context.project
-      projectInstructions = await readInstructionsFile(path.join(context.workspaceRoot, 'AGENTS.md'))
+      projectInstructionSources = await readInstructionSources(projectInstructionCandidates(context.workspaceRoot))
     } catch {
       // project not found or inaccessible — leave projectInstructions null
     }
   }
 
-  const globalInstructions = await readInstructionsFile(path.join(dataDir, 'AGENTS.md'))
+  const globalInstructionSources = await readInstructionSources(globalInstructionCandidates())
+  const globalInstructions = combineInstructionSources(globalInstructionSources)
+  const projectInstructions = combineInstructionSources(projectInstructionSources)
   const globalSkills = await loadSelectedGlobalSkills(config.globalSkills)
-  const projectSkills = project?.skills && project?.path
+  const projectSkills = project?.path
     ? await loadSelectedProjectSkills(project.skills, project.path)
     : []
   const activeSkills = mergeSkills(globalSkills, projectSkills)
@@ -331,6 +378,8 @@ export async function buildInstructionsPayload(projectId) {
       : null,
     global: globalInstructions,
     project: projectInstructions,
+    globalSources: globalInstructionSources,
+    projectSources: projectInstructionSources,
     globalSkills: globalSkills.map(stripRuntimeFields),
     projectSkills: projectSkills.map(stripRuntimeFields),
     skills: activeSkills.map(stripRuntimeFields),

package/server/routes/agent.mjs

@@ -23,7 +23,6 @@ import {
   approveAutoCompact,
   rejectAutoCompact,
   abortToolCall,
-  replaceSessionMessages,
   rollbackSessionMessages,
   continueSession,
   agentEvents,
@@ -83,7 +82,7 @@ export async function handleAgentApi(req, res, url) {
       error.statusCode = 400
       throw error
     }
-    const result = await runPrompt(sessionId, message)
+    const result = await runPrompt(sessionId, message, body?.selectedCapabilities)
     sendJson(res, 200, result)
     return
   }
@@ -169,20 +168,6 @@ export async function handleAgentApi(req, res, url) {
     return
   }
 
-  // POST /api/agents/:sessionId/messages — replace session messages (legacy rollback/sync)
-  if (req.method === 'POST' && subPath === 'messages') {
-    const body = await readJsonBody(req)
-    const messages = body?.messages
-    if (!Array.isArray(messages)) {
-      const error = new Error('Missing messages array in request body')
-      error.statusCode = 400
-      throw error
-    }
-    const state = await replaceSessionMessages(sessionId, messages)
-    sendJson(res, 200, { ok: true, messages: state?.messages })
-    return
-  }
-
   // POST /api/agents/:sessionId/rollback — roll back from a message index on the authoritative server state
   if (req.method === 'POST' && subPath === 'rollback') {
     const body = await readJsonBody(req)

package/server/routes/plugins.mjs

@@ -0,0 +1,63 @@
+import { sendJson, readJsonBody, decodeSegment } from '../utils/response.mjs'
+import { refreshAllSessionTools } from '../agent-manager.mjs'
+import { projectContextFromId, readProjectConfig } from '../project-config.mjs'
+import { getPluginStatus, refreshPlugins, setPluginConfig, setPluginEnabled } from '../plugins/registry.mjs'
+
+async function activeProjectContext() {
+  const config = await readProjectConfig()
+  const activeProject = config.projects.find((project) => project.id === config.activeProjectId) || config.projects[0]
+  if (!activeProject?.id) return null
+  return projectContextFromId(activeProject.id)
+}
+
+async function refreshPluginsAndAgentTools() {
+  const projectContext = await activeProjectContext()
+  await refreshPlugins(projectContext)
+  const refreshedSessions = await refreshAllSessionTools()
+  return { ...(await getPluginStatus(projectContext)), refreshedSessions }
+}
+
+export async function handlePluginsApi(req, res, url) {
+  const parts = url.pathname.split('/').filter(Boolean)
+
+  if (req.method === 'GET' && url.pathname === '/api/plugins') {
+    sendJson(res, 200, await getPluginStatus(await activeProjectContext()))
+    return
+  }
+
+  if (req.method === 'POST' && url.pathname === '/api/plugins/reload') {
+    sendJson(res, 200, await refreshPluginsAndAgentTools())
+    return
+  }
+
+  if (req.method === 'GET' && parts[0] === 'api' && parts[1] === 'plugins' && parts[2]) {
+    const name = decodeSegment(parts[2])
+    const status = await getPluginStatus(await activeProjectContext())
+    const plugin = status.plugins.find((item) => item.name === name)
+    if (!plugin) {
+      const error = new Error(`Unknown plugin: ${name}`)
+      error.statusCode = 404
+      throw error
+    }
+    sendJson(res, 200, { ...status, plugin })
+    return
+  }
+
+  if (req.method === 'PUT' && parts[0] === 'api' && parts[1] === 'plugins' && parts[2] && parts[3] === 'enabled') {
+    const body = await readJsonBody(req)
+    await setPluginEnabled(decodeSegment(parts[2]), body?.enabled === true)
+    sendJson(res, 200, await refreshPluginsAndAgentTools())
+    return
+  }
+
+  if (req.method === 'PUT' && parts[0] === 'api' && parts[1] === 'plugins' && parts[2] && parts[3] === 'config') {
+    const body = await readJsonBody(req)
+    await setPluginConfig(decodeSegment(parts[2]), body?.config || body || {})
+    sendJson(res, 200, await refreshPluginsAndAgentTools())
+    return
+  }
+
+  const error = new Error('Not found')
+  error.statusCode = 404
+  throw error
+}

package/server/routes/project.mjs

@@ -29,6 +29,8 @@ export async function handleProjectApi(req, res, url) {
         allowEdit: command.allowEdit,
         allowCommands: command.allowCommands,
         relativePath: command.relativePath,
+        source: command.source,
+        pluginName: command.pluginName,
       })),
     })
     return