@davait/aipictury 1.19.5 → 1.20.1

package/ext/about.js

@@ -26,7 +26,7 @@ function render({ server, version, about, error, config, account = {}, access =
   const roles = about?.roles || {}
   const gpus = about?.gpus || []
   const generation = about?.generation || []
-  const roleName = { agent: 'coding agent', edit: 'quick edits', commit: 'commit messages', vision: 'images' }
+  const roleName = { agent: 'coding agent', commit: 'commit messages', vision: 'images' }
   const modelRows = models.map((m) => `
       <li class="model${m.roles?.length ? ' used' : ''}">
         <div class="line">${esc(modelLine(m))}</div>
@@ -103,7 +103,7 @@ ${online ? `<tr><td>AIPictury</td><td id="server-version">${esc(s.version)}</td>
 </table>
 ${online ? `
 <h2>Models</h2>
-<details id="models" open><summary>Language models on this server (${models.length})</summary><ul>${modelRows || '<li class="sub">none installed</li>'}</ul></details>
+<details id="models" open><summary>Language models on this server (${models.length})</summary><ul>${modelRows || `<li class="sub">${esc(about?.models_error || 'none installed')}</li>`}</ul></details>
 <details id="generation" open><summary>Pictures and video (${generation.length})</summary><ul>${genRows || '<li class="sub">none</li>'}</ul></details>
 <h2>GPUs</h2>
 <ul id="gpus">${gpuRows || '<li class="sub">no GPU reported</li>'}</ul>` : ''}

package/ext/accountUi.js

@@ -13,11 +13,14 @@ const gpuServer = require('./gpuServer')
 const { Cloud, PREFERENCES } = require('./cloud')
 const sessions = require('./sessions')
 const memory = require('./memory')
+const keeping = require('./keeping')
 const usage = require('./usage')
 const prefs = require('./prefs')
 const log = require('./log')
 
 const SECRET = 'aipictury.account'
+// A "delete everything" under way on this machine: { uid, server, at }, until all of it is done.
+const CLEARING = 'aipictury.clearing'
 // VS Code settings that follow you (a subset of cloud.PREFERENCES; the rest come from settings.json).
 const VSCODE_PREFS = ['effort', 'approval', 'showThinking', 'focusView', 'autoMemory', 'notifications', 'useCtrlEnterToSend', 'browser.headless']
 const config = () => vscode.workspace.getConfiguration('aipictury')
@@ -65,10 +68,11 @@ function register(context, { registry, sessionsView, serverUrl }) {
   // ---- keeping things in step ----
   context.subscriptions.push(sessions.onWrite((e) => {
     if (!e.folder || !keeps('conversations')) return
-    if (e.type === 'remove') { cloud.deleteConversation(e.folder, e.id).catch((err) => log.warn(`cloud: ${e.id} not deleted: ${err.message}`)); return }
+    if (e.type === 'remove') { cloud.cancel(e.id); cloud.deleteConversation(e.folder, e.id).catch((err) => log.warn(`cloud: ${e.id} not deleted: ${err.message}`)); return }
     cloud.schedule(e.folder, e.entry, e.type === 'patch' ? 500 : 5000).catch(() => {})
   }))
-  memory.useAccountRules({ active: async () => keeps('memory'), get: () => cloud.getRules(), set: (rules) => cloud.setRules(rules) })
+  memory.useAccountRules({ active: async () => keeps('memory'), get: () => cloud.getRules(),
+    add: (rule) => cloud.addRules([rule]), remove: (id) => cloud.removeRule(id) })
   const pushProjectRules = debounce(async () => {
     if (!keeps('memory') || !folder()) return
     try { await cloud.setProjectMemory(folder(), await projectRulesText()) } catch (err) { log.warn(`cloud: project rules not pushed: ${err.message}`) }
@@ -113,7 +117,7 @@ function register(context, { registry, sessionsView, serverUrl }) {
         try {
           const r = await fetch(`${server}/api/memory`, { signal: AbortSignal.timeout(8000) })
           const old = r.ok ? (await r.json()).rules || [] : []
-          if (old.length) await cloud.setRules(old.map((x) => ({ id: String(x.id), text: x.text, created: Date.now() })))
+          if (old.length) await cloud.addRules(old.slice(0, 500).map((x) => ({ id: String(x.id), text: x.text, created: Date.now() })))
         } catch { /* the server's list stays where it is */ }
       }
       // The project's rules: brought back when this checkout has none, kept up to date otherwise.
@@ -144,6 +148,8 @@ function register(context, { registry, sessionsView, serverUrl }) {
     if (user) {
       findServer()
       settle().catch((err) => log.warn(`account: not settled: ${err.message}`))
+      offerToFinishClearing().catch((err) => log.warn(`account: unfinished delete not offered: ${err.message}`))
+      keepRenders()                         // what an earlier session left halfway
     } else gpuServer.adopt(null)            // signed out: the account's server goes with it
     require('./about').refreshOpen()
   }
@@ -157,18 +163,41 @@ function register(context, { registry, sessionsView, serverUrl }) {
       if (user) await gpuServer.adopt(prefs?.values?.gpuServer)
     } catch (err) { log.warn(`account: GPU server not read: ${err.message}`) }
   }
-  // Every render the agent makes here is kept with the account (Renders, on the web too).
-  context.subscriptions.push(require('./mediagen').onRendered((server, jobId, keep = () => {}) => {
-    if (!user) return
-    cloud.keepRender(server, jobId, (_, state) => keep(state)).then((kept) => kept && log.info(`render ${jobId} kept with the account`))
-      .catch((err) => { keep({ stage: 'failed', error: err.message }); log.warn(`render ${jobId} not kept with the account: ${err.message}`) })
+  // Every render the agent makes here is kept with the account (Renders, on the web too): noted in
+  // the outbox first (keeping.js), so a reload or an exit halfway only delays it; its card follows.
+  context.subscriptions.push(require('./mediagen').onRendered((server, jobId) => {
+    if (!user || !jobId) return
+    keeping.add(server, jobId, user.uid)
+    keepRenders()
   }))
+  function keepRenders() {
+    keeping.drain(cloud, { onState: (jobId, state) => {
+      for (const p of registry.all()) p?.keepState?.(jobId, state)
+      if (state.stage === 'kept') log.info(`render ${jobId} kept with the account`)
+      if (state.stage === 'failed') log.warn(`render ${jobId} not kept with the account${state.again ? ' (tried again later)' : ''}: ${state.error}`)
+    } }).catch((err) => log.warn(`renders not kept with the account: ${err.message}`))
+  }
+
+  /** Where keeping a render of an earlier session stands, for its card when the conversation is
+   *  reopened: still to do (it carries on), kept (with its figures), or null. */
+  async function keptState(jobId) {
+    if (keeping.pending().some((j) => j.job === jobId)) return { stage: 'waiting' }
+    if (!user) return null
+    const entry = await cloud.db.get(`${await cloud.base()}/renders/${jobId}`).catch(() => null)
+    if (!entry) return null
+    const stats = (entry.assets || []).find((a) => a.stats)?.stats
+    return stats ? { stage: 'kept', stats } : { stage: 'kept' }
+  }
   // Asked from the web ("control it from here"): this window, when it has the conversation, shares
   // it by remote control. One long request at a time, while signed in; an older server: later.
   let listening = true
   context.subscriptions.push({ dispose: () => { listening = false } })
   ;(async function listenForAsks() {
-    let since = Date.now() / 1000
+    // 0: the server answers every ask of its last minute and gives its own clock back, so an ask
+    // made while this window reloaded is answered, and no client clock is compared with its own.
+    // One already acted on (kept here) is not acted on again after a reload (1.20.0).
+    let since = 0
+    const ASKED = 'aipictury.remoteAsked'
     while (listening) {
       const server = serverUrl()
       if (!user || !server) { await new Promise((r) => setTimeout(r, 10_000)); continue }
@@ -177,11 +206,15 @@ function register(context, { registry, sessionsView, serverUrl }) {
         if (!r.ok) { await new Promise((res) => setTimeout(res, r.status === 404 ? 120_000 : 15_000)); continue }
         const body = await r.json()
         since = body.now || since
-        for (const ask of body.asks || []) await registry.shareAsked?.(ask.conversation).catch((err) => log.warn(`remote control not started: ${err.message}`))
+        for (const ask of body.asks || []) {
+          if ((ask.at || 0) <= (context.workspaceState.get(ASKED) || 0)) continue
+          await context.workspaceState.update(ASKED, ask.at || 0)
+          await registry.shareAsked?.(ask.conversation).catch((err) => log.warn(`remote control not started: ${err.message}`))
+        }
       } catch { await new Promise((res) => setTimeout(res, 5000)) }
     }
   })()
-  const recheck = setInterval(() => { if (user) findServer() }, 10 * 60_000)
+  const recheck = setInterval(() => { if (user) { findServer(); keepRenders() } }, 10 * 60_000)
   context.subscriptions.push({ dispose: () => clearInterval(recheck) })
   context.subscriptions.push(gpuServer.onChange((url) => {
     log.info(`GPU server: ${url || 'none set'} (${gpuServer.source() || 'nowhere'})`)
@@ -218,25 +251,54 @@ function register(context, { registry, sessionsView, serverUrl }) {
         + 'What is on this machine stays, and is not sent back up by itself: only what you do from now on is kept again (while '
         + 'its switch is on).' }, yes)
     if (ok !== yes) return null
-    const server = gpuServer.url()                    // read first: the delete must find it
-    const n = await cloud.deleteEverything()
-    const there = await forgetOnServer('all', server)
-    return `Deleted (${n} records and files)${there}. Your account stays — sign out or keep using it.`
+    return clearEverything(gpuServer.url())          // the server read first: the delete must find it
+  }
+
+  /** The delete itself, its steps in an order that survives being cut (cloud.deleteEverything),
+   *  and noted here until every one is done: VS Code closed or reloaded halfway, the next start
+   *  offers to finish it rather than leave half the account deleted (1.20.0). */
+  async function clearEverything(server) {
+    await context.globalState.update(CLEARING, { uid: user?.uid, server: server || null, at: Date.now() })
+    // A server that keeps renders deletes the account's cloud too, and finishes it whatever happens here.
+    const byServer = !!server && await cloud.serverKeeps(server)
+    const n = await cloud.deleteEverything({ byServer })
+    const there = await deleteOnServer('all', server)
+    if (there.ok) await context.globalState.update(CLEARING, undefined)
+    if (byServer) return `Deleting what your account keeps: the server finishes it${there.said}. Your account stays — sign out or keep using it.`
+    return `Deleted (${n} records and files)${there.said}. Your account stays — sign out or keep using it.`
+  }
+
+  /** At start, signed in: a delete of everything this machine began and did not finish. */
+  async function offerToFinishClearing() {
+    const left = context.globalState.get(CLEARING)
+    if (!left || !user) return
+    if (left.uid && left.uid !== user.uid) { await context.globalState.update(CLEARING, undefined); return }
+    const finish = 'Finish deleting'
+    const choice = await vscode.window.showWarningMessage(`AIPictury: deleting everything kept with your account did not finish `
+      + `(${new Date(left.at).toLocaleString()}). Finish it now?`, { modal: false }, finish, 'Leave it')
+    if (choice === 'Leave it') { await context.globalState.update(CLEARING, undefined); return }
+    if (choice !== finish) return                     // asked again at the next start
+    try {
+      vscode.window.showInformationMessage(`AIPictury: ${await clearEverything(left.server || gpuServer.url())}`)
+    } catch (error) { vscode.window.showErrorMessage(`AIPictury: not deleted — ${error.message}`) }
   }
 
   /** The GPU server's own copies of the account's work go too — renders, chats, attached files,
    *  its copy of the rules: the web app listed them (Renders) and copied them back. Said, not
    *  hidden, when the server cannot be reached. */
-  async function forgetOnServer(what, server = gpuServer.url()) {
-    if (!server) return '; no GPU server is set, so nothing there was touched'
+  async function forgetOnServer(what, server = gpuServer.url()) { return (await deleteOnServer(what, server)).said }
+
+  /** forgetOnServer, and whether it was done ({ ok, said }). */
+  async function deleteOnServer(what, server) {
+    if (!server) return { ok: true, said: '; no GPU server is set, so nothing there was touched' }
     try {
       const r = await fetch(`${server}/api/account/data?what=${what}`, { method: 'DELETE', signal: AbortSignal.timeout(120_000) })
       if (!r.ok) throw new Error(`it answered ${r.status}`)
       const d = (await r.json()).deleted || {}
-      return what === 'chats' ? `, and ${d.chats || 0} chats on the GPU server`
-        : `, and on the GPU server ${d.renders || 0} renders, ${d.chats || 0} chats and ${d.files || 0} files`
+      return { ok: true, said: what === 'chats' ? `, and ${d.chats || 0} chats on the GPU server`
+        : `, and on the GPU server ${d.renders || 0} renders, ${d.chats || 0} chats and ${d.files || 0} files` }
     } catch (error) {
-      return `. The GPU server could not be reached (${error.message}): its copies stay — delete again once it answers`
+      return { ok: false, said: `. The GPU server could not be reached (${error.message}): its copies stay — delete again once it answers` }
     }
   }
 
@@ -271,7 +333,7 @@ function register(context, { registry, sessionsView, serverUrl }) {
   context.subscriptions.push({ dispose: () => { globalThis.fetch = plainFetch } })
 
   account.user().then(changed).catch(() => changed(null))
-  return { account, cloud, signedIn, signIn, signOut, deleteCloudData, deleteKind, forgetOnServer, keeps, user: () => user }
+  return { account, cloud, signedIn, signIn, signOut, deleteCloudData, deleteKind, forgetOnServer, keeps, keptState, user: () => user }
 }
 
 async function projectRulesText() {

package/ext/agent.js

@@ -161,11 +161,19 @@ Your answers are rendered as Markdown: fenced code blocks tagged with their lang
 tables where they help, and \`backticks\` for paths and identifiers. Keep prose short —
 this is a side panel, not an essay.`
 
-/** One streamed turn from the server. Returns what the model said and wants done. */
-async function turn(server, messages, { role = 'agent', tools, model, think = true, effort, signal, onDelta, onThinking,
+/** One streamed turn from the server. Returns what the model said and wants done. The run's
+ *  hold on the GPU is kept alive while it streams, and only then (gpuRun.using): a long local
+ *  step between turns no longer keeps every other app off an idle GPU (1.20.0). */
+async function turn(server, messages, options = {}) {
+  const done = require('./gpuRun').using()
+  try { return await streamTurn(server, messages, options) } finally { done() }
+}
+
+async function streamTurn(server, messages, { role = 'agent', tools, model, think = true, effort, signal, onDelta, onThinking,
                                           onWaiting, onSpeed, watchReasoning = false, watchLoops = false, steer,
                                           thinkBudget = 0 } = {}) {
-  const sent = compact(messages)
+  // A render's job id (deliverPending) is the editor's own note, never the model's.
+  const sent = compact(messages).map((m) => { if (!m.pending) return m; const rest = { ...m }; delete rest.pending; return rest })
   // Our own switch for cutting the reasoning short, tied to the caller's Stop as well.
   const cut = new AbortController()
   const onStop = () => cut.abort()
@@ -208,6 +216,13 @@ async function turn(server, messages, { role = 'agent', tools, model, think = tr
       throw failure('a generation is using the GPU right now, so the agent waits for it '
         + 'to finish', { busy: true })
     }
+    // 423: another app took the GPU while this run did no GPU work (a long local step let its
+    // hold lapse, gpuRun.js). Waited for as a render is, never the end of the run (1.20.0).
+    if (response.status === 423) {
+      let said = ''
+      try { said = JSON.parse(detail).detail || '' } catch { /* not JSON */ }
+      throw failure(`${said || 'the GPU is in use by another app'} — the agent waits for it`, { busy: true })
+    }
     throw failure(`the server answered ${response.status}: ${detail.slice(0, 300)}`,
       { transient: response.status >= 500 || response.status === 429 })
   }
@@ -529,7 +544,7 @@ const proposedProvider = {
 }
 
 /** The model's question, answered. Blocks on the panel's chooser — except in Auto mode,
- *  where a question not marked important takes the recommended options at once and is
+ *  where every question, important ones too, takes its recommended option at once and is
  *  kept as a decision the user can change when the run ends. */
 async function askUser(args, report, signal, hooks) {
   let questions
@@ -579,11 +594,14 @@ async function makeMedia(call, session, report, signal, server, hooks = {}) {
     return 'Plan mode: nothing was generated. Describe the picture in your plan instead.'
   }
   // Writing a file needs the same yes as any write: asked for in Manual only.
-  const ask = async (question) => {
+  const ask = async (question, { path } = {}) => {
     if (unattended(mode) || mode === 'edits' || session.allowAll) return true
     report({ tool: 'generate_media', args, status: 'asking' })
     if (hooks.approve) {
-      const answer = await Promise.race([hooks.approve({ kind: 'media', question, path: args.save_to }, signal), stopped(signal)])
+      // One shape every client draws: the question (what, where, the prompt), the file it goes to
+      // — the CLI said "Use undefined {}" when it got only a kind and a path the agent had not given.
+      const request = { kind: 'media', tool: 'generate_media', question, path: path || args.save_to, args }
+      const answer = await Promise.race([hooks.approve(request, signal), stopped(signal)])
       if (answer === STOPPED || !answer || answer.decision === 'deny') return false
       if (answer.decision === 'allow_all') session.allowAll = true
       return true
@@ -596,8 +614,10 @@ async function makeMedia(call, session, report, signal, server, hooks = {}) {
   }
   try {
     const result = await mediagen.generate(server, args, {
-      ask, signal, report: (update) => report({ tool: 'generate_media', args, ...update }) })
+      ask, signal, report: (update) => report({ tool: 'generate_media', args, ...update }),
+      onJob: (job) => hooks.onMediaJob?.({ ...job, args }) })
     if (result.refused) report({ tool: 'generate_media', args, status: 'refused' })
+    if (result.stopped) report({ tool: 'generate_media', args, status: 'failed', result: result.text })
     return result.text
   } catch (error) {
     if (error.name === 'AbortError' || signal?.aborted) return 'stopped by the user'
@@ -606,6 +626,30 @@ async function makeMedia(call, session, report, signal, server, hooks = {}) {
   }
 }
 
+/**
+ * generate_media calls whose render was still going when their run was cut off — a reload, an
+ * exit, a lost link: each one's result in the conversation is a placeholder holding its job id
+ * (`pending`). Each is followed by that id to the end, written where it was asked for, and its
+ * real result takes the placeholder's place, in place — so the model is never left without one,
+ * and never asks for the same picture twice (1.20.0). `onTool` updates its row in the panel.
+ * Returns how many were settled; one the server cannot be reached for stays pending.
+ */
+async function deliverPending(server, messages, { onTool, onSettled, signal } = {}) {
+  let settled = 0
+  for (const m of messages) {
+    if (m?.role !== 'tool' || !m.pending) continue
+    const p = m.pending
+    const text = await mediagen.resume(server, p, { signal,
+      report: (update) => onTool?.({ tool: 'generate_media', args: p.args || {}, ...update, id: p.row }) })
+    if (text == null) break
+    m.content = capResult(text)
+    delete m.pending
+    settled += 1
+    onSettled?.()
+  }
+  return settled
+}
+
 /** The to-do list the model keeps, cleaned: at most 30 items, a known status each. */
 function normalizeTodos(todos) {
   let list = todos
@@ -660,7 +704,19 @@ async function execute(call, session, report, signal, server, hooks = {}) {
 // The tools that take a path: in a worktree, their paths are the worktree's.
 const PATH_TOOLS = new Set(['read_file', 'write_file', 'edit_file', 'notebook_edit', 'list_files', 'grep', 'glob', 'code_intel', 'search'])
 
+/** One tool call, whatever its tool. A handler that throws is a failed call the model reads,
+ *  never the end of the run: 1.20.0 — push_notification threw a TypeError in the CLI (its
+ *  stand-in for VS Code had no window.state), and that one exception ended the whole run. */
 async function executeTool(call, session, report, signal, server, hooks = {}) {
+  try {
+    return await callTool(call, session, report, signal, server, hooks)
+  } catch (error) {
+    report({ tool: call.function.name, args: parsedArgs(call), status: 'failed', result: error.message })
+    return `error: ${error.message}`
+  }
+}
+
+async function callTool(call, session, report, signal, server, hooks = {}) {
   const name = call.function.name
   let args = call.function.arguments || {}
   if (typeof args === 'string') { try { args = JSON.parse(args) } catch { args = {} } }
@@ -825,7 +881,7 @@ async function executeTool(call, session, report, signal, server, hooks = {}) {
     const title = String(args.title || '').trim().slice(0, 60) || 'AIPictury'
     const sent = workbench.notify(title, message)
     report({ tool: name, args: { title, message }, status: 'done', result: sent ? 'sent' : 'not sent' })
-    return sent ? 'The user was notified.' : 'Not sent: the user is looking at VS Code right now, or notifications are off — say it in your reply.'
+    return sent ? 'The user was notified.' : 'Not sent: the user is looking at VS Code right now, or notifications are off here — say it in your reply.'
   }
 
   if (name === 'report_findings') {
@@ -1722,6 +1778,12 @@ async function work({ server, model, history, session, signal,
   const rules = await memory.block(server)
   await mcp.ensure({ trust: trustMcp }).catch(() => [])
   messages.push({ role: 'system', content: systemPrompt(modeNow(), rules, effortOf(chosenEffort || settings().get('effort', 'high'))) }, ...history)
+  // A picture or clip an earlier run left rendering is delivered before the model is asked
+  // anything: it then reads the real result, not a gap it would fill with a second render.
+  if (history.some((m) => m.pending)) {
+    await deliverPending(server, messages, { onTool, signal, onSettled: () => onMessages?.(messages.slice(1)) })
+    if (signal?.aborted) return { messages: messages.slice(1), stopped: true }
+  }
   // What the user wrote, as opposed to the notes the loop adds in their voice.
   const fromUser = new Set(history.filter((m) => m.role === 'user'))
   let known = null           // the dependencies the workspace declares, read when first needed
@@ -1927,12 +1989,23 @@ async function work({ server, model, history, session, signal,
           continue
         }
       }
-      const result = await execute(call, session, (event) => onTool?.({ ...event, id: callId }), signal, server, hooks)
+      // A render, once queued: its job id stands as this call's result and is saved at once, so a
+      // run cut off mid-render delivers it on the next run (deliverPending) instead of losing it.
+      let placeholder = null
+      const onMediaJob = (job) => {
+        placeholder = { role: 'tool', tool_name: call.function.name, pending: { ...job, row: callId },
+          content: `[rendering on the server as job ${job.job}: the result comes when it is done]` }
+        messages.push(placeholder)
+        onMessages?.(messages.slice(1), { now: true })
+      }
+      const result = await execute(call, session, (event) => onTool?.({ ...event, id: callId }), signal, server,
+        call.function.name === 'generate_media' ? { ...hooks, onMediaJob } : hooks)
       if (WRITES.has(call.function.name) || call.function.name === 'generate_media') changed = true
       const content = typeof result === 'object' ? result.text : result
       const toolMessage = { role: 'tool', tool_name: call.function.name, content: capResult(content) }
       if (typeof result === 'object' && result.images?.length) toolMessage.images = result.images
-      messages.push(toolMessage)
+      if (placeholder && messages.includes(placeholder)) messages.splice(messages.indexOf(placeholder), 1, toolMessage)
+      else messages.push(toolMessage)
       onMessages?.(messages.slice(1))
       if (session.hookStop) {
         onNudge?.('hook', { text: `a hook stopped the run: ${session.hookStop}` })
@@ -1945,5 +2018,5 @@ async function work({ server, model, history, session, signal,
   }
 }
 
-module.exports = { appendSystem, helpersOf, findHelper, listHelpers, modeNow, setWindow, targetTokens, sideQuestion, run, turn, steadyTurn, execute, runHelper, normalizeTodos, commandPrefix, previewChange, approve, EFFORT, effortOf, systemPrompt, estimateTokens, summaryPlan, plain, commandEnv, AUTO_NOTE, thinkingLoops, distill, summarizeEarlier, runCommand, openSideBySide, stopBackground, compact, capResult, looksLikeCode, onlyQuotes, askedForChange, overthinking, calibrate, budget, SYSTEM, MODES,
+module.exports = { appendSystem, helpersOf, findHelper, listHelpers, modeNow, setWindow, targetTokens, sideQuestion, run, turn, steadyTurn, execute, runHelper, deliverPending, normalizeTodos, commandPrefix, previewChange, approve, EFFORT, effortOf, systemPrompt, estimateTokens, summaryPlan, plain, commandEnv, AUTO_NOTE, thinkingLoops, distill, summarizeEarlier, runCommand, openSideBySide, stopBackground, compact, capResult, looksLikeCode, onlyQuotes, askedForChange, overthinking, calibrate, budget, SYSTEM, MODES,
   TARGET_TOKENS, proposedProvider, proposedContents }

package/ext/attachments.js

@@ -0,0 +1,55 @@
+'use strict'
+// Files attached to a message that is not sent yet, kept on this machine as the server converted
+// them (a picture as itself or described, a PDF as its text) — ~/.aipictury/attachments/<project>/
+// <slot>.json, private — until the message goes. They lived only in the panel's memory: a window
+// reloaded, or VS Code restarted, between attaching a PDF and pressing Send lost it, and its chip
+// with it (1.20.0). A slot is one panel: the side bar's, or a tab's (whose webview state carries
+// its slot across a reload). Nothing here is sent anywhere.
+const fs = require('fs')
+const path = require('path')
+const crypto = require('crypto')
+const { home, projectKey } = require('./sessions')
+
+const KEEP_FOR = 7 * 24 * 3600_000        // a draft's files left longer than this are not brought back
+const KINDS = new Set(['text', 'image'])  // what a converted attachment is ('loading' is not kept)
+
+const dir = (folder) => path.join(home(), 'attachments', projectKey(folder || 'no-folder'))
+const fileOf = (folder, slot) => path.join(dir(folder), `${String(slot || 'none').replace(/[^\w-]/g, '').slice(0, 60) || 'none'}.json`)
+
+/** What waits to go with this panel's next message, replacing what was kept: none, nothing kept. */
+function save(folder, slot, items) {
+  const file = fileOf(folder, slot)
+  const ready = (items || []).filter((a) => a && KINDS.has(a.kind))
+  try {
+    if (!ready.length) { fs.rmSync(file, { force: true }); return }
+    fs.mkdirSync(path.dirname(file), { recursive: true })
+    // Written whole or not at all: a reload in the middle never leaves half a list.
+    const tmp = `${file}.${process.pid}.${crypto.randomBytes(4).toString('hex')}.tmp`
+    fs.writeFileSync(tmp, JSON.stringify({ saved: Date.now(), items: ready }), { mode: 0o600 })
+    fs.renameSync(tmp, file)
+  } catch { /* not kept: the files still go with the message if the window stays */ }
+}
+
+/** What this panel had attached and not sent, as it was kept: [{ id, name, kind, text | image, images }].
+ *  Lists that no panel took back within KEEP_FOR (a tab closed with files on it) are removed. */
+function load(folder, slot, now = Date.now()) {
+  prune(folder, now)
+  try {
+    const kept = JSON.parse(fs.readFileSync(fileOf(folder, slot), 'utf8'))
+    return (kept.items || []).filter((a) => a && a.id && a.name && KINDS.has(a.kind))
+  } catch { return [] }
+}
+
+function prune(folder, now = Date.now()) {
+  let names
+  try { names = fs.readdirSync(dir(folder)) } catch { return }
+  for (const name of names) {
+    const file = path.join(dir(folder), name)
+    try { if (now - fs.statSync(file).mtimeMs > KEEP_FOR) fs.rmSync(file, { force: true }) } catch { /* gone */ }
+  }
+}
+
+/** A slot for a new tab: its own, so two tabs' files never mix. */
+const newSlot = () => `tab-${crypto.randomBytes(6).toString('hex')}`
+
+module.exports = { save, load, newSlot, fileOf, KEEP_FOR }