@shawnstack/quickforge 1.6.11 → 1.6.13

package/server/image-generation.mjs

@@ -0,0 +1,130 @@
+import { builtinImagesModels } from '@earendil-works/pi-ai/providers/all'
+import { resolveOpenRouterConfig } from './provider-config.mjs'
+import { deleteSessionAsset, writeSessionAsset } from './session-assets.mjs'
+
+export const DEFAULT_IMAGE_MODEL = 'google/gemini-2.5-flash-image'
+export const MAX_GENERATED_IMAGES = 4
+export const MAX_GENERATED_IMAGE_BYTES = 50 * 1024 * 1024
+
+function requestError(message, statusCode = 400) {
+  const error = new Error(message)
+  error.statusCode = statusCode
+  return error
+}
+
+function normalizeBucket(value) {
+  if (value?.scope === 'project') return { scope: 'project', projectId: value.projectId }
+  return { scope: 'global' }
+}
+
+function resolveImagesModels(runtime) {
+  const candidate = runtime.imagesModels
+  if (candidate && typeof candidate.getModel === 'function') return candidate
+  if (typeof candidate === 'function') return candidate()
+  return builtinImagesModels()
+}
+
+function imageByteLength(data) {
+  const normalized = typeof data === 'string' ? data.replace(/\s+/g, '') : ''
+  if (!normalized || normalized.length % 4 !== 0 || !/^[A-Za-z0-9+/]*={0,2}$/.test(normalized)) {
+    throw requestError('Image provider returned invalid base64 data')
+  }
+  const buffer = Buffer.from(normalized, 'base64')
+  if (buffer.toString('base64') !== normalized) {
+    throw requestError('Image provider returned invalid base64 data')
+  }
+  return buffer.byteLength
+}
+
+function resultText(output) {
+  return output
+    .filter((item) => item?.type === 'text' && typeof item.text === 'string' && item.text.trim())
+    .map((item) => item.text.trim())
+    .join('\n\n')
+}
+
+function contentSummary(count, text) {
+  const generated = `Generated ${count} image${count === 1 ? '' : 's'}.`
+  return text ? `${generated}\n\n${text}` : generated
+}
+
+export async function generateSessionImages(params, context = {}, runtime = {}) {
+  const prompt = typeof params?.prompt === 'string' ? params.prompt.trim() : ''
+  if (!prompt) throw requestError('prompt is required')
+
+  const sessionId = typeof context.sessionId === 'string' ? context.sessionId : params?.sessionId
+  if (!sessionId) throw requestError('sessionId is required')
+  const bucket = normalizeBucket(context.bucket || context.sessionBucket || params?.bucket || {
+    scope: context.scope,
+    projectId: context.projectId,
+  })
+  const requestedModel = typeof params?.model === 'string' && params.model.trim()
+    ? params.model.trim()
+    : DEFAULT_IMAGE_MODEL
+
+  const imagesModels = resolveImagesModels(runtime)
+  const model = imagesModels.getModel('openrouter', requestedModel)
+  if (!model || model.api !== 'openrouter-images') {
+    throw requestError(`Unsupported image model: ${requestedModel}`)
+  }
+
+  const resolveConfig = runtime.resolveOpenRouterConfig || resolveOpenRouterConfig
+  const config = await resolveConfig(runtime)
+  const requestModel = config.baseUrl ? { ...model, baseUrl: config.baseUrl } : model
+  const response = await imagesModels.generateImages(
+    requestModel,
+    { input: [{ type: 'text', text: prompt }] },
+    {
+      apiKey: config.apiKey,
+      ...(config.headers ? { headers: config.headers } : {}),
+      ...(runtime.signal || context.signal ? { signal: runtime.signal || context.signal } : {}),
+    },
+  )
+
+  if (response?.stopReason !== 'stop') {
+    throw new Error(response?.errorMessage || `Image generation stopped: ${response?.stopReason || 'unknown'}`)
+  }
+
+  const output = Array.isArray(response.output) ? response.output : []
+  const images = output.filter((item) => item?.type === 'image')
+  if (!images.length) throw new Error('Image generation returned no images')
+  if (images.length > MAX_GENERATED_IMAGES) {
+    throw requestError(`Image generation returned more than ${MAX_GENERATED_IMAGES} images`, 413)
+  }
+
+  let totalBytes = 0
+  for (const image of images) {
+    totalBytes += imageByteLength(image.data)
+    if (totalBytes > MAX_GENERATED_IMAGE_BYTES) {
+      throw requestError(`Generated images exceed the ${MAX_GENERATED_IMAGE_BYTES} byte limit`, 413)
+    }
+  }
+
+  const writeAsset = runtime.writeSessionAsset || writeSessionAsset
+  const deleteAsset = runtime.deleteSessionAsset || deleteSessionAsset
+  const assets = []
+  try {
+    for (const image of images) {
+      assets.push(await writeAsset(bucket, sessionId, image))
+    }
+  } catch (error) {
+    await Promise.allSettled(assets.map((asset) => deleteAsset(bucket, sessionId, asset.assetId)))
+    throw error
+  }
+
+  const text = resultText(output)
+  return {
+    content: contentSummary(assets.length, text),
+    details: {
+      type: 'generated_image_result',
+      sessionId,
+      prompt,
+      model: requestedModel,
+      assets,
+      text,
+      usage: response.usage,
+    },
+  }
+}
+
+export const generateImages = generateSessionImages

