@davait/aipictury 1.9.2

package/main.js

@@ -0,0 +1,758 @@
+#!/usr/bin/env node
+'use strict'
+// aipictury — the AIPictury agent in a terminal, as Claude Code's `claude`: the extension's own
+// agent (its tools, permission rules, hooks, MCP servers, skills, sandbox), on your AIPictury
+// server's model, working in the folder it is started in. Interactive, or one prompt with -p.
+// Conversations are the extension's too: one started here can be carried on in VS Code, and the
+// other way round (--continue, --resume).
+const Module = require('module')
+const path = require('path')
+const fs = require('fs')
+const os = require('os')
+const readline = require('readline')
+
+// ---- `vscode` is the stand-in, for every module of the agent ----
+const SHIM = require.resolve('./vscode-shim.js')
+const resolveFilename = Module._resolveFilename
+Module._resolveFilename = function (request, ...rest) { return request === 'vscode' ? SHIM : resolveFilename.call(this, request, ...rest) }
+const vscode = require('./vscode-shim.js')
+
+// The agent's modules: packed beside the CLI (npm: ext/, see pack.mjs), or the extension's own
+// folder when run from the repository.
+const EXT = fs.existsSync(path.join(__dirname, 'ext', 'agent.js')) ? path.join(__dirname, 'ext') : path.join(__dirname, '..', 'vscode')
+const pkg = require(path.join(EXT, 'package.json'))
+const VERSION = pkg.version
+
+const HELP = `aipictury ${VERSION} — the AIPictury agent in a terminal
+
+Usage:
+  aipictury login [--no-browser]     sign in to your AIPictury account (needed), in the browser
+  aipictury logout | whoami          sign out on this machine | who is signed in
+  aipictury [prompt]                 interactive (a first prompt is optional)
+  aipictury -p "prompt"              one prompt, the answer printed, then exit
+  cat log.txt | aipictury -p "why does it fail?"
+
+Options:
+  -p, --print                        print mode: no questions asked (what needs a yes is refused)
+  --output-format text|json|stream-json   print mode's output (default text)
+  -c, --continue                     carry on the latest conversation of this folder
+  -r, --resume [id]                  carry on a conversation (none given: list them)
+  --permission-mode <mode>           default (asks; the start) | acceptEdits | auto | plan | bypassPermissions
+  --dangerously-skip-permissions     bypassPermissions, for this run
+  --allowedTools "<rule>,…"          allowed without asking, as permission rules: "Bash(npm test:*),Edit"
+  --disallowedTools "<rule>,…"       denied, as permission rules; a bare tool ("Bash", "WebFetch") is not even offered
+  --mcp-config <file|json>           MCP servers for this run (a file, or JSON with "mcpServers"); repeatable
+  --add-dir <folder>                 another folder the agent may work in, besides this one; repeatable
+  --append-system-prompt "<text>"    added at the end of the system prompt
+  --model <name>                     the model (default: the server's agent model)
+  --effort low|medium|high|max|ultra how hard it reasons
+  --max-turns <n>                    stop after this many model turns (print mode)
+  --server <url>                     the AIPictury server (default: aipictury.server, or AIPICTURY_URL)
+  -v, --version                      the version
+  -h, --help                         this help
+
+In a conversation: / for commands (/help lists them; Tab completes), @path mentions a file,
+!command runs it here, a line ending in \\ continues on the next. Esc or Ctrl+C stops a run;
+Ctrl+C twice at the prompt quits. Up and down bring back what you typed, across runs.
+Settings: ~/.aipictury/cli.json (the extension's names, e.g. {"aipictury.approval": "ask"}).
+Copyright © 2026 Davait, Inc. All rights reserved. See LICENSE.md.
+`
+
+const MODE_OF = { default: 'ask', acceptEdits: 'edits', auto: 'never', plan: 'plan', bypassPermissions: 'bypass', ask: 'ask', edits: 'edits', never: 'never', bypass: 'bypass' }
+
+function parseArgs(argv) {
+  const o = { prompt: [], format: 'text' }
+  for (let i = 0; i < argv.length; i += 1) {
+    const a = argv[i]
+    const next = () => { if (i + 1 >= argv.length) throw new Error(`${a} needs a value`); i += 1; return argv[i] }
+    if (a === '-p' || a === '--print') o.print = true
+    else if (a === '-c' || a === '--continue') o.continue = true
+    else if (a === '-r' || a === '--resume') o.resume = argv[i + 1] && !argv[i + 1].startsWith('-') ? next() : true
+    else if (a === '--output-format') o.format = next()
+    else if (a === '--permission-mode') o.mode = next()
+    else if (a === '--dangerously-skip-permissions') o.mode = 'bypassPermissions'
+    else if (a === '--allowedTools' || a === '--allowed-tools') o.allowed = next().split(/[,\s]+(?![^(]*\))/).filter(Boolean)
+    else if (a === '--disallowedTools' || a === '--disallowed-tools') o.denied = next().split(/[,\s]+(?![^(]*\))/).filter(Boolean)
+    else if (a === '--mcp-config') (o.mcp ||= []).push(next())
+    else if (a === '--add-dir') (o.dirs ||= []).push(next())
+    else if (a === '--append-system-prompt') o.appendSystem = next()
+    else if (a === '--model') o.model = next()
+    else if (a === '--effort') o.effort = next()
+    else if (a === '--max-turns') o.maxTurns = Number(next())
+    else if (a === '--server') o.server = next()
+    else if (a === '-v' || a === '--version') o.version = true
+    else if (a === '-h' || a === '--help') o.help = true
+    else if (a.startsWith('-')) throw new Error(`unknown option ${a} — aipictury --help`)
+    else o.prompt.push(a)
+  }
+  o.prompt = o.prompt.join(' ').trim()
+  if (o.mode && !MODE_OF[o.mode]) throw new Error(`--permission-mode is one of: default, acceptEdits, auto, plan, bypassPermissions`)
+  if (!['text', 'json', 'stream-json'].includes(o.format)) throw new Error('--output-format is text, json or stream-json')
+  return o
+}
+
+// ---- the terminal ----
+const tty = process.stdout.isTTY
+const paint = (code) => (t) => (tty ? `\x1b[${code}m${t}\x1b[0m` : String(t))
+const dim = paint(2); const bold = paint(1); const red = paint(31); const green = paint(32); const yellow = paint(33); const cyan = paint(36)
+
+function setup(o) {
+  const home = process.env.AIPICTURY_HOME || path.join(os.homedir(), '.aipictury')
+  vscode.state.root = process.cwd()
+  vscode.state.settingsFile = path.join(home, 'cli.json')
+  vscode.state.logFile = path.join(home, 'logs', 'cli.log')
+  for (const [k, v] of Object.entries(pkg.contributes.configuration.properties)) if ('default' in v) vscode.state.defaults[k] = v.default
+  // The terminal starts as Claude Code's does: asking before changes and commands (in print
+  // mode, refusing them) — a script gets only what it allows. cli.json or --permission-mode
+  // choose otherwise.
+  vscode.state.defaults['aipictury.approval'] = 'ask'
+  try { Object.assign(vscode.state.settings, JSON.parse(fs.readFileSync(vscode.state.settingsFile, 'utf8'))) } catch { /* no settings yet */ }
+  // This run's choices: never written to the settings file.
+  if (o.server || process.env.AIPICTURY_URL) vscode.state.settings['aipictury.server'] = (o.server || process.env.AIPICTURY_URL).replace(/\/+$/, '')
+  if (o.mode) {
+    vscode.state.settings['aipictury.approval'] = MODE_OF[o.mode]
+    if (MODE_OF[o.mode] === 'bypass') vscode.state.settings['aipictury.allowDangerouslySkipPermissions'] = true
+  }
+  if (o.effort) vscode.state.settings['aipictury.effort'] = o.effort
+  // Tools that only an editor has are not offered here.
+  vscode.cli = true
+  RUN.allowed = o.allowed
+  RUN.denied = o.denied
+  for (const dir of o.dirs || []) {
+    if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) throw new Error(`--add-dir: ${dir} is not a folder`)
+  }
+  if (o.dirs?.length) require(path.join(EXT, 'paths.js')).addRoots(o.dirs)
+  if (o.mcp?.length) {
+    require(path.join(EXT, 'mcp.js')).addConfigs(o.mcp.map((given) => {
+      if (String(given).trim().startsWith('{')) {
+        try { return { servers: JSON.parse(given).mcpServers || {} } } catch { throw new Error('--mcp-config: that JSON does not parse') }
+      }
+      if (!fs.existsSync(given)) throw new Error(`--mcp-config: ${given} does not exist`)
+      return path.resolve(given)
+    }))
+  }
+  if (o.appendSystem) require(path.join(EXT, 'agent.js')).appendSystem(o.appendSystem)
+}
+
+// The GPU server: --server, AIPICTURY_URL or the settings file; else the one chosen with your account.
+const server = () => require(path.join(EXT, 'gpuServer.js')).url()
+
+async function serverConfig() {
+  if (!server()) throw new Error('no GPU server is set — choose it at https://aipictury.com (it is kept with your account), or pass --server')
+  const r = await fetch(`${server()}/api/vscode/config`, { signal: AbortSignal.timeout(15_000) })
+  if (!r.ok) throw new Error(`the server answered ${r.status}${r.status === 401 ? `: ${(await r.json().catch(() => ({}))).detail || 'your account is refused'}` : ''}`)
+  return r.json()
+}
+
+/** One conversation, saved where the extension keeps this folder's conversations. */
+// What this run was started with that every conversation of it carries (setup).
+const RUN = {}
+
+class Conversation {
+  constructor(store, entry = null) {
+    this.store = store
+    this.id = entry?.id || `c${Date.now().toString(36)}`
+    this.created = entry?.created || Date.now()
+    this.title = entry?.title && entry.renamed ? entry.title : null
+    this.aiTitle = entry?.aiTitle || null
+    this.history = entry?.history || []
+    this.transcript = entry?.transcript || []
+    this.todos = entry?.todos || []
+    // This run's own rules (--allowedTools, --disallowedTools): every conversation, both modes.
+    this.session = { allowAll: false, ...(RUN.allowed?.length ? { commandAllow: RUN.allowed } : {}), ...(RUN.denied?.length ? { commandDeny: RUN.denied } : {}) }
+    this.usage = entry?.usage || { turns: 0, prompt: 0, output: 0 }
+  }
+
+  get displayTitle() {
+    const first = this.history.find((m) => m.role === 'user')
+    return this.title || this.aiTitle || (first ? String(first.content).replace(/\[[^\]]*\]\n?/g, '').replace(/\s+/g, ' ').trim().slice(0, 80) : 'New conversation')
+  }
+
+  save(model) {
+    if (!this.history.some((m) => m.role === 'user')) return
+    this.store.save({ id: this.id, title: this.displayTitle, renamed: !!this.title, aiTitle: this.aiTitle || undefined, created: this.created,
+      updated: Date.now(), server: server(), model: model || null, history: this.history, transcript: this.transcript, todos: this.todos,
+      usage: this.usage, origin: 'cli' })
+  }
+}
+
+/** One turn of the conversation: the agent runs until it answers. Returns the run's result. */
+async function runTurn(convo, text, ui, { model, maxTurns, content } = {}) {
+  const agent = require(path.join(EXT, 'agent.js'))
+  convo.history.push({ role: 'user', content: content || text })
+  convo.transcript.push({ kind: 'user', text, at: Date.now() })
+  const controller = new AbortController()
+  ui.onStart?.(controller)
+  let turns = 0
+  let lastText = ''
+  try {
+    const result = await agent.run({
+      server: server(), model, history: convo.history, session: convo.session, signal: controller.signal,
+      onDelta: (d) => ui.delta?.(d),
+      onThinking: (d) => ui.thinking?.(d),
+      onTool: (event) => {
+        const key = event.id || `${event.tool}:${JSON.stringify(event.args)}`
+        const existing = convo.transcript.find((t) => t.kind === 'tool' && t.key === key)
+        if (existing) Object.assign(existing, event); else convo.transcript.push({ kind: 'tool', key, at: Date.now(), ...event })
+        ui.tool?.(event)
+      },
+      onNudge: (reason, detail) => ui.nudge?.(reason, detail),
+      askUser: (questions, signal) => ui.askUser(questions, signal),
+      approve: (request, signal) => ui.approve(request, signal),
+      approvePlan: (plan, signal) => ui.approvePlan(plan, signal),
+      onTodos: (todos) => { convo.todos = todos; ui.todos?.(todos) },
+      trustHooks: (groups) => ui.trust('hooks', groups),
+      trustMcp: (servers) => ui.trust('MCP servers', servers),
+      onMessages: (messages) => { convo.history = messages; convo.save(model) },
+      onTurn: ({ text: said, meta }) => {
+        turns += 1
+        if (String(said || '').trim()) { convo.transcript.push({ kind: 'assistant', text: said, meta, at: Date.now() }); lastText = said }
+        convo.usage.turns += 1
+        convo.usage.prompt += meta?.context_used || 0
+        convo.usage.output += meta?.eval_tokens || meta?.tokens || 0
+        ui.turn?.({ text: said, meta })
+        if (maxTurns && turns >= maxTurns) controller.abort()
+      },
+    })
+    convo.history = result.messages
+    if (result.error) convo.transcript.push({ kind: 'error', text: result.error, at: Date.now() })
+    convo.save(model)
+    return { ...result, text: lastText, turns }
+  } finally { ui.onEnd?.() }
+}
+
+// ---- print mode: one prompt, no questions ----
+async function printMode(o, convo, text) {
+  const started = Date.now()
+  const events = o.format === 'stream-json'
+  const emit = (obj) => process.stdout.write(`${JSON.stringify(obj)}\n`)
+  if (events) emit({ type: 'system', subtype: 'init', session_id: convo.id, cwd: process.cwd(), model: o.model || null, version: VERSION })
+  let planText = null
+  const ui = {
+    delta: () => {},
+    tool: (e) => { if (events && (e.status === 'done' || e.status === 'failed' || e.status === 'refused')) emit({ type: 'tool', tool: e.tool, args: e.args, status: e.status, result: typeof e.result === 'string' ? e.result.slice(0, 4000) : undefined }) },
+    turn: ({ text: said }) => { if (events && String(said || '').trim()) emit({ type: 'assistant', text: said }) },
+    // Nobody to ask: what needs a yes is refused, a question is left to the agent.
+    approve: async (request) => ({ decision: 'deny', feedback: `not allowed in print mode (-p): ${request.kind === 'command' ? request.command : request.path || request.tool} — allow it with --allowedTools or --permission-mode` }),
+    askUser: async () => ({ dismissed: true }),
+    // The plan is the answer: the run ends there, with no further turn.
+    approvePlan: async (plan) => { planText = plan; ui.controller?.abort(); return { approved: false, feedback: 'Stop here: the plan is the answer.' } },
+    trust: async () => false,
+  }
+  const result = await runTurn(convo, text, { ...ui, onStart: (c) => { ui.controller = c; if (planText === null) process.once('SIGINT', () => c.abort()) } }, { model: o.model, maxTurns: o.maxTurns })
+  const answer = planText ?? result.text
+  const failed = !!result.error && !result.stopped
+  if (o.format === 'text') process.stdout.write(`${answer || (result.error ? `error: ${result.error}` : '')}\n`)
+  else emit({ type: 'result', subtype: failed ? 'error' : 'success', is_error: failed, result: answer, session_id: convo.id, num_turns: result.turns,
+    duration_ms: Date.now() - started, error: result.error || undefined, usage: { prompt_tokens: convo.usage.prompt, output_tokens: convo.usage.output } })
+  return failed ? 1 : 0
+}
+
+// ---- interactive ----
+// What can be typed after / here — the extension's names, where a terminal can do them.
+// The project's custom commands (.aipictury/commands, .claude/commands) and skills follow.
+const SLASH = [
+  ['help', 'What can be typed here', ''],
+  ['clear', 'Start a new conversation', ''],
+  ['compact', 'Summarize the conversation so far, to free context', '[what to focus on]'],
+  ['btw', 'Ask a side question without adding it to the conversation', '<question>'],
+  ['resume', 'Carry on an earlier conversation of this folder', ''],
+  ['rename', 'Rename this conversation', '<title>'],
+  ['export', 'Save the conversation as Markdown', '[file]'],
+  ['todos', 'The agent\'s to-do list', ''],
+  ['model', 'Switch the model', '[name]'],
+  ['effort', 'How hard the model reasons', '[low|medium|high|max|ultra]'],
+  ['mode', 'When the agent asks first', '[default|acceptEdits|auto|plan]'],
+  ['permissions', 'What it may do without asking, must ask about, may never do', '[allow|ask|deny <rule>]'],
+  ['mcp', 'MCP servers and their tools', ''],
+  ['status', 'Version, account server, model, mode, folder', ''],
+  ['usage', 'Tokens and time this conversation has used', ''],
+  ['init', 'Write an AIPICTURY.md that explains this codebase to the agent', ''],
+  ['review', 'Review the uncommitted changes', '[what to focus on]'],
+  ['exit', 'Quit', ''],
+]
+
+async function interactive(o, convo, first, cfg) {
+  const T = require('./terminal.js')
+  const agent = require(path.join(EXT, 'agent.js'))
+  const context = require(path.join(EXT, 'context.js'))
+  const ext = require(path.join(EXT, 'extension.js'))
+  // A terminal gets line editing, completion and a remembered history; a pipe (a script, a
+  // test) plain lines, each one a message.
+  const terminal = !!(process.stdin.isTTY && process.stdout.isTTY)
+  const historyFile = path.join(HOME(), 'cli-history.json')
+  let remembered = []
+  try { remembered = terminal ? JSON.parse(fs.readFileSync(historyFile, 'utf8')) : [] } catch { /* none yet */ }
+  const names = () => [...SLASH.map(([n]) => n), ...context.commands().map((c) => c.name), ...context.skills().map((s) => s.name)]
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout, terminal, historySize: 500, history: remembered,
+    removeHistoryDuplicates: true,
+    completer: terminal ? T.completer({ commands: names, files: async (q) => (await ext.mentionCandidates(q)).map((c) => c.path) }) : undefined })
+
+  // Every line typed comes here; a question waiting takes the next one, else it is a message.
+  const inbox = []
+  let waiting = null
+  let closed = false
+  rl.on('line', (line) => {
+    if (waiting?.question) { const w = waiting; waiting = null; w.resolve(line); return }
+    inbox.push({ line, at: Date.now() })
+    if (running && terminal && line.trim()) say(dim(`  queued: ${line.trim().slice(0, 80)}`))
+    if (waiting) { const w = waiting; waiting = null; w.resolve() }
+  })
+  rl.on('close', () => { closed = true; if (waiting) { const w = waiting; waiting = null; w.resolve(null) } })
+  const nextLine = () => new Promise((resolve) => {
+    if (inbox.length) { resolve(inbox.shift().line); return }
+    if (closed) { resolve(null); return }
+    waiting = { resolve: () => resolve(inbox.length ? inbox.shift().line : null) }
+  })
+  /** A question at the prompt: its answer, or null when it is called off (Ctrl+C, Ctrl+D). */
+  const ask = (q) => new Promise((resolve) => {
+    spinner.pause()
+    if (streamed) { md.end(); process.stdout.write('\n'); streamed = false }
+    // A script answers with the lines it has already sent.
+    if (!terminal && inbox.length) { process.stdout.write(q); resolve(inbox.shift().line); return }
+    if (closed) { resolve(null); return }
+    waiting = { question: true, resolve: (a) => { rl.setPrompt(PROMPT); resolve(a) } }
+    rl.setPrompt(q)
+    rl.prompt()
+  })
+
+  let running = null
+  let model = o.model || null
+  let streamed = false
+  let shellContext = []       // what was run with ! since the last message: the next one carries it
+  const shown = new Map()
+  const PROMPT = `${bold('›')} `
+  const md = new T.MarkdownStream()
+  const spinner = new T.Spinner({ busyTyping: () => !!rl.line })
+  const say = (t) => { spinner.pause(); if (streamed) { md.end(); process.stdout.write('\n'); streamed = false } process.stdout.write(`${t}\n`); if (running) spinner.start() }
+  const mode = () => agent.modeNow()
+  const label = (e) => {
+    const a = e.args || {}
+    return String(a.command || a.path || a.pattern || a.url || a.query || a.description || a.title || a.action || '').replace(/\s+/g, ' ').slice(0, 100)
+  }
+  const ui = {
+    onStart: (c) => { running = c; streamed = false; spinner.start('thinking') },
+    onEnd: () => { running = null; spinner.stop(); if (streamed) { md.end(); process.stdout.write('\n'); streamed = false } },
+    delta: (d) => {
+      spinner.pause()
+      if (!streamed) { process.stdout.write('\n'); streamed = true }
+      md.push(d)
+    },
+    thinking: () => { if (!streamed) spinner.start('thinking') },
+    tool: (e) => {
+      const key = e.id || `${e.tool}:${JSON.stringify(e.args)}`
+      if (e.status === 'running' && !shown.has(key)) { shown.set(key, true); say(`${cyan('⏺')} ${bold(e.tool)} ${dim(label(e))}`); spinner.start(e.tool) }
+      if (['done', 'failed', 'refused', 'plan'].includes(e.status)) {
+        const out = typeof e.result === 'string' ? e.result.trim().split('\n') : []
+        const mark = e.status === 'done' ? green('⎿') : red('⎿')
+        if (!shown.has(key)) say(`${cyan('⏺')} ${bold(e.tool)} ${dim(label(e))}`)
+        shown.set(key, 'end')
+        say(`  ${mark} ${dim(`${out[0]?.slice(0, 160) || e.status}${out.length > 1 ? `  (+${out.length - 1} lines)` : ''}`)}`)
+        spinner.start('thinking')
+      }
+    },
+    nudge: (reason, detail) => { if (detail?.text) say(dim(`  · ${detail.text}`)) },
+    todos: (todos) => say(dim(todos.map((t) => `  ${t.status === 'completed' ? '☑' : t.status === 'in_progress' ? '▸' : '☐'} ${t.content}`).join('\n'))),
+    async approve(request) {
+      const what = request.kind === 'command' ? `Run ${bold(request.command)}`
+        : request.kind === 'edit' ? `${request.before == null ? 'Create' : 'Change'} ${bold(request.path)}`
+          : request.tool === 'browser' ? `Use the browser on ${bold(request.site || 'a page')}` : `Use ${bold(request.tool)} ${dim(JSON.stringify(request.args || {}).slice(0, 200))}`
+      say(`\n${yellow('?')} ${what}${request.because ? dim(` — ${request.because}`) : ''}`)
+      if (request.kind === 'edit') for (const h of (request.hunks || []).slice(0, 6)) say([...h.removed.slice(0, 8).map((l) => red(`  - ${l}`)), ...h.added.slice(0, 12).map((l) => green(`  + ${l}`))].join('\n'))
+      const answer = await ask(`  ${bold('y')}es · ${bold('a')}lways${request.rule ? dim(` (${request.rule}, this conversation)`) : ' (this conversation)'} · ${bold('n')}o, or say what to do instead › `)
+      spinner.start()
+      if (answer === null) return { decision: 'deny', feedback: '' }
+      const a = answer.trim()
+      if (/^y(es)?$/i.test(a) || a === '') return { decision: 'allow' }
+      if (/^a(lways)?$/i.test(a)) return { decision: 'allow_all', destination: 'conversation', prefix: request.prefix }
+      return { decision: 'deny', feedback: /^no?$/i.test(a) ? '' : a }
+    },
+    async askUser(questions) {
+      const answers = []
+      for (const q of questions) {
+        say(`\n${yellow('?')} ${bold(q.question)}`)
+        q.options.forEach((opt, i) => say(`  ${i + 1}. ${opt.label}${opt.description ? dim(` — ${opt.description}`) : ''}`))
+        const answer = await ask(`  ${q.multiSelect ? 'numbers (1,3)' : 'a number'}, your own answer, or Enter to let the agent decide › `)
+        const a = (answer || '').trim()
+        if (!a) { spinner.start(); return { dismissed: true } }
+        const nums = a.split(/[,\s]+/).map(Number)
+        if (nums.every((n) => Number.isInteger(n) && n >= 1 && n <= q.options.length)) answers.push({ header: q.header, question: q.question, picked: nums.map((n) => q.options[n - 1].label) })
+        else answers.push({ header: q.header, question: q.question, picked: [], other: a })
+      }
+      spinner.start()
+      return { answers }
+    },
+    async approvePlan(plan) {
+      say(`\n${bold('The plan:')}\n`)
+      const view = new T.MarkdownStream()
+      view.push(`${plan}\n`)
+      view.end()
+      const answer = await ask(`\n  ${bold('y')}es, go ahead (asking as now) · ${bold('a')}uto (go ahead, asking only when risky) · or say what to change › `)
+      spinner.start()
+      if (answer === null) return { approved: false, feedback: '' }
+      const a = answer.trim()
+      if (/^y(es)?$/i.test(a) || a === '') return { approved: true, mode: 'ask' }
+      if (/^a(uto)?$/i.test(a)) return { approved: true, mode: 'never' }
+      return { approved: false, feedback: a }
+    },
+    async trust(what, items) {
+      say(`\n${yellow('?')} This project has ${what} of its own: ${dim(JSON.stringify(items).slice(0, 300))}`)
+      const answer = await ask(`  trust and use them? ${bold('y')}/${bold('n')} › `)
+      spinner.start()
+      return /^y/i.test((answer || '').trim())
+    },
+  }
+  const contextShare = () => Math.min(100, Math.round((agent.estimateTokens(convo.history) / Math.max(1, agent.budget())) * 100))
+  const status = () => `${dim(`${server()} · ${model || cfg?.roles?.agent || 'the agent model'} · ${agent.MODES[mode()]?.label || mode()} · ${process.cwd()}`)}`
+  say(`${bold('AIPictury')} ${VERSION} — ${convo.history.length ? `carrying on: ${convo.displayTitle}` : 'a new conversation'}\n${status()}`)
+  say(dim(terminal ? '/ for commands (Tab completes) · @ to mention a file · ! runs a command · end a line with \\ for another · Esc stops a run · Ctrl+C twice quits'
+    : '/help for commands · Ctrl+C stops a run · Ctrl+C twice quits'))
+  let quitArmed = false
+  rl.on('SIGINT', () => {
+    if (running) { running.abort(); say(dim('\n  stopped')); return }
+    if (waiting?.question) { const w = waiting; waiting = null; process.stdout.write('\n'); w.resolve(null); return }
+    if (quitArmed) { rl.close(); return }
+    quitArmed = true
+    rl.line && rl.write(null, { ctrl: true, name: 'u' })
+    say(dim('\n  (Ctrl+C again to quit)'))
+    rl.prompt()
+  })
+  if (terminal) process.stdin.on('keypress', (_, key) => { if (key?.name === 'escape' && running) running.abort() })
+
+  const turn = async (text, extra = []) => {
+    const started = Date.now()
+    try {
+      // @mentions are read now, as the editor does; what ! ran goes with the message too.
+      const mentioned = await ext.resolveMentions(text, convo.session).catch(() => [])
+      const parts = [text, ...shellContext.splice(0)]
+      if (mentioned.length) parts.push(`Files the user referenced (already read for you):\n\n${mentioned.join('\n\n')}`)
+      const r = await runTurn(convo, text, ui, { model, content: [...parts, ...extra].join('\n\n') })
+      if (r.error && !r.stopped) say(red(`\n  error: ${r.error}`))
+    } catch (error) { say(red(`\n  error: ${error.message}`)) }
+    if (terminal) say(dim(`  ${Math.round((Date.now() - started) / 100) / 10}s · ${convo.usage.output} tokens written · context ${contextShare()}% used`))
+  }
+  const shell = (command) => {
+    const { spawnSync } = require('child_process')
+    const r = spawnSync(process.env.SHELL || '/bin/sh', ['-c', command], { cwd: process.cwd(), encoding: 'utf8', timeout: 120_000, maxBuffer: 8 * 1024 * 1024 })
+    const out = `${r.stdout || ''}${r.stderr || ''}`.replace(/\s+$/, '')
+    const lines = out ? out.split('\n') : []
+    lines.slice(0, 40).forEach((l) => say(`  ${dim('⎿')} ${l}`))
+    if (lines.length > 40) say(dim(`  … ${lines.length - 40} more lines (all of it goes with your next message)`))
+    if (r.status) say(red(`  exit ${r.status}`))
+    if (r.error) say(red(`  ${r.error.message}`))
+    shellContext.push(`I ran this myself in the terminal: \`${command}\`${r.status ? ` (exit ${r.status})` : ''}\n\n\`\`\`\n${out.slice(-20_000)}\n\`\`\``)
+  }
+  const command = async (line) => {
+    const [name, ...rest] = line.slice(1).split(/\s+/)
+    const arg = rest.join(' ').trim()
+    const cfgSet = (k, v) => { vscode.state.settings[`aipictury.${k}`] = v }
+    const folder = process.cwd()
+    switch (name) {
+      case 'help': {
+        const width = Math.max(...SLASH.map(([n, , h]) => `/${n} ${h}`.length))
+        for (const [n, d, h] of SLASH) say(`  ${cyan(`/${n}`)} ${dim(h)}${' '.repeat(width - `/${n} ${h}`.length)}  ${d}`)
+        const custom = context.commands()
+        if (custom.length) say(dim(`  this project's commands: ${custom.map((c) => `/${c.name}`).join(', ')}`))
+        say(dim('  @path mentions a file · !command runs it here (its output goes with your next message) · a line ending in \\ continues'))
+        return true
+      }
+      case 'exit': case 'quit': rl.close(); return true
+      case 'clear': convo.save(model); Object.assign(convo, new Conversation(convo.store)); shellContext = []; say(dim('  a new conversation')); return true
+      case 'model': if (arg) { model = arg } say(dim(`  model: ${model || cfg?.roles?.agent}${arg ? '' : `  (installed: ${(cfg?.models || []).filter((m) => m.tools).map((m) => m.name).join(', ')})`}`)); return true
+      case 'effort': if (arg) { if (!agent.EFFORT[arg]) { say(red(`  one of: ${Object.keys(agent.EFFORT).join(', ')}`)); return true } cfgSet('effort', arg) } say(dim(`  effort: ${vscode.workspace.getConfiguration('aipictury').get('effort')}`)); return true
+      case 'mode': if (arg) { if (!MODE_OF[arg] || MODE_OF[arg] === 'bypass') { say(red('  one of: default, acceptEdits, auto, plan')); return true } cfgSet('approval', MODE_OF[arg]) } say(status()); return true
+      case 'status': say(`  AIPictury ${VERSION}`); say(status()); say(dim(`  conversation ${convo.id}: ${convo.displayTitle}`)); return true
+      case 'usage': case 'cost': case 'context':
+        say(dim(`  ${convo.usage.turns} model turns · ${convo.usage.prompt} tokens read · ${convo.usage.output} written · context ${contextShare()}% used (${agent.estimateTokens(convo.history)} of ${agent.budget()} tokens)`))
+        return true
+      case 'rename': if (!arg) { say(red('  /rename <title>')); return true } convo.title = arg; convo.save(model); say(dim(`  renamed: ${arg}`)); return true
+      case 'todos':
+        if (!convo.todos.length) say(dim('  no to-do list in this conversation'))
+        else ui.todos(convo.todos)
+        return true
+      case 'export': {
+        if (!convo.transcript.length) { say(dim('  nothing to export yet')); return true }
+        const file = path.resolve(arg || `aipictury-${convo.id}.md`)
+        fs.writeFileSync(file, ext.toMarkdown(convo.displayTitle, convo.transcript))
+        say(dim(`  saved ${file}`))
+        return true
+      }
+      case 'permissions': case 'allowed-tools': {
+        const prefs = require(path.join(EXT, 'prefs.js'))
+        const m = /^(allow|ask|deny)\s+(.+)$/.exec(arg)
+        if (m) {
+          if (!require(path.join(EXT, 'permissions.js')).parseRule(m[2])) { say(red('  write a rule like Bash(npm test:*) or Read(./.env)')); return true }
+          const file = prefs.addRule(folder, 'local', m[1], m[2])
+          say(dim(`  added ${m[2]} to ${m[1]} (${file.replace(os.homedir(), '~')})`))
+          return true
+        }
+        const merged = prefs.load(folder).merged.permissions
+        for (const kind of ['allow', 'ask', 'deny']) {
+          const rules = merged[kind] || []
+          say(`  ${bold(kind)} ${dim(`(${rules.length})`)}`)
+          for (const r of rules.slice(0, 30)) say(`    ${r.rule} ${dim(r.file.replace(os.homedir(), '~'))}`)
+          if (rules.length > 30) say(dim(`    … ${rules.length - 30} more`))
+        }
+        if (RUN.allowed?.length || RUN.denied?.length) say(dim(`  this run: allowed ${RUN.allowed?.join(', ') || '—'} · denied ${RUN.denied?.join(', ') || '—'}`))
+        say(dim('  add one: /permissions allow|ask|deny <rule>  (kept for this project, just you)'))
+        return true
+      }
+      case 'mcp': {
+        const mcp = require(path.join(EXT, 'mcp.js'))
+        const live = new Map(mcp.status().map((s) => [s.name, s]))
+        const configured = [...mcp.detailed(folder).entries()]
+        if (!configured.length && !live.size) { say(dim('  no MCP servers configured (.mcp.json, ~/.aipictury/mcp.json, --mcp-config)')); return true }
+        for (const [n, c] of configured) {
+          const s = live.get(n)
+          say(`  ${bold(n)} ${dim(c.disabled ? 'disabled' : s ? `${s.state}${s.error ? ` — ${s.error}` : ''}` : 'connects when the agent first needs it')}`)
+          if (s?.tools?.length) say(dim(`    ${s.tools.join(', ')}`))
+        }
+        return true
+      }
+      case 'compact': {
+        if (convo.history.length < 3) { say(dim('  nothing to summarize yet')); return true }
+        const before = agent.estimateTokens(convo.history)
+        spinner.start('summarizing'); running = new AbortController()
+        try {
+          const next = await agent.summarizeEarlier(server(), [{ role: 'system', content: '' }, ...convo.history], { model: model || undefined, force: true, focus: arg, signal: running.signal })
+          running = null; spinner.stop()
+          if (!next) say(dim('  the conversation is already short — nothing to summarize'))
+          else { convo.history = next.slice(1); convo.save(model); say(dim(`  summarized: ${before} → ${agent.estimateTokens(convo.history)} tokens`)) }
+        } catch (error) { running = null; spinner.stop(); say(red(`  could not summarize: ${error.message}`)) }
+        return true
+      }
+      case 'btw': {
+        if (!arg) { say(red('  /btw <question>')); return true }
+        const side = new T.MarkdownStream()
+        spinner.start('thinking'); running = new AbortController()
+        let started = false
+        try {
+          const answer = await agent.sideQuestion(server(), convo.history, arg, { model: model || undefined, session: convo.session, signal: running.signal,
+            onDelta: (d) => { spinner.pause(); if (!started) { process.stdout.write(`\n${dim('(aside)')} `); started = true } side.push(d) } })
+          if (!started && answer) { spinner.pause(); process.stdout.write(`\n${dim('(aside)')} `); side.push(answer) }
+          side.end(); process.stdout.write('\n')
+        } catch (error) { say(red(`  error: ${error.message}`)) } finally { running = null; spinner.stop() }
+        return true
+      }
+      case 'init': await turn(ext.INIT_PROMPT); return true
+      case 'review': await turn(arg ? `${ext.REVIEW_PROMPT}\n\nFocus on: ${arg}` : ext.REVIEW_PROMPT); return true
+      case 'resume': {
+        const list = convo.store.list().slice(0, 15)
+        if (!list.length) { say(dim('  no conversations in this folder yet')); return true }
+        list.forEach((e, i) => say(`  ${i + 1}. ${e.title}  ${dim(new Date(e.updated).toLocaleString())}`))
+        const a = ((await ask('  which (number), or Enter › ')) || '').trim()
+        const entry = list[Number(a) - 1] && convo.store.get(list[Number(a) - 1].id)
+        if (entry) { convo.save(model); Object.assign(convo, new Conversation(convo.store, entry)); say(dim(`  carrying on: ${convo.displayTitle}`)) }
+        return true
+      }
+      default: {
+        // The project's own commands, in Claude Code's format, and its skills.
+        const prompt = context.expandCommand(line)
+        if (prompt) {
+          const meta = context.commandMeta(line)
+          const permissions = require(path.join(EXT, 'permissions.js'))
+          const shellMod = require(path.join(EXT, 'shell.js'))
+          const allowed = (cmd) => {
+            const verdict = permissions.decide('run_command', { command: cmd }, { folder })
+            if (verdict.decision === 'deny') return false
+            const granted = permissions.decide('run_command', { command: cmd }, { rules: { allow: meta.allowedTools, ask: [], deny: [] } }).decision === 'allow'
+            return granted || verdict.decision === 'allow' || shellMod.isReadOnly(cmd)
+          }
+          const before = convo.session.commandAllow
+          convo.session.commandAllow = [...(RUN.allowed || []), ...meta.allowedTools]
+          try { await turn(await context.runInline(prompt, { cwd: folder, allowed })) } finally { convo.session.commandAllow = before }
+          return true
+        }
+        const skill = context.skills().find((s) => s.name === name)
+        if (skill) { await turn(`Use the ${skill.name} skill${arg ? ` on: ${arg}` : ''}.`); return true }
+        return false
+      }
+    }
+  }
+
+  /** The next message: a line, the lines after it while each ends in \, or a paste of many. */
+  const nextMessage = async () => {
+    rl.setPrompt(PROMPT)
+    rl.prompt()
+    let line = await nextLine()
+    if (line === null) return null
+    const lines = []
+    for (;;) {
+      if (line.endsWith('\\')) {
+        lines.push(line.slice(0, -1))
+        rl.setPrompt(dim('… '))
+        rl.prompt()
+        line = await nextLine()
+        if (line === null) break
+        continue
+      }
+      lines.push(line)
+      // Pasted lines come in one burst: they are one message. A person types slower.
+      if (!terminal) break
+      await new Promise((r) => setTimeout(r, 25))
+      if (!inbox.length) break
+      line = inbox.shift().line
+    }
+    return lines.join('\n')
+  }
+
+  if (first) await turn(first)
+  for (;;) {
+    const message = await nextMessage()
+    if (message === null) break
+    quitArmed = false
+    const text = message.trim()
+    if (!text) continue
+    if (text.startsWith('!') && text.length > 1) { shell(text.slice(1).trim()); continue }
+    if (!(text.startsWith('/') && !text.includes('\n') && await command(text))) await turn(text)
+    if (closed) break
+  }
+  convo.save(model)
+  if (terminal) {
+    try { fs.mkdirSync(HOME(), { recursive: true }); fs.writeFileSync(historyFile, JSON.stringify(rl.history.slice(0, 500)), { mode: 0o600 }) } catch { /* not remembered */ }
+  }
+  if (!closed) rl.close()
+  return 0
+}
+
+// ---- the AIPictury account (needed, as in VS Code) ----
+const HOME = () => process.env.AIPICTURY_HOME || path.join(os.homedir(), '.aipictury')
+
+function accountFor() {
+  const { Account, fileStore } = require(path.join(EXT, 'account.js'))
+  const config = require(path.join(EXT, 'media', 'vendor', 'firebase-config.json'))
+  return new Account({ store: fileStore(path.join(HOME(), 'credentials.json')), config, client: 'the aipictury CLI' })
+}
+
+/** The conversations of this run, kept with the account: what was saved is pushed before exiting. */
+function cloudFor(account) {
+  const { Cloud } = require(path.join(EXT, 'cloud.js'))
+  const { emulatorHosts } = require(path.join(EXT, 'account.js'))
+  const config = require(path.join(EXT, 'media', 'vendor', 'firebase-config.json'))
+  const deviceFile = path.join(HOME(), 'device.json')
+  let id
+  try { id = JSON.parse(fs.readFileSync(deviceFile, 'utf8')).id } catch { /* first run */ }
+  if (!id) { id = require('crypto').randomUUID(); fs.mkdirSync(HOME(), { recursive: true }); fs.writeFileSync(deviceFile, JSON.stringify({ id })) }
+  const cloud = new Cloud({ account, projectId: config.projectId, emulator: emulatorHosts().firestore,
+    bucket: config.storageBucket, storageEmulator: emulatorHosts().storage,
+    device: { id, name: os.hostname(), app: 'cli', platform: process.platform, version: VERSION } })
+  const pending = new Map()
+  const removed = []
+  const on = (kind) => vscode.workspace.getConfiguration('aipictury').get(`cloud.${kind}`, true)
+  require(path.join(EXT, 'sessions.js')).onWrite((e) => {
+    if (!e.folder || !on('conversations')) return
+    if (e.type === 'remove') { pending.delete(e.id); removed.push([e.folder, e.id]); return }
+    pending.set(e.id, [e.folder, { ...e.entry, origin: 'cli' }])
+  })
+  // Every render the agent makes is kept with the account; the run waits for it before it ends.
+  const keeping = []
+  require(path.join(EXT, 'mediagen.js')).onRendered((base, jobId) => {
+    keeping.push(cloud.keepRender(base, jobId).catch((err) => process.stderr.write(dim(`  (render not kept with your account: ${err.message})\n`))))
+  })
+  return {
+    cloud,
+    async flush() {
+      await Promise.all(keeping)
+      if (!(await account.user())) return
+      for (const [folder, entry] of pending.values()) await cloud.pushConversation(folder, entry).catch((err) => process.stderr.write(dim(`  (not kept with your account: ${err.message})\n`)))
+      for (const [folder, id] of removed) await cloud.deleteConversation(folder, id).catch(() => {})
+      pending.clear()
+    },
+  }
+}
+
+function openBrowser(url) {
+  const { spawn } = require('child_process')
+  const cmd = process.platform === 'darwin' ? ['open', [url]] : process.platform === 'win32' ? ['cmd', ['/c', 'start', '', url]] : ['xdg-open', [url]]
+  try { spawn(cmd[0], cmd[1], { stdio: 'ignore', detached: true }).unref() } catch { /* the address is printed anyway */ }
+}
+
+async function accountCommand(name, argv) {
+  const account = accountFor()
+  if (name === 'whoami') {
+    const u = await account.user()
+    if (!u) { process.stdout.write('Not signed in — aipictury login\n'); return 1 }
+    process.stdout.write(`${u.email || u.displayName} (${u.uid})\n`)
+    return 0
+  }
+  if (name === 'logout') {
+    await account.signOut()
+    process.stdout.write('Signed out: nothing of the account is kept on this machine.\n')
+    return 0
+  }
+  const noBrowser = argv.includes('--no-browser')
+  try {
+    const u = await account.signIn({ open: async (url) => {
+      process.stderr.write(`Sign in to AIPictury in your browser:\n  ${url}\n`)
+      if (!noBrowser) openBrowser(url)
+    } })
+    process.stdout.write(`Signed in as ${u.email || u.displayName}.\n`)
+    return 0
+  } catch (error) { process.stderr.write(`aipictury: not signed in — ${error.message}\n`); return 1 }
+}
+
+async function main() {
+  const first = process.argv[2]
+  if (['login', 'logout', 'whoami'].includes(first)) return accountCommand(first, process.argv.slice(3))
+  let o
+  try { o = parseArgs(process.argv.slice(2)) } catch (error) { process.stderr.write(`aipictury: ${error.message}\n`); return 2 }
+  if (o.help) { process.stdout.write(`${HELP}\n`); return 0 }
+  if (o.version) { process.stdout.write(`${VERSION}\n`); return 0 }
+  setup(o)
+  // AIPictury needs the account, here as in VS Code.
+  const account = accountFor()
+  if (!(await account.user())) { process.stderr.write('aipictury: AIPictury needs your account — run: aipictury login\n'); return 1 }
+  try { await account.idToken() } catch (error) {
+    if (!(await account.user())) { process.stderr.write('aipictury: your session has ended — run: aipictury login\n'); return 1 }
+    process.stderr.write(dim(`  (the account cannot be reached now: ${error.message})\n`))
+  }
+  const sync = cloudFor(account)
+  // No server set here: the one chosen with the account (aipictury.com), as the editor does.
+  if (!require(path.join(EXT, 'gpuServer.js')).explicit()) {
+    try { await require(path.join(EXT, 'gpuServer.js')).adopt((await sync.cloud.getPreferences())?.values?.gpuServer) } catch { /* said below if none */ }
+  }
+  // Every call to the GPU server carries the account's token (the server may require it), and only those.
+  const { serverFetch } = require(path.join(EXT, 'account.js'))
+  globalThis.fetch = serverFetch({ fetch: globalThis.fetch, account, server })
+  try { return await mainRun(o) } finally { await sync.flush() }
+}
+
+async function mainRun(o) {
+  const { SessionStore } = require(path.join(EXT, 'sessions.js'))
+  const store = new SessionStore(process.cwd())
+  let entry = null
+  if (o.continue) entry = store.list()[0] ? store.get(store.list()[0].id) : null
+  if (typeof o.resume === 'string') {
+    entry = store.get(o.resume)
+    if (!entry) { process.stderr.write(`aipictury: no conversation ${o.resume} in this folder\n`); return 1 }
+  }
+  if (o.resume === true && o.print) { process.stderr.write('aipictury: --resume needs an id in print mode\n'); return 2 }
+  const convo = new Conversation(store, entry)
+  let text = o.prompt
+  if (!process.stdin.isTTY && o.print) {
+    const piped = fs.readFileSync(0, 'utf8')
+    if (piped.trim()) text = text ? `${text}\n\n${piped}` : piped
+  }
+  let cfg
+  try { cfg = await serverConfig() } catch (error) {
+    process.stderr.write(server() ? `aipictury: cannot use the server at ${server()} — ${error.message}\n` : `aipictury: ${error.message}\n`)
+    return 1
+  }
+  if (o.print) {
+    if (!text) { process.stderr.write('aipictury: -p needs a prompt\n'); return 2 }
+    return printMode(o, convo, text)
+  }
+  if (o.resume === true) {
+    const list = store.list().slice(0, 15)
+    if (!list.length) process.stdout.write('No conversations in this folder yet.\n')
+    else list.forEach((e) => process.stdout.write(`${e.id}  ${e.title}\n`))
+    return 0
+  }
+  return interactive(o, convo, text, cfg)
+}
+
+main().then((code) => {
+  require(path.join(EXT, 'agent.js')).stopBackground?.()
+  try { require(path.join(EXT, 'mcp.js')).closeAll() } catch { /* none */ }
+  require(path.join(EXT, 'browser.js')).close().finally(() => process.exit(code))
+}, (error) => { process.stderr.write(`aipictury: ${error.stack || error.message}\n`); process.exit(1) })