@davait/aipictury 1.18.1 → 1.19.1

package/README.md

@@ -34,6 +34,18 @@ aipictury -p "…" --allowedTools "Bash(npm test:*),Edit" --disallowedTools "Web
 aipictury -p "…" --mcp-config servers.json --add-dir ../shared --append-system-prompt "Be brief."
 ```
 
+## Logs
+
+`~/.aipictury/logs/cli.log` keeps what went wrong. `--debug` (or `AIPICTURY_DEBUG=1`) writes every
+level — each request to the server with its status and time, each step of the run — as JSON lines
+to `~/.cache/aipictury/cli.jsonl` (rotated at 5 MB, one older file kept), to read with `jq`:
+
+```
+jq -c 'select(.level=="warn" or .level=="error")' ~/.cache/aipictury/cli.jsonl
+```
+
+No token and no conversation text is ever written.
+
 ## License
 
 Copyright © 2026 Davait, Inc. All rights reserved. Proprietary software: see LICENSE.md.

package/ext/extension.js

@@ -2298,6 +2298,8 @@ function activate(context) {
   // This window names itself on every call to its GPU server (gpuRun.js).
   gpuRun.setApp({ client: 'vscode', server: serverUrl })
   gpuRun.nameCalls()
+  // …and every call to it is in the log (Output → AIPictury, at Debug: method, path, status, ms).
+  log.watchFetch({ server: serverUrl })
   try { moveConversationsToDisk(context) } catch { /* tried again next start */ }
   syncCommandEnv().catch(() => { /* again before each run */ })
   undoOldThinkingSwitch(context).catch(() => { /* the setting stays as it was */ })

package/ext/log.js

@@ -1,7 +1,15 @@
 'use strict'
 // The extension's log: View → Output → "AIPictury", or the "AIPictury: Show Logs" command.
 // What is worth reading after something went wrong — a turn, a failure, a stall, a setting
-// that could not be written — never the conversation itself.
+// that could not be written — never the conversation itself, never a token.
+//
+// Levels as VS Code's log channel has them: error, warn, info are always shown; debug and trace
+// (every request to the server with its status and time, the websocket's events, a run's steps)
+// when the channel's level is set to Debug or Trace (the gear in the Output view, or
+// `code --log aipictury.aipictury:debug`). In the terminal (the CLI) the same module writes to a
+// file — cli/vscode-shim.js stands in for `vscode` — and `--debug` turns the two lower levels on.
+//
+//   log.event('debug', 'http.request', { method: 'POST', path: '/api/agent/turn', status: 200, ms: 812 })
 const vscode = require('vscode')
 
 let channel = null
@@ -17,8 +25,10 @@ function out() {
 const recent = []
 const KEEP = 400
 
+const say = (p) => (p instanceof Error ? p.stack || p.message : typeof p === 'string' ? p : JSON.stringify(p))
+
 const write = (level) => (...parts) => {
-  const text = parts.map((p) => (p instanceof Error ? p.stack || p.message : typeof p === 'string' ? p : JSON.stringify(p))).join(' ')
+  const text = parts.map(say).join(' ')
   recent.push(`${new Date().toISOString()} [${level}] ${text}`)
   if (recent.length > KEEP) recent.splice(0, recent.length - KEEP)
   const c = out()
@@ -26,4 +36,62 @@ const write = (level) => (...parts) => {
   else if (c) c.appendLine(`[${level}] ${text}`)
 }
 
-module.exports = { tail: () => [...recent], info: write('info'), warn: write('warn'), error: write('error'), show: () => out()?.show(true), channel: out }
+const levels = { trace: write('trace'), debug: write('debug'), info: write('info'), warn: write('warn'), error: write('error') }
+
+/** A short form of a value for a record's field: one line, at most 160 characters. */
+function short(value) {
+  if (value === undefined || value === null) return 'null'
+  const text = typeof value === 'string' ? value : JSON.stringify(value)
+  const line = String(text).replace(/\s+/g, ' ')
+  return line.length > 160 ? `${line.slice(0, 157)}…` : line
+}
+
+/**
+ * One structured record: `name` is what happened ("http.request", "ws.open", "run.ended"), the
+ * fields what it happened to and how. Written as `name key=value …`; in the terminal as JSON.
+ */
+function event(level, name, fields = {}) {
+  const c = out()
+  if (c && typeof c.record === 'function') { c.record(level, name, fields); return }
+  const shown = Object.entries(fields).filter(([, v]) => v !== undefined).map(([k, v]) => `${k}=${short(v)}`).join(' ')
+  ;(levels[level] || levels.info)(`${name}${shown ? ` ${shown}` : ''}`)
+}
+
+/** A URL's path, never its query: a websocket's token rides there. */
+function pathOf(url) {
+  try { return new URL(url).pathname } catch { return String(url).split('?')[0] }
+}
+
+/**
+ * Every call to the GPU server in the log: method, path, status and milliseconds at debug; a
+ * failure to connect, or the server's error, at warn. `server()`: its address. Installed once.
+ */
+function watchFetch({ server }) {
+  if (globalThis.fetch.watched) return
+  const base = globalThis.fetch
+  const watched = async (input, init = {}) => {
+    const url = typeof input === 'string' ? input : input?.url || String(input)
+    const home = String(server() || '').replace(/\/+$/, '')
+    if (!home || !url.startsWith(home)) return base(input, init)
+    const method = init.method || (typeof input === 'object' && input?.method) || 'GET'
+    const started = Date.now()
+    try {
+      const response = await base(input, init)
+      const ms = Date.now() - started
+      const level = response.status >= 500 ? 'warn' : 'debug'
+      event(level, 'http.request', { method, path: pathOf(url), status: response.status, ms })
+      return response
+    } catch (error) {
+      // Stopped on purpose (a run stopped: AbortError) is not a failure; a timeout is.
+      const aborted = error?.name === 'AbortError'
+      event(aborted ? 'debug' : 'warn', 'http.failed', { method, path: pathOf(url), ms: Date.now() - started,
+        error: aborted ? 'aborted' : error?.name === 'TimeoutError' ? 'timed out' : error?.message || String(error) })
+      throw error
+    }
+  }
+  watched.watched = true
+  watched.namesRuns = base.namesRuns
+  globalThis.fetch = watched
+}
+
+module.exports = { tail: () => [...recent], ...levels, event, watchFetch, pathOf, show: () => out()?.show(true), channel: out }

package/ext/package.json

@@ -2,7 +2,7 @@
   "name": "aipictury",
   "displayName": "AIPictury",
   "description": "A coding agent and a generation studio running on your own GPU, with uncensored local models.",
-  "version": "1.18.1",
+  "version": "1.19.1",
   "publisher": "aipictury",
   "license": "SEE LICENSE IN LICENSE.md",
   "engines": {

package/ext/remote.js

@@ -10,6 +10,7 @@
 // or run a slash command: those stay in VS Code.
 // No VS Code here: the panel is handed in.
 const crypto = require('crypto')
+const logs = require('./log')
 
 const ITEMS = 60                       // transcript entries sent (the latest)
 const TEXT_CAP = 8000                  // characters of one entry
@@ -103,22 +104,27 @@ class RemoteLink {
     if (!this.active) return
     const ws = new WebSocket(`${this.server.replace(/^http/, 'ws')}/ws/remote/host${token ? `?token=${encodeURIComponent(token)}` : ''}`)
     this.ws = ws
-    ws.onopen = () => { ws.send(JSON.stringify({ type: 'hello', id: this.id, key: this.key })) }
+    const opened = Date.now()
+    logs.event('debug', 'ws.connecting', { path: '/ws/remote/host', attempt: this.tries + 1, signedIn: Boolean(token) })
+    ws.onopen = () => { logs.event('debug', 'ws.open', { path: '/ws/remote/host', ms: Date.now() - opened }); ws.send(JSON.stringify({ type: 'hello', id: this.id, key: this.key })) }
     ws.onmessage = (event) => {
       let msg
-      try { msg = JSON.parse(String(event.data)) } catch { return }
+      try { msg = JSON.parse(String(event.data)) } catch { logs.event('debug', 'ws.message', { path: '/ws/remote/host', unreadable: true }); return }
+      logs.event('trace', 'ws.message', { path: '/ws/remote/host', type: msg.type, viewers: msg.viewers, command: msg.command?.type })
       if (msg.type === 'ready') { this.tries = 0; this.connected = true; this.setViewers(msg.viewers); this.send() }
       if (msg.type === 'viewers') this.setViewers(msg.viewers)
-      if (msg.type === 'command') this.command(msg.command || {}).catch((error) => this.log(`remote command failed: ${error.message}`))
+      if (msg.type === 'command') this.command(msg.command || {}).catch((error) => { logs.event('warn', 'remote.command_failed', { type: msg.command?.type, error: error.message }); this.log(`remote command failed: ${error.message}`) })
     }
     ws.onclose = (event) => {
       this.connected = false
-      if (!this.active || event.code === 4403 || event.code === 4409) return
+      const refused = event.code === 4403 || event.code === 4409
+      logs.event(refused ? 'warn' : 'debug', 'ws.close', { path: '/ws/remote/host', code: event.code, reason: event.reason || undefined, seconds: Math.round((Date.now() - opened) / 1000), retrying: this.active && !refused })
+      if (!this.active || refused) return
       const wait = RETRY[Math.min(this.tries, RETRY.length - 1)]
       this.tries += 1
       this.retry = setTimeout(() => this.connect(), wait)
     }
-    ws.onerror = () => {}                                   // onclose follows, and retries
+    ws.onerror = (event) => { logs.event('debug', 'ws.error', { path: '/ws/remote/host', error: event?.message || event?.error?.message || 'socket error' }) }   // onclose follows, and retries
   }
 
   setViewers(n) { this.viewers = n || 0; this.onViewers(this.viewers) }

package/main.js

@@ -48,6 +48,7 @@ Options:
   --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)
+  --debug                            a detailed log of this run (or AIPICTURY_DEBUG=1), see Logs below
   -v, --version                      the version
   -h, --help                         this help
 
@@ -55,6 +56,9 @@ In a conversation: / for commands (/help lists them; Tab completes), @path menti
 !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"}).
+Logs: ~/.aipictury/logs/cli.log (what went wrong); with --debug, every request to the server and
+every step of the run as JSON lines in ~/.cache/aipictury/cli.jsonl (rotated at 5 MB, one kept):
+  jq -c 'select(.level=="warn" or .level=="error")' ~/.cache/aipictury/cli.jsonl
 Copyright © 2026 Davait, Inc. All rights reserved. See LICENSE.md.
 `
 
