@simonyea/holysheep-cli 2.1.40 → 2.1.42

package/src/webui/workspace-runtime.js

@@ -1,288 +0,0 @@
-'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,
-}

package/src/webui/workspace-store.js

@@ -1,325 +0,0 @@
-'use strict'
-
-const fs = require('fs')
-const path = require('path')
-const crypto = require('crypto')
-const { CONFIG_DIR } = require('../utils/config')
-
-const STATE_FILE = path.join(CONFIG_DIR, 'workspace-state.json')
-const STATE_VERSION = 1
-
-function now() {
-  return new Date().toISOString()
-}
-
-function createDefaultState() {
-  return {
-    version: STATE_VERSION,
-    updatedAt: now(),
-    holySheepApi: {
-      apiKey: '',
-      baseUrl: '',
-      model: '',
-    },
-    conversations: [],
-    scheduledTasks: [],
-  }
-}
-
-function ensureDir() {
-  fs.mkdirSync(CONFIG_DIR, { recursive: true })
-}
-
-function clone(value) {
-  return JSON.parse(JSON.stringify(value))
-}
-
-function normalizeConversation(item = {}) {
-  const createdAt = item.createdAt || now()
-  const messages = Array.isArray(item.messages)
-    ? item.messages.map((message) => ({
-        id: message.id || crypto.randomUUID(),
-        role: message.role === 'assistant' ? 'assistant' : 'user',
-        content: String(message.content || ''),
-        status: message.status || 'done',
-        createdAt: message.createdAt || createdAt,
-        meta: typeof message.meta === 'object' && message.meta ? message.meta : {},
-      }))
-    : []
-
-  const lastMessage = messages[messages.length - 1] || null
-
-  return {
-    id: item.id || crypto.randomUUID().slice(0, 8),
-    title: String(item.title || 'New Conversation'),
-    toolId: String(item.toolId || 'codex'),
-    createdAt,
-    updatedAt: item.updatedAt || lastMessage?.createdAt || createdAt,
-    pinned: Boolean(item.pinned),
-    summary: String(item.summary || lastMessage?.content || '').slice(0, 240),
-    messages,
-  }
-}
-
-function normalizeTask(item = {}) {
-  return {
-    id: item.id || crypto.randomUUID().slice(0, 8),
-    title: String(item.title || 'Untitled Task'),
-    prompt: String(item.prompt || ''),
-    schedule: String(item.schedule || '1h'),
-    active: item.active !== false,
-    createdAt: item.createdAt || now(),
-    updatedAt: item.updatedAt || now(),
-    lastRunAt: item.lastRunAt || null,
-    lastStatus: item.lastStatus || 'idle',
-    lastResult: String(item.lastResult || ''),
-    conversationId: item.conversationId || null,
-    modelOverride: item.modelOverride ? String(item.modelOverride) : '',
-  }
-}
-
-function normalizeState(raw = {}) {
-  const state = createDefaultState()
-  state.holySheepApi = {
-    ...state.holySheepApi,
-    ...(typeof raw.holySheepApi === 'object' && raw.holySheepApi ? raw.holySheepApi : {}),
-  }
-  state.conversations = Array.isArray(raw.conversations) ? raw.conversations.map(normalizeConversation) : []
-  state.scheduledTasks = Array.isArray(raw.scheduledTasks) ? raw.scheduledTasks.map(normalizeTask) : []
-  state.updatedAt = raw.updatedAt || now()
-  return state
-}
-
-function loadState() {
-  ensureDir()
-  try {
-    if (!fs.existsSync(STATE_FILE)) {
-      return createDefaultState()
-    }
-    return normalizeState(JSON.parse(fs.readFileSync(STATE_FILE, 'utf8')))
-  } catch {
-    return createDefaultState()
-  }
-}
-
-function saveState(next) {
-  ensureDir()
-  const normalized = normalizeState(next)
-  normalized.updatedAt = now()
-  fs.writeFileSync(STATE_FILE, JSON.stringify(normalized, null, 2), 'utf8')
-  return normalized
-}
-
-function updateState(mutator) {
-  const current = loadState()
-  const draft = clone(current)
-  const result = mutator(draft) || draft
-  return saveState(result)
-}
-
-function sortConversations(items) {
-  return [...items].sort((a, b) => {
-    if (a.pinned !== b.pinned) return a.pinned ? -1 : 1
-    return Date.parse(b.updatedAt) - Date.parse(a.updatedAt)
-  })
-}
-
-function listConversations() {
-  return sortConversations(loadState().conversations).map((item) => ({
-    id: item.id,
-    title: item.title,
-    toolId: item.toolId,
-    pinned: item.pinned,
-    summary: item.summary,
-    createdAt: item.createdAt,
-    updatedAt: item.updatedAt,
-    messageCount: item.messages.length,
-  }))
-}
-
-function getConversation(id) {
-  return loadState().conversations.find((item) => item.id === id) || null
-}
-
-function ensureConversation(id) {
-  const conversation = getConversation(id)
-  if (!conversation) throw new Error('Conversation not found')
-  return conversation
-}
-
-function createConversation(payload = {}) {
-  const conversation = normalizeConversation({
-    title: payload.title || 'New Conversation',
-    toolId: payload.toolId || 'codex',
-    pinned: Boolean(payload.pinned),
-  })
-  updateState((state) => {
-    state.conversations.unshift(conversation)
-  })
-  return conversation
-}
-
-function updateConversation(id, patch = {}) {
-  let updated = null
-  updateState((state) => {
-    const index = state.conversations.findIndex((item) => item.id === id)
-    if (index === -1) throw new Error('Conversation not found')
-    const current = state.conversations[index]
-    updated = normalizeConversation({
-      ...current,
-      ...patch,
-      messages: patch.messages || current.messages,
-      updatedAt: now(),
-    })
-    state.conversations[index] = updated
-  })
-  return updated
-}
-
-function addMessage(conversationId, payload = {}) {
-  let updated = null
-  updateState((state) => {
-    const conversation = state.conversations.find((item) => item.id === conversationId)
-    if (!conversation) throw new Error('Conversation not found')
-    const message = {
-      id: payload.id || crypto.randomUUID(),
-      role: payload.role === 'assistant' ? 'assistant' : 'user',
-      content: String(payload.content || ''),
-      status: payload.status || 'done',
-      createdAt: payload.createdAt || now(),
-      meta: typeof payload.meta === 'object' && payload.meta ? payload.meta : {},
-    }
-    conversation.messages.push(message)
-    conversation.updatedAt = message.createdAt
-    if (!conversation.summary || message.role === 'assistant') {
-      conversation.summary = message.content.slice(0, 240)
-    }
-    updated = clone(message)
-  })
-  return updated
-}
-
-function searchWorkspace(query) {
-  const needle = String(query || '').trim().toLowerCase()
-  if (!needle) return { conversations: [], tasks: [] }
-
-  const state = loadState()
-  const conversations = state.conversations
-    .filter((item) => {
-      if (item.title.toLowerCase().includes(needle)) return true
-      if (String(item.summary || '').toLowerCase().includes(needle)) return true
-      return item.messages.some((message) => String(message.content || '').toLowerCase().includes(needle))
-    })
-    .map((item) => ({
-      id: item.id,
-      title: item.title,
-      summary: item.summary,
-      updatedAt: item.updatedAt,
-      toolId: item.toolId,
-    }))
-
-  const tasks = state.scheduledTasks
-    .filter((item) => {
-      return item.title.toLowerCase().includes(needle) || item.prompt.toLowerCase().includes(needle)
-    })
-    .map((item) => ({
-      id: item.id,
-      title: item.title,
-      prompt: item.prompt.slice(0, 180),
-      schedule: item.schedule,
-      active: item.active,
-      updatedAt: item.updatedAt,
-    }))
-
-  return { conversations, tasks }
-}
-
-function listTasks() {
-  return [...loadState().scheduledTasks].sort((a, b) => Date.parse(b.updatedAt) - Date.parse(a.updatedAt))
-}
-
-function getTask(id) {
-  return loadState().scheduledTasks.find((item) => item.id === id) || null
-}
-
-function saveTask(payload = {}) {
-  let result = null
-  updateState((state) => {
-    if (payload.id) {
-      const index = state.scheduledTasks.findIndex((item) => item.id === payload.id)
-      if (index === -1) throw new Error('Task not found')
-      result = normalizeTask({
-        ...state.scheduledTasks[index],
-        ...payload,
-        updatedAt: now(),
-      })
-      state.scheduledTasks[index] = result
-      return
-    }
-    result = normalizeTask({
-      ...payload,
-      createdAt: now(),
-      updatedAt: now(),
-    })
-    state.scheduledTasks.unshift(result)
-  })
-  return result
-}
-
-function deleteTask(id) {
-  updateState((state) => {
-    state.scheduledTasks = state.scheduledTasks.filter((item) => item.id !== id)
-  })
-}
-
-function updateTaskRun(id, patch = {}) {
-  let result = null
-  updateState((state) => {
-    const index = state.scheduledTasks.findIndex((item) => item.id === id)
-    if (index === -1) throw new Error('Task not found')
-    result = normalizeTask({
-      ...state.scheduledTasks[index],
-      ...patch,
-      updatedAt: now(),
-    })
-    state.scheduledTasks[index] = result
-  })
-  return result
-}
-
-function getHolySheepApiConfig() {
-  return loadState().holySheepApi
-}
-
-function saveHolySheepApiConfig(config = {}) {
-  let result = null
-  updateState((state) => {
-    state.holySheepApi = {
-      apiKey: String(config.apiKey || state.holySheepApi.apiKey || ''),
-      baseUrl: String(config.baseUrl || state.holySheepApi.baseUrl || ''),
-      model: String(config.model || state.holySheepApi.model || ''),
-    }
-    result = clone(state.holySheepApi)
-  })
-  return result
-}
-
-module.exports = {
-  STATE_FILE,
-  loadState,
-  saveState,
-  listConversations,
-  getConversation,
-  createConversation,
-  updateConversation,
-  addMessage,
-  searchWorkspace,
-  listTasks,
-  getTask,
-  saveTask,
-  deleteTask,
-  updateTaskRun,
-  getHolySheepApiConfig,
-  saveHolySheepApiConfig,
-  ensureConversation,
-}