@simonyea/holysheep-cli 1.7.135 → 2.0.0

package/src/webui/server.js

@@ -15,9 +15,14 @@ const path = require('path')
 const { execSync, spawn } = require('child_process')
 const { loadConfig, saveConfig, getApiKey, BASE_URL_ANTHROPIC, BASE_URL_OPENAI, BASE_URL_CLAUDE_RELAY, SHOP_URL, CONFIG_FILE } = require('../utils/config')
 const { removeEnvFromShell, writeEnvToShell, getShellRcFiles } = require('../utils/shell')
-const { commandExists } = require('../utils/which')
+const { commandExistsAsync } = require('../utils/which')
 const TOOLS = require('../tools')
 const pkg = require('../../package.json')
+const workspaceStore = require('./workspace-store')
+const workspaceRuntime = require('./workspace-runtime')
+
+const TOOL_CHECK_CACHE_TTL_MS = 10_000
+const toolStateCache = new Map()
 
 // ── Helpers ──────────────────────────────────────────────────────────────────
 
@@ -92,6 +97,52 @@ function parseBody(req) {
   })
 }
 
+function getToolCommand(toolId) {
+  const cmds = {
+    'claude-code': 'claude',
+    'codex': 'codex',
+    'droid': 'droid',
+    'gemini-cli': 'gemini',
+    'opencode': 'opencode',
+    'openclaw': 'openclaw',
+    'aider': 'aider',
+    'env-config': null,
+  }
+  return cmds[toolId] ?? null
+}
+
+async function detectToolInstalled(tool) {
+  if (tool.id === 'env-config') return true
+
+  const now = Date.now()
+  const cached = toolStateCache.get(tool.id)
+  if (cached && now - cached.checkedAt < TOOL_CHECK_CACHE_TTL_MS) {
+    return cached.installed
+  }
+
+  const command = getToolCommand(tool.id)
+  const installed = command ? await commandExistsAsync(command) : false
+  toolStateCache.set(tool.id, { installed, checkedAt: now })
+  return installed
+}
+
+async function buildToolSummary(tool) {
+  const installed = await detectToolInstalled(tool)
+  return {
+    id: tool.id,
+    name: tool.name,
+    installed,
+    configured: installed ? (tool.isConfigured?.() || false) : false,
+    version: installed ? await getVersionAsync(tool) : null,
+    installCmd: tool.installCmd,
+    hint: tool.hint || null,
+    launchCmd: tool.launchCmd || null,
+    canAutoInstall: !!AUTO_INSTALL[tool.id],
+    canUpgrade: !!UPGRADABLE_TOOLS.find((item) => item.id === tool.id),
+    npmPkg: UPGRADABLE_TOOLS.find((item) => item.id === tool.id)?.npmPkg || null,
+  }
+}
+
 function json(res, data, status = 200) {
   res.writeHead(status, { 'Content-Type': 'application/json' })
   res.end(JSON.stringify(data))
@@ -190,6 +241,11 @@ async function handleLogin(req, res) {
     const valid = await validateApiKey(apiKey)
     if (!valid) return json(res, { success: false, message: 'API Key 无效' }, 401)
     saveConfig({ apiKey, savedAt: new Date().toISOString() })
+    workspaceStore.saveHolySheepApiConfig({
+      apiKey,
+      baseUrl: workspaceStore.getHolySheepApiConfig().baseUrl || BASE_URL_OPENAI,
+      model: workspaceStore.getHolySheepApiConfig().model || 'gpt-5.4',
+    })
     json(res, { success: true, apiKey: maskKey(apiKey) })
   } catch (e) {
     json(res, { success: false, message: `验证失败: ${e.message}` }, 500)
@@ -201,6 +257,11 @@ async function handleLogout(_req, res) {
   delete config.apiKey
   delete config.savedAt
   fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2))
+  workspaceStore.saveHolySheepApiConfig({
+    apiKey: '',
+    baseUrl: workspaceStore.getHolySheepApiConfig().baseUrl || BASE_URL_OPENAI,
+    model: workspaceStore.getHolySheepApiConfig().model || 'gpt-5.4',
+  })
   json(res, { success: true })
 }
 
