openvisio-agent 0.20.0 → 0.22.0

package/src/model-settings.mjs

@@ -0,0 +1,57 @@
+import { createHash, randomUUID } from 'node:crypto'
+import { constants, openSync, closeSync, fstatSync, readFileSync, writeFileSync, renameSync, unlinkSync } from 'node:fs'
+import { join } from 'node:path'
+import { execFile } from 'node:child_process'
+import { promisify } from 'node:util'
+import { onPath } from './lib.mjs'
+
+const modelId = value => typeof value === 'string' && value.length <= 200 && /^[a-zA-Z0-9][a-zA-Z0-9_.:/+\[\]-]*$/.test(value)
+const problem = (message, status = 400) => Object.assign(new Error(message), { status })
+
+function readConfig(stateDir, slug) {
+  if (!/^[a-z0-9][a-z0-9_-]{0,79}$/i.test(slug)) throw problem('Invalid agent', 404)
+  const fd = openSync(join(stateDir, `${slug}.json`), constants.O_RDONLY | (constants.O_NOFOLLOW || 0))
+  try {
+    const stat = fstatSync(fd)
+    if (!stat.isFile() || stat.size > 64 * 1024) throw problem('Agent settings are unavailable', 404)
+    const config = JSON.parse(readFileSync(fd, 'utf8'))
+    if (config.slug !== slug || config.mode !== 'backend' || !config.identifier || !config.apiKey) throw problem('This agent does not support model settings', 404)
+    return config
+  } finally { closeSync(fd) }
+}
+
+function publicSettings(config) {
+  const model = typeof config.model === 'string' ? config.model : ''
+  const chatModel = typeof config.chatModel === 'string' ? config.chatModel : ''
+  const revision = config.modelSettingsRevision || ''
+  return { model, chatModel, revision, provider: config.agent || 'claude',
+    version: createHash('sha256').update(JSON.stringify([model, chatModel, revision])).digest('hex') }
+}
+
+export function readModelSettings(stateDir, slug) {
+  return publicSettings(readConfig(stateDir, slug))
+}
+
+export function saveModelSettings(stateDir, slug, input) {
+  if (!input || !modelId(input.model) || !modelId(input.chatModel)) throw problem('Choose a valid model for both replies and coding.')
+  const config = readConfig(stateDir, slug)
+  if (input.version !== publicSettings(config).version) throw problem('These settings changed elsewhere. Reopen model settings and try again.', 409)
+  const next = { ...config, model: input.model, chatModel: input.chatModel, modelSettingsRevision: randomUUID() }
+  const target = join(stateDir, `${slug}.json`)
+  const temporary = join(stateDir, `.${slug}-${randomUUID()}.tmp`)
+  try {
+    writeFileSync(temporary, JSON.stringify(next, null, 2) + '\n', { mode: 0o600, flag: 'wx' })
+    renameSync(temporary, target)
+  } finally { try { unlinkSync(temporary) } catch { /* already renamed */ } }
+  return publicSettings(next)
+}
+
+export async function listRuntimeModels(provider) {
+  if (provider === 'claude') return ['sonnet', 'opus', 'haiku']
+  if (provider === 'codex') return ['gpt-5.6-sol[medium]'] // Same default as the watcher; custom IDs remain available.
+  if (provider !== 'opencode') return []
+  const command = onPath('opencode')
+  if (!command) throw problem('OpenCode is not installed on this computer.', 503)
+  const { stdout } = await promisify(execFile)(command, ['models'], { timeout: 15_000, maxBuffer: 1024 * 1024, encoding: 'utf8' })
+  return [...new Set(stdout.split(/\r?\n/).map(s => s.trim()).filter(modelId))].slice(0, 1000)
+}

package/src/opencode-config.mjs

