@davait/aipictury 1.9.2

package/ext/mcp.js

@@ -0,0 +1,469 @@
+'use strict'
+// MCP servers: tools from outside — a database, GitHub, a browser — the way Claude Code
+// connects them. Configured in the project's .mcp.json (Claude Code's own file, so one
+// written for it works here unchanged), .aipictury/mcp.json, or the aipictury.mcpServers
+// setting:
+//   { "mcpServers": { "name": { "command": "npx", "args": ["-y", "pkg"], "env": {…} } } }
+//   { "mcpServers": { "name": { "type": "http", "url": "https://…", "headers": {…} } } }
+// ${VAR} and ${VAR:-default} in any string are read from the environment.
+// Scopes, as Claude Code's: user (~/.aipictury/mcp.json; and Claude Code's ~/.claude.json,
+// read-only), project (.mcp.json — shared, Claude Code's too — and .aipictury/mcp.json), local
+// (.aipictury/mcp.local.json; and Claude Code's per-project entry, read-only). Local beats
+// project beats user. A project's own servers start processes from the repository: they
+// connect only once the user trusts them (asked again when they change).
+// Their tools reach the model as mcp__<server>__<tool>. A tool that declares itself
+// read-only needs no approval; any other is approved like a command.
+
+const vscode = require('vscode')
+const { spawn } = require('child_process')
+const path = require('path')
+const os = require('os')
+const fs = require('fs')
+const crypto = require('crypto')
+const { root } = require('./paths')
+const { home } = require('./sessions')
+const prefs = require('./prefs')
+const mcpAuth = require('./mcpAuth')
+
+// OAuth for remote servers: where tokens are kept, how the browser is opened, where it comes
+// back — given by the extension (VS Code's secret storage, openExternal, the vscode:// link).
+let auth = null
+function configureAuth(options) { auth = options }
+
+const PROTOCOL = '2025-06-18'
+const CONNECT_TIMEOUT = 30_000
+const CALL_TIMEOUT = 300_000
+
+const servers = new Map()      // name → { name, config, state, tools, error, client }
+let untrusted = []             // a project's servers not connected: not trusted (yet)
+
+const expand = (v) => (typeof v === 'string'
+  ? v.replace(/\$\{(\w+)(?::-([^}]*))?\}/g, (_, k, d) => process.env[k] ?? d ?? '')
+  : Array.isArray(v) ? v.map(expand)
+  : v && typeof v === 'object' ? Object.fromEntries(Object.entries(v).map(([k, x]) => [k, expand(x)])) : v)
+
+const readFile = (file) => { try { return JSON.parse(fs.readFileSync(file, 'utf8')) } catch { return null } }
+const claudeJsonFile = () => path.join(process.env.CLAUDE_CONFIG_DIR || os.homedir(), '.claude.json')
+
+const extraConfigs = []
+/** MCP servers given for this run (the CLI's --mcp-config): files with "mcpServers", or { servers }. */
+function addConfigs(files) { for (const f of files || []) if (!extraConfigs.includes(f)) extraConfigs.push(f) }
+
+/** Every place servers are configured, least specific first: { scope, file, editable, origin, servers }. */
+function sources(folder) {
+  const claude = readFile(claudeJsonFile()) || {}
+  const out = [
+    { scope: 'user', file: path.join(home(), 'mcp.json'), editable: true, origin: 'AIPictury' },
+    { scope: 'user', file: claudeJsonFile(), editable: false, origin: 'Claude Code', servers: claude.mcpServers || {} },
+    { scope: 'user', file: 'aipictury.mcpServers', editable: false, origin: 'VS Code settings',
+      servers: vscode.workspace.getConfiguration('aipictury').get('mcpServers', {}) || {} },
+  ]
+  if (folder) {
+    out.push({ scope: 'project', file: path.join(folder, '.mcp.json'), editable: true, origin: 'project' },
+      { scope: 'project', file: path.join(folder, '.aipictury', 'mcp.json'), editable: true, origin: 'AIPictury' },
+      { scope: 'local', file: path.join(folder, '.aipictury', 'mcp.local.json'), editable: true, origin: 'AIPictury' },
+      { scope: 'local', file: claudeJsonFile(), editable: false, origin: 'Claude Code', servers: claude.projects?.[folder]?.mcpServers || {} })
+  }
+  // This run's own (the CLI's --mcp-config): given on the command line, so trusted as the user's.
+  for (const c of extraConfigs) out.push(typeof c === 'string' ? { scope: 'user', file: c, editable: false, origin: '--mcp-config' }
+    : { scope: 'user', file: '--mcp-config', editable: false, origin: '--mcp-config', servers: c.servers })
+  for (const s of out) if (!s.servers) s.servers = readFile(s.file)?.mcpServers || {}
+  // Plugins' servers: installed by the user, so not asked about like a project's.
+  try {
+    const fromPlugins = require('./plugins').mcpServers(folder)
+    if (Object.keys(fromPlugins).length) out.splice(3, 0, { scope: 'user', file: 'plugins', editable: false, origin: 'plugin', servers: fromPlugins })
+  } catch { /* no plugins */ }
+  return out
+}
+
+/** Every configured server with where it is from: name → { config, scope, file, editable, origin, disabled }. */
+function detailed(folder = folderPath()) {
+  const merged = prefs.load(folder).merged
+  const disabled = new Set([...(merged.disabledMcpServers || []), ...(merged.disabledMcpjsonServers || [])])
+  const all = new Map()
+  for (const s of sources(folder)) {
+    for (const [name, config] of Object.entries(s.servers)) {
+      all.set(name, { name, config: expand(config), scope: s.scope, file: s.file, editable: s.editable, origin: s.origin,
+        disabled: disabled.has(name) || !!config.disabled })
+    }
+  }
+  return all
+}
+
+function folderPath() { try { return root().fsPath } catch { return undefined } }
+
+/** Every configured server that is not turned off, as { name: config } (later scopes win). */
+async function configured() {
+  return Object.fromEntries([...detailed().values()].filter((s) => !s.disabled).map((s) => [s.name, s.config]))
+}
+
+/** A fingerprint of the project's servers: trust given to them is for these exactly. */
+const fingerprint = (list) => crypto.createHash('sha256').update(JSON.stringify(list.map((s) => [s.name, s.config]))).digest('hex').slice(0, 16)
+
+/** Adds or replaces a server in an editable file of a scope. Returns the file. */
+function save(folder, scope, name, config) {
+  // user: yours everywhere; project: the shared .mcp.json (Claude Code reads it too); local:
+  // yours, in this project only.
+  const file = { user: path.join(home(), 'mcp.json'),
+    project: folder && path.join(folder, '.mcp.json'), local: folder && path.join(folder, '.aipictury', 'mcp.local.json') }[scope]
+  if (!file) throw new Error(scope === 'user' ? 'no such scope' : `a ${scope} server needs a folder open`)
+  if (!/^[\w.-]{1,40}$/.test(name)) throw new Error('a server name is letters, digits, - _ or . (up to 40)')
+  const data = readFile(file) || {}
+  data.mcpServers = { ...(data.mcpServers || {}), [name]: config }
+  fs.mkdirSync(path.dirname(file), { recursive: true })
+  fs.writeFileSync(file, `${JSON.stringify(data, null, 2)}\n`)
+  if (scope === 'local') keepOutOfGit(folder, '.aipictury/mcp.local.json')
+  return file
+}
+
+/** Removes a server from the file it is in (never Claude Code's). */
+function remove(folder, name) {
+  const found = detailed(folder).get(name)
+  if (!found) throw new Error(`no server called ${name}`)
+  if (!found.editable) throw new Error(`${name} is configured in ${found.origin === 'Claude Code' ? 'Claude Code\'s file' : 'VS Code settings'} — change it there`)
+  const data = readFile(found.file) || {}
+  delete data.mcpServers?.[name]
+  fs.writeFileSync(found.file, `${JSON.stringify(data, null, 2)}\n`)
+  return found.file
+}
+
+/** Turns a server off or on — kept in your local settings, as Claude Code keeps it. */
+function setEnabled(folder, name, on) {
+  return prefs.edit(folder, folder ? 'local' : 'user', (data) => {
+    const list = new Set(data.disabledMcpServers || [])
+    if (on) list.delete(name); else list.add(name)
+    data.disabledMcpServers = [...list]
+    if (!data.disabledMcpServers.length) delete data.disabledMcpServers
+  })
+}
+
+function keepOutOfGit(folder, entry) {
+  const ignore = path.join(folder, '.gitignore')
+  try {
+    const text = fs.readFileSync(ignore, 'utf8')
+    if (!text.split('\n').includes(entry)) fs.appendFileSync(ignore, `${text.endsWith('\n') ? '' : '\n'}${entry}\n`)
+  } catch { /* no .gitignore: not ours to create */ }
+}
+
+// ---- transports ----
+
+class StdioClient {
+  constructor(config) {
+    this.pending = new Map()
+    this.next = 1
+    this.buffer = ''
+    this.stderr = ''
+    const cwd = config.cwd ? path.resolve(root().fsPath, config.cwd) : root().fsPath
+    this.child = spawn(config.command, config.args || [], { cwd, env: { ...process.env, ...(config.env || {}) },
+      stdio: ['pipe', 'pipe', 'pipe'], shell: process.platform === 'win32' })
+    this.child.stdout.on('data', (d) => this.onData(d))
+    this.child.stderr.on('data', (d) => { this.stderr = (this.stderr + d).slice(-4000) })
+    this.child.on('error', (e) => this.failAll(e))
+    this.child.on('close', (code) => this.failAll(new Error(`the server exited (${code})${this.stderr ? `: ${this.stderr.trim().split('\n').pop()}` : ''}`)))
+  }
+
+  onData(chunk) {
+    this.buffer += chunk
+    let at
+    while ((at = this.buffer.indexOf('\n')) !== -1) {
+      const line = this.buffer.slice(0, at).trim()
+      this.buffer = this.buffer.slice(at + 1)
+      if (!line) continue
+      let msg
+      try { msg = JSON.parse(line) } catch { continue }
+      this.receive(msg)
+    }
+  }
+
+  receive(msg) {
+    if (msg.id !== undefined && this.pending.has(msg.id)) {
+      const { ok, fail, timer } = this.pending.get(msg.id)
+      clearTimeout(timer)
+      this.pending.delete(msg.id)
+      if (msg.error) fail(new Error(msg.error.message || JSON.stringify(msg.error)))
+      else ok(msg.result)
+    } else if (msg.id !== undefined && msg.method) {
+      // A request from the server (roots, sampling…): politely unsupported.
+      this.send({ jsonrpc: '2.0', id: msg.id, error: { code: -32601, message: 'not supported by this client' } })
+    }
+  }
+
+  failAll(error) {
+    this.dead = error
+    for (const { fail, timer } of this.pending.values()) { clearTimeout(timer); fail(error) }
+    this.pending.clear()
+  }
+
+  send(msg) { if (!this.dead) this.child.stdin.write(`${JSON.stringify(msg)}\n`) }
+
+  request(method, params, timeout = CONNECT_TIMEOUT) {
+    if (this.dead) return Promise.reject(this.dead)
+    const id = this.next++
+    return new Promise((ok, fail) => {
+      const timer = setTimeout(() => { this.pending.delete(id); fail(new Error(`${method} timed out after ${timeout / 1000}s`)) }, timeout)
+      this.pending.set(id, { ok, fail, timer })
+      this.send({ jsonrpc: '2.0', id, method, params })
+    })
+  }
+
+  notify(method, params) { this.send({ jsonrpc: '2.0', method, params }) }
+  close() { try { this.child.kill() } catch { /* gone */ } }
+}
+
+class HttpClient {
+  constructor(config) {
+    this.url = config.url
+    this.headers = config.headers || {}
+    this.next = 1
+  }
+
+  /** The headers of a request, with the server's OAuth token when it has one. */
+  async headersFor(force = false) {
+    const bearer = auth && !Object.keys(this.headers).some((h) => h.toLowerCase() === 'authorization')
+      ? await mcpAuth.token(this.url, { store: auth.store, fetchImpl: auth.fetch || fetch, force }).catch(() => null) : null
+    return { 'Content-Type': 'application/json', Accept: 'application/json, text/event-stream', 'MCP-Protocol-Version': PROTOCOL,
+      ...(this.session ? { 'Mcp-Session-Id': this.session } : {}), ...this.headers, ...(bearer ? { Authorization: `Bearer ${bearer}` } : {}) }
+  }
+
+  async request(method, params, timeout = CONNECT_TIMEOUT) {
+    const id = this.next++
+    const send = async (force) => fetch(this.url, { method: 'POST', headers: await this.headersFor(force),
+      body: JSON.stringify({ jsonrpc: '2.0', id, method, params }), signal: AbortSignal.timeout(timeout) })
+    let response = await send(false)
+    // 401: an expired token is refreshed once; otherwise the user must sign in.
+    if (response.status === 401) {
+      const header = response.headers.get('www-authenticate')
+      const fresh = auth ? await mcpAuth.token(this.url, { store: auth.store, fetchImpl: auth.fetch || fetch, force: true }).catch(() => null) : null
+      if (fresh) response = await send(false)
+      if (response.status === 401) throw new mcpAuth.AuthNeeded(this.url, response.headers.get('www-authenticate') || header)
+    }
+    this.session = response.headers.get('mcp-session-id') || this.session
+    if (!response.ok) throw new Error(`${response.status} ${(await response.text()).slice(0, 200)}`)
+    const type = response.headers.get('content-type') || ''
+    let msg
+    if (type.includes('text/event-stream')) {
+      const text = await response.text()
+      for (const block of text.split(/\n\n/)) {
+        const data = block.split('\n').filter((l) => l.startsWith('data:')).map((l) => l.slice(5).trim()).join('\n')
+        if (!data) continue
+        try { const m = JSON.parse(data); if (m.id === id) msg = m } catch { /* keep reading */ }
+      }
+    } else {
+      msg = await response.json()
+    }
+    if (!msg) throw new Error(`no answer to ${method}`)
+    if (msg.error) throw new Error(msg.error.message || JSON.stringify(msg.error))
+    return msg.result
+  }
+
+  notify(method, params) {
+    this.headersFor().then((headers) => fetch(this.url, { method: 'POST', headers,
+      body: JSON.stringify({ jsonrpc: '2.0', method, params }) })).catch(() => {})
+  }
+
+  close() {}
+}
+
+// ---- servers ----
+
+const toolName = (server, tool) => `mcp__${server}__${tool}`.replace(/[^A-Za-z0-9_-]/g, '_').slice(0, 64)
+
+async function connect(name, config) {
+  const entry = { name, config, state: 'connecting', tools: [] }
+  servers.set(name, entry)
+  try {
+    if (config.disabled) { entry.state = 'disabled'; return entry }
+    const http = config.type === 'http' || config.type === 'sse' || (!config.command && config.url)
+    entry.client = http ? new HttpClient(config) : new StdioClient(config)
+    const init = await entry.client.request('initialize', { protocolVersion: PROTOCOL, capabilities: {},
+      clientInfo: { name: 'aipictury', version: '1.6' } })
+    entry.info = init?.serverInfo
+    entry.resources = !!init?.capabilities?.resources
+    entry.client.notify('notifications/initialized', {})
+    let cursor
+    do {
+      const page = await entry.client.request('tools/list', cursor ? { cursor } : {})
+      entry.tools.push(...(page?.tools || []))
+      cursor = page?.nextCursor
+    } while (cursor)
+    entry.state = 'connected'
+  } catch (error) {
+    entry.state = error.name === 'AuthNeeded' ? 'needs-auth' : 'failed'
+    entry.error = error.message
+    entry.authHeader = error.header
+    entry.client?.close()
+  }
+  return entry
+}
+
+/** Signs in to a remote server in the browser, then connects it. */
+async function signIn(name) {
+  const found = detailed().get(name)
+  if (!found?.config.url) throw new Error(`${name} is not a remote (http) server`)
+  if (!auth) throw new Error('signing in is not available here')
+  await mcpAuth.signIn(found.config.url, { header: servers.get(name)?.authHeader, store: auth.store, open: auth.open,
+    redirectUri: await auth.redirectUri(), fetchImpl: auth.fetch || fetch })
+  return reconnect(name)
+}
+
+async function signOut(name) {
+  const found = detailed().get(name)
+  if (found?.config.url && auth) await mcpAuth.signOut(found.config.url, { store: auth.store })
+  return reconnect(name)
+}
+
+/** Connects every configured server not yet connected (or whose configuration changed). A
+ *  project's own servers connect only when `trust(servers, fingerprint)` says yes. */
+async function ensure({ trust } = {}) {
+  const all = [...detailed().values()].filter((s) => !s.disabled)
+  const fromProject = all.filter((s) => s.scope === 'project' && s.editable)
+  const trusted = !fromProject.length || (trust ? await trust(fromProject, fingerprint(fromProject)) : false)
+  untrusted = trusted ? [] : fromProject.map((s) => s.name)
+  const wanted = Object.fromEntries(all.filter((s) => trusted || !fromProject.includes(s)).map((s) => [s.name, s.config]))
+  for (const [name, entry] of servers) {
+    if (!wanted[name] || JSON.stringify(wanted[name]) !== JSON.stringify(entry.config)) {
+      entry.client?.close(); servers.delete(name)
+    }
+  }
+  await Promise.all(Object.entries(wanted).filter(([name]) => !servers.has(name)).map(([n, c]) => connect(n, c)))
+  return status()
+}
+
+function status() {
+  return [...servers.values()].map((s) => ({ name: s.name, state: s.state, error: s.error,
+    tools: s.tools.map((t) => t.name), server: s.info?.name })).concat(untrusted.filter((n) => !servers.has(n))
+    .map((name) => ({ name, state: 'untrusted', error: 'a project server, not trusted yet', tools: [] })))
+}
+
+/** Closes a server and connects it again. */
+async function reconnect(name) {
+  const entry = servers.get(name)
+  entry?.client?.close()
+  servers.delete(name)
+  const found = detailed().get(name)
+  if (!found || found.disabled) return null
+  return connect(name, found.config)
+}
+
+// Past this many MCP tools, the model gets their names only and loads what it needs with
+// tool_search — their definitions would otherwise fill a local model's context.
+const DEFER_AT = 20
+
+const shaped = (s, t) => ({ type: 'function', function: { name: toolName(s.name, t.name),
+  description: `[${s.name}] ${t.description || t.title || t.name}`.slice(0, 1024),
+  parameters: t.inputSchema || { type: 'object', properties: {} } } })
+
+function allTools({ readOnly = false } = {}) {
+  const out = []
+  for (const s of servers.values()) {
+    if (s.state !== 'connected') continue
+    for (const t of s.tools) if (!readOnly || t.annotations?.readOnlyHint) out.push({ server: s, tool: t })
+  }
+  return out
+}
+
+/** The tools every connected server offers, shaped for the model. With many of them, only
+ *  those `loaded` (by tool_search) are given whole, and tool_search lists the rest by name. */
+function schema({ readOnly = false, loaded = null } = {}) {
+  const all = allTools({ readOnly })
+  if (!loaded || all.length <= DEFER_AT) return all.map(({ server, tool }) => shaped(server, tool))
+  const whole = all.filter(({ server, tool }) => loaded.has(toolName(server.name, tool.name)))
+  const rest = all.filter((x) => !whole.includes(x))
+  const list = rest.map(({ server, tool }) => `- ${toolName(server.name, tool.name)}: ${String(tool.description || tool.title || '').split('\n')[0].slice(0, 70)}`)
+  return [...whole.map(({ server, tool }) => shaped(server, tool)), ...(rest.length ? [{ type: 'function', function: {
+    name: 'tool_search',
+    description: `Load MCP tools before using them: their full definitions are not given until loaded. Ask by name ("select:a,b") or by words. Not loaded yet:\n${list.join('\n')}`.slice(0, 8000),
+    parameters: { type: 'object', properties: {
+      query: { type: 'string', description: '"select:mcp__server__tool,…" for exact tools, or a few words to search their names and descriptions' },
+      max_results: { type: 'integer', description: 'optional: at most this many (default 5)' } }, required: ['query'] } } }] : [])]
+}
+
+/** tool_search: the tools that match, loaded into `loaded`; their definitions for the model. */
+function search({ query, max_results: max = 5 }, loaded) {
+  const all = allTools()
+  const q = String(query || '').trim()
+  let hits
+  if (q.startsWith('select:')) {
+    const want = new Set(q.slice(7).split(',').map((x) => x.trim()).filter(Boolean))
+    hits = all.filter(({ server, tool }) => want.has(toolName(server.name, tool.name)))
+  } else {
+    const words = q.toLowerCase().split(/\s+/).filter(Boolean)
+    hits = all.map((x) => ({ x, score: words.filter((w) => `${toolName(x.server.name, x.tool.name)} ${x.tool.description || ''}`.toLowerCase().includes(w)).length }))
+      .filter((h) => h.score).sort((a, b) => b.score - a.score).map((h) => h.x)
+  }
+  hits = hits.slice(0, Math.max(1, Math.min(20, Number(max) || 5)))
+  for (const { server, tool } of hits) loaded.add(toolName(server.name, tool.name))
+  if (!hits.length) return `No MCP tool matches "${q}".`
+  return `Loaded — you can call these now:\n${hits.map(({ server, tool }) => JSON.stringify(shaped(server, tool).function)).join('\n')}`
+}
+
+// ---- resources ----
+
+/** The resource tools, when a connected server has resources. */
+function resourceSchema() {
+  const any = [...servers.values()].some((s) => s.state === 'connected' && s.resources)
+  if (!any) return []
+  return [
+    { type: 'function', function: { name: 'list_mcp_resources', description: 'List the resources (documents, data) MCP servers offer.',
+      parameters: { type: 'object', properties: { server: { type: 'string', description: 'optional: only this server' } } } } },
+    { type: 'function', function: { name: 'read_mcp_resource', description: 'Read one MCP resource by its URI.',
+      parameters: { type: 'object', properties: { server: { type: 'string', description: 'the server it is on' },
+        uri: { type: 'string', description: 'its URI, as list_mcp_resources gave it' } }, required: ['server', 'uri'] } } },
+  ]
+}
+
+async function listResources({ server } = {}) {
+  const lines = []
+  for (const s of servers.values()) {
+    if (s.state !== 'connected' || !s.resources || (server && s.name !== server)) continue
+    let cursor
+    do {
+      const page = await s.client.request('resources/list', cursor ? { cursor } : {})
+      for (const r of page?.resources || []) lines.push(`- ${s.name}: ${r.uri}${r.name ? ` — ${r.name}` : ''}${r.description ? `: ${r.description}` : ''}${r.mimeType ? ` (${r.mimeType})` : ''}`)
+      cursor = page?.nextCursor
+    } while (cursor && lines.length < 500)
+  }
+  return lines.length ? lines.join('\n') : server ? `${server} offers no resources (or is not connected).` : 'No MCP server offers resources.'
+}
+
+async function readResource({ server, uri }) {
+  const s = servers.get(server)
+  if (!s || s.state !== 'connected') throw new Error(`${server} is not connected (see /mcp)`)
+  const result = await s.client.request('resources/read', { uri })
+  return (result?.contents || []).map((c) => (c.text !== undefined ? c.text
+    : `[${c.mimeType || 'binary'} content, ${Math.round((c.blob || '').length * 0.75)} bytes — not shown]`)).join('\n\n') || '(empty)'
+}
+
+function find(name) {
+  for (const s of servers.values()) {
+    for (const t of s.tools) if (toolName(s.name, t.name) === name) return { server: s, tool: t }
+  }
+  return null
+}
+
+const isMcp = (name) => String(name).startsWith('mcp__')
+const readOnly = (name) => !!find(name)?.tool.annotations?.readOnlyHint
+
+/** Calls an MCP tool. Returns { text, images } for the model. */
+async function call(name, args) {
+  const found = find(name)
+  if (!found) throw new Error(`${name} is not available (its server may have disconnected — see /mcp)`)
+  const result = await found.server.client.request('tools/call', { name: found.tool.name, arguments: args || {} }, CALL_TIMEOUT)
+  const texts = []
+  const images = []
+  for (const part of result?.content || []) {
+    if (part.type === 'text') texts.push(part.text)
+    else if (part.type === 'image') images.push(part.data)
+    else if (part.type === 'resource') texts.push(part.resource?.text || `[resource ${part.resource?.uri}]`)
+    else if (part.type === 'resource_link') texts.push(`[${part.name || 'resource'}: ${part.uri}]`)
+  }
+  if (result?.structuredContent && !texts.length) texts.push(JSON.stringify(result.structuredContent, null, 1))
+  const text = texts.join('\n\n') || '(no content)'
+  if (result?.isError) throw new Error(text)
+  return { text, images }
+}
+
+function closeAll() { for (const s of servers.values()) s.client?.close(); servers.clear() }
+
+module.exports = { addConfigs, configureAuth, signIn, signOut, ensure, status, schema, search, resourceSchema, listResources, readResource, DEFER_AT, call, isMcp, readOnly, closeAll, configured, detailed, sources, save, remove,
+  setEnabled, reconnect, fingerprint, toolName }