@@ -240,19 +301,7 @@ async function handleDoctor(_req, res) {
   const nodeMajor = parseInt(process.version.slice(1), 10)
 
   // Tools
-  const tools = TOOLS.map(t => {
-    const installed = t.checkInstalled()
-    return {
-      id: t.id,
-      name: t.name,
-      installed,
-      configured: installed ? (t.isConfigured?.() || false) : false,
-      version: installed ? getVersion(t) : null,
-      installCmd: t.installCmd,
-      hint: t.hint || null,
-      launchCmd: t.launchCmd || null,
-    }
-  })
+  const tools = await Promise.all(TOOLS.map((tool) => buildToolSummary(tool)))
 
   // Connectivity
   let connectivity = { ok: false, modelCount: 0 }
@@ -297,22 +346,7 @@ function isClaudeProxyRunning() {
 }
 
 async function handleTools(_req, res) {
-  const tools = await Promise.all(TOOLS.map(async t => {
-    const installed = t.checkInstalled()
-    return {
-      id: t.id,
-      name: t.name,
-      installed,
-      configured: installed ? (t.isConfigured?.() || false) : false,
-      version: installed ? await getVersionAsync(t) : null,
-      installCmd: t.installCmd,
-      hint: t.hint || null,
-      launchCmd: t.launchCmd || null,
-      canAutoInstall: !!AUTO_INSTALL[t.id],
-      canUpgrade: !!UPGRADABLE_TOOLS.find(u => u.id === t.id),
-      npmPkg: UPGRADABLE_TOOLS.find(u => u.id === t.id)?.npmPkg || null,
-    }
-  }))
+  const tools = await Promise.all(TOOLS.map((tool) => buildToolSummary(tool)))
 
   // 追加 claude-proxy 虚拟工具
   const proxyState = isClaudeProxyRunning()
@@ -1034,6 +1068,192 @@ function handleModels(_req, res) {
   ])
 }
 
