@davait/aipictury 1.9.2

package/ext/dialogs.js

@@ -0,0 +1,803 @@
+'use strict'
+// The dialogs that open from the panel — Memory, Instructions, Slash commands, Report a
+// problem — built on the panel's one dialog component. Each is a spec (what to show) and a
+// handler (what each click does, returning the next spec, or null to close).
+const fs = require('fs')
+const os = require('os')
+const path = require('path')
+const vscode = require('vscode')
+const memory = require('./memory')
+const context = require('./context')
+const feedback = require('./feedback')
+const log = require('./log')
+const prefs = require('./prefs')
+const permissions = require('./permissions')
+const sandboxing = require('./sandbox')
+const mcp = require('./mcp')
+const plugins = require('./plugins')
+const usageLog = require('./usage')
+
+const config = () => vscode.workspace.getConfiguration('aipictury')
+const root = () => vscode.workspace.workspaceFolders?.[0]?.uri.fsPath || null
+const lines = (file) => { try { return fs.readFileSync(file, 'utf8').split('\n').length } catch { return 0 } }
+
+async function openFile(file, content) {
+  if (!fs.existsSync(file) && content !== undefined) {
+    fs.mkdirSync(path.dirname(file), { recursive: true })
+    fs.writeFileSync(file, content)
+  }
+  await vscode.window.showTextDocument(vscode.Uri.file(file), { preview: false })
+}
+
+// ---- Memory ----
+
+async function memorySpec(server, note) {
+  const [project, user] = await Promise.all([memory.projectRules(), memory.userRules(server)])
+  const forget = [{ id: 'forget', label: 'Forget', danger: true }]
+  return {
+    id: 'memory',
+    title: 'Memory',
+    note: note || 'Rules the agent always follows. Tip: start a message with # to remember something for this project, ## for everywhere.',
+    sections: [
+      { title: 'Remembering', items: [{ id: 'auto', label: 'Save a rule when you ask for one',
+        detail: 'When you say "always…" or "from now on…", the agent remembers it. Off: rules are added only by you, here.',
+        toggle: { on: config().get('autoMemory', true) } }] },
+      { title: 'This project', note: 'Kept in .aipictury/memory.md — commit it to share them.',
+        empty: 'No rules for this project yet.',
+        items: project.map((r) => ({ id: `p:${r}`, label: r, actions: forget })) },
+      { title: 'You, everywhere', note: 'Kept on your AIPictury server: every editor and the web app follow them.',
+        empty: 'No rules yet — or the server cannot be reached.',
+        items: user.map((r) => ({ id: `u:${r.id}`, label: r.text, actions: forget })) },
+      { title: 'File', items: [{ id: 'open', label: 'Open .aipictury/memory.md', open: true }] },
+    ],
+    form: {
+      title: 'Add a rule',
+      fields: [
+        { id: 'text', label: 'Rule', placeholder: 'e.g. Use pnpm, never npm' },
+        { id: 'scope', label: 'Applies to', value: 'project',
+          options: [{ value: 'project', label: 'This project' }, { value: 'user', label: 'Everywhere' }] },
+      ],
+      submit: { id: 'add', label: 'Remember' },
+    },
+  }
+}
+
+function memoryHandler(server) {
+  return async (action, message) => {
+    const item = String(message.item || '')
+    if (action === 'toggle' && item === 'auto') {
+      await config().update('autoMemory', !!message.value, vscode.ConfigurationTarget.Global)
+      return memorySpec(server, message.value ? 'The agent saves rules you ask it to remember.' : 'Only you add rules now.')
+    }
+    if (action === 'forget') {
+      if (item.startsWith('p:')) await memory.removeProjectRule(item.slice(2))
+      else if (item.startsWith('u:')) await memory.deleteUserRule(server, item.slice(2))
+      return memorySpec(server, 'Forgotten.')
+    }
+    if (action === 'open') {
+      const uri = memory.projectUri()
+      if (!uri) throw new Error('open a folder first')
+      await openFile(uri.fsPath, '# Rules for this project\n\n')
+      return null
+    }
+    if (action === 'add') {
+      const text = String(message.fields?.text || '').trim()
+      if (!text) throw new Error('write the rule first')
+      const said = message.fields?.scope === 'user' ? await memory.addUserRule(server, text) : await memory.addProjectRule(text)
+      return memorySpec(server, said || 'Remembered.')
+    }
+    return undefined
+  }
+}
+
+// ---- Instructions: AIPICTURY.md, AGENTS.md, CLAUDE.md… ----
+
+function instructionFiles() {
+  const dir = root()
+  const files = [{ id: 'home', name: '~/.aipictury/AIPICTURY.md', file: path.join(os.homedir(), '.aipictury', 'AIPICTURY.md'),
+    detail: 'yours, in every project' }]
+  if (dir) {
+    for (const name of context.INSTRUCTION_FILES) {
+      files.push({ id: name, name, file: path.join(dir, name),
+        detail: /CLAUDE/.test(name) ? 'written for Claude Code — read here too' : name === 'AGENTS.md' ? 'the shared agents file' : 'this project' })
+    }
+  }
+  return files
+}
+
+function instructionsSpec(note) {
+  const items = instructionFiles().map((f) => {
+    const n = lines(f.file)
+    const mine = f.id === 'home' || f.id === 'AIPICTURY.md'
+    return { id: f.id, label: f.name, detail: `${f.detail} · ${n ? `${n} lines, followed` : 'not there'}`,
+      badge: n ? 'in use' : undefined, badgeKind: n ? 'ok' : undefined, open: !!n,
+      actions: n ? [{ id: 'open', label: 'Open' }]
+        : mine ? [{ id: 'create', label: 'Create' }, ...(f.id === 'AIPICTURY.md' ? [{ id: 'init', label: 'Have the agent write it' }] : [])] : [] }
+  })
+  return {
+    id: 'instructions',
+    title: 'Instructions',
+    note: note || 'Files the agent reads at the start of every step and always follows. Edits apply from the next step.',
+    sections: [{ items }],
+  }
+}
+
+function instructionsHandler(panel) {
+  return async (action, message) => {
+    const f = instructionFiles().find((x) => x.id === message.item)
+    if (!f) return undefined
+    if (action === 'open') { await openFile(f.file); return null }
+    if (action === 'create') {
+      await openFile(f.file, `# ${path.basename(f.file)}\n\nThis file guides AI coding agents working ${f.id === 'home' ? 'in every project' : 'in this repository'}.\n`)
+      return null
+    }
+    if (action === 'init') { panel.post({ type: 'draft', text: '/init' }); return null }
+    return undefined
+  }
+}
+
+// ---- Slash commands ----
+
+const COMMAND_NAME = /^[\w.-]{1,40}$/
+
+function slashSpec(builtIn, note) {
+  const use = [{ id: 'use', label: 'Use' }]
+  return {
+    id: 'slash',
+    title: 'Slash commands',
+    note: note || 'Type / in the input to use one. Your own commands are prompts kept as Markdown files.',
+    sections: [
+      { title: 'Built in', items: builtIn.map(([name, description, hint]) => ({ id: `b:${name}`, label: `/${name}${hint ? ` ${hint}` : ''}`, detail: description, actions: use })) },
+      { title: 'Yours', note: 'In .aipictury/commands/ (or .claude/commands/) of the project, or of your home folder. $ARGUMENTS stands for what follows the command.',
+        empty: 'None yet — add one below.',
+        items: context.commands().map((c) => ({ id: `c:${c.name}`, label: `/${c.name}${c.hint ? ` ${c.hint}` : ''}`, detail: c.description,
+          badge: /[\\/]\.claude[\\/]/.test(c.file) ? 'Claude Code' : undefined, actions: [...use, { id: 'edit', label: 'Edit' }] })) },
+      { title: 'Skills', empty: 'No skills. A skill is .aipictury/skills/<name>/SKILL.md, with a name and a description.',
+        items: context.skills().map((s) => ({ id: `s:${s.name}`, label: `/${s.name}`, detail: s.description, actions: [...use, { id: 'edit', label: 'Edit' }] })) },
+    ],
+    form: {
+      title: 'New command',
+      fields: [
+        { id: 'name', label: 'Name', placeholder: 'e.g. test-changed' },
+        { id: 'description', label: 'What it does', placeholder: 'e.g. Run the tests for the files I changed' },
+        { id: 'prompt', label: 'The prompt', multiline: true, rows: 4, placeholder: 'e.g. Find the tests for the files changed in git diff and run them. $ARGUMENTS' },
+        { id: 'where', label: 'Kept', value: 'project', options: [{ value: 'project', label: 'In this project' }, { value: 'user', label: 'For me, everywhere' }] },
+      ],
+      submit: { id: 'create', label: 'Create' },
+    },
+  }
+}
+
+function slashHandler(panel, builtIn) {
+  return async (action, message) => {
+    const item = String(message.item || '')
+    const name = item.slice(2)
+    if (action === 'use') { panel.post({ type: 'draft', text: `/${name} ` }); return null }
+    if (action === 'edit') {
+      const found = item.startsWith('c:') ? context.commands().find((c) => c.name === name) : context.skills().find((s) => s.name === name)
+      if (found) await openFile(found.file)
+      return null
+    }
+    if (action === 'create') {
+      const f = message.fields || {}
+      const clean = String(f.name || '').trim().replace(/^\//, '')
+      if (!COMMAND_NAME.test(clean)) throw new Error('a name is letters, digits, - _ or . (up to 40)')
+      if (builtIn.some(([b]) => b === clean)) throw new Error(`/${clean} is built in — choose another name`)
+      const prompt = String(f.prompt || '').trim()
+      if (!prompt) throw new Error('write the prompt the command stands for')
+      const base = f.where === 'user' ? os.homedir() : root()
+      if (!base) throw new Error('open a folder first, or keep it for you everywhere')
+      const file = path.join(base, '.aipictury', 'commands', `${clean}.md`)
+      if (fs.existsSync(file)) throw new Error(`/${clean} already exists — edit it instead`)
+      const description = String(f.description || '').trim().replace(/\n/g, ' ')
+      fs.mkdirSync(path.dirname(file), { recursive: true })
+      fs.writeFileSync(file, `${description ? `---\ndescription: ${description}\n---\n\n` : ''}${prompt}\n`)
+      panel.postCommands?.()
+      return slashSpec(builtIn, `Created /${clean} (${path.relative(base, file)}).`)
+    }
+    return undefined
+  }
+}
+
+// ---- Permissions: the allow, ask and deny rules of every settings file ----
+
+const KINDS = [
+  { id: 'allow', label: 'Allow', note: 'Done without asking — in any mode but Plan.' },
+  { id: 'ask', label: 'Ask', note: 'Always asked first, even in Auto mode and for reads.' },
+  { id: 'deny', label: 'Deny', note: 'Never done, whatever the mode. Deny beats ask beats allow.' },
+]
+const LEVEL_NAMES = { user: 'You, everywhere', project: 'This project (shared)', local: 'This project, just you' }
+
+function permissionsSpec(folder, { tab = 'allow', note } = {}) {
+  const merged = prefs.load(folder).merged.permissions
+  const kind = KINDS.find((k) => k.id === tab) || KINDS[0]
+  const items = (merged[kind.id] || []).map((r) => ({
+    id: JSON.stringify([r.level, r.rule, r.file]),
+    label: r.rule,
+    detail: `${LEVEL_NAMES[r.level] || r.level} · ${r.file.replace(os.homedir(), '~')}`,
+    badge: r.editable ? undefined : 'Claude Code', badgeKind: r.editable ? undefined : 'info',
+    readOnly: !r.editable, readOnlyNote: r.editable ? undefined : 'read-only here',
+    actions: [{ id: 'remove', label: 'Remove', danger: true }, { id: 'openFile', label: 'Open file', always: true }],
+  }))
+  return {
+    id: 'permissions',
+    title: 'Permissions',
+    note: note || 'Rules in Claude Code\'s syntax: Bash(npm run test:*), Read(./.env), Edit(src/**), WebFetch(domain:github.com), mcp__server. Claude Code\'s own files are read too, never written.',
+    tabs: KINDS.map((k) => ({ id: k.id, label: `${k.label} (${(merged[k.id] || []).length})` })),
+    tab: kind.id,
+    sections: [{ note: kind.note, empty: `No ${kind.label.toLowerCase()} rules yet.`, items }],
+    form: {
+      title: `Add a rule to ${kind.label}`,
+      fields: [
+        { id: 'rule', label: 'Rule', placeholder: kind.id === 'deny' ? 'e.g. Read(./.env)' : 'e.g. Bash(npm run test:*)' },
+        { id: 'level', label: 'Kept', value: 'local', options: [{ value: 'local', label: LEVEL_NAMES.local },
+          { value: 'project', label: LEVEL_NAMES.project }, { value: 'user', label: LEVEL_NAMES.user }] },
+      ],
+      submit: { id: 'add', label: 'Add rule' },
+    },
+  }
+}
+
+function permissionsHandler(folder) {
+  let tab = 'allow'
+  const spec = (note) => permissionsSpec(folder, { tab, note })
+  return async (action, message) => {
+    if (action === 'tab') { tab = message.value; return spec() }
+    if (action === 'add') {
+      const rule = String(message.fields?.rule || '').trim()
+      if (!permissions.parseRule(rule) || !rule) throw new Error('write a rule like Bash(npm test:*) or Read(./.env)')
+      if (!folder && message.fields?.level !== 'user') throw new Error('open a folder for a project rule, or keep it for you everywhere')
+      const file = prefs.addRule(folder, message.fields?.level || 'local', tab, rule)
+      return spec(`Added ${rule} to ${tab} (${path.basename(file)}).`)
+    }
+    const [level, rule, file] = (() => { try { return JSON.parse(message.item || '[]') } catch { return [] } })()
+    if (action === 'openFile' && file) { await openFile(file); return null }
+    if (action === 'remove' && rule) {
+      const source = prefs.sources(folder).find((x) => x.file === file)
+      if (!source?.editable) throw new Error('that rule is in Claude Code\'s file — change it there')
+      prefs.removeRule(folder, level, tab, rule)
+      return spec(`Removed ${rule}.`)
+    }
+    return undefined
+  }
+}
+
+// ---- Hooks: commands that run at moments of the agent's work ----
+
+const HOOK_EVENTS = [
+  ['PreToolUse', 'Before a tool runs — can block it (exit 2) or decide allow/ask/deny'],
+  ['PostToolUse', 'After a tool ran — what it says reaches the model'],
+  ['UserPromptSubmit', 'When you send a message — can stop it, or add context'],
+  ['Stop', 'When the agent is about to finish — can make it carry on'],
+  ['SubagentStop', 'When a helper agent is about to report'],
+  ['SessionStart', 'When a conversation starts or resumes — its output is context'],
+  ['SessionEnd', 'When a conversation is cleared'],
+  ['Notification', 'When the agent waits for you'],
+  ['PreCompact', 'Before the conversation is summarized'],
+]
+const TOOL_EVENTS = new Set(['PreToolUse', 'PostToolUse'])
+
+function hooksSpec(folder, { tab = 'PreToolUse', note } = {}) {
+  const configured = prefs.load(folder).merged.hooks || {}
+  const [event, about] = HOOK_EVENTS.find(([e]) => e === tab) || HOOK_EVENTS[0]
+  const items = (configured[event] || []).flatMap((group) => (group.hooks || []).map((h) => ({
+    id: JSON.stringify([group.level, group.file, group.matcher ?? '', h.command]),
+    label: h.command,
+    detail: `${TOOL_EVENTS.has(event) ? `matcher ${group.matcher || '(every tool)'} · ` : ''}${h.timeout ? `${h.timeout} s · ` : ''}`
+      + `${LEVEL_NAMES[group.level] || group.level} · ${group.file.replace(os.homedir(), '~')}`,
+    badge: group.editable ? undefined : 'Claude Code', badgeKind: group.editable ? undefined : 'info',
+    readOnly: !group.editable, readOnlyNote: group.editable ? undefined : 'read-only here',
+    actions: [{ id: 'remove', label: 'Remove', danger: true }, { id: 'openFile', label: 'Open file', always: true }],
+  })))
+  const fields = [{ id: 'command', label: 'Command', placeholder: 'e.g. npx prettier --write "$(jq -r .tool_input.file_path)"' }]
+  if (TOOL_EVENTS.has(event)) fields.push({ id: 'matcher', label: 'For tools (a regular expression)', placeholder: 'e.g. Bash or Edit|Write — empty for every tool' })
+  fields.push({ id: 'timeout', label: 'Timeout (seconds)', placeholder: '60' },
+    { id: 'level', label: 'Kept', value: 'local', options: [{ value: 'local', label: LEVEL_NAMES.local },
+      { value: 'project', label: LEVEL_NAMES.project }, { value: 'user', label: LEVEL_NAMES.user }] })
+  return {
+    id: 'hooks',
+    title: 'Hooks',
+    note: note || 'Your commands, run as the agent works — Claude Code\'s format, its files read too. A hook gets the event as JSON on stdin; exit 2 blocks, with stderr as the reason. A project\'s own hooks run only once you trust them.',
+    tabs: HOOK_EVENTS.map(([e]) => ({ id: e, label: `${e}${(configured[e] || []).length ? ` (${(configured[e] || []).reduce((n, g) => n + (g.hooks || []).length, 0)})` : ''}` })),
+    tab: event,
+    sections: [{ note: about, empty: `No ${event} hooks.`, items }],
+    form: { title: `Add a ${event} hook`, fields, submit: { id: 'add', label: 'Add hook' } },
+  }
+}
+
+function hooksHandler(folder) {
+  let tab = 'PreToolUse'
+  const spec = (note) => hooksSpec(folder, { tab, note })
+  return async (action, message) => {
+    if (action === 'tab') { tab = message.value; return spec() }
+    if (action === 'add') {
+      const f = message.fields || {}
+      const command = String(f.command || '').trim()
+      if (!command) throw new Error('write the command to run')
+      const matcher = TOOL_EVENTS.has(tab) ? String(f.matcher || '').trim() : ''
+      if (matcher) { try { new RegExp(matcher) } catch { throw new Error(`"${matcher}" is not a regular expression`) } }
+      const timeout = f.timeout ? Number(f.timeout) : undefined
+      if (timeout !== undefined && !(timeout > 0 && timeout <= 3600)) throw new Error('a timeout is 1 to 3600 seconds')
+      if (!folder && (f.level || 'local') !== 'user') throw new Error('open a folder for a project hook, or keep it for you everywhere')
+      prefs.edit(folder, f.level || 'local', (data) => {
+        const groups = ((data.hooks ||= {})[tab] ||= [])
+        let group = groups.find((g) => (g.matcher || '') === matcher)
+        if (!group) { group = matcher ? { matcher, hooks: [] } : { hooks: [] }; groups.push(group) }
+        group.hooks.push({ type: 'command', command, ...(timeout ? { timeout } : {}) })
+      })
+      return spec(`Added a ${tab} hook.`)
+    }
+    const [level, file, matcher, command] = (() => { try { return JSON.parse(message.item || '[]') } catch { return [] } })()
+    if (action === 'openFile' && file) { await openFile(file); return null }
+    if (action === 'remove' && command) {
+      const source = prefs.sources(folder).find((x) => x.file === file)
+      if (!source?.editable) throw new Error('that hook is in Claude Code\'s file — change it there')
+      prefs.edit(folder, level, (data) => {
+        const groups = data.hooks?.[tab] || []
+        for (const g of groups) if ((g.matcher || '') === matcher) g.hooks = (g.hooks || []).filter((h) => h.command !== command)
+        data.hooks[tab] = groups.filter((g) => (g.hooks || []).length)
+        if (!data.hooks[tab].length) delete data.hooks[tab]
+      })
+      return spec('Removed.')
+    }
+    return undefined
+  }
+}
+
+// ---- /usage ----
+
+function usageSpec(tab = 'conversation', { conversation = {}, context = 0, records } = {}) {
+  const k = (n) => (n >= 10_000 ? `${Math.round(n / 1000)}k` : String(n))
+  const rows = (list, what) => list.slice(0, 12).map(([name, n]) => ({ id: `${what}:${name}`, label: name, detail: `${n} time${n === 1 ? '' : 's'}` }))
+  if (tab === 'conversation') {
+    const u = conversation
+    return { id: 'usage', title: 'Usage', tab, tabs: USAGE_TABS,
+      note: 'Everything runs on your own GPU: no cost, no plan limits.',
+      sections: [{ items: [
+        { id: 'turns', label: `${u.turns || 0} turns · ${Math.round(u.seconds || 0)} s of model time`, detail: `${k(u.prompt || 0)} prompt tokens · ${k(u.output || 0)} written${u.output && u.genSeconds ? ` · ${(u.output / u.genSeconds).toFixed(1)} tokens/s` : ''}` },
+        { id: 'context', label: `Context now: ~${k(context)} tokens`, detail: 'the conversation so far, as the model reads it' },
+      ] }] }
+  }
+  const s = usageLog.summary(tab === 'week' ? 'week' : 'today', records ? { records } : {})
+  return { id: 'usage', title: 'Usage', tab, tabs: USAGE_TABS,
+    note: `${s.turns} turns in ${s.conversations} conversation(s) · ${k(s.context)} prompt tokens (${s.read === 0 ? 'none' : k(s.read)} read anew) · ${k(s.output)} written · ${Math.round(s.genSeconds)} s writing`,
+    sections: [
+      { title: 'Worth knowing', empty: 'Nothing: the prompt cache served the conversations, and none ran out of room.', items: s.flags.map((f, i) => ({ id: `flag${i}`, label: f })) },
+      { title: 'Tools', empty: 'None used.', items: rows(s.tools, 'tool') },
+      { title: 'Helpers', empty: 'None.', items: rows(s.helpers, 'helper') },
+      { title: 'MCP servers', empty: 'None.', items: rows(s.mcp, 'mcp') },
+      { title: 'Skills', empty: 'None.', items: rows(s.skills, 'skill') },
+    ] }
+}
+const USAGE_TABS = [{ id: 'conversation', label: 'This conversation' }, { id: 'today', label: 'Today' }, { id: 'week', label: 'This week' }]
+
+// ---- Published pages ----
+
+async function pagesSpec(server, note, fetchImpl = fetch) {
+  let items = []
+  let problem = ''
+  try {
+    const r = await fetchImpl(`${server}/api/pages`)
+    if (!r.ok) throw new Error(`the server answered ${r.status}`)
+    items = (await r.json()).pages || []
+  } catch (error) { problem = error.message }
+  return {
+    id: 'pages', title: 'Published pages',
+    note: note || (problem ? `The server cannot be reached: ${problem}` : 'Pages the agent published on your server — private: only those with the link can open them.'),
+    sections: [{ empty: 'None yet — the agent publishes one with publish_page.', items: items.map((p) => ({ id: p.id, label: p.title,
+      detail: `${new Date((p.created || 0) * 1000).toLocaleString()} · ${Math.round((p.bytes || 0) / 1024)} KB · ${server}/p/${p.id}`,
+      actions: [{ id: 'open', label: 'Open', always: true }, { id: 'delete', label: 'Delete', danger: true }] })) }],
+  }
+}
+
+function pagesHandler(server, fetchImpl = fetch) {
+  return async (action, message) => {
+    if (action === 'open') { await vscode.env.openExternal(vscode.Uri.parse(`${server}/p/${message.item}`)); return undefined }
+    if (action === 'delete') {
+      const r = await fetchImpl(`${server}/api/pages/${encodeURIComponent(message.item)}`, { method: 'DELETE' })
+      if (!r.ok) throw new Error(`the server answered ${r.status}`)
+      return pagesSpec(server, 'Deleted — the link no longer opens it.', fetchImpl)
+    }
+    return undefined
+  }
+}
+
+// ---- The agent map: helpers and background commands ----
+
+function agentsSpec(panel, note) {
+  const helpers = [...(panel.session?.helpers?.values() || [])]
+  const shell = require('./shell')
+  const commands = shell.taskList()
+  const secs = (from) => `${Math.round((Date.now() - from) / 1000)} s`
+  return {
+    id: 'agents', title: 'Agents',
+    note: note || 'The helpers of this conversation and the commands running in the background.',
+    sections: [
+      { title: 'Helpers', empty: 'No helpers yet — the agent starts them with the task tool.',
+        items: helpers.map((h) => ({ id: h.id, label: `${h.id}${h.name ? ` · ${h.name}` : ''} — ${h.role || h.type}`,
+          detail: `${h.status}${h.background ? ' (background)' : ''} · ${h.state.steps} steps · ${h.state.tokens} tokens · ${secs(h.started)}`
+            + `${h.state.last ? ` · now: ${h.state.last}` : ''} · ${h.description}`,
+          badge: h.status, badgeKind: h.status === 'running' ? 'info' : h.status === 'done' ? 'ok' : 'bad',
+          actions: [{ id: 'transcript', label: 'Transcript', always: true }, ...(h.status === 'running' ? [{ id: 'stop', label: 'Stop', danger: true }] : [])] })) },
+      { title: 'Background commands', empty: 'None.',
+        items: commands.map((c) => ({ id: c.id, label: `${c.id} — ${c.command.slice(0, 80)}`,
+          detail: c.running ? `running · ${c.seconds} s` : `exited: ${c.exit}`, actions: c.running ? [{ id: 'kill', label: 'Stop', danger: true }] : [] })) },
+    ],
+  }
+}
+
+function agentsHandler(panel) {
+  return async (action, message) => {
+    const h = panel.session?.helpers?.get(message.item)
+    if (action === 'stop' && h) { h.controller?.abort(); return agentsSpec(panel, `${h.id} stopped.`) }
+    if (action === 'kill') { require('./shell').killShell({ shell_id: message.item }); return agentsSpec(panel, `${message.item} stopped.`) }
+    if (action === 'transcript' && h) {
+      const lines = h.messages.slice(1).map((m) => (m.role === 'tool' ? `> **${m.tool_name}** →\n> ${String(m.content).slice(0, 2000).replace(/\n/g, '\n> ')}`
+        : `**${m.role === 'assistant' ? h.id : 'Task'}**: ${String(m.content || '').trim()}${m.tool_calls?.length ? `\n\n_calls: ${m.tool_calls.map((c) => c.function.name).join(', ')}_` : ''}`))
+      const doc = await vscode.workspace.openTextDocument({ language: 'markdown', content: `# ${h.id}${h.name ? ` (${h.name})` : ''} — ${h.description}\n\n${lines.join('\n\n')}\n` })
+      await vscode.window.showTextDocument(doc, { preview: true })
+      return null
+    }
+    return undefined
+  }
+}
+
+// ---- Plugins and marketplaces (Claude Code's format) ----
+
+function pluginsSpec(folder, { tab = 'installed', note } = {}) {
+  const on = new Set(plugins.enabled(folder).map((p) => p.id))
+  const have = plugins.installed()
+  const known = plugins.marketplaces()
+  const offered = plugins.available()
+  let sections
+  let form
+  if (tab === 'installed') {
+    sections = [{ empty: 'No plugins yet — add a marketplace, then install from Discover.',
+      items: Object.entries(have).map(([id, x]) => ({ id, label: id, detail: `${x.version ? `v${x.version} · ` : ''}${x.description}`,
+        toggle: { on: on.has(id) }, actions: [{ id: 'update', label: 'Update' }, { id: 'uninstall', label: 'Uninstall', danger: true }] })) }]
+  } else if (tab === 'discover') {
+    sections = [{ empty: Object.keys(known).length ? 'Every plugin is installed.' : 'Add a marketplace first (Marketplaces).',
+      items: offered.filter((p) => !p.installed).map((p) => ({ id: p.id, label: p.id, detail: `${p.category ? `${p.category} · ` : ''}${p.description}`.slice(0, 300),
+        actions: [{ id: 'install', label: 'Install for me' }, { id: 'installProject', label: 'For this project' }] })) }]
+  } else {
+    sections = [{ empty: 'No marketplace yet.', items: Object.entries(known).map(([name, m]) => ({ id: name, label: name,
+      detail: `${m.label} · ${offered.filter((p) => p.market === name).length} plugins`,
+      actions: [{ id: 'updateMarket', label: 'Update' }, { id: 'removeMarket', label: 'Remove', danger: true }] })) }]
+    form = { title: 'Add a marketplace', fields: [{ id: 'source', label: 'GitHub owner/repo, a git URL, or a folder', placeholder: 'e.g. anthropics/claude-code' }],
+      submit: { id: 'addMarket', label: 'Add' } }
+  }
+  return {
+    id: 'plugins', title: 'Plugins',
+    note: note || 'Commands, helper agents, skills, hooks and MCP servers, packaged — in Claude Code\'s format, so its plugins work here.',
+    tabs: [{ id: 'installed', label: `Installed (${Object.keys(have).length})` }, { id: 'discover', label: 'Discover' }, { id: 'marketplaces', label: `Marketplaces (${Object.keys(known).length})` }],
+    tab, sections, form,
+  }
+}
+
+function pluginsHandler(folder, { changed = () => {} } = {}) {
+  let tab = 'installed'
+  const spec = (note) => pluginsSpec(folder, { tab, note })
+  return async (action, message) => {
+    const id = String(message.item || '')
+    if (action === 'tab') { tab = message.value; return spec() }
+    if (action === 'toggle') { plugins.setEnabled(id, !!message.value, { folder, level: folder ? 'local' : 'user' }); changed(); return spec(`${id} is ${message.value ? 'on' : 'off'}.`) }
+    if (action === 'install' || action === 'installProject') {
+      const done = await plugins.install(id, { folder, level: action === 'install' ? 'user' : 'project' })
+      changed()
+      return spec(`Installed ${id}${done.version ? ` v${done.version}` : ''}${action === 'install' ? '' : ' for this project'}.`)
+    }
+    if (action === 'update') { const level = 'user'; await plugins.install(id, { folder, level }); changed(); return spec(`Updated ${id}.`) }
+    if (action === 'uninstall') { plugins.uninstall(id, { folder }); changed(); return spec(`Uninstalled ${id}.`) }
+    if (action === 'addMarket') {
+      const source = String(message.fields?.source || '').trim()
+      if (!source) throw new Error('write owner/repo, a git URL or a folder')
+      const m = await plugins.addMarketplace(source)
+      tab = 'discover'
+      return spec(`Added ${m.name}: ${m.plugins} plugins.`)
+    }
+    if (action === 'updateMarket') { const m = await plugins.updateMarketplace(id); return spec(`Updated ${m.name}: ${m.plugins} plugins.`) }
+    if (action === 'removeMarket') { plugins.removeMarketplace(id); changed(); return spec(`Removed ${id} and its plugins.`) }
+    return undefined
+  }
+}
+
+// ---- Skills: which the model sees, and how ----
+
+const SHOW = [{ value: 'on', label: 'On' }, { value: 'name', label: 'Name only' }, { value: 'off', label: 'Off' }]
+
+function skillsSpec(folder, note) {
+  const seen = context.skillVisibility()
+  return {
+    id: 'skills',
+    title: 'Skills',
+    note: note || 'Instructions (and files) for a kind of task, used when a task matches. On: the model sees the name and description; name only: just the name; off: hidden.',
+    sections: [{ empty: 'No skills yet — create one below, or add .aipictury/skills/<name>/SKILL.md (or .claude/skills/…).',
+      items: context.skills().map((x) => ({ id: x.name, label: x.name, detail: `${x.description || '(no description)'} · ${x.file.replace(os.homedir(), '~')}`,
+        badge: /[\\/]\.claude[\\/]/.test(x.file) ? 'Claude Code' : undefined, badgeKind: 'info',
+        select: { label: 'shown', value: seen[x.name] || 'on', options: SHOW, action: 'show' },
+        actions: [{ id: 'edit', label: 'Edit', always: true }] })) }],
+    form: { title: 'Create a skill', fields: [
+      { id: 'name', label: 'Name', placeholder: 'e.g. release-notes' },
+      { id: 'description', label: 'When to use it', placeholder: 'e.g. Writing release notes from the git log' },
+      { id: 'body', label: 'What to do', multiline: true, rows: 5, placeholder: 'The steps, the format, what to check…' },
+      { id: 'where', label: 'Kept', value: 'project', options: [{ value: 'project', label: 'In this project' }, { value: 'user', label: 'For me, everywhere' }] },
+    ], submit: { id: 'create', label: 'Create skill' } },
+  }
+}
+
+function skillsHandler(folder) {
+  return async (action, message) => {
+    if (action === 'show') {
+      prefs.edit(folder, folder ? 'local' : 'user', (data) => { data.skillVisibility = { ...(data.skillVisibility || {}), [message.item]: message.value } })
+      return skillsSpec(folder, `${message.item}: ${SHOW.find((x) => x.value === message.value)?.label.toLowerCase()}.`)
+    }
+    if (action === 'edit') { const x = context.skills().find((k) => k.name === message.item); if (x) await openFile(x.file); return null }
+    if (action === 'create') {
+      const f = message.fields || {}
+      const name = String(f.name || '').trim()
+      if (!/^[a-z0-9][\w-]{0,39}$/i.test(name)) throw new Error('a skill name is letters, digits, - or _ (up to 40)')
+      if (!String(f.description || '').trim()) throw new Error('say when to use it: the model decides from that')
+      const baseDir = f.where === 'user' ? os.homedir() : folder
+      if (!baseDir) throw new Error('open a folder, or keep it for you everywhere')
+      const file = path.join(baseDir, '.aipictury', 'skills', name, 'SKILL.md')
+      if (fs.existsSync(file)) throw new Error(`${name} already exists — edit it instead`)
+      fs.mkdirSync(path.dirname(file), { recursive: true })
+      fs.writeFileSync(file, `---\nname: ${name}\ndescription: ${String(f.description).trim().replace(/\n/g, ' ')}\n---\n\n${String(f.body || '').trim()}\n`)
+      return skillsSpec(folder, `Created ${name}.`)
+    }
+    return undefined
+  }
+}
+
+// ---- Output styles: how the agent writes ----
+
+function outputStyleSpec(folder, note) {
+  const now = context.outputStyle().name
+  return {
+    id: 'output-style',
+    title: 'Output style',
+    note: note || `In use: ${now}. A style changes how the agent writes its answers, not what it can do.`,
+    sections: [{ items: context.outputStyles().map((x) => ({ id: x.name, label: x.name, detail: `${x.description || ''}${x.file ? ` · ${x.file.replace(os.homedir(), '~')}` : ' · built in'}`,
+      badge: x.name === now ? 'in use' : undefined, badgeKind: 'ok',
+      actions: [...(x.name === now ? [] : [{ id: 'use', label: 'Use' }]), ...(x.file ? [{ id: 'edit', label: 'Edit', always: true }] : [])] })) }],
+    form: { title: 'Build a custom style', fields: [
+      { id: 'name', label: 'Name', placeholder: 'e.g. Terse' },
+      { id: 'description', label: 'What it is', placeholder: 'e.g. Answers in as few words as possible' },
+      { id: 'body', label: 'How to write', multiline: true, rows: 5, placeholder: 'e.g. Answer in at most three sentences. No preamble, no recap.' },
+    ], submit: { id: 'create', label: 'Create and use' } },
+  }
+}
+
+function outputStyleHandler(folder) {
+  const use = (name) => prefs.edit(folder, folder ? 'local' : 'user', (data) => { if (name === 'Default') delete data.outputStyle; else data.outputStyle = name })
+  return async (action, message) => {
+    if (action === 'use') { use(message.item); return outputStyleSpec(folder, `${message.item} is in use from the next message.`) }
+    if (action === 'edit') { const x = context.outputStyles().find((k) => k.name === message.item); if (x?.file) await openFile(x.file); return null }
+    if (action === 'create') {
+      const f = message.fields || {}
+      const name = String(f.name || '').trim()
+      if (!/^[\w][\w -]{0,39}$/.test(name)) throw new Error('a style name is letters, digits, spaces, - or _ (up to 40)')
+      if (context.outputStyles().some((x) => x.name.toLowerCase() === name.toLowerCase())) throw new Error(`${name} already exists`)
+      if (!String(f.body || '').trim()) throw new Error('say how the agent should write')
+      if (!folder) throw new Error('open a folder first')
+      const file = path.join(folder, '.aipictury', 'output-styles', `${name.toLowerCase().replace(/\s+/g, '-')}.md`)
+      fs.mkdirSync(path.dirname(file), { recursive: true })
+      fs.writeFileSync(file, `---\nname: ${name}\ndescription: ${String(f.description || '').trim().replace(/\n/g, ' ')}\n---\n\n${String(f.body).trim()}\n`)
+      use(name)
+      return outputStyleSpec(folder, `Created ${name} — in use from the next message.`)
+    }
+    return undefined
+  }
+}
+
+// ---- MCP servers ----
+
+const SCOPES = [['local', 'This project, just you'], ['project', 'This project, shared (.mcp.json)'], ['user', 'You, everywhere']]
+
+/** "npx -y @org/server --flag 'a b'" → ['npx', '-y', '@org/server', '--flag', 'a b'] */
+function splitCommandLine(text) {
+  const out = []
+  for (const m of String(text).matchAll(/"((?:[^"\\]|\\.)*)"|'([^']*)'|(\S+)/g)) out.push(m[1] ?? m[2] ?? m[3])
+  return out
+}
+
+function mcpSpec(folder, note) {
+  const live = new Map(mcp.status().map((x) => [x.name, x]))
+  const all = [...mcp.detailed(folder).values()]
+  return {
+    id: 'mcp',
+    title: 'MCP servers',
+    note: note || 'Tools from outside — a database, GitHub, a browser — in Claude Code\'s format. A project\'s servers start programs from the repository: they connect once you trust them.',
+    sections: SCOPES.map(([scope, title]) => ({
+      title,
+      empty: scope === 'project' ? 'None in .mcp.json.' : 'None.',
+      items: all.filter((x) => x.scope === scope).map((x) => {
+        const st = x.disabled ? { state: 'off' } : live.get(x.name) || { state: 'not connected' }
+        const what = x.config.command ? [x.config.command, ...(x.config.args || [])].join(' ') : x.config.url || ''
+        return {
+          id: x.name,
+          label: x.name,
+          detail: `${st.state === 'connected' ? `${st.tools.length} tools` : st.state}${st.error ? ` — ${st.error}` : ''} · ${what.slice(0, 80)} · ${x.origin}${x.file.startsWith('aipictury.') ? '' : ` · ${x.file.replace(os.homedir(), '~')}`}`,
+          badge: st.state === 'connected' ? 'connected' : st.state === 'failed' ? 'failed' : st.state === 'untrusted' ? 'not trusted' : st.state === 'needs-auth' ? 'sign in' : undefined,
+          badgeKind: st.state === 'connected' ? 'ok' : st.state === 'failed' ? 'bad' : 'info',
+          toggle: { on: !x.disabled },
+          actions: [
+            ...(st.state === 'untrusted' ? [{ id: 'trust', label: 'Trust', always: true }] : []),
+            ...(st.state === 'needs-auth' ? [{ id: 'signin', label: 'Sign in', always: true }] : []),
+            ...(x.config.url && st.state === 'connected' ? [{ id: 'signout', label: 'Sign out', always: true }] : []),
+            { id: 'reconnect', label: 'Reconnect', always: true },
+            ...(x.editable ? [{ id: 'remove', label: 'Remove', danger: true }] : []),
+            ...(x.file.startsWith('aipictury.') || x.origin === 'plugin' ? [] : [{ id: 'openFile', label: 'Open file', always: true }]),
+          ],
+        }
+      }),
+    })),
+    form: {
+      title: 'Add a server',
+      fields: [
+        { id: 'name', label: 'Name', placeholder: 'e.g. github' },
+        { id: 'target', label: 'Command, or URL', placeholder: 'e.g. npx -y @modelcontextprotocol/server-filesystem . — or https://…/mcp' },
+        { id: 'scope', label: 'Kept', value: 'local', options: SCOPES.map(([value, label]) => ({ value, label })) },
+      ],
+      submit: { id: 'add', label: 'Add and connect' },
+    },
+  }
+}
+
+function mcpHandler(folder, { trust } = {}) {
+  const refresh = async (note) => { await mcp.ensure({ trust }).catch(() => {}); return mcpSpec(folder, note) }
+  return async (action, message) => {
+    const name = String(message.item || '')
+    if (action === 'toggle') { mcp.setEnabled(folder, name, !!message.value); return refresh(`${name} is ${message.value ? 'on' : 'off'}.`) }
+    if (action === 'reconnect') { const e = await mcp.reconnect(name); return mcpSpec(folder, e ? `${name}: ${e.state}${e.error ? ` — ${e.error}` : ''}` : `${name} is off.`) }
+    if (action === 'remove') { mcp.remove(folder, name); return refresh(`Removed ${name}.`) }
+    if (action === 'trust') return refresh()
+    if (action === 'signin') { const e = await mcp.signIn(name); return mcpSpec(folder, `${name}: ${e?.state === 'connected' ? `signed in — ${e.tools.length} tools` : e?.error || 'not connected'}`) }
+    if (action === 'signout') { await mcp.signOut(name); return mcpSpec(folder, `Signed out of ${name}.`) }
+    if (action === 'openFile') { const x = mcp.detailed(folder).get(name); if (x) await openFile(x.file); return null }
+    if (action === 'add') {
+      const f = message.fields || {}
+      const id = String(f.name || '').trim()
+      const target = String(f.target || '').trim()
+      if (!id) throw new Error('give the server a name')
+      if (!target) throw new Error('write the command that starts it, or its URL')
+      const config = /^https?:\/\//i.test(target) ? { type: 'http', url: target }
+        : (() => { const [command, ...args] = splitCommandLine(target); return { command, args } })()
+      mcp.save(folder, f.scope || 'local', id, config)
+      const spec = await refresh()
+      const st = mcp.status().find((x) => x.name === id)
+      spec.note = `Added ${id}: ${st ? `${st.state}${st.state === 'connected' ? ` — ${st.tools.length} tools` : st.error ? ` — ${st.error}` : ''}` : 'saved'}.`
+      return spec
+    }
+    return undefined
+  }
+}
+
+// ---- The sandbox for commands ----
+
+function sandboxSpec(note) {
+  const c = config()
+  const kind = sandboxing.available()
+  const toggle = (id, label, detail, key, on) => ({ id, label, detail, toggle: { on: c.get(key, on) } })
+  return {
+    id: 'sandbox',
+    title: 'Sandbox',
+    note: note || (kind ? `This machine has a sandbox (${kind === 'macos' ? 'sandbox-exec' : 'bubblewrap'}).`
+      : 'This machine has no sandbox (sandbox-exec on macOS, bubblewrap on Linux): with it on, every command is asked.'),
+    sections: [
+      { items: [
+        toggle('enabled', 'Run commands in the sandbox', 'They can write only inside the workspace and the temp folders.', 'sandbox.enabled', false),
+        toggle('allowNetwork', 'Let them reach the internet', 'Off: only this machine (localhost) is reachable.', 'sandbox.allowNetwork', false),
+        toggle('autoAllow', 'Run sandboxed commands without asking', 'Only with the internet off; deny and ask rules still apply.', 'sandbox.autoAllow', true),
+      ] },
+      { title: 'Left out of the sandbox', note: 'These commands run outside it, asked as usual.', empty: 'None.',
+        items: c.get('sandbox.excludedCommands', []).map((x) => ({ id: x, label: x, actions: [{ id: 'remove', label: 'Remove', danger: true }] })) },
+    ],
+    form: { title: 'Leave a command out', fields: [{ id: 'command', label: 'Command', placeholder: 'e.g. docker' }], submit: { id: 'add', label: 'Leave it out' } },
+  }
+}
+
+function sandboxHandler() {
+  const save = (key, value) => config().update(`sandbox.${key}`, value, vscode.ConfigurationTarget.Global)
+  return async (action, message) => {
+    if (action === 'toggle') { await save(message.item, !!message.value); return sandboxSpec() }
+    const list = config().get('sandbox.excludedCommands', [])
+    if (action === 'add') {
+      const command = String(message.fields?.command || '').trim()
+      if (!command) throw new Error('write the command, e.g. docker')
+      if (!list.includes(command)) await save('excludedCommands', [...list, command])
+      return sandboxSpec(`${command} runs outside the sandbox now.`)
+    }
+    if (action === 'remove') { await save('excludedCommands', list.filter((x) => x !== message.item)); return sandboxSpec() }
+    return undefined
+  }
+}
+
+// ---- Report a problem ----
+
+/** The extension's own settings, for a report: redacted by feedback.save. */
+function settingsSnapshot() {
+  const pkg = require('./package.json')
+  const out = {}
+  for (const key of Object.keys(pkg.contributes?.configuration?.properties || {})) {
+    out[key.replace(/^aipictury\./, '')] = vscode.workspace.getConfiguration().get(key)
+  }
+  return out
+}
+
+function reportSpec(kind = 'bug', description = '', note) {
+  return {
+    id: 'report',
+    title: kind === 'feedback' ? 'Send feedback' : 'Report a problem',
+    note: note || 'Saved on this machine with the versions, your settings and the last lines of the log — keys, tokens and passwords taken out. Sent to your AIPictury server only if you choose to.',
+    form: {
+      fields: [
+        { id: 'kind', label: 'Kind', value: kind, options: [{ value: 'bug', label: 'Something is wrong' }, { value: 'feedback', label: 'An idea or a wish' }] },
+        { id: 'description', label: 'What happened', multiline: true, rows: 6, value: description,
+          placeholder: 'What you did, what you expected, what happened instead' },
+        { id: 'send', label: 'Send it', value: 'server', options: [{ value: 'server', label: 'Save it here and send it to my AIPictury server' }, { value: 'local', label: 'Only save it here' }] },
+      ],
+      submit: { id: 'send', label: 'Save report' },
+    },
+  }
+}
+
+/** Posts a report to the server; resolves to its id, or throws with why not. */
+async function sendReport(server, body) {
+  const controller = new AbortController()
+  const timer = setTimeout(() => controller.abort(), 10_000)
+  try {
+    const response = await fetch(`${server}/api/feedback`, { method: 'POST', headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body), signal: controller.signal })
+    const data = await response.json().catch(() => ({}))
+    if (!response.ok) throw new Error(data.detail || `the server answered ${response.status}`)
+    return data.id
+  } catch (error) {
+    throw new Error(error.name === 'AbortError' ? 'the server did not answer in 10 s' : error.message, { cause: error })
+  } finally { clearTimeout(timer) }
+}
+
+function reportHandler({ server, version, send = sendReport }) {
+  let saved = null
+  let sentId = null
+  return async (action, message) => {
+    if (action === 'send') {
+      const f = message.fields || {}
+      const description = String(f.description || '').trim()
+      if (!description) throw new Error('say what happened')
+      const kind = f.kind === 'feedback' ? 'feedback' : 'bug'
+      saved = feedback.save({ kind, description, versions: { extension: version, vscode: vscode.version },
+        settings: settingsSnapshot(), log: log.tail() })
+      log.info(`problem report saved: ${saved.file}`)
+      let sent = 'Kept only on this machine.'
+      if (f.send !== 'local') {
+        try { sentId = await send(server, saved.body); sent = `Sent to your AIPictury server as ${sentId}.` } catch (error) {
+          sent = `Not sent: ${error.message}. It is saved here — send it later from this folder.`
+          log.warn('problem report not sent', error)
+        }
+      }
+      return {
+        id: 'report', title: 'Report saved', note: `${sent} Nothing secret is in it.`,
+        sections: [{ items: [
+          { id: 'file', label: path.basename(saved.file), detail: saved.file, open: true,
+            actions: [{ id: 'open', label: 'Open' }, ...(sentId ? [{ id: 'withdraw', label: 'Withdraw it from the server', always: true }] : [])] },
+          { id: 'folder', label: 'The reports folder', detail: feedback.dir(), actions: [{ id: 'reveal', label: 'Show folder', always: true }] },
+        ] }],
+      }
+    }
+    if (action === 'open' && saved) { await openFile(saved.file); return null }
+    if (action === 'withdraw' && sentId) {
+      const response = await fetch(`${server}/api/feedback/${encodeURIComponent(sentId)}`, { method: 'DELETE' })
+      if (!response.ok) throw new Error(`the server answered ${response.status}`)
+      const gone = sentId
+      sentId = null
+      return { id: 'report', title: 'Report withdrawn', note: `${gone} is no longer on the server; the copy on this machine stays.`,
+        sections: [{ items: [{ id: 'file', label: path.basename(saved.file), detail: saved.file, open: true, actions: [{ id: 'open', label: 'Open' }] }] }] }
+    }
+    if (action === 'reveal') { await vscode.commands.executeCommand('revealFileInOS', vscode.Uri.file(saved?.file || feedback.dir())); return undefined }
+    return undefined
+  }
+}
+
+module.exports = { usageSpec, pagesSpec, pagesHandler, agentsSpec, agentsHandler, pluginsSpec, pluginsHandler, skillsSpec, skillsHandler, outputStyleSpec, outputStyleHandler, mcpSpec, mcpHandler, splitCommandLine, sandboxSpec, sandboxHandler, hooksSpec, hooksHandler, permissionsSpec, permissionsHandler, memorySpec, memoryHandler, instructionsSpec, instructionsHandler, slashSpec, slashHandler,
+  reportSpec, reportHandler, sendReport, settingsSnapshot }