@anionex/dsh-vision-toolkit 0.1.38 → 0.1.40

package/src/storage-history.ts

@@ -0,0 +1,172 @@
+/** Durable configured-storage history used to authorize persisted image paths after Profile restarts. */
+
+import type { Context, Fiber } from '@deepseek-ai/cordis'
+import { defineDomain } from '@deepseek-ai/dsh-storage-domain'
+import type { DomainGlobal } from '@deepseek-ai/dsh-storage-domain'
+import { z } from 'zod'
+import { resolveConfig, type VisionToolkitConfig } from './config.ts'
+
+const storageHistoryStateSchema = z.object({
+  roots: z.array(z.string().min(1)),
+})
+
+type StorageHistoryState = z.infer<typeof storageHistoryStateSchema>
+
+/** Plugin-owned storage roots that survive Settings-provider and Profile restarts. */
+export const storageHistoryDomainSpec = defineDomain({
+  name: 'vision_toolkit_storage',
+  version: 0,
+  global: {
+    schema: storageHistoryStateSchema,
+    initial: { roots: [] },
+  },
+  tables: {},
+})
+
+interface StorageBinding {
+  accepting: boolean
+  global: DomainGlobal<StorageHistoryState>
+}
+
+function sameRoots(left: readonly string[], right: readonly string[]): boolean {
+  return left.length === right.length && left.every((root, index) => root === right[index])
+}
+
+/**
+ * Return every configured root that must remain readable, including the active root.
+ * @param config - Settings generation to summarize.
+ * @returns normalized configured roots in retention order.
+ */
+export function configuredStorageRoots(config: VisionToolkitConfig): string[] {
+  const resolved = resolveConfig(config)
+  return [...new Set([
+    ...resolved.storageHistory,
+    ...(resolved.storageDir === undefined ? [] : [resolved.storageDir]),
+  ])]
+}
+
+/**
+ * Merge plugin-owned roots into a Settings generation without retaining its active root as history.
+ * @param config - Settings generation being restored.
+ * @param durableRoots - roots loaded from the plugin-owned sidecar.
+ * @returns the original generation when unchanged, otherwise a generation with restored history.
+ */
+export function restoreDurableStorageHistory(
+  config: VisionToolkitConfig,
+  durableRoots: readonly string[],
+): VisionToolkitConfig {
+  const resolved = resolveConfig(config)
+  const storageHistory = [...new Set([...resolved.storageHistory, ...durableRoots])]
+    .filter(root => root !== resolved.storageDir)
+  if (sameRoots(storageHistory, resolved.storageHistory)) return config
+  return { ...config, storageHistory }
+}
+
+/** Optional storage-domain sidecar for storage roots that Settings cannot persist itself. */
+export class StorageHistoryStore {
+  private storage: StorageBinding | undefined
+  private storageFiber: (Fiber & PromiseLike<Fiber>) | undefined
+  private storageReady: Promise<void> | undefined
+  private mutationTail: Promise<void> = Promise.resolve()
+  private desiredRoots: readonly string[] | undefined
+  private persistenceTicket = 0
+  private warned = false
+
+  constructor(private readonly ctx: Context) {
+    if (typeof ctx.inject !== 'function') return
+    this.storageFiber = ctx.inject(['storageDomain'], async (storageCtx: Context) => {
+      const domain = await storageCtx.storageDomain.open(storageHistoryDomainSpec)
+      const binding: StorageBinding = { accepting: true, global: domain.global }
+      this.storage = binding
+      try {
+        if (this.desiredRoots !== undefined) {
+          await this.write(binding, this.desiredRoots, this.persistenceTicket)
+        }
+      } catch (error) {
+        this.storage = undefined
+        await domain.close()
+        throw error
+      }
+      return async () => {
+        binding.accepting = false
+        if (this.storage === binding) this.storage = undefined
+        await this.mutationTail
+        await domain.close()
+      }
+    })
+    this.storageReady = Promise.resolve(this.storageFiber).then(
+      () => undefined,
+      (error: unknown) => { this.warnOnce(error) },
+    )
+  }
+
+  /**
+   * Restore durable roots into one Settings generation before runtime preparation.
+   * @param config - Settings generation to restore.
+   * @returns the generation with available durable roots merged into its history.
+   */
+  async restore(config: VisionToolkitConfig): Promise<VisionToolkitConfig> {
+    const binding = await this.prepareStorage()
+    return restoreDurableStorageHistory(config, binding?.global.get().roots ?? [])
+  }
+
+  /**
+   * Persist the active and historical configured roots.
+   * @param config - validated generation whose roots must survive restart.
+   * @returns false when no storage-domain is available; true after persistence or when there are no roots.
+   */
+  async persist(config: VisionToolkitConfig): Promise<boolean> {
+    const roots = configuredStorageRoots(config)
+    const ticket = ++this.persistenceTicket
+    this.desiredRoots = roots
+    if (roots.length === 0) return true
+    const binding = await this.prepareStorage()
+    if (binding === undefined) return false
+    await this.write(binding, roots, ticket)
+    return true
+  }
+
+  /** Release the optional storage-domain binding with the plugin lifecycle. */
+  dispose(): void {
+    const fiber = this.storageFiber
+    this.storageFiber = undefined
+    this.storageReady = undefined
+    if (fiber !== undefined) void fiber.dispose().catch(error => { this.warnOnce(error) })
+  }
+
+  private async prepareStorage(): Promise<StorageBinding | undefined> {
+    const current = this.activeStorage()
+    if (current !== undefined) return current
+    if (this.ctx.get('storageDomain') === undefined) return undefined
+    await this.storageReady
+    return this.activeStorage()
+  }
+
+  private activeStorage(): StorageBinding | undefined {
+    return this.storage?.accepting === true ? this.storage : undefined
+  }
+
+  private write(binding: StorageBinding, roots: readonly string[], ticket: number): Promise<void> {
+    return this.enqueueMutation(async () => {
+      if (!binding.accepting) throw new Error('the storage-domain provider changed while storage history was pending')
+      if (ticket !== this.persistenceTicket) return
+      if (sameRoots(binding.global.get().roots, roots)) return
+      await binding.global.set({ roots: [...roots] })
+    })
+  }
+
+  private enqueueMutation(operation: () => Promise<void>): Promise<void> {
+    const result = this.mutationTail.then(operation)
+    this.mutationTail = result.then(() => undefined, () => undefined)
+    return result
+  }
+
+  private warnOnce(error: unknown): void {
+    if (this.warned) return
+    this.warned = true
+    this.ctx.logger?.warn(
+      'dsh-vision-toolkit: configured storage history sidecar is unavailable. %s',
+      (error instanceof Error ? error.message : String(error)).slice(0, 500),
+    )
+  }
+}