+function getWorkspacePayload() {
+  const config = workspaceRuntime.normalizeRuntimeConfig({})
+  const hasRuntimeConfig = Boolean(config.apiKey && config.baseUrl && config.model)
+  return {
+    conversations: workspaceStore.listConversations(),
+    scheduledTasks: workspaceStore.listTasks(),
+    holySheepApi: {
+      ...config,
+      apiKeyMasked: config.apiKey ? maskKey(config.apiKey) : null,
+      ready: hasRuntimeConfig,
+    },
+    tools: TOOLS.map((tool) => ({
+      id: tool.id,
+      name: tool.name,
+      launchCmd: tool.launchCmd || null,
+      hint: tool.hint || null,
+    })),
+  }
+}
+
+async function handleWorkspaceState(_req, res) {
+  json(res, getWorkspacePayload())
+}
+
+async function handleWorkspaceSearch(req, res, url) {
+  const query = url.searchParams.get('q') || ''
+  json(res, workspaceStore.searchWorkspace(query))
+}
+
+async function handleWorkspaceApiConfig(req, res) {
+  if (req.method === 'GET') {
+    const config = workspaceRuntime.normalizeRuntimeConfig({})
+    return json(res, {
+      apiKey: config.apiKey,
+      apiKeyMasked: config.apiKey ? maskKey(config.apiKey) : null,
+      baseUrl: config.baseUrl,
+      model: config.model,
+      ready: Boolean(config.apiKey && config.baseUrl && config.model),
+    })
+  }
+
+  const body = await parseBody(req)
+  const apiKey = String(body.apiKey || '').trim()
+  const baseUrl = String(body.baseUrl || '').trim() || BASE_URL_OPENAI
+  const model = String(body.model || '').trim()
+  if (!apiKey || !apiKey.startsWith('cr_')) {
+    return json(res, { success: false, error: 'HolySheep API Key 必须以 cr_ 开头' }, 400)
+  }
+  if (!model) {
+    return json(res, { success: false, error: '模型不能为空' }, 400)
+  }
+
+  workspaceStore.saveHolySheepApiConfig({ apiKey, baseUrl, model })
+  saveConfig({ apiKey, savedAt: new Date().toISOString() })
+  json(res, { success: true, config: getWorkspacePayload().holySheepApi })
+}
+
+async function handleWorkspaceConversations(req, res) {
+  if (req.method === 'GET') {
+    return json(res, workspaceStore.listConversations())
+  }
+  const body = await parseBody(req)
+  const conversation = workspaceStore.createConversation({
+    title: body.title,
+    toolId: body.toolId,
+    pinned: body.pinned,
+  })
+  json(res, { success: true, conversation })
+}
+
+async function handleWorkspaceConversationById(req, res, conversationId) {
+  const conversation = workspaceStore.getConversation(conversationId)
+  if (!conversation) return json(res, { success: false, error: '会话不存在' }, 404)
+
+  if (req.method === 'GET') {
+    return json(res, conversation)
+  }
+
+  if (req.method === 'PATCH') {
+    const body = await parseBody(req)
+    const updated = workspaceStore.updateConversation(conversationId, {
+      title: body.title,
+      toolId: body.toolId,
+      pinned: body.pinned,
+    })
+    return json(res, { success: true, conversation: updated })
+  }
+
+  return json(res, { success: false, error: 'Method not allowed' }, 405)
+}
+
+async function handleWorkspaceConversationMessages(req, res, conversationId) {
+  if (req.method === 'GET') {
+    const conversation = workspaceStore.getConversation(conversationId)
+    if (!conversation) return json(res, { success: false, error: '会话不存在' }, 404)
+    return json(res, conversation.messages)
+  }
+
+  const body = await parseBody(req)
+  const content = String(body.content || '').trim()
+  if (!content) return json(res, { success: false, error: '消息不能为空' }, 400)
+
+  try {
+    const result = await workspaceRuntime.sendConversationMessage(conversationId, content, body.runtimeConfig || {})
+    return json(res, {
+      success: true,
+      messages: [result.userMessage, result.assistantMessage],
+      conversation: workspaceStore.getConversation(conversationId),
+    })
+  } catch (error) {
+    return json(res, {
+      success: false,
+      error: error.message,
+      conversation: workspaceStore.getConversation(conversationId),
+    }, 500)
+  }
+}
+
+async function handleWorkspaceTasks(req, res) {
+  if (req.method === 'GET') {
+    return json(res, workspaceStore.listTasks())
+  }
+  const body = await parseBody(req)
+  const title = String(body.title || '').trim()
+  const prompt = String(body.prompt || '').trim()
+  if (!title || !prompt) return json(res, { success: false, error: '任务标题和提示词不能为空' }, 400)
+
+  try {
+    workspaceRuntime.parseScheduleToMs(body.schedule || '1h')
+  } catch (error) {
+    return json(res, { success: false, error: error.message }, 400)
+  }
+
+  const task = workspaceStore.saveTask({
+    title,
+    prompt,
+    schedule: body.schedule || '1h',
+    active: body.active !== false,
+    conversationId: body.conversationId || null,
+    modelOverride: body.modelOverride || '',
+  })
+  workspaceRuntime.rescheduleAllTasks()
+  json(res, { success: true, task })
+}
+
+async function handleWorkspaceTaskById(req, res, taskId) {
+  if (req.method === 'DELETE') {
+    workspaceStore.deleteTask(taskId)
+    workspaceRuntime.rescheduleAllTasks()
+    return json(res, { success: true })
+  }
+
+  if (req.method === 'PATCH') {
+    const body = await parseBody(req)
+    if (body.schedule) {
+      try {
+        workspaceRuntime.parseScheduleToMs(body.schedule)
+      } catch (error) {
+        return json(res, { success: false, error: error.message }, 400)
+      }
+    }
+    const task = workspaceStore.saveTask({
+      id: taskId,
+      title: body.title,
+      prompt: body.prompt,
+      schedule: body.schedule,
+      active: body.active,
+      conversationId: body.conversationId,
+      modelOverride: body.modelOverride,
+    })
+    workspaceRuntime.rescheduleAllTasks()
+    return json(res, { success: true, task })
+  }
+
+  if (req.method === 'POST') {
+    try {
+      const result = await workspaceRuntime.runTask(taskId)
+      return json(res, { success: true, result })
+    } catch (error) {
+      return json(res, { success: false, error: error.message }, 500)
+    }
+  }
+
+  return json(res, { success: false, error: 'Method not allowed' }, 405)
+}
+
 // ── Router ───────────────────────────────────────────────────────────────────
 
 async function handleRequest(req, res) {
@@ -1062,6 +1282,17 @@ async function handleRequest(req, res) {
     if (route === '/api/doctor'  && req.method === 'GET')  return await handleDoctor(req, res)
     if (route === '/api/tools'   && req.method === 'GET')  return await handleTools(req, res)
     if (route === '/api/models'  && req.method === 'GET')  return await handleModels(req, res)
+    if (route === '/api/workspace/state' && req.method === 'GET') return await handleWorkspaceState(req, res)
+    if (route === '/api/workspace/search' && req.method === 'GET') return await handleWorkspaceSearch(req, res, url)
+    if (route === '/api/workspace/api-config' && (req.method === 'GET' || req.method === 'POST')) return await handleWorkspaceApiConfig(req, res)
+    if (route === '/api/workspace/conversations' && (req.method === 'GET' || req.method === 'POST')) return await handleWorkspaceConversations(req, res)
+    const conversationMatch = route.match(/^\/api\/workspace\/conversations\/([^/]+)$/)
+    if (conversationMatch) return await handleWorkspaceConversationById(req, res, conversationMatch[1])
+    const messagesMatch = route.match(/^\/api\/workspace\/conversations\/([^/]+)\/messages$/)
+    if (messagesMatch) return await handleWorkspaceConversationMessages(req, res, messagesMatch[1])
+    if (route === '/api/workspace/tasks' && (req.method === 'GET' || req.method === 'POST')) return await handleWorkspaceTasks(req, res)
+    const taskMatch = route.match(/^\/api\/workspace\/tasks\/([^/]+)$/)
+    if (taskMatch) return await handleWorkspaceTaskById(req, res, taskMatch[1])
     if (route === '/api/upgrade' && req.method === 'POST') return await handleUpgrade(req, res)
     if (route === '/api/tool/install'   && req.method === 'POST') return await handleToolInstall(req, res)
     if (route === '/api/tool/configure' && req.method === 'POST') return await handleToolConfigure(req, res)
@@ -1113,13 +1344,19 @@ function startServer(port) {
         setTimeout(() => {
           const retry = http.createServer(handleRequest)
           retry.on('error', (err2) => reject(err2))
-          retry.listen(port, '127.0.0.1', () => resolve(retry))
+          retry.listen(port, '127.0.0.1', () => {
+            workspaceRuntime.startScheduler()
+            resolve(retry)
+          })
         }, 500)
       } else {
         reject(err)
       }
     })