package/server/index.mjs

@@ -23,6 +23,7 @@ import { handleBackupApi } from './routes/backup.mjs'
 import { handleSystemApi } from './routes/system.mjs'
 import { handleSharesApi } from './routes/shares.mjs'
 import { handleSharedConversationApi } from './routes/shared-conversation.mjs'
+import { handleSessionAssetsApi } from './routes/session-assets.mjs'
 import { handleLanAccessApi, renderLanUnlockPage } from './routes/lan-access.mjs'
 import { handleMcpApi } from './routes/mcp.mjs'
 import { handlePluginsApi } from './routes/plugins.mjs'
@@ -288,6 +289,11 @@ async function handleApi(req, res, url) {
     return
   }
 
+  if (pathname.startsWith('/api/session-assets/')) {
+    await handleSessionAssetsApi(req, res, url)
+    return
+  }
+
   if (pathname === '/api/lan-access/status' || pathname === '/api/lan-access/settings' || pathname === '/api/lan-access/unlock' || pathname === '/api/lan-access/logout' || pathname === '/api/lan-access/revoke-all') {
     await handleLanAccessApi(req, res, url, {
       port,

package/server/provider-config.mjs

@@ -0,0 +1,78 @@
+import { readStore } from './storage.mjs'
+
+const DEFAULT_OPENROUTER_BASE_URL = 'https://openrouter.ai/api/v1'
+
+function requestError(message, statusCode = 400) {
+  const error = new Error(message)
+  error.statusCode = statusCode
+  return error
+}
+
+function providersFromStore(store) {
+  return Array.isArray(store)
+    ? store
+    : Object.entries(store || {}).map(([id, provider]) => (
+        provider && typeof provider === 'object' ? { id, ...provider } : provider
+      ))
+}
+
+function isOpenRouterProvider(provider) {
+  if (!provider || typeof provider !== 'object') return false
+  const id = String(provider.id || '').trim().toLowerCase()
+  const name = String(provider.name || '').trim().toLowerCase()
+  if (id === 'openrouter' || name === 'openrouter') return true
+
+  try {
+    return new URL(String(provider.baseUrl || '')).hostname.toLowerCase() === 'openrouter.ai'
+  } catch {
+    return false
+  }
+}
+
+function normalizeHeaders(provider) {
+  const source = provider?.headers || provider?.models?.find((model) => model?.headers)?.headers
+  if (!source || typeof source !== 'object' || Array.isArray(source)) return undefined
+  const headers = {}
+  for (const [key, value] of Object.entries(source)) {
+    if (typeof value === 'string' && key.trim()) headers[key.trim()] = value
+  }
+  return Object.keys(headers).length ? headers : undefined
+}
+
+function findProviderKey(keys, providerName) {
+  if (!keys || typeof keys !== 'object' || Array.isArray(keys)) return undefined
+  if (typeof keys[providerName] === 'string' && keys[providerName].trim()) return keys[providerName].trim()
+
+  const wanted = String(providerName || '').trim().toLowerCase()
+  for (const [key, value] of Object.entries(keys)) {
+    const normalized = key.trim().toLowerCase()
+    if ((normalized === wanted || normalized === 'openrouter') && typeof value === 'string' && value.trim()) {
+      return value.trim()
+    }
+  }
+  return undefined
+}
+
+export async function resolveOpenRouterConfig(runtime = {}) {
+  const read = runtime.readStore || readStore
+  const [providerStore, providerKeys] = await Promise.all([
+    read('custom-providers'),
+    read('provider-keys'),
+  ])
+  const provider = providersFromStore(providerStore).find(isOpenRouterProvider)
+  if (!provider) throw requestError('OpenRouter provider is not configured')
+
+  const providerName = String(provider.name || provider.id || 'openrouter').trim()
+  const apiKey = findProviderKey(providerKeys, providerName)
+  if (!apiKey) throw requestError('OpenRouter API key is not configured')
+
+  const baseUrl = typeof provider.baseUrl === 'string' && provider.baseUrl.trim()
+    ? provider.baseUrl.trim().replace(/\/$/, '')
+    : DEFAULT_OPENROUTER_BASE_URL
+
+  return {
+    apiKey,
+    baseUrl,
+    headers: normalizeHeaders(provider),
+  }
+}

package/server/routes/agent.mjs

@@ -16,6 +16,7 @@ import {
   touchSession,
   listSessions,
   updateSessionAccessMode,
+  updateSessionTitle,
   updateSessionYoloMode,
   updateSessionModel,
   updateSessionThinkingLevel,
@@ -153,6 +154,14 @@ export async function handleAgentApi(req, res, url) {
     return
   }
 
+  // POST /api/agents/:sessionId/title — update the authoritative session title
+  if (req.method === 'POST' && subPath === 'title') {
+    const body = await readJsonBody(req)
+    const result = await updateSessionTitle(sessionId, body?.title)
+    sendJson(res, 200, result)
+    return
+  }
+
   // POST /api/agents/:sessionId/access-mode — update session Agent access mode
   if (req.method === 'POST' && subPath === 'access-mode') {
     const body = await readJsonBody(req)

package/server/routes/project.mjs

@@ -99,12 +99,7 @@ export async function handleProjectApi(req, res, url) {
 
   if (req.method === 'POST' && url.pathname.startsWith('/api/project/') && url.pathname.endsWith('/open-in-explorer')) {
     const id = decodeSegment(url.pathname.split('/').filter(Boolean)[2])
-    const selected = config.projects.find((project) => project.id === id)
-    if (!selected) {
-      const error = new Error('Unknown project')
-      error.statusCode = 404
-      throw error
-    }
+    const selected = resolveRequestedProject(config, id, getDefaultWorkspaceRoot())
     await openPathInFileManager(selected.path)
     sendJson(res, 200, { ok: true })
     return
@@ -112,12 +107,7 @@ export async function handleProjectApi(req, res, url) {
 
   if (req.method === 'POST' && url.pathname.startsWith('/api/project/') && url.pathname.endsWith('/open-in-vscode')) {
     const id = decodeSegment(url.pathname.split('/').filter(Boolean)[2])
-    const selected = config.projects.find((project) => project.id === id)
-    if (!selected) {
-      const error = new Error('Unknown project')
-      error.statusCode = 404
-      throw error
-    }
+    const selected = resolveRequestedProject(config, id, getDefaultWorkspaceRoot())
     await openPathInVSCode(selected.path)
     sendJson(res, 200, { ok: true })
     return
@@ -125,12 +115,7 @@ export async function handleProjectApi(req, res, url) {
 
   if (req.method === 'POST' && url.pathname.startsWith('/api/project/') && url.pathname.endsWith('/open-in-idea')) {
     const id = decodeSegment(url.pathname.split('/').filter(Boolean)[2])
-    const selected = config.projects.find((project) => project.id === id)
-    if (!selected) {
-      const error = new Error('Unknown project')
-      error.statusCode = 404
-      throw error
-    }
+    const selected = resolveRequestedProject(config, id, getDefaultWorkspaceRoot())
     await openPathInIDEA(selected.path)
     sendJson(res, 200, { ok: true })
     return

package/server/routes/session-assets.mjs

@@ -0,0 +1,49 @@
+import { findSessionBucket } from '../storage.mjs'
+import { readSessionAsset } from '../session-assets.mjs'
+import { decodeSegment } from '../utils/response.mjs'
+
+function notFound(message = 'Image asset not found') {
+  const error = new Error(message)
+  error.statusCode = 404
+  return error
+}
+
+export async function sendSessionAsset(res, bucket, sessionId, assetId) {
+  let asset
+  try {
+    asset = await readSessionAsset(bucket, sessionId, assetId)
+  } catch (error) {
+    if (error?.code === 'ENOENT') throw notFound()
+    throw error
+  }
+
+  res.writeHead(200, {
+    'content-type': asset.mimeType,
+    'content-length': String(asset.size),
+    'cache-control': 'private, max-age=31536000, immutable',
+    'content-disposition': 'inline',
+    'x-content-type-options': 'nosniff',
+  })
+  res.end(asset.data)
+}
+
+export async function handleSessionAssetsApi(req, res, url) {
+  if (req.method !== 'GET') {
+    const error = new Error('Session asset endpoints require GET')
+    error.statusCode = 405
+    throw error
+  }
+
+  const parts = url.pathname.split('/').filter(Boolean)
+  const sessionId = decodeSegment(parts[2])
+  const assetId = decodeSegment(parts[3])
+  if (!sessionId || !assetId || parts.length !== 4) {
+    const error = new Error('Missing session image asset path')
+    error.statusCode = 400
+    throw error
+  }
+
+  const bucket = await findSessionBucket(sessionId)
+  if (!bucket) throw notFound('Session not found')
+  await sendSessionAsset(res, bucket, sessionId, assetId)
+}

package/server/routes/shared-conversation.mjs

@@ -1,5 +1,6 @@
 import { sendJson, readJsonBody, decodeSegment } from '../utils/response.mjs'
 import { readSessionValue, readStore } from '../storage.mjs'
+import { sendSessionAsset } from './session-assets.mjs'
 import { abortRun, restoreAgent, runPrompt, getSessionState, getSessionEventBus, updateSessionModel, updateSessionThinkingLevel } from '../agent-manager.mjs'
 import {
   assertShareActive,
@@ -307,6 +308,7 @@ export async function handleSharedConversationApi(req, res, url) {
   const parts = url.pathname.split('/').filter(Boolean)
   const shareId = decodeSegment(parts[2])
   const action = parts[3]
+  const actionId = parts[4]
 
   if (!shareId) {
     const error = new Error('Missing share id')
@@ -343,6 +345,14 @@ export async function handleSharedConversationApi(req, res, url) {
     const record = await requireShareAuth(req, shareId)
     if (record.permission === 'operate' && !record.passwordHash) throw passwordRequiredError()
 
+    if (req.method === 'GET' && action === 'assets' && actionId) {
+      const bucket = record.scope === 'project'
+        ? { scope: 'project', projectId: record.projectId }
+        : { scope: 'global' }
+      await sendSessionAsset(res, bucket, record.sessionId, decodeSegment(actionId))
+      return
+    }
+
     if (req.method === 'GET' && action === 'session') {
     sendJson(res, 200, await sharedSessionPayload(record))
     return

package/server/routes/tools.mjs

@@ -8,7 +8,7 @@ import { callPluginTool, createPluginToolDefinitions, isPluginToolName } from '.
 import { safeReadTools } from '../approval-store.mjs'
 import { projectContextFromId, readProjectConfig } from '../project-config.mjs'
 
-const directRouteDisabledTools = new Set(['run_subagent', 'manage_global_memory'])
+const directRouteDisabledTools = new Set(['run_subagent', 'manage_global_memory', 'generate_image'])
 
 /**
  * GET /api/tools — returns canonical tool definitions (no project context needed).

package/server/routes/workspace.mjs

@@ -304,9 +304,12 @@ async function countWorkspaceLines(context, relativePath) {
   }
 }
 
-async function listGitStatus(context) {
+export async function listGitStatus(context) {
   if (!(await isGitRepository(context.workspaceRoot))) return { isGitRepository: false, files: [] }
-  const result = await git(['status', '--porcelain=v1', '-z'], context.workspaceRoot)
+  const result = await git(
+    ['status', '--porcelain=v1', '-z', '--untracked-files=all'],
+    context.workspaceRoot,
+  )
   const files = parseGitStatus(result.stdout)
   const numstat = await collectNumstat(context)
   for (const file of files) {

package/server/session-assets.mjs

@@ -0,0 +1,134 @@
+import { promises as fs } from 'node:fs'
+import path from 'node:path'
+import { randomUUID } from 'node:crypto'
+import { storageDir } from './storage.mjs'
+
+export const MAX_SESSION_IMAGE_BYTES = 25 * 1024 * 1024
+
+const MIME_TYPES = new Map([
+  ['image/png', 'png'],
+  ['image/jpeg', 'jpg'],
+  ['image/webp', 'webp'],
+  ['image/gif', 'gif'],
+])
+
+const SAFE_SEGMENT_RE = /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/
+const ASSET_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\.(?:png|jpg|webp|gif)$/i
+
+function requestError(message, statusCode = 400) {
+  const error = new Error(message)
+  error.statusCode = statusCode
+  return error
+}
+
+function assertSafeSegment(value, label) {
+  if (typeof value !== 'string' || !SAFE_SEGMENT_RE.test(value)) {
+    throw requestError(`Invalid ${label}`)
+  }
+  return value
+}
+
+function normalizeBucket(bucket) {
+  if (!bucket || typeof bucket !== 'object' || Array.isArray(bucket)) {
+    throw requestError('Invalid session asset scope')
+  }
+  if (bucket.scope === 'global') return { scope: 'global' }
+  if (bucket.scope === 'project') {
+    return {
+      scope: 'project',
+      projectId: assertSafeSegment(bucket.projectId, 'projectId'),
+    }
+  }
+  throw requestError('Invalid session asset scope')
+}
+
+function assetsRoot(bucket) {
+  if (bucket.scope === 'project') {
+    return path.join(storageDir, 'conversations', 'projects', bucket.projectId, 'assets')
+  }
+  return path.join(storageDir, 'conversations', 'global', 'assets')
+}
+
+function sessionAssetsDir(bucket, sessionId) {
+  return path.join(assetsRoot(normalizeBucket(bucket)), assertSafeSegment(sessionId, 'sessionId'))
+}
+
+function normalizeMimeType(mimeType) {
+  const value = typeof mimeType === 'string' ? mimeType.trim().toLowerCase() : ''
+  const extension = MIME_TYPES.get(value)
+  if (!extension) throw requestError(`Unsupported image MIME type: ${mimeType || ''}`)
+  return { mimeType: value, extension }
+}
+
+function decodeBase64(value) {
+  const normalized = typeof value === 'string' ? value.replace(/\s+/g, '') : ''
+  if (!normalized || normalized.length % 4 !== 0 || !/^[A-Za-z0-9+/]*={0,2}$/.test(normalized)) {
+    throw requestError('Invalid base64 image data')
+  }
+  const buffer = Buffer.from(normalized, 'base64')
+  if (buffer.toString('base64') !== normalized) throw requestError('Invalid base64 image data')
+  return buffer
+}
+
+function normalizeImageData(data) {
+  if (Buffer.isBuffer(data)) return data
+  if (data instanceof Uint8Array) return Buffer.from(data)
+  return decodeBase64(data)
+}
+
+function mimeTypeFromAssetId(assetId) {
+  const extension = path.extname(assetId).slice(1).toLowerCase()
+  for (const [mimeType, candidate] of MIME_TYPES) {
+    if (candidate === extension) return mimeType
+  }
+  throw requestError('Invalid assetId')
+}
+
+function assetMetadata(assetId, mimeType, size) {
+  return { assetId, mimeType, size }
+}
+
+export function validateSessionAssetId(assetId) {
+  if (typeof assetId !== 'string' || !ASSET_ID_RE.test(assetId)) {
+    throw requestError('Invalid assetId')
+  }
+  return assetId
+}
+
+export async function writeSessionAsset(bucket, sessionId, image) {
+  const dir = sessionAssetsDir(bucket, sessionId)
+  const { mimeType, extension } = normalizeMimeType(image?.mimeType)
+  const data = normalizeImageData(image?.data)
+  if (data.byteLength > MAX_SESSION_IMAGE_BYTES) {
+    throw requestError(`Image exceeds the ${MAX_SESSION_IMAGE_BYTES} byte limit`, 413)
+  }
+
+  await fs.mkdir(dir, { recursive: true })
+  const assetId = `${randomUUID()}.${extension}`
+  await fs.writeFile(path.join(dir, assetId), data, { flag: 'wx' })
+  return assetMetadata(assetId, mimeType, data.byteLength)
+}
+
+export async function readSessionAsset(bucket, sessionId, assetId) {
+  const dir = sessionAssetsDir(bucket, sessionId)
+  const safeAssetId = validateSessionAssetId(assetId)
+  const data = await fs.readFile(path.join(dir, safeAssetId))
+  if (data.byteLength > MAX_SESSION_IMAGE_BYTES) {
+    throw requestError('Stored image exceeds the allowed size', 413)
+  }
+  return {
+    ...assetMetadata(safeAssetId, mimeTypeFromAssetId(safeAssetId), data.byteLength),
+    data,
+  }
+}
+
+export async function deleteSessionAsset(bucket, sessionId, assetId) {
+  const dir = sessionAssetsDir(bucket, sessionId)
+  const safeAssetId = validateSessionAssetId(assetId)
+  await fs.rm(path.join(dir, safeAssetId), { force: true })
+}
+
+export async function deleteSessionAssets(bucket, sessionId) {
+  const dir = sessionAssetsDir(bucket, sessionId)
+  await fs.rm(dir, { recursive: true, force: true })
+}

package/server/storage.mjs

@@ -517,7 +517,12 @@ async function writeSessionValues(data) {
     existingFiles.map(async (file) => {
       const sessionId = path.basename(file, '.json')
       if (!nextIds.has(sessionId)) {
+        const bucket = sessionBucketIndex.get(sessionId) || await findSessionBucketByDataFile(sessionId)
         await fs.rm(file, { force: true })
+        if (bucket) {
+          const { deleteSessionAssets } = await import('./session-assets.mjs')
+          await deleteSessionAssets(bucket, sessionId)
+        }
         sessionBucketIndex.delete(sessionId)
       }
     }),
@@ -574,7 +579,12 @@ export async function findSessionBucket(sessionId) {
     await ensureStorage()
     await rebuildBucketIndex()
   }
-  return sessionBucketIndex.get(sessionId) ?? null
+  const indexed = sessionBucketIndex.get(sessionId)
+  if (indexed) return indexed
+
+  const recovered = await findSessionBucketByDataFile(sessionId)
+  if (recovered) sessionBucketIndex.set(sessionId, recovered)
+  return recovered
 }
 
 export async function readSessionValue(sessionId) {
@@ -599,6 +609,8 @@ export async function deleteSessionValue(sessionId) {
     const bucket = await findSessionBucket(sessionId)
     if (!bucket) return
     await fs.rm(sessionDataFile(sessionId, bucket), { force: true })
+    const { deleteSessionAssets } = await import('./session-assets.mjs')
+    await deleteSessionAssets(bucket, sessionId)
     sessionBucketIndex.delete(sessionId)
   })
 }

package/server/tools/definitions.mjs

@@ -116,6 +116,16 @@ export const workspaceTools = [
     }),
     executionMode: 'sequential',
   },
+  {
+    name: 'generate_image',
+    label: 'Generate image',
+    description: 'Generate images with the configured OpenRouter provider and save them as assets owned by the current conversation. Use this when the user explicitly asks for a generated bitmap image. The operation may incur provider charges.',
+    parameters: Type.Object({
+      prompt: Type.String({ description: 'Detailed image-generation prompt.' }),
+      model: Type.Optional(Type.String({ description: 'Optional OpenRouter image model ID. Defaults to google/gemini-2.5-flash-image.' })),
+    }),
+    executionMode: 'sequential',
+  },
   {
     name: 'present_files',
     label: 'Present files',

package/server/tools/index.mjs

@@ -15,6 +15,7 @@ import {
 } from '../skills.mjs'
 import { getToolWorkspaceRoot } from '../utils/workspace.mjs'
 import { manageGlobalMemory } from '../global-memory.mjs'
+import { generateSessionImages } from '../image-generation.mjs'
 
 const require = createRequire(import.meta.url)
 
@@ -1100,6 +1101,7 @@ export const toolHandlers = {
   write_file: toolWriteFile,
   edit_file: toolEditFile,
   run_command: toolRunCommand,
+  generate_image: generateSessionImages,
   present_files: toolPresentFiles,
   activate_skill: toolActivateSkill,
   read_skill_resource: toolReadSkillResource,

package/server/utils/platform.mjs

@@ -131,6 +131,22 @@ async function findExistingFile(candidates) {
   return undefined
 }
 
+export function createExternalAppEnv(source = process.env) {
+  const env = { ...source }
+  delete env.ELECTRON_RUN_AS_NODE
+  delete env.ELECTRON_NO_ATTACH_CONSOLE
+  delete env.ATOM_SHELL_INTERNAL_RUN_AS_NODE
+  return env
+}
+
+export function createVSCodeOpenArgs(targetPath, platform = process.platform) {
+  return platform === 'win32' ? ['--reuse-window', targetPath] : [targetPath]
+}
+
+export function shouldHideVSCodeLauncherWindow(command, platform = process.platform) {
+  return platform === 'win32' && path.win32.basename(command).toLowerCase() === 'cmd.exe'
+}
+
 async function findIntelliJIdeaExecutable() {
   const roots = [
     process.env.LOCALAPPDATA ? path.join(process.env.LOCALAPPDATA, 'Programs') : undefined,
@@ -206,10 +222,10 @@ export async function openPathInVSCode(targetPath) {
     const codeExecutable = await findExistingFile(candidates)
     if (codeExecutable) {
       command = codeExecutable
-      args = [resolved]
+      args = createVSCodeOpenArgs(resolved)
     } else {
       command = 'cmd.exe'
-      args = ['/d', '/s', '/c', 'start', '""', '/b', 'code', resolved]
+      args = ['/d', '/s', '/c', 'start', '""', '/b', 'code', '--reuse-window', resolved]
     }
   }
 
@@ -217,8 +233,9 @@ export async function openPathInVSCode(targetPath) {
     const child = spawn(command, args, {
       detached: true,
       stdio: 'ignore',
-      windowsHide: true,
+      windowsHide: shouldHideVSCodeLauncherWindow(command),
       shell: false,
+      env: createExternalAppEnv(),
     })
     child.once('error', (error) => {
       error.statusCode = 500