@goodandready/dsh-subscriptions 0.6.26 → 0.6.28

package/lib/images.js

@@ -109,3 +109,128 @@ export async function generateOnce(options) {
   }
   return parseImages(payload)
 }
+
+// Multimodal Payload Normalization for Vision Models
+export function parseDataUri(uri) {
+  if (typeof uri !== 'string') return null
+  const m = /^data:([a-zA-Z0-9.+/-]+);base64,(.+)$/.exec(uri.trim())
+  if (!m) return null
+  return { mimeType: m[1], base64: m[2] }
+}
+
+export function normalizeImage(item) {
+  if (!item) return null
+
+  // 1. Direct string (data URI or URL)
+  if (typeof item === 'string') {
+    const dataUri = parseDataUri(item)
+    if (dataUri) {
+      return { mimeType: dataUri.mimeType, base64: dataUri.base64, url: item.trim() }
+    }
+    if (/^https?:\/\//i.test(item.trim())) {
+      return { mimeType: 'image/jpeg', base64: null, url: item.trim() }
+    }
+    return null
+  }
+
+  if (typeof item !== 'object') return null
+
+  // 2. Anthropic style: { type: 'image', source: { type: 'base64', media_type, data } }
+  if (item.source && item.source.type === 'base64' && item.source.data) {
+    const mimeType = item.source.media_type || 'image/jpeg'
+    const base64 = item.source.data
+    return {
+      mimeType,
+      base64,
+      url: `data:${mimeType};base64,${base64}`,
+    }
+  }
+
+  // 3. Gemini style: { inlineData: { mimeType, data } }
+  if (item.inlineData && item.inlineData.data) {
+    const mimeType = item.inlineData.mimeType || 'image/jpeg'
+    const base64 = item.inlineData.data
+    return {
+      mimeType,
+      base64,
+      url: `data:${mimeType};base64,${base64}`,
+    }
+  }
+
+  // 4. OpenAI style: { type: 'image_url', image_url: { url } } or { type: 'image', image: '...' }
+  const rawUrl = (item.image_url && (item.image_url.url || item.image_url)) ||
+                 item.image || item.url
+
+  if (typeof rawUrl === 'string') {
+    const dataUri = parseDataUri(rawUrl)
+    if (dataUri) {
+      return { mimeType: dataUri.mimeType, base64: dataUri.base64, url: rawUrl.trim() }
+    }
+    if (/^https?:\/\//i.test(rawUrl.trim())) {
+      return { mimeType: 'image/jpeg', base64: null, url: rawUrl.trim() }
+    }
+  }
+
+  return null
+}
+
+export function extractImages(content) {
+  if (!Array.isArray(content)) {
+    const norm = normalizeImage(content)
+    return norm ? [norm] : []
+  }
+  const images = []
+  for (const block of content) {
+    if (!block) continue
+    if (typeof block === 'string') {
+      const norm = normalizeImage(block)
+      if (norm) images.push(norm)
+      continue
+    }
+    if (block.type === 'image' || block.type === 'image_url' || block.inlineData || block.image_url || block.image) {
+      const norm = normalizeImage(block)
+      if (norm) images.push(norm)
+    }
+  }
+  return images
+}
+
+export function toOpenAiImage(norm) {
+  const url = norm.url || (norm.base64 ? `data:${norm.mimeType};base64,${norm.base64}` : null)
+  if (!url) return null
+  return {
+    type: 'image_url',
+    image_url: { url },
+  }
+}
+
+export function toAnthropicImage(norm) {
+  if (!norm.base64) return null
+  return {
+    type: 'image',
+    source: {
+      type: 'base64',
+      media_type: norm.mimeType || 'image/jpeg',
+      data: norm.base64,
+    },
+  }
+}
+
+export function toGeminiImage(norm) {
+  if (!norm.base64) return null
+  return {
+    inlineData: {
+      mimeType: norm.mimeType || 'image/jpeg',
+      data: norm.base64,
+    },
+  }
+}
+
+export function toCodexImage(norm) {
+  const url = norm.url || (norm.base64 ? `data:${norm.mimeType};base64,${norm.base64}` : null)
+  if (!url) return null
+  return {
+    type: 'input_image',
+    image_url: url,
+  }
+}