-    server.listen(port, '127.0.0.1', () => resolve(server))
+    server.listen(port, '127.0.0.1', () => {
+      workspaceRuntime.startScheduler()
+      resolve(server)
+    })
   })
 }
 

package/src/webui/workspace-runtime.js

@@ -0,0 +1,288 @@
+'use strict'
+
+const fetch = require('node-fetch')
+const {
+  addMessage,
+  createConversation,
+  ensureConversation,
+  getConversation,
+  getHolySheepApiConfig,
+  listTasks,
+  updateConversation,
+  updateTaskRun,
+} = require('./workspace-store')
+const { getApiKey, BASE_URL_OPENAI } = require('../utils/config')
+
+const schedulerHandles = new Map()
+
+function normalizeRuntimeConfig(config = {}) {
+  const saved = getHolySheepApiConfig()
+  const apiKey = String(config.apiKey || saved.apiKey || getApiKey() || '').trim()
+  const baseUrl = String(config.baseUrl || saved.baseUrl || BASE_URL_OPENAI).replace(/\/+$/, '')
+  const model = String(config.model || saved.model || '').trim()
+  return { apiKey, baseUrl, model }
+}
+
+function assertRuntimeConfig(config) {
+  if (!config.apiKey || !config.apiKey.startsWith('cr_')) {
+    throw new Error('HolySheep API Key is required')
+  }
+  if (!config.baseUrl) {
+    throw new Error('HolySheep API Base URL is required')
+  }
+  if (!config.model) {
+    throw new Error('HolySheep API model is required')
+  }
+}
+
+function buildSystemPrompt(toolId) {
+  const toolName = String(toolId || 'codex')
+  return [
+    `You are operating inside HolySheep Workspace.`,
+    `The selected coding tool is "${toolName}".`,
+    `Respond with concise, implementation-focused guidance suitable for a coding assistant workspace.`,
+    `When you mention commands, prefer copy-paste-ready shell commands.`,
+  ].join(' ')
+}
+
+async function requestCompletion(messages, config) {
+  const controller = new AbortController()
+  const timeout = setTimeout(() => controller.abort(), 20_000)
+  let response
+  try {
+    response = await fetch(`${config.baseUrl}/chat/completions`, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${config.apiKey}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        model: config.model,
+        temperature: 0.2,
+        messages,
+      }),
+      signal: controller.signal,
+    })
+  } catch (error) {
+    if (error.name === 'AbortError') {
+      throw new Error('HolySheep API request timed out')
+    }
+    throw error
+  } finally {
+    clearTimeout(timeout)
+  }
+
+  const payload = await response.json().catch(() => null)
+  if (!response.ok) {
+    const reason = payload?.error?.message || payload?.message || `HTTP ${response.status}`
+    throw new Error(reason)
+  }
+
+  const content = payload?.choices?.[0]?.message?.content
+  if (typeof content === 'string' && content.trim()) return content.trim()
+  if (Array.isArray(content)) {
+    const text = content
+      .map((part) => {
+        if (typeof part === 'string') return part
+        if (typeof part?.text === 'string') return part.text
+        if (typeof part?.content === 'string') return part.content
+        return ''
+      })
+      .filter(Boolean)
+      .join('\n')
+      .trim()
+    if (text) return text
+  }
+  const fallbacks = [
+    payload?.choices?.[0]?.text,
+    payload?.output_text,
+    payload?.response,
+    payload?.message,
+  ]
+  for (const item of fallbacks) {
+    if (typeof item === 'string' && item.trim()) return item.trim()
+  }
+  if (Array.isArray(payload?.output)) {
+    const text = payload.output
+      .map((part) => {
+        if (typeof part?.content === 'string') return part.content
+        if (typeof part?.text === 'string') return part.text
+        if (Array.isArray(part?.content)) {
+          return part.content.map((child) => child?.text || child?.content || '').join('\n')
+        }
+        return ''
+      })
+      .filter(Boolean)
+      .join('\n')
+      .trim()
+    if (text) return text
+  }
+  return 'No response content returned.'
+}
+
+async function sendConversationMessage(conversationId, input, options = {}) {
+  const conversation = ensureConversation(conversationId)
+  const config = normalizeRuntimeConfig(options)
+  assertRuntimeConfig(config)
+
+  const userMessage = addMessage(conversationId, {
+    role: 'user',
+    content: String(input || ''),
+    meta: {
+      source: 'workspace',
+    },
+  })
+
+  try {
+    const messages = [
+      { role: 'system', content: buildSystemPrompt(conversation.toolId) },
+      ...conversation.messages
+        .concat(userMessage)
+        .map((message) => ({
+          role: message.role,
+          content: message.content,
+        })),
+    ]
+    const reply = await requestCompletion(messages, config)
+    const assistantMessage = addMessage(conversationId, {
+      role: 'assistant',
+      content: reply,
+      meta: {
+        model: config.model,
+        source: 'holysheep-api',
+      },
+    })
+    updateConversation(conversationId, {
+      summary: reply.slice(0, 240),
+    })
+    return { userMessage, assistantMessage }
+  } catch (error) {
+    const assistantMessage = addMessage(conversationId, {
+      role: 'assistant',
+      content: `Error: ${error.message}`,
+      status: 'error',
+      meta: {
+        model: config.model,
+        source: 'holysheep-api',
+      },
+    })
+    updateConversation(conversationId, {
+      summary: assistantMessage.content.slice(0, 240),
+    })
+    throw error
+  }
+}
+
+function parseScheduleToMs(schedule) {
+  const value = String(schedule || '').trim().toLowerCase()
+  const match = value.match(/^(\d+)\s*([smhd])$/)
+  if (!match) throw new Error('Schedule must use format like 30s, 5m, 1h, 1d')
+  const amount = Number(match[1])
+  const unit = match[2]
+  if (!Number.isFinite(amount) || amount <= 0) throw new Error('Invalid schedule amount')
+  const factors = { s: 1000, m: 60_000, h: 3_600_000, d: 86_400_000 }
+  return amount * factors[unit]
+}
+
+async function runTask(taskId, options = {}) {
+  const task = listTasks().find((item) => item.id === taskId)
+  if (!task) throw new Error('Task not found')
+
+  const config = normalizeRuntimeConfig({
+    ...options,
+    model: task.modelOverride || options.model,
+  })
+  assertRuntimeConfig(config)
+  updateTaskRun(taskId, {
+    lastStatus: 'running',
+  })
+
+  let conversationId = task.conversationId
+  if (!conversationId) {
+    const conversation = createConversation({
+      title: task.title,
+      toolId: 'codex',
+    })
+    conversationId = conversation.id
+    updateTaskRun(taskId, { conversationId })
+  }
+
+  try {
+    const { assistantMessage } = await sendConversationMessage(conversationId, task.prompt, config)
+    updateTaskRun(taskId, {
+      lastRunAt: new Date().toISOString(),
+      lastStatus: 'ok',
+      lastResult: assistantMessage.content,
+      conversationId,
+    })
+    return assistantMessage
+  } catch (error) {
+    updateTaskRun(taskId, {
+      lastRunAt: new Date().toISOString(),
+      lastStatus: 'error',
+      lastResult: error.message,
+      conversationId,
+    })
+    throw error
+  }
+}
+
+function clearTaskHandle(taskId) {
+  const existing = schedulerHandles.get(taskId)
+  if (!existing) return
+  clearInterval(existing)
+  schedulerHandles.delete(taskId)
+}
+
+function scheduleTask(task) {
+  clearTaskHandle(task.id)
+  if (!task.active) return
+
+  let intervalMs
+  try {
+    intervalMs = parseScheduleToMs(task.schedule)
+  } catch {
+    return
+  }
+
+  const handle = setInterval(() => {
+    void runTask(task.id).catch(() => {})
+  }, intervalMs)
+  schedulerHandles.set(task.id, handle)
+}
+
+function rescheduleAllTasks() {
+  const tasks = listTasks()
+  const seen = new Set(tasks.map((task) => task.id))
+  for (const taskId of schedulerHandles.keys()) {
+    if (!seen.has(taskId)) {
+      clearTaskHandle(taskId)
+    }
+  }
+  for (const task of tasks) {
+    scheduleTask(task)
+  }
+}
+
+function stopScheduler() {
+  for (const taskId of schedulerHandles.keys()) {
+    clearTaskHandle(taskId)
+  }
+}
+
+function startScheduler() {
+  rescheduleAllTasks()
+}
+
+module.exports = {
+  normalizeRuntimeConfig,
+  assertRuntimeConfig,
+  sendConversationMessage,
+  parseScheduleToMs,
+  runTask,
+  startScheduler,
+  stopScheduler,
+  rescheduleAllTasks,
+  createConversation,
+  getConversation,
+}