package/src/upstream.ts

@@ -541,9 +541,19 @@ const VISION_MODEL_GUARD = [
   '        requested=prompt or vision_client.DEFAULT_PROMPT',
   '        return original_describe(image_url,f"{policy}\\n\\n{requested}",*args,**kwargs)',
   '    vision_client.describe_image=guarded_describe',
+  '    ground_module=None',
+  '    original_parse_matches=None',
+  '    if Path(script).name in {"ground","detect"} and importlib.util.find_spec("ground") is not None:',
+  '        import ground as ground_module',
+  '        original_parse_matches=ground_module.parse_matches',
+  '        def normalized_parse_matches(*args,**kwargs):',
+  '            matches=original_parse_matches(*args,**kwargs)',
+  '            return [ground_module.Match(" ".join(str(match.label).split()),match.bbox) for match in matches]',
+  '        ground_module.parse_matches=normalized_parse_matches',
   '    try:',
   '        runpy.run_path(script,run_name="__main__")',
   '    finally:',
+  '        if ground_module is not None: ground_module.parse_matches=original_parse_matches',
   '        vision_client.describe_image=original_describe',
 ].join('\n')
 

package/src/web.ts

@@ -22,6 +22,7 @@ import {
 } from './paste-images.ts'
 import {
   resolveConfig,
+  retainedStorageHistory,
   isBuiltInFreeVisionProvider,
   VISION_TOOLKIT_SETTINGS_NAMESPACE,
   type ResolvedVisionToolkitConfig,
@@ -303,16 +304,22 @@ export class VisionToolkitWebBackend {
 
   private async save(request: SaveRequest): Promise<VisionToolkitSettingsSnapshot> {
     if (!this.ctx.settings.writable) throw new Error('settings provider is read-only')
+    const current = resolveConfig(descriptorOf(this.ctx).value as VisionToolkitConfig)
+    const storageHistory = retainedStorageHistory(request.value, current)
+    const value: VisionToolkitConfig = {
+      ...request.value,
+      ...(storageHistory.length === 0 ? {} : { storageHistory }),
+    }
     let candidate: PreparedRuntimeGeneration
     try {
-      candidate = await this.manager.prepareCandidate(request.value)
+      candidate = await this.manager.prepareCandidate(value)
     } catch (error) {
       this.manager.recordFailure(error)
       throw error
     }
     await this.ctx.settings.replace(
       VISION_TOOLKIT_SETTINGS_NAMESPACE,
-      request.value as object,
+      value as object,
       request.expectedRevision,
     )
     this.manager.activateCandidate(candidate)