@davait/aipictury 1.9.2

package/ext/accountUi.js

@@ -0,0 +1,287 @@
+'use strict'
+// The AIPictury account in VS Code (docs/accounts-plan.md). Using the extension needs it: signed
+// out, the panel shows a sign-in screen and nothing reaches the agent. (The server checks the
+// account too: this is the experience, the server is the lock.) Signed in, what is yours is kept
+// in step with the account: conversations (every save, rename, archive and delete, through the
+// session store), your rules, your preferences, the project's rules, each day's usage.
+// Signing out leaves nothing: the secret, the token, every cache and every scheduled push go.
+const vscode = require('vscode')
+const os = require('os')
+const crypto = require('crypto')
+const { Account, emulatorHosts, serverFetch } = require('./account')
+const gpuServer = require('./gpuServer')
+const { Cloud, PREFERENCES } = require('./cloud')
+const sessions = require('./sessions')
+const memory = require('./memory')
+const usage = require('./usage')
+const prefs = require('./prefs')
+const log = require('./log')
+
+const SECRET = 'aipictury.account'
+// 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')
+const folder = () => vscode.workspace.workspaceFolders?.[0]?.uri.fsPath || null
+
+function register(context, { registry, sessionsView, serverUrl }) {
+  const firebase = require('./media/vendor/firebase-config.json')
+  const account = new Account({
+    config: firebase, client: 'VS Code',
+    store: {
+      get: async () => { const v = await context.secrets.get(SECRET); try { return v ? JSON.parse(v) : undefined } catch { return undefined } },
+      set: async (v) => context.secrets.store(SECRET, JSON.stringify(v)),
+      delete: async () => context.secrets.delete(SECRET),
+    },
+  })
+  let deviceId = context.globalState.get('aipictury.deviceId')
+  if (!deviceId) { deviceId = crypto.randomUUID(); context.globalState.update('aipictury.deviceId', deviceId) }
+  const cloud = new Cloud({
+    account, projectId: firebase.projectId, emulator: emulatorHosts().firestore, log: (l) => log.warn(l),
+    bucket: firebase.storageBucket, storageEmulator: emulatorHosts().storage,
+    device: { id: deviceId, name: os.hostname(), app: 'vscode', platform: process.platform, version: context.extension?.packageJSON?.version || '' },
+  })
+  let user = null
+  const signedIn = () => !!user
+  /** Is this kind of thing kept with the account, here and now? */
+  const keeps = (kind) => {
+    if (!user || !config().get(`cloud.${kind}`, true)) return false
+    if (kind === 'conversations' || kind === 'memory') {
+      try { if (prefs.load(folder()).merged.cloudSync === false) return false } catch { /* no settings file */ }
+    }
+    return true
+  }
+
+  // ---- the status bar ----
+  const status = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Right, 90)
+  status.command = 'aipictury.account'
+  const showStatus = () => {
+    status.text = user ? `$(account) ${user.displayName || user.email}` : '$(account) Sign in to AIPictury'
+    status.tooltip = user ? `AIPictury: signed in as ${user.email}. Click for your account.` : 'AIPictury needs your account: click to sign in or create one.'
+    status.backgroundColor = user ? undefined : new vscode.ThemeColor('statusBarItem.warningBackground')
+    status.show()
+  }
+  context.subscriptions.push(status)
+
+  // ---- 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 }
+    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) })
+  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}`) }
+  }, 2000)
+  context.subscriptions.push(memory.onProjectRules(pushProjectRules))
+  context.subscriptions.push(usage.onRecord((entry, now) => {
+    if (!keeps('usage')) return
+    cloud.addUsage(new Date(now).toISOString().slice(0, 10), entry).catch((err) => log.warn(`cloud: usage not added: ${err.message}`))
+  }))
+  const pushPreferences = debounce(async () => {
+    if (!keeps('settings')) return
+    try { await cloud.setPreferences(localPreferences()) } catch (err) { log.warn(`cloud: preferences not pushed: ${err.message}`) }
+  }, 3000)
+  context.subscriptions.push(vscode.workspace.onDidChangeConfiguration((e) => {
+    if (applying) return
+    if (VSCODE_PREFS.some((k) => e.affectsConfiguration(`aipictury.${k}`))) pushPreferences()
+  }))
+
+  /** This project's conversations made here before the account had them (or changed since):
+   *  carried up, so the account's history — on the web too — is the whole of it. Each once,
+   *  and only when it changed (the push compares hashes). */
+  async function bringUp() {
+    const here = folder()
+    if (!here) return
+    try {
+      const up = await cloud.bringUp(here, sessions.storeFor(here), { still: () => Boolean(user) })
+      if (up) { log.info(`cloud: ${up} conversation(s) of this project carried up to the account`); sessionsView?.refresh?.() }
+    } catch (err) { log.warn(`cloud: history not carried up: ${err.message}`) }
+  }
+
+  let applying = false
+  /** After signing in: what the account has is brought here, what is only here goes up. */
+  async function settle() {
+    if (!['conversations', 'memory', 'settings', 'usage'].some((k) => keeps(k))) return
+    await cloud.hello()
+    if (keeps('conversations')) await bringUp()
+    if (keeps('memory')) {
+      // Your rules: the first time, the server's list moves into the account.
+      const rules = await cloud.getRules()
+      if (!rules.length) {
+        const server = 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() })))
+        } 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.
+      if (folder()) {
+        const local = await projectRulesText()
+        const remote = await cloud.getProjectMemory(folder())
+        if (!local.trim() && remote?.text) await vscode.workspace.fs.writeFile(memory.projectUri(), new TextEncoder().encode(remote.text))
+        else if (local.trim() && local !== remote?.text) await cloud.setProjectMemory(folder(), local)
+      }
+    }
+    if (keeps('settings')) {
+      const remote = await cloud.getPreferences()
+      if (remote?.values && Object.keys(remote.values).length) {
+        applying = true
+        try {
+          for (const k of VSCODE_PREFS) if (k in remote.values && config().get(k) !== remote.values[k]) await config().update(k, remote.values[k], vscode.ConfigurationTarget.Global)
+        } finally { applying = false }
+      } else await cloud.setPreferences(localPreferences())
+    }
+  }
+
+  function changed(next) {
+    user = next
+    showStatus()
+    vscode.commands.executeCommand('setContext', 'aipictury.signedIn', !!user)
+    for (const p of registry.all()) p.postAccount?.(user)
+    sessionsView?.setCloud?.(user ? cloud : null)
+    if (user) {
+      findServer()
+      settle().catch((err) => log.warn(`account: not settled: ${err.message}`))
+    } else gpuServer.adopt(null)            // signed out: the account's server goes with it
+    require('./about').refreshOpen()
+  }
+  context.subscriptions.push(account.onChange(changed))
+
+  // The GPU server chosen with the account (aipictury.com): used when this machine sets none,
+  // and looked at again now and then — it may be changed on the web.
+  async function findServer() {
+    try {
+      const prefs = await cloud.getPreferences()
+      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}`) })
+  }))
+  // 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
+    while (listening) {
+      const server = serverUrl()
+      if (!user || !server) { await new Promise((r) => setTimeout(r, 10_000)); continue }
+      try {
+        const r = await fetch(`${server}/api/remote/requests?since=${since}&wait=25`, { signal: AbortSignal.timeout(40_000) })
+        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}`))
+      } catch { await new Promise((res) => setTimeout(res, 5000)) }
+    }
+  })()
+  const recheck = setInterval(() => { if (user) findServer() }, 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'})`)
+    for (const p of registry.all()) p.refreshStatus?.()
+    require('./about').refreshOpen()
+  }))
+
+  async function signIn() {
+    try {
+      await vscode.window.withProgress({ location: vscode.ProgressLocation.Notification, title: 'AIPictury: sign in in your browser…', cancellable: true },
+        (_, token) => {
+          const ctrl = new AbortController()
+          token.onCancellationRequested(() => ctrl.abort())
+          return account.signIn({ signal: ctrl.signal, open: (url) => vscode.env.openExternal(vscode.Uri.parse(url)) })
+        })
+      vscode.window.showInformationMessage(`AIPictury: signed in as ${user?.email || user?.displayName}.`)
+    } catch (error) {
+      if (!/cancelled/.test(error.message)) vscode.window.showErrorMessage(`AIPictury: not signed in — ${error.message}`)
+    }
+  }
+
+  async function signOut() {
+    for (const p of registry.all()) p.abort?.abort()          // nothing keeps running for an account that left
+    await account.signOut()                                   // the secret, the token; the cloud forgets (onChange)
+    vscode.window.showInformationMessage('AIPictury: signed out. Nothing of the account is kept on this machine.')
+  }
+
+  async function deleteCloudData() {
+    const yes = 'Delete everything'
+    const ok = await vscode.window.showWarningMessage('Delete everything of yours kept with your AIPictury account?', {
+      modal: true, detail: 'Conversations, projects, rules, preferences and usage kept in the cloud, from every machine. What is on this machine stays.' }, yes)
+    if (ok !== yes) return null
+    const n = await cloud.deleteEverything()
+    return `Deleted (${n} records). Your account stays — sign out or keep using it.`
+  }
+
+  function localPreferences() {
+    const values = {}
+    for (const k of VSCODE_PREFS) values[k] = config().get(k)
+    try {
+      const merged = prefs.load(folder()).merged
+      for (const k of ['outputStyle', 'skillVisibility', 'enabledPlugins', 'permissions']) if (merged[k] !== undefined) values[k] = merged[k]
+    } catch { /* no settings file */ }
+    return Object.fromEntries(Object.entries(values).filter(([k, v]) => PREFERENCES.includes(k) && v !== undefined))
+  }
+
+  // Every call to the GPU server carries the account's token (the server may require it: AUTH),
+  // and only calls to that server — never another site.
+  const plainFetch = globalThis.fetch
+  globalThis.fetch = serverFetch({ fetch: plainFetch, account, server: serverUrl, signedIn: () => Boolean(user) })
+  context.subscriptions.push({ dispose: () => { globalThis.fetch = plainFetch } })
+
+  account.user().then(changed).catch(() => changed(null))
+  return { account, cloud, signedIn, signIn, signOut, deleteCloudData, keeps, user: () => user }
+}
+
+async function projectRulesText() {
+  try { return new TextDecoder().decode(await vscode.workspace.fs.readFile(memory.projectUri())) } catch { return '' }
+}
+
+function debounce(fn, ms) {
+  let t = null
+  return () => { clearTimeout(t); t = setTimeout(fn, ms) }
+}
+
+/** The Account dialog (dialogs.js's component). */
+function accountSpec(ctl, note) {
+  const u = ctl.user()
+  if (!u) {
+    return { id: 'account', title: 'Your AIPictury account',
+      note: note || 'AIPictury needs your account (the same as at aipictury.com). Signing in happens in your browser.',
+      sections: [{ title: 'Signed out', items: [{ id: 'signin', label: 'Sign in, or create an account', detail: 'Email and password, or Google.', actions: [{ id: 'signin', label: 'Sign in', always: true }] }] }] }
+  }
+  const kinds = [['conversations', 'Conversations', 'Every conversation of your projects, so another machine (or the CLI) can open it.'],
+    ['memory', 'Rules', 'Your rules, and each project\'s .aipictury/memory.md.'],
+    ['settings', 'Preferences', 'Effort, permission mode, reasoning, focus view… (never keys, tokens or MCP settings).'],
+    ['usage', 'Usage', 'Each day\'s turns, tokens, tools and models.']]
+  return { id: 'account', title: 'Your AIPictury account',
+    note: note || `Signed in as ${u.email || u.displayName}. What is yours is kept with the account, readable by you alone.`,
+    sections: [
+      { title: 'Kept with your account', items: kinds.map(([id, label, detail]) => ({ id: `keep:${id}`, label, detail, toggle: { on: config().get(`cloud.${id}`, true) } })) },
+      { title: 'Account', items: [
+        { id: 'signout', label: 'Sign out', detail: 'Forgets the session on this machine: nothing of the account stays here.', actions: [{ id: 'signout', label: 'Sign out', always: true }] },
+        { id: 'delete', label: 'Delete what is kept in the cloud', detail: 'Everything above, from every machine. Local files stay.', actions: [{ id: 'delete', label: 'Delete…', danger: true, always: true }] },
+      ] },
+    ] }
+}
+
+function accountHandler(ctl) {
+  return async (action, message) => {
+    const item = String(message.item || '')
+    if (action === 'toggle' && item.startsWith('keep:')) {
+      await config().update(`cloud.${item.slice(5)}`, !!message.value, vscode.ConfigurationTarget.Global)
+      return accountSpec(ctl, message.value ? 'Kept with your account from now on.' : 'No longer sent. What is in the cloud stays until you delete it.')
+    }
+    if (action === 'signin') { await ctl.signIn(); return accountSpec(ctl) }
+    if (action === 'signout') { await ctl.signOut(); return accountSpec(ctl, 'Signed out.') }
+    if (action === 'delete') { const said = await ctl.deleteCloudData(); return accountSpec(ctl, said || undefined) }
+    return undefined
+  }
+}
+
+module.exports = { register, accountSpec, accountHandler, VSCODE_PREFS, SECRET }