@@ -80,6 +84,7 @@ function parseArgs(argv) {
     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 === '--debug') o.debug = true
     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`)
@@ -101,6 +106,10 @@ function setup(o) {
   vscode.state.root = process.cwd()
   vscode.state.settingsFile = path.join(home, 'cli.json')
   vscode.state.logFile = path.join(home, 'logs', 'cli.log')
+  if (o.debug || /^(1|true|yes|on)$/i.test(process.env.AIPICTURY_DEBUG || '')) {
+    const cache = process.env.XDG_CACHE_HOME || path.join(os.homedir(), '.cache')
+    vscode.state.debugFile = process.env.AIPICTURY_DEBUG_LOG || path.join(cache, 'aipictury', 'cli.jsonl')
+  }
   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
@@ -716,7 +725,19 @@ async function main() {
   // 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() }
+  // …and each of those calls is in the log (--debug: method, path, status, ms).
+  const log = require(path.join(EXT, 'log.js'))
+  log.watchFetch({ server })
+  log.event('info', 'cli.start', { version: VERSION, mode: o.print ? 'print' : 'interactive', format: o.print ? o.format : undefined, server: server(), model: o.model, effort: o.effort, permission: o.mode, cwd: process.cwd(), debug: vscode.state.debugFile || undefined })
+  const started = Date.now()
+  try {
+    const code = await mainRun(o)
+    log.event('info', 'cli.end', { code, seconds: Math.round((Date.now() - started) / 1000) })
+    return code
+  } catch (error) {
+    log.event('error', 'cli.failed', { error: error.stack || error.message, seconds: Math.round((Date.now() - started) / 1000) })
+    throw error
+  } finally { await sync.flush() }
 }
 
 async function mainRun(o) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@davait/aipictury",
-  "version": "1.18.1",
+  "version": "1.19.1",
   "description": "The AIPictury agent in a terminal: the VS Code extension's agent, on your own GPU server, signed in to your AIPictury account.",
   "bin": {
     "aipictury": "main.js"

package/vscode-shim.js

@@ -14,8 +14,10 @@ const state = {
   defaults: {},                 // "aipictury.x" → default, from the extension's package.json
   settings: {},                 // "aipictury.x" → value, from ~/.aipictury/cli.json and flags
   settingsFile: null,
-  logFile: null,
+  logFile: null,                // ~/.aipictury/logs/cli.log: info and up, readable lines
+  debugFile: null,              // --debug / AIPICTURY_DEBUG: every level, JSON lines (main.js)
 }
+const DEBUG_MB = 5              // the debug log is rotated at this size, one older file kept
 
 class Uri {
   constructor(scheme, p, extra = {}) {
@@ -151,15 +153,38 @@ class EventEmitter {
   dispose() { this.listeners.clear() }
 }
 
+/** Appends a line to `file`, making its folder; past `limitMb` the file is rotated (one kept). */
+function appendLine(file, line, limitMb = 0) {
+  try {
+    fs.mkdirSync(path.dirname(file), { recursive: true })
+    if (limitMb) {
+      let size = 0
+      try { size = fs.statSync(file).size } catch { /* none yet */ }
+      if (size > limitMb * 1024 * 1024) fs.renameSync(file, `${file}.1`)
+    }
+    fs.appendFileSync(file, `${line}\n`)
+  } catch { /* a log is never worth failing for */ }
+}
+
+const SHOWN = { error: 0, warn: 1, info: 2, debug: 3, trace: 4 }
+
+/**
+ * The extension's log (log.js) in the terminal: info and up as readable lines in cli.log; with
+ * --debug, every level — each request to the server, the run's steps — as JSON lines in the
+ * debug file (one object a line: ts, level, event, msg and the event's fields).
+ */
 function outputChannel() {
-  const write = (level) => (text) => {
-    if (!state.logFile) return
-    try {
-      fs.mkdirSync(path.dirname(state.logFile), { recursive: true })
-      fs.appendFileSync(state.logFile, `${new Date().toISOString()} [${level}] ${text}\n`)
-    } catch { /* a log is never worth failing for */ }
+  const record = (level, event, fields = {}, text = null) => {
+    if (SHOWN[level] <= SHOWN.info && state.logFile) {
+      const shown = text ?? `${event} ${Object.entries(fields).map(([k, v]) => `${k}=${typeof v === 'string' ? v : JSON.stringify(v)}`).join(' ')}`.trim()
+      appendLine(state.logFile, `${new Date().toISOString()} [${level}] ${shown}`)
+    }
+    if (state.debugFile) {
+      appendLine(state.debugFile, JSON.stringify({ ts: new Date().toISOString(), level, event, ...(text !== null ? { msg: text } : {}), ...fields }), DEBUG_MB)
+    }
   }
-  return { info: write('info'), warn: write('warn'), error: write('error'), appendLine: write('info'), append: write('info'), show() {}, clear() {}, dispose() {} }
+  const write = (level) => (text) => record(level, 'log', {}, text)
+  return { record, trace: write('trace'), debug: write('debug'), info: write('info'), warn: write('warn'), error: write('error'), appendLine: write('info'), append: write('info'), show() {}, clear() {}, dispose() {} }
 }
 
 /** Where an installed VS Code keeps its files: its ripgrep is used for search, as in the editor. */