@davait/aipictury 1.19.5 → 1.20.2

package/main.js

@@ -177,6 +177,13 @@ class Conversation {
     return this.title || this.aiTitle || (first ? String(first.content).replace(/\[[^\]]*\]\n?/g, '').replace(/\s+/g, ' ').trim().slice(0, 80) : 'New conversation')
   }
 
+  /** One row per tool call, updated in place as it runs, kept with its output. */
+  toolRow(event) {
+    const key = event.id || `${event.tool}:${JSON.stringify(event.args)}`
+    const existing = this.transcript.find((t) => t.kind === 'tool' && t.key === key)
+    if (existing) Object.assign(existing, event); else this.transcript.push({ kind: 'tool', key, at: Date.now(), ...event })
+  }
+
   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,
@@ -200,9 +207,7 @@ async function runTurn(convo, text, ui, { model, maxTurns, content } = {}) {
       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 })
+        convo.toolRow(event)
         ui.tool?.(event)
       },
       onNudge: (reason, detail) => ui.nudge?.(reason, detail),
@@ -230,6 +235,27 @@ async function runTurn(convo, text, ui, { model, maxTurns, content } = {}) {
   } finally { ui.onEnd?.() }
 }
 
+/** What an approval asks, for a terminal: each kind the agent sends (agent.js), else the question
+ *  it brings. A render's approval (kind 'media') fell through to "Use undefined {}" (1.20.0). */
+function approvalText(request, b = (t) => t, d = (t) => t) {
+  if (request.kind === 'command') return `Run ${b(request.command)}`
+  if (request.kind === 'edit') return `${request.before == null ? 'Create' : 'Change'} ${b(request.path)}`
+  if (request.kind === 'plan-mode') return `Switch to Plan mode first${request.reason ? d(` — ${request.reason}`) : ''}`
+  if (request.tool === 'browser') return `Use the browser on ${b(request.site || 'a page')}`
+  if (request.question) {
+    // The question's first line says what and where (the verb, the file); the rest is the prompt.
+    const [head, ...rest] = String(request.question).split('\n')
+    const body = rest.join('\n').trim()
+    return `${b(head)}${request.path && !head.includes(request.path) ? ` ${d(`(${request.path})`)}` : ''}${body ? `\n${d(body.split('\n').map((l) => `    ${l}`).join('\n'))}` : ''}`
+  }
+  return `Use ${b(request.tool || request.kind || 'a tool')} ${d(JSON.stringify(request.args || {}).slice(0, 200))}`
+}
+
+/** The one line print mode says when it refuses what needs a yes. */
+const refusedText = (request) => `not allowed in print mode (-p): ${request.kind === 'command' ? request.command
+  : request.kind === 'media' ? `${request.question ? String(request.question).split('\n')[0] : 'a generated picture or clip'}${request.path ? ` (${request.path})` : ''}`
+    : request.path || request.tool || request.kind} — allow it with --allowedTools or --permission-mode`
+
 // ---- print mode: one prompt, no questions ----
 async function printMode(o, convo, text) {
   const started = Date.now()
@@ -242,7 +268,7 @@ async function printMode(o, convo, text) {
     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` }),
+    approve: async (request) => ({ decision: 'deny', feedback: refusedText(request) }),
     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.' } },
@@ -363,10 +389,7 @@ async function interactive(o, convo, first, cfg) {
     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}`) : ''}`)
+      say(`\n${yellow('?')} ${approvalText(request, bold, dim)}${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()
@@ -605,6 +628,17 @@ async function interactive(o, convo, first, cfg) {
     return lines.join('\n')
   }
 
+  // A picture or clip the last run left rendering (an exit or Ctrl+C cut it): delivered now by its
+  // job id and written where it was asked for — not at the next message, nor made again (1.20.0).
+  if (convo.history.some((m) => m.pending)) {
+    say(dim('  a render the last run left going is being delivered (Esc or Ctrl+C leaves it for later)'))
+    running = new AbortController()
+    spinner.start('rendering')
+    try {
+      await agent.deliverPending(server(), convo.history, { signal: running.signal,
+        onTool: (event) => { convo.toolRow(event); ui.tool(event) }, onSettled: () => convo.save(model) })
+    } catch (error) { say(red(`  not delivered: ${error.message}`)) } finally { running = null; spinner.stop() }
+  }
   if (first) await turn(first)
   for (;;) {
     const message = await nextMessage()
@@ -633,7 +667,10 @@ function accountFor() {
   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. */
+/** The conversations of this run, kept with the account as VS Code keeps them: each save pushed a
+ *  few seconds later (at least every half minute while a run goes on), and what is left pushed
+ *  before exiting. It used to push at a clean exit only: a CLI killed, crashed or with its
+ *  terminal closed left the account's copy as it was when the run began (1.20.0). */
 function cloudFor(account) {
   const { Cloud } = require(path.join(EXT, 'cloud.js'))
   const { emulatorHosts } = require(path.join(EXT, 'account.js'))
@@ -643,29 +680,54 @@ function cloudFor(account) {
   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,
+    bucket: config.storageBucket, storageEmulator: emulatorHosts().storage, log: (line) => {
+      require(path.join(EXT, 'log.js')).warn(line)
+      if (exiting) process.stderr.write(dim(`  (${line.replace(/^cloud: /, '')} — not kept with your account)\n`))
+    },
     device: { id, name: os.hostname(), app: 'cli', platform: process.platform, version: VERSION } })
-  const pending = new Map()
-  const removed = []
+  const removing = new Set()
+  let exiting = false              // a push failing now is said; during the run, only logged
   const on = (kind) => vscode.workspace.getConfiguration('aipictury').get(`cloud.${kind}`, true)
-  require(path.join(EXT, 'sessions.js')).onWrite((e) => {
+  const sessions = require(path.join(EXT, 'sessions.js'))
+  sessions.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' }])
+    if (e.type === 'remove') {
+      cloud.cancel(e.id)
+      const gone = cloud.deleteConversation(e.folder, e.id).catch(() => {}).finally(() => removing.delete(gone))
+      removing.add(gone)
+      return
+    }
+    cloud.schedule(e.folder, { ...e.entry, origin: 'cli' }, e.type === 'patch' ? 500 : 5000).catch(() => {})
   })
-  // Every render the agent makes is kept with the account; the run waits for it before it ends.
-  const keeping = []
+  // What this folder's conversations hold that the account lacks — a run an earlier CLI was
+  // killed in, before its push — goes up at the start, as VS Code's sign-in does (cloud.bringUp).
+  let bringing = Promise.resolve()
+  const bringUp = () => {
+    if (!on('conversations')) return
+    bringing = cloud.bringUp(process.cwd(), sessions.storeFor(process.cwd()))
+      .catch((err) => process.stderr.write(dim(`  (conversations not carried up to your account: ${err.message})\n`)))
+  }
+  // Every render the agent makes is kept with the account: noted in the outbox the extension shares
+  // (keeping.js), so Ctrl+C twice or a kill only delays it — the next start of either app finishes
+  // it — and what an earlier run left is taken up now. The run waits for the keeping in progress.
+  const keeping = require(path.join(EXT, 'keeping.js'))
+  const keep = () => keeping.drain(cloud, { onState: (_, state) => {
+    if (state.stage === 'failed') process.stderr.write(dim(`  (render not kept with your account${state.again ? ' yet: tried again at the next start' : ''}: ${state.error})\n`))
+  } }).catch((err) => process.stderr.write(dim(`  (renders not kept with your account: ${err.message})\n`)))
   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`))))
+    account.user().then((u) => { if (u) { keeping.add(base, jobId, u.uid); keep() } }).catch(() => {})
   })
   return {
     cloud,
+    keep,
+    bringUp,
     async flush() {
-      await Promise.all(keeping)
+      await keeping.settled()
+      await bringing
+      await Promise.allSettled([...removing])
       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()
+      exiting = true
+      await cloud.flush()
     },
   }
 }
@@ -725,6 +787,8 @@ 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 })
+  sync.keep()                     // renders an earlier run (or VS Code) left halfway, with the token now
+  sync.bringUp()                  // and conversations an earlier run left unpushed
   // …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 })
@@ -774,8 +838,13 @@ async function mainRun(o) {
   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) })
+// Run as the `aipictury` command; required (a check), it only hands out what can be tested alone.
+if (require.main === module) {
+  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) })
+}
+
+module.exports = { approvalText, refusedText }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@davait/aipictury",
-  "version": "1.19.5",
+  "version": "1.20.2",
   "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

@@ -242,6 +242,9 @@ module.exports = {
   window: {
     activeTextEditor: undefined,
     visibleTextEditors: [],
+    // A terminal cannot tell whether it is in front: taken as not, so push_notification is sent
+    // (1.20.0: without state, its TypeError ended the CLI's run).
+    state: { focused: false },
     createOutputChannel: outputChannel,
     showInformationMessage: async () => undefined,
     showWarningMessage: async () => undefined,