package/lib/import-auth.js

@@ -169,7 +169,27 @@ async function discoverLocalCliSessionsInner() {
   }
 
   // 9. GitHub Copilot token
-  if (process.env.GITHUB_COPILOT_TOKEN || process.env.GH_TOKEN) {
+  const copilotPaths = [
+    homeFile('.config', 'github-copilot', 'hosts.json'),
+    homeFile('.config', 'github-copilot', 'apps.json'),
+  ]
+  for (const p of copilotPaths) {
+    const cp = await readJson(p)
+    if (cp) {
+      const gh = cp['github.com'] || cp
+      const tok = gh.oauth_token || gh.token || gh.access_token
+      if (tok) {
+        detected.copilot = {
+          provider: 'copilot',
+          path: p,
+          email: gh.user || 'GitHub Copilot User',
+          hasRefreshToken: false,
+        }
+        break
+      }
+    }
+  }
+  if (!detected.copilot && (process.env.GITHUB_COPILOT_TOKEN || process.env.GH_TOKEN)) {
     detected.copilot = {
       provider: 'copilot',
       path: 'GITHUB_COPILOT_TOKEN env',
@@ -217,12 +237,23 @@ export async function loadLocalCliBlob(provider, options = {}) {
   }
 
   if (provider === 'copilot') {
-    const tok = process.env.GITHUB_COPILOT_TOKEN || process.env.GH_TOKEN || ''
+    let tok = process.env.GITHUB_COPILOT_TOKEN || process.env.GH_TOKEN || ''
+    let email = 'GitHub Copilot User'
+    if (info.path && info.path !== 'GITHUB_COPILOT_TOKEN env') {
+      const cp = await readJson(info.path)
+      if (cp) {
+        const gh = cp['github.com'] || cp
+        tok = gh.oauth_token || gh.token || gh.access_token || tok
+        email = gh.user || email
+      }
+    }
     return {
       accessToken: tok,
       refreshToken: tok,
+      githubToken: tok,
       expiresAt: Date.now() + 30 * 86400 * 1000,
-      email: 'GitHub Copilot User'
+      email,
+      label: email,
     }
   }
 

package/lib/messages.js

@@ -1,3 +1,5 @@
+import { extractImages, toOpenAiImage, toAnthropicImage, toGeminiImage, toCodexImage } from './images.js'
+import { normalizeTools } from './tools-normalizer.js'
 import { geminiFunctionDeclarations } from './gemini-schema.js'
 
 function flattenText(content) {
@@ -64,7 +66,18 @@ export function openaiMessages(options) {
     }
     const results = toolResults(message.content)
     const text = flattenText(message.content)
-    if (text || !results.length) out.push({ role: 'user', content: text })
+    const images = extractImages(message.content)
+    if (images.length) {
+      const parts = []
+      if (text) parts.push({ type: 'text', text })
+      for (const img of images) {
+        const blk = toOpenAiImage(img)
+        if (blk) parts.push(blk)
+      }
+      out.push({ role: 'user', content: parts })
+    } else if (text || !results.length) {
+      out.push({ role: 'user', content: text })
+    }
     for (const result of results) {
       out.push({
         role: 'tool',
@@ -77,14 +90,14 @@ export function openaiMessages(options) {
 }
 
 export function openaiTools(options) {
-  const tools = options.tools
-  if (!Array.isArray(tools) || !tools.length) return undefined
+  const tools = normalizeTools(options && options.tools)
+  if (!tools) return undefined
   return tools.map((tool) => ({
     type: 'function',
     function: {
       name: tool.name,
-      description: tool.description || '',
-      parameters: tool.parameters || { type: 'object' },
+      description: tool.description,
+      parameters: tool.parameters,
     },
   }))
 }
@@ -147,6 +160,18 @@ export function reconcileResponsesInput(items) {
   return result
 }
 
+export function normalizeSystemPrefix(parts) {
+  if (!Array.isArray(parts)) return ""
+  return parts
+    .map((p) => {
+      if (!p) return ""
+      const s = typeof p === "string" ? p : (p.text || String(p))
+      return s.replace(/\r\n/g, "\n").trim()
+    })
+    .filter(Boolean)
+    .join("\n\n")
+}
+
 export function codexResponsesBody(options, fallbackInstructions, vendorCfg) {
   const systemParts = []
   if (options.system) systemParts.push(options.system)
@@ -215,6 +240,15 @@ export function codexResponsesBody(options, fallbackInstructions, vendorCfg) {
     const results = toolResults(message.content)
     const text = flattenText(message.content)
     if (text) addText('user', text)
+    const images = extractImages(message.content)
+    for (const img of images) {
+      const blk = toCodexImage(img)
+      if (blk) {
+        if (pendingRole && pendingRole !== 'user') flush()
+        pendingRole = 'user'
+        pendingContent.push(blk)
+      }
+    }
     for (const result of results) {
       flush()
       const callId = String(result.toolCallId || result.tool_call_id || result.call_id || result.id || '')
@@ -239,7 +273,7 @@ export function codexResponsesBody(options, fallbackInstructions, vendorCfg) {
     description: tool.function.description,
     parameters: tool.function.parameters,
   }))
-  const instructions = systemParts.filter(Boolean).join('\n\n') || fallbackInstructions
+  const instructions = normalizeSystemPrefix(systemParts) || (fallbackInstructions ? fallbackInstructions.replace(/\r\n/g, "\n").trim() : undefined)
   return {
     model: options.model,
     stream: true,
@@ -265,77 +299,123 @@ export function anthropicPayload(options, extraSystem) {
   if (options.system) systemParts.push(options.system)
   const messages = []
   for (const message of options.messages || []) {
-    if (message.role === 'system') {
+    if (message.role === "system") {
       systemParts.push(flattenText(message.content))
       continue
     }
-    if (message.role === 'assistant') {
+    if (message.role === "assistant") {
       const blocks = []
       const text = flattenText(message.content)
-      if (text) blocks.push({ type: 'text', text })
+      if (text) blocks.push({ type: "text", text })
       const calls = [
         ...toolCalls(message.content),
         ...((message.tool_calls || message.toolCalls || []).map((c) => ({
           id: c.id || c.call_id,
           name: c.name || (c.function && c.function.name),
-          arguments: c.arguments || (c.function && c.function.arguments) || '{}',
+          arguments: c.arguments || (c.function && c.function.arguments) || "{}",
         }))),
       ]
       for (const call of calls) {
         if (!call.id) continue
         blocks.push({
-          type: 'tool_use',
+          type: "tool_use",
           id: call.id,
           name: call.name,
           input: safeJson(call.arguments),
         })
       }
-      messages.push({ role: 'assistant', content: blocks.length ? blocks : [{ type: 'text', text: '' }] })
+      messages.push({ role: "assistant", content: blocks.length ? blocks : [{ type: "text", text: "" }] })
       continue
     }
-    if (message.role === 'tool') {
-      const toolUseId = String(message.toolCallId || message.tool_call_id || message.tool_use_id || message.id || '')
-      const content = typeof message.content === 'string'
+    if (message.role === "tool") {
+      const toolUseId = String(message.toolCallId || message.tool_call_id || message.tool_use_id || message.id || "")
+      const content = typeof message.content === "string"
         ? message.content
-        : (flattenText(message.content) || JSON.stringify(message.content || ''))
+        : (flattenText(message.content) || JSON.stringify(message.content || ""))
       messages.push({
-        role: 'user',
+        role: "user",
         content: [{
-          type: 'tool_result',
+          type: "tool_result",
           tool_use_id: toolUseId,
-          content: content || '',
+          content: content || "",
         }],
       })
       continue
     }
     const blocks = []
     const text = flattenText(message.content)
-    if (text) blocks.push({ type: 'text', text })
+    if (text) blocks.push({ type: "text", text })
+    const images = extractImages(message.content)
+    for (const img of images) {
+      const blk = toAnthropicImage(img)
+      if (blk) blocks.push(blk)
+    }
     for (const result of toolResults(message.content)) {
-      const toolUseId = String(result.toolCallId || result.tool_call_id || result.tool_use_id || result.id || '')
-      const content = typeof result.content === 'string'
+      const toolUseId = String(result.toolCallId || result.tool_call_id || result.tool_use_id || result.id || "")
+      const content = typeof result.content === "string"
         ? result.content
-        : (flattenText(result.content) || (result.output != null ? (typeof result.output === 'string' ? result.output : JSON.stringify(result.output)) : ''))
+        : (flattenText(result.content) || (result.output != null ? (typeof result.output === "string" ? result.output : JSON.stringify(result.output)) : ""))
       blocks.push({
-        type: 'tool_result',
+        type: "tool_result",
         tool_use_id: toolUseId,
-        content: content || '',
+        content: content || "",
       })
     }
-    messages.push({ role: 'user', content: blocks.length ? blocks : [{ type: 'text', text: '' }] })
+    messages.push({ role: "user", content: blocks.length ? blocks : [{ type: "text", text: "" }] })
   }
-  const tools = Array.isArray(options.tools)
-    ? options.tools.map((tool) => ({
-      name: tool.name,
-      description: tool.description || '',
-      input_schema: tool.parameters || { type: 'object' },
-    }))
+
+  const useCacheControl = options.cacheControl !== false
+  const systemText = normalizeSystemPrefix(systemParts)
+  let system
+  if (systemText) {
+    if (useCacheControl) {
+      system = [{ type: "text", text: systemText, cache_control: { type: "ephemeral" } }]
+    } else {
+      system = systemText
+    }
+  }
+
+  const normTools = normalizeTools(options.tools)
+  const tools = normTools
+    ? normTools.map((tool, idx) => {
+      const item = {
+        name: tool.name,
+        description: tool.description,
+        input_schema: tool.parameters,
+      }
+      if (useCacheControl && idx === normTools.length - 1) {
+        item.cache_control = { type: "ephemeral" }
+      }
+      return item
+    })
     : undefined
+
+  if (useCacheControl) {
+    const userTurnIndices = []
+    for (let i = 0; i < messages.length; i++) {
+      if (messages[i].role === "user") {
+        userTurnIndices.push(i)
+      }
+    }
+    if (userTurnIndices.length >= 2) {
+      const targetIdx = userTurnIndices[userTurnIndices.length - 2]
+      const targetMsg = messages[targetIdx]
+      if (Array.isArray(targetMsg.content) && targetMsg.content.length > 0) {
+        const lastBlockIdx = targetMsg.content.length - 1
+        const lastBlock = targetMsg.content[lastBlockIdx]
+        targetMsg.content[lastBlockIdx] = {
+          ...lastBlock,
+          cache_control: { type: "ephemeral" },
+        }
+      }
+    }
+  }
+
   return {
     model: options.model,
     max_tokens: options.maxTokens || 8192,
     stream: true,
-    ...(systemParts.length ? { system: systemParts.join('\n\n') } : {}),
+    ...(system ? { system } : {}),
     messages,
     ...(tools && tools.length ? { tools } : {}),
     ...(options.temperature != null ? { temperature: options.temperature } : {}),
@@ -371,6 +451,11 @@ export function googleContents(options) {
     const parts = []
     const text = flattenText(message.content)
     if (text) parts.push({ text })
+    const images = extractImages(message.content)
+    for (const img of images) {
+      const blk = toGeminiImage(img)
+      if (blk) parts.push(blk)
+    }
     const calls = [
       ...toolCalls(message.content),
       ...((message.tool_calls || message.toolCalls || []).map((c) => ({
@@ -400,7 +485,10 @@ export function googleContents(options) {
   const tools = declarations ? [{ functionDeclarations: declarations }] : undefined
   return {
     contents,
-    ...(systemParts.length ? { systemInstruction: { parts: systemParts } } : {}),
+    ...(() => {
+      const systemText = normalizeSystemPrefix(systemParts)
+      return systemText ? { systemInstruction: { parts: [{ text: systemText }] } } : {}
+    })(),
     ...(tools ? { tools } : {}),
     generationConfig: {
       ...(options.temperature != null ? { temperature: options.temperature } : {}),

package/lib/refs.js

@@ -55,6 +55,7 @@ const DISPLAY = {
   glm: 'Zhipu GLM',
   cursor: 'Cursor',
   kiro: 'AWS Kiro',
+  copilot: 'GitHub Copilot',
 }
 
 export function displayName(provider) {

package/lib/routes/accounts.js

@@ -349,100 +349,117 @@ export function registerAccountsRoutes(ctx, state) {
     }),
   }), 'dsh-subscriptions: /logout')
 
-  // #353: Encrypted Vault export
+  const handleVaultExport = safeJsonHandler(async (req, res) => {
+    if (req.method !== 'POST') {
+      writeJson(res, 405, { ok: false, error: { code: 'method', message: 'POST only' } })
+      return
+    }
+    if (!isTrustedSettingsRequest(req)) {
+      writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'same-origin only' } })
+      return
+    }
+    let payload
+    try { payload = JSON.parse((await readBody(req, 8 * 1024)).toString('utf8') || '{}') } catch {
+      writeJson(res, 400, { ok: false, error: { code: 'json', message: 'invalid json' } })
+      return
+    }
+    const passphrase = payload.passphrase
+    const algorithm = payload.algorithm || 'pbkdf2'
+    try {
+      const slots = live().slots || []
+      const blobs = {}
+      for (const slot of normalizeSlots(slots)) {
+        try {
+          const blob = await store.loadBlob(slot.ref)
+          if (blob) blobs[slot.ref] = blob
+        } catch { /* ignore */ }
+      }
+      const result = exportVault({ slots, blobs, algorithm }, passphrase)
+      writeJson(res, 200, result)
+    } catch (e) {
+      writeJson(res, 400, { ok: false, error: { code: 'vault_export', message: String(e && e.message || e) } })
+    }
+  })
+
+  // #353 & #396: Encrypted Vault export
   ctx.effect(() => ctx.webServer.register({
     kind: 'exact',
     path: '/dsh-subscriptions/vault/export',
-    handler: safeJsonHandler(async (req, res) => {
-      if (req.method !== 'POST') {
-        writeJson(res, 405, { ok: false, error: { code: 'method', message: 'POST only' } })
-        return
-      }
-      if (!isTrustedSettingsRequest(req)) {
-        writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'same-origin only' } })
-        return
-      }
-      let payload
-      try { payload = JSON.parse((await readBody(req, 8 * 1024)).toString('utf8') || '{}') } catch {
-        writeJson(res, 400, { ok: false, error: { code: 'json', message: 'invalid json' } })
-        return
-      }
-      const passphrase = payload.passphrase
-      try {
-        const slots = live().slots || []
-        const blobs = {}
-        for (const slot of normalizeSlots(slots)) {
-          try {
-            const blob = await store.loadBlob(slot.ref)
-            if (blob) blobs[slot.ref] = blob
-          } catch { /* ignore */ }
-        }
-        const result = exportVault({ slots, blobs }, passphrase)
-        writeJson(res, 200, result)
-      } catch (e) {
-        writeJson(res, 400, { ok: false, error: { code: 'vault_export', message: String(e && e.message || e) } })
-      }
-    }),
+    handler: handleVaultExport,
   }), 'dsh-subscriptions: /vault/export')
 
-  // #353: Encrypted Vault import
   ctx.effect(() => ctx.webServer.register({
     kind: 'exact',
-    path: '/dsh-subscriptions/vault/import',
-    handler: safeJsonHandler(async (req, res) => {
-      if (req.method !== 'POST') {
-        writeJson(res, 405, { ok: false, error: { code: 'method', message: 'POST only' } })
-        return
-      }
-      if (!isTrustedSettingsRequest(req)) {
-        writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'same-origin only' } })
-        return
-      }
-      let payload
-      try { payload = JSON.parse((await readBody(req, 2 * 1024 * 1024)).toString('utf8') || '{}') } catch {
-        writeJson(res, 400, { ok: false, error: { code: 'json', message: 'invalid json' } })
-        return
-      }
-      const { passphrase, vault } = payload
-      try {
-        const result = importVault(vault, passphrase)
-        const settings = getSettingsApi()
-        let parsed
-        if (result.slots.length) {
-          if (!settings) throw new Error('settings are unavailable for vault import')
-          const curSlots = Array.isArray(live().slots) ? live().slots.slice() : []
-          for (const s of result.slots) {
-            const idx = curSlots.findIndex((c) => c.provider === s.provider && Number(c.index) === Number(s.index))
-            if (idx >= 0) {
-              curSlots[idx] = { ...curSlots[idx], ...s }
-            } else {
-              curSlots.push(s)
-            }
+    path: '/dsh-subscriptions/export-backup',
+    handler: handleVaultExport,
+  }), 'dsh-subscriptions: /export-backup')
+
+  const handleVaultImport = safeJsonHandler(async (req, res) => {
+    if (req.method !== 'POST') {
+      writeJson(res, 405, { ok: false, error: { code: 'method', message: 'POST only' } })
+      return
+    }
+    if (!isTrustedSettingsRequest(req)) {
+      writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'same-origin only' } })
+      return
+    }
+    let payload
+    try { payload = JSON.parse((await readBody(req, 2 * 1024 * 1024)).toString('utf8') || '{}') } catch {
+      writeJson(res, 400, { ok: false, error: { code: 'json', message: 'invalid json' } })
+      return
+    }
+    const { passphrase, vault } = payload
+    try {
+      const result = importVault(vault, passphrase)
+      const settings = getSettingsApi()
+      let parsed
+      if (result.slots.length) {
+        if (!settings) throw new Error('settings are unavailable for vault import')
+        const curSlots = Array.isArray(live().slots) ? live().slots.slice() : []
+        for (const s of result.slots) {
+          const idx = curSlots.findIndex((c) => c.provider === s.provider && Number(c.index) === Number(s.index))
+          if (idx >= 0) {
+            curSlots[idx] = { ...curSlots[idx], ...s }
+          } else {
+            curSlots.push(s)
           }
-          parsed = Config({ ...live(), slots: stripLegacySlots(curSlots) })
-        }
-        let blobCount = 0
-        for (const [ref, blob] of Object.entries(result.blobs)) {
-          await store.saveBlob(ref, blob)
-          blobCount++
-        }
-        if (parsed) {
-          await settings.replace(parsed)
-          syncCustomVendors()
         }
-        await syncAdapter()
-        refreshModels().catch(() => {})
-        writeJson(res, 200, {
-          ok: true,
-          slotCount: result.slots.length,
-          blobCount,
-          exportedAt: result.exportedAt,
-          accounts: await accountsView(),
-        })
-      } catch (e) {
-        writeJson(res, 400, { ok: false, error: { code: 'vault_import', message: String(e && e.message || e) } })
+        parsed = Config({ ...live(), slots: stripLegacySlots(curSlots) })
       }
-    }),
+      let blobCount = 0
+      for (const [ref, blob] of Object.entries(result.blobs)) {
+        await store.saveBlob(ref, blob)
+        blobCount++
+      }
+      if (parsed) {
+        await settings.replace(parsed)
+        syncCustomVendors()
+      }
+      await syncAdapter()
+      refreshModels().catch(() => {})
+      writeJson(res, 200, {
+        ok: true,
+        slotCount: result.slots.length,
+        blobCount,
+        exportedAt: result.exportedAt,
+        accounts: await accountsView(),
+      })
+    } catch (e) {
+      writeJson(res, 400, { ok: false, error: { code: 'vault_import', message: String(e && e.message || e) } })
+    }
+  })
+
+  // #353 & #396: Encrypted Vault import
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-subscriptions/vault/import',
+    handler: handleVaultImport,
   }), 'dsh-subscriptions: /vault/import')
 
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-subscriptions/import-backup',
+    handler: handleVaultImport,
+  }), 'dsh-subscriptions: /import-backup')
+
 }