package/ext/mcpAuth.js

@@ -0,0 +1,128 @@
+'use strict'
+// OAuth for remote MCP servers, as the MCP authorization spec has it: the server answers 401
+// and points to its protected-resource metadata (RFC 9728); its authorization server's
+// metadata (RFC 8414) gives the endpoints; AIPictury registers itself there (dynamic client
+// registration, RFC 7591) and signs in with the authorization code and PKCE (S256) in the
+// browser; the browser comes back through vscode://aipictury.aipictury/oauth. Tokens are kept
+// in VS Code's secret storage and refreshed when they expire. No VS Code here: the storage,
+// the browser and fetch are given, so the tests run the whole flow against a local server.
+const crypto = require('crypto')
+
+const b64url = (buf) => Buffer.from(buf).toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')
+const KEY = (serverUrl) => `aipictury.mcp.oauth:${new URL(serverUrl).origin}${new URL(serverUrl).pathname}`
+const CLIENT_KEY = (issuer) => `aipictury.mcp.oauth.client:${issuer}`
+const pending = new Map()             // state → { resolve, reject, timer }
+
+class AuthNeeded extends Error {
+  constructor(serverUrl, header) {
+    super('this server needs you to sign in — /mcp, Sign in')
+    this.name = 'AuthNeeded'
+    this.serverUrl = serverUrl
+    this.header = header || ''
+  }
+}
+
+/** The parameters of a WWW-Authenticate: Bearer header. */
+function challenge(header) {
+  const out = {}
+  for (const m of String(header || '').matchAll(/(\w+)="([^"]*)"/g)) out[m[1]] = m[2]
+  return out
+}
+
+async function json(fetchImpl, url, init) {
+  const r = await fetchImpl(url, { ...init, headers: { Accept: 'application/json', ...(init?.headers || {}) } })
+  if (!r.ok) throw new Error(`${new URL(url).pathname}: ${r.status} ${(await r.text()).slice(0, 200)}`)
+  return r.json()
+}
+
+/** Where to sign in for this server: its resource, its authorization server and that server's endpoints. */
+async function discover(serverUrl, header, fetchImpl = fetch) {
+  const given = challenge(header)
+  const origin = new URL(serverUrl).origin
+  let resource
+  for (const url of [given.resource_metadata, `${origin}/.well-known/oauth-protected-resource${new URL(serverUrl).pathname}`, `${origin}/.well-known/oauth-protected-resource`].filter(Boolean)) {
+    try { resource = await json(fetchImpl, url); break } catch { /* the next place */ }
+  }
+  const issuer = resource?.authorization_servers?.[0] || origin
+  let meta
+  for (const url of [`${issuer.replace(/\/$/, '')}/.well-known/oauth-authorization-server`, `${issuer.replace(/\/$/, '')}/.well-known/openid-configuration`]) {
+    try { meta = await json(fetchImpl, url); break } catch { /* the next place */ }
+  }
+  if (!meta?.authorization_endpoint || !meta?.token_endpoint) throw new Error(`no OAuth metadata at ${issuer}`)
+  if (meta.code_challenge_methods_supported && !meta.code_challenge_methods_supported.includes('S256')) throw new Error(`${issuer} does not offer PKCE (S256)`)
+  return { resource: resource?.resource || serverUrl, issuer: meta.issuer || issuer, meta, scope: given.scope || (resource?.scopes_supported || []).join(' ') }
+}
+
+/** This client at that authorization server: registered once, kept. */
+async function client(found, { store, redirectUri, fetchImpl = fetch }) {
+  const saved = await store.get(CLIENT_KEY(found.issuer))
+  if (saved) { const c = JSON.parse(saved); if (c.redirect_uris?.includes(redirectUri)) return c }
+  if (!found.meta.registration_endpoint) throw new Error(`${found.issuer} does not let clients register themselves — add a client id to the server's config`)
+  const registered = await json(fetchImpl, found.meta.registration_endpoint, { method: 'POST', headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ client_name: 'AIPictury', redirect_uris: [redirectUri], grant_types: ['authorization_code', 'refresh_token'],
+      response_types: ['code'], token_endpoint_auth_method: 'none' }) })
+  await store.set(CLIENT_KEY(found.issuer), JSON.stringify(registered))
+  return registered
+}
+
+async function tokenRequest(found, body, fetchImpl) {
+  const r = await fetchImpl(found.meta.token_endpoint, { method: 'POST',
+    headers: { 'Content-Type': 'application/x-www-form-urlencoded', Accept: 'application/json' }, body: new URLSearchParams(body).toString() })
+  const data = await r.json().catch(() => ({}))
+  if (!r.ok || !data.access_token) throw new Error(`token: ${data.error_description || data.error || r.status}`)
+  return { ...data, expires_at: data.expires_in ? Date.now() + data.expires_in * 1000 - 30_000 : null }
+}
+
+/**
+ * Signs in to a server in the browser. `open(url)` opens it; the flow ends when the browser
+ * comes back (handleCallback). Resolves to the tokens, kept in `store`.
+ */
+async function signIn(serverUrl, { header, store, open, redirectUri, fetchImpl = fetch, timeoutMs = 5 * 60_000 }) {
+  const found = await discover(serverUrl, header, fetchImpl)
+  const c = await client(found, { store, redirectUri, fetchImpl })
+  const verifier = b64url(crypto.randomBytes(48))
+  const state = b64url(crypto.randomBytes(24))
+  const url = new URL(found.meta.authorization_endpoint)
+  for (const [k, v] of Object.entries({ response_type: 'code', client_id: c.client_id, redirect_uri: redirectUri, state,
+    code_challenge: b64url(crypto.createHash('sha256').update(verifier).digest()), code_challenge_method: 'S256',
+    resource: found.resource, ...(found.scope ? { scope: found.scope } : {}) })) url.searchParams.set(k, v)
+  const code = await new Promise((resolve, reject) => {
+    const timer = setTimeout(() => { pending.delete(state); reject(new Error('the sign-in was not finished in time')) }, timeoutMs)
+    pending.set(state, { resolve, reject, timer })
+    Promise.resolve(open(url.toString())).catch((error) => { clearTimeout(timer); pending.delete(state); reject(error) })
+  })
+  const tokens = await tokenRequest(found, { grant_type: 'authorization_code', code, redirect_uri: redirectUri, client_id: c.client_id,
+    code_verifier: verifier, resource: found.resource }, fetchImpl)
+  await store.set(KEY(serverUrl), JSON.stringify({ ...tokens, found: { issuer: found.issuer, meta: found.meta, resource: found.resource }, client_id: c.client_id }))
+  return tokens
+}
+
+/** The browser came back: ?code=…&state=… (or ?error=…). True when it was one of ours. */
+function handleCallback(query) {
+  const params = query instanceof URLSearchParams ? query : new URLSearchParams(query)
+  const flow = pending.get(params.get('state'))
+  if (!flow) return false
+  pending.delete(params.get('state'))
+  clearTimeout(flow.timer)
+  if (params.get('error')) flow.reject(new Error(`sign-in refused: ${params.get('error_description') || params.get('error')}`))
+  else flow.resolve(params.get('code'))
+  return true
+}
+
+/** The access token for a server: kept, refreshed when expired, or null when one must sign in. */
+async function token(serverUrl, { store, fetchImpl = fetch, force = false } = {}) {
+  const saved = await store.get(KEY(serverUrl))
+  if (!saved) return null
+  const t = JSON.parse(saved)
+  if (!force && (!t.expires_at || t.expires_at > Date.now())) return t.access_token
+  if (!t.refresh_token) return null
+  try {
+    const fresh = await tokenRequest(t.found, { grant_type: 'refresh_token', refresh_token: t.refresh_token, client_id: t.client_id, resource: t.found.resource }, fetchImpl)
+    await store.set(KEY(serverUrl), JSON.stringify({ ...t, ...fresh, refresh_token: fresh.refresh_token || t.refresh_token }))
+    return fresh.access_token
+  } catch { return null }
+}
+
+async function signOut(serverUrl, { store }) { await store.delete(KEY(serverUrl)) }
+
+module.exports = { AuthNeeded, challenge, discover, signIn, handleCallback, token, signOut }

package/ext/media/vendor/firebase-config.json

@@ -0,0 +1,9 @@
+{
+  "apiKey": "AIzaSyBsvK8wmSONFUQaHeSzST-4UMbcH5ZB3Ps",
+  "authDomain": "aipictury.firebaseapp.com",
+  "projectId": "aipictury",
+  "storageBucket": "aipictury.firebasestorage.app",
+  "messagingSenderId": "662869441939",
+  "appId": "1:662869441939:web:b3c8d0fe77266e0d84fc66",
+  "measurementId": "G-VC48099T1J"
+}