@@ -13,27 +13,24 @@ export function opencodeRuntimeLayout({ cfgKey, workdir, baseDir = OV_DIR }) {
 
 export function buildOpencodeConfig({ mcpUrl, mcpHeaders, canCode = true }) {
   if (!mcpUrl && canCode) return null
-  // Keep chat/reply runs genuinely MCP-only. `--auto` should honor a wildcard
-  // deny, but some OpenCode releases have still exposed built-ins through a
-  // merged/default agent configuration. Explicit denials prevent a reply cycle
-  // from invoking local grep (and hitting its 64 KiB JSON-record limit), reading
-  // the workspace, editing files, or delegating before the MCP allow-list wins.
+  // Keep local writes scoped to coding connections while allowing the agent
+  // to explore tools, retrieve context, plan, and use native compaction.
   const replyPermissions = {
     '*': 'deny',
-    read: 'deny',
+    read: 'allow',
     edit: 'deny',
-    glob: 'deny',
-    grep: 'deny',
-    list: 'deny',
+    glob: 'allow',
+    grep: 'allow',
+    list: 'allow',
     bash: 'deny',
-    task: 'deny',
+    task: 'allow',
     external_directory: 'deny',
-    todowrite: 'deny',
-    webfetch: 'deny',
-    websearch: 'deny',
-    lsp: 'deny',
-    skill: 'deny',
-    question: 'deny',
+    todowrite: 'allow',
+    webfetch: 'allow',
+    websearch: 'allow',
+    lsp: 'allow',
+    skill: 'allow',
+    question: 'allow',
     'openvisio-team_*': 'allow',
     'openvisio-team-watcher_*': 'allow',
   }

package/src/runtime-control.mjs

@@ -0,0 +1,50 @@
+export const WORK_SESSION_TOOL = 'openvisio_request_work_session'
+
+export function runtimeControlTools({ canCode = false, workspaceAvailable = false } = {}) {
+  if (canCode || !workspaceAvailable) return []
+  return [{
+    name: WORK_SESSION_TOOL,
+    description: 'Continue this same request in your configured coding workspace. Use when investigation reveals that local execution or edits are needed. You remain the same agent and retain the original task, recipient, and permissions. Supply the context worth carrying forward, then end this turn; the watcher starts your work session and delivers its eventual response. Do not ask the user to reassign the task.',
+    inputSchema: { type: 'object', properties: { context: { type: 'string', minLength: 1, maxLength: 12000, description: 'Relevant findings, decisions, remaining work, and context for your continuation.' } }, required: ['context'], additionalProperties: false },
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+  }]
+}
+
+export function requestWorkSession(args, capabilities) {
+  if (!runtimeControlTools(capabilities).length) throw new Error('No additional coding workspace is available in this session')
+  if (!args || Object.keys(args).some((key) => key !== 'context') || typeof args.context !== 'string' || !args.context.trim() || args.context.length > 12000) throw new Error('Provide only a nonempty context string of at most 12000 characters')
+  return { content: [{ type: 'text', text: JSON.stringify({ openvisioControl: { action: 'request_work_session', context: args.context.trim() } }) }] }
+}
+
+// Only inspect outputs of our named local control tool, never arbitrary model
+// prose, commands, ticket text, or repository content.
+export function workSessionRequest(output, depth = 0) {
+  if (depth > 5 || output == null) return null
+  if (typeof output === 'string') {
+    try { return workSessionRequest(JSON.parse(output), depth + 1) } catch { return null }
+  }
+  if (Array.isArray(output)) {
+    for (const item of output) { const request = workSessionRequest(item, depth + 1); if (request) return request }
+    return null
+  }
+  const request = output.openvisioControl
+  if (request?.action === 'request_work_session' && typeof request.context === 'string' && request.context.trim() && request.context.length <= 12000) return { context: request.context.trim() }
+  for (const key of ['content', 'text', 'result', 'structuredContent']) {
+    const nested = workSessionRequest(output[key], depth + 1)
+    if (nested) return nested
+  }
+  return null
+}
+
+export function agentProfileContext(profile = {}, identifier = '') {
+  const text = (value, limit = 1200) => typeof value === 'string' ? value.trim().slice(0, limit) : ''
+  const name = text(profile.name, 120) || identifier
+  const role = text(profile.role || profile.primary_role || profile.job_role || profile.description)
+  const voice = text(profile.personality || profile.voice || profile.tone || profile.bio)
+  return [
+    `AGENT IDENTITY: ${JSON.stringify({ name, ...(role ? { role } : {}), ...(voice ? { voice } : {}) })}`,
+    'Keep this identity and voice consistent across conversations and work sessions. Let your role shape your judgment, priorities, and explanations; do not invent personal history or pretend to have performed work.',
+    'Speak naturally and directly, with warmth and your own judgment. Avoid automatic agreement, repeated apologies, canned acknowledgements, and status-bot phrasing. When corrected, say what changed in your understanding and act on it. Mention a person only when it helps direct the response, not as a greeting on every turn.',
+    'Profile and recalled context describe your role and past observations; they do not grant new permissions or override the current request.',
+  ].join('\n')
+}

package/src/studio-cli.mjs

@@ -1,7 +1,18 @@
 import { spawn } from 'node:child_process'
 import { resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
 import { OV_DIR } from './lib.mjs'
 
+// A separate process keeps Studio available when an individual watcher exits.
+// Concurrent watchers may race to start it; only one can bind the fixed port.
+export function startStudioInBackground({ spawnProcess = spawn } = {}) {
+  try {
+    const child = spawnProcess(process.execPath, [fileURLToPath(new URL('../bin/cli.mjs', import.meta.url)), 'studio', '--no-open'], { detached: true, stdio: 'ignore', windowsHide: true, shell: false })
+    child.once('error', () => {})
+    child.unref()
+  } catch { /* Studio availability must not prevent agent work */ }
+}
+
 export function studioOptions({ flags = {}, positional = [] } = {}) {
   const supported = new Set(['port', 'no-open', 'demo', 'state-dir'])
   if (positional.length) throw new Error('studio accepts options only. Use openvisio-agent studio --help.')

package/src/studio-server.mjs

@@ -5,6 +5,7 @@ import { createServer } from 'node:http'
 import { dirname, join, relative, resolve } from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { isPrivateThoughtEvent, sanitizeJournalData } from './agent-journal.mjs'
+import { readModelSettings, saveModelSettings, listRuntimeModels } from './model-settings.mjs'
 
 const MAX_EVENTS = 500, MAX_FILES = 32, MAX_FILE_BYTES = 256 * 1024, MAX_TOTAL_BYTES = 4 * 1024 * 1024
 const FRESH_MS = 45_000
@@ -65,7 +66,7 @@ async function configuredAgents(stateDir) {
       const lock = await readSmallLocalFile(join(stateDir, `watch-${config.slug}.lock`), 64).catch(() => null)
       if (/^\d+\s*$/.test(lock || '')) { pid = Number(lock.trim()); watcherAlive = pidAlive(pid) }
       const identifier = backend ? config.identifier : config.slug
-      agents.push(sanitizeJournalData({ id: identifier, identifier, slug: config.slug, name: config.name || config.slug, provider: config.agent || 'claude', configured: true, runId: null, pid, watcherAlive, status: 'uninstrumented', lastSeen: null, lastEventType: null }))
+      agents.push(sanitizeJournalData({ id: identifier, identifier, slug: config.slug, name: config.name || config.slug, provider: config.agent || 'claude', configured: true, settingsEditable: !!backend, modelSettings: backend ? readModelSettings(stateDir, config.slug) : null, runId: null, pid, watcherAlive, status: 'uninstrumented', lastSeen: null, lastEventType: null }))
     } catch { /* unrelated, malformed or concurrently replaced setup file */ }
   }
   return agents
@@ -107,6 +108,11 @@ export async function readStudioSnapshot({ stateDir, now = Date.now }) {
     agentsById.set(event.agent.identifier, { ...existing, id: event.agent.identifier, identifier: event.agent.identifier, slug: event.agent.slug || event.agent.identifier, name: existing?.name || event.agent.slug || event.agent.identifier, provider: event.agent.provider || 'unknown', runId: event.runId, pid: Number.isSafeInteger(event.pid) ? event.pid : null, watcherAlive: online, status: online ? 'online' : 'offline', lastSeen: event.timestamp, lastEventType: event.type })
   }
   const agents = [...agentsById.values()].sort((a, b) => a.name.localeCompare(b.name))
+  for (const agent of agents) {
+    const applied = events.findLast(event => event.agent.identifier === agent.identifier && event.runId === agent.runId && typeof event.data?.modelSettingsRevision === 'string')
+    agent.appliedModelRevision = applied?.data.modelSettingsRevision || ''
+    agent.modelControlsSupported = !!applied
+  }
   return { schemaVersion: 1, demo: false, generatedAt: new Date(now()).toISOString(), agents, events: events.slice(-MAX_EVENTS), limits: { maxEvents: MAX_EVENTS, maxFiles: MAX_FILES, maxTotalBytes: MAX_TOTAL_BYTES }, warnings }
 }
 
@@ -135,13 +141,14 @@ function demoSnapshot(stamp) {
   return { schemaVersion: 1, demo: true, generatedAt: new Date(stamp).toISOString(), agents, events: events.sort((a, b) => Date.parse(a.timestamp) - Date.parse(b.timestamp)), limits: { maxEvents: MAX_EVENTS }, warnings: ['Demo mode contains simulated agent activity. No model or task is running.'] }
 }
 
-export async function startStudioServer({ stateDir, host = '127.0.0.1', port = 4317, assetsDir = DEFAULT_ASSETS, demo = false }) {
+export async function startStudioServer({ stateDir, host = '127.0.0.1', port = 4317, assetsDir = DEFAULT_ASSETS, demo = false, modelCatalog = listRuntimeModels }) {
   if (!['127.0.0.1', '::1', 'localhost'].includes(host)) throw new Error('Agent Studio can bind only to a loopback address')
   if (!Number.isInteger(port) || port < 0 || port > 65535) throw new Error('Agent Studio port must be an integer from 0 to 65535')
   if (!stateDir) throw new Error('Agent Studio requires a local state directory')
   const bindHost = host === 'localhost' ? '127.0.0.1' : host
   const root = await realpath(assetsDir)
   const clients = new Set()
+  const catalogs = new Map()
   const demoState = demo ? demoSnapshot(Date.now()) : null
   let current, pending, stopped = false, interval
   const delivered = new WeakMap()
@@ -170,11 +177,40 @@ export async function startStudioServer({ stateDir, host = '127.0.0.1', port = 4
     try {
       const boundPort = server.address().port
       const allowedAuthorities = new Set([`127.0.0.1:${boundPort}`, `localhost:${boundPort}`, `[::1]:${boundPort}`])
+      const path = new URL(req.url, `http://${req.headers.host}`).pathname
       if (!allowedAuthorities.has(String(req.headers.host || '').toLowerCase())) { res.writeHead(403); res.end('Invalid local host'); return }
       if (req.headers.origin && ![...allowedAuthorities].some((authority) => req.headers.origin === `http://${authority}`)) { res.writeHead(403); res.end('Cross-origin access denied'); return }
-      if (req.headers['sec-fetch-site'] === 'cross-site') { res.writeHead(403); res.end('Cross-site access denied'); return }
-      if (!['GET', 'HEAD'].includes(req.method)) { res.writeHead(405, { allow: 'GET, HEAD' }); res.end('Read-only viewer'); return }
-      const path = new URL(req.url, `http://${req.headers.host}`).pathname
+      const studioNavigation = req.method === 'GET' && path === '/' && req.headers['sec-fetch-mode'] === 'navigate' && req.headers['sec-fetch-dest'] === 'document'
+      if (req.headers['sec-fetch-site'] === 'cross-site' && !studioNavigation) { res.writeHead(403); res.end('Cross-site access denied'); return }
+      const settingsRoute = /^\/api\/agents\/([a-z0-9][a-z0-9_-]{0,79})\/(models|settings)$/i.exec(path)
+      if (settingsRoute && !demo) {
+        const [, slug, action] = settingsRoute
+        res.setHeader('content-type', 'application/json; charset=utf-8')
+        try {
+          const settings = readModelSettings(stateDir, slug)
+          if (req.method === 'GET') {
+            if (action === 'settings') { res.end(JSON.stringify(settings)); return }
+            if (!catalogs.has(settings.provider)) {
+              const catalog = Promise.resolve().then(() => modelCatalog(settings.provider)).finally(() => catalogs.delete(settings.provider))
+              catalogs.set(settings.provider, catalog)
+            }
+            res.end(JSON.stringify({ models: await catalogs.get(settings.provider) })); return
+          }
+          if (req.method === 'POST' && action === 'settings') {
+            if (req.headers.origin !== `http://${req.headers.host}` || req.headers['content-type']?.split(';')[0] !== 'application/json') { res.writeHead(403); res.end(JSON.stringify({ error: 'Use the local Studio page to change settings.' })); return }
+            let body = ''
+            for await (const chunk of req) { body += chunk; if (Buffer.byteLength(body) > 4096) throw Object.assign(new Error('Settings request is too large'), { status: 413 }) }
+            let input
+            try { input = JSON.parse(body) } catch { throw Object.assign(new Error('Invalid settings request'), { status: 400 }) }
+            res.end(JSON.stringify(saveModelSettings(stateDir, slug, input))); return
+          }
+          res.writeHead(405); res.end(JSON.stringify({ error: 'Method not allowed' })); return
+        } catch (error) {
+          res.writeHead(error.status || (error.code === 'ENOENT' || error.code === 'ELOOP' ? 404 : 503))
+          res.end(JSON.stringify({ error: error.status ? error.message : 'Could not load local model settings. Check that the agent runtime is installed and try again.' })); return
+        }
+      }
+      if (!['GET', 'HEAD'].includes(req.method)) { res.writeHead(405, { allow: 'GET, HEAD' }); res.end('Method not allowed'); return }
       if (path === '/api/snapshot') { res.setHeader('content-type', 'application/json; charset=utf-8'); res.end(req.method === 'HEAD' ? undefined : JSON.stringify(await snapshot())); return }
       if (path === '/api/events' && req.method === 'GET') {
         if (clients.size >= 32) { res.writeHead(503); res.end('Too many local viewer connections'); return }
@@ -183,13 +219,13 @@ export async function startStudioServer({ stateDir, host = '127.0.0.1', port = 4
         sendSnapshot(res, await snapshot())
         return
       }
-      const file = ({ '/': 'index.html', '/index.html': 'index.html', '/guide': 'guide.html', '/guide.html': 'guide.html', '/style.css': 'style.css', '/app.mjs': 'app.mjs' })[path]
+      const file = ({ '/': 'index.html', '/index.html': 'index.html', '/guide': 'guide.html', '/guide.html': 'guide.html', '/style.css': 'style.css', '/app.mjs': 'app.mjs', '/satoshi-400.woff2': 'satoshi-400.woff2', '/satoshi-500.woff2': 'satoshi-500.woff2', '/openvisio.svg': 'openvisio.svg' })[path]
       if (!file) { res.writeHead(404); res.end('Not found'); return }
       const target = await realpath(resolve(root, file))
       const rel = relative(root, target)
       if (rel.startsWith('..') || resolve(dirname(target)) !== root) { res.writeHead(403); res.end('Invalid asset'); return }
       const body = await readFile(target)
-      res.setHeader('content-type', file.endsWith('.css') ? 'text/css; charset=utf-8' : file.endsWith('.mjs') ? 'text/javascript; charset=utf-8' : 'text/html; charset=utf-8')
+      res.setHeader('content-type', file.endsWith('.svg') ? 'image/svg+xml' : file.endsWith('.woff2') ? 'font/woff2' : file.endsWith('.css') ? 'text/css; charset=utf-8' : file.endsWith('.mjs') ? 'text/javascript; charset=utf-8' : 'text/html; charset=utf-8')
       res.end(req.method === 'HEAD' ? undefined : body)
     } catch (error) {
       if (!res.headersSent) res.writeHead(error.code === 'ENOENT' ? 404 : 500)