@igstack/app-catalog-backend-core 0.16.0 → 0.17.1-alpha-20260821043201

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@igstack/app-catalog-backend-core",
-  "version": "0.16.0",
+  "version": "0.17.1-alpha-20260821043201",
   "description": "Backend core library for App Catalog",
   "homepage": "https://github.com/lislon/app-catalog",
   "repository": {
@@ -24,14 +24,14 @@
     "prisma.config.ts"
   ],
   "dependencies": {
-    "@ai-sdk/mcp": "^1.0.25",
+    "@ai-sdk/mcp": "1.0.70",
     "@better-auth/prisma-adapter": "^1.5.3",
     "@kubernetes/client-node": "^1.2.0",
     "@modelcontextprotocol/sdk": "^1.27.1",
     "@trpc/client": "^11.8.1",
     "@trpc/server": "^11.4.2",
-    "ai": "^6.0.37",
-    "better-auth": "^1.4.18",
+    "ai": "6.0.250",
+    "better-auth": ">=1.4.18 <1.7.0",
     "cors": "^2.8.5",
     "dotenv": "^17.3.1",
     "dotenv-defaults": "5.0.2",
@@ -45,8 +45,8 @@
     "tsyringe": "^4.10.0",
     "yaml": "^2.8.0",
     "zod": "^4.3.5",
-    "@igstack/app-catalog-shared-core": "0.16.0",
-    "@igstack/app-catalog-table-sync": "0.16.0"
+    "@igstack/app-catalog-shared-core": "0.17.1-alpha-20260821043201",
+    "@igstack/app-catalog-table-sync": "0.17.1-alpha-20260821043201"
   },
   "devDependencies": {
     "@tanstack/vite-config": "^0.4.3",
@@ -73,7 +73,7 @@
   "engines": {
     "node": ">=24"
   },
-  "gitHead": "8ef46d75c527a6d4a00965f7529e000c03cf0bc6",
+  "gitHead": "304d9c364de826d155069ac01370baffb0620c78",
   "scripts": {
     "build": "tsdown",
     "build:lenient": "tsdown",

package/prisma/migrations/20260813000000_add_ai_memory/migration.sql

@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "DbResource" ADD COLUMN "aiMemory" TEXT;

package/prisma/schema.prisma

@@ -147,6 +147,7 @@ model DbResource {
   /// [AppDeprecation] - Deprecation info with optional replacement slug
   deprecated                 Json?
   aiPrompt                   String?
+  aiMemory                   String?
   urlIssues                  String[]          @default([])
   /// [TierVariant[]]
   tiers                      Json?
@@ -164,10 +165,13 @@ model DbResource {
   accessComments             String?
   /// [SubResourceExtra]
   extra                      Json?
-  // Freshness (autoupdate scan): when sources were last verified and when the
-  // next check is due. Nullable — apps that have never been scanned carry null.
+  // Freshness (autoupdate scan): when sources were last verified, when the next
+  // check is due, and when the source content last actually changed (what the UI
+  // shows as "Updated" — a source can be re-read without changing).
+  // Nullable — apps that have never been scanned carry null.
   lastCheckedAt              DateTime?
   nextCheckAfter             DateTime?
+  lastContentChangeAt        DateTime?
   createdAt                  DateTime          @default(now())
   updatedAt                  DateTime          @updatedAt
 

package/src/__tests__/assetMime.test.ts

@@ -18,25 +18,37 @@ describe('parseAssetMeta mime derivation', () => {
   })
 })
 
-describe('upsertAsset mimeType repair', () => {
-  const fakePrisma = (existing: { id: string; mimeType: string } | null) => {
-    const update = vi.fn().mockResolvedValue(existing)
-    const create = vi.fn().mockResolvedValue({ id: 'created' })
-    const prisma = {
-      dbAsset: {
-        findUnique: vi.fn().mockResolvedValue(existing),
-        update,
-        create,
-      },
-    } as unknown as PrismaClient
+const fakePrisma = (
+  existing: {
+    id: string
+    mimeType: string
+    checksum: string
+  } | null,
+) => {
+  const update = vi.fn().mockResolvedValue(existing)
+  const create = vi.fn().mockResolvedValue({ id: 'created' })
+  const prisma = {
+    dbAsset: {
+      findUnique: vi.fn().mockResolvedValue(existing),
+      update,
+      create,
+    },
+  } as unknown as PrismaClient
 
-    return { prisma, update, create }
-  }
+  return { prisma, update, create }
+}
+
+describe('upsertAsset mimeType repair', () => {
+  it('rewrites a stale mimeType on an already-stored asset (same bytes, wrong derivation)', async () => {
+    const { checksum } = await parseAssetMeta({
+      buffer: SVG,
+      originalFilename: 'example-icon.svg',
+    })
 
-  it('rewrites a stale mimeType on an already-stored asset', async () => {
     const { prisma, update } = fakePrisma({
       id: 'existing',
       mimeType: 'image/svg',
+      checksum,
     })
 
     const id = await upsertAsset({
@@ -55,9 +67,15 @@ describe('upsertAsset mimeType repair', () => {
   })
 
   it('leaves an already-correct asset untouched', async () => {
+    const { checksum } = await parseAssetMeta({
+      buffer: SVG,
+      originalFilename: 'example-icon.svg',
+    })
+
     const { prisma, update } = fakePrisma({
       id: 'existing',
       mimeType: 'image/svg+xml',
+      checksum,
     })
 
     const id = await upsertAsset({
@@ -72,3 +90,75 @@ describe('upsertAsset mimeType repair', () => {
     expect(update).not.toHaveBeenCalled()
   })
 })
+
+describe('upsertAsset content replacement', () => {
+  const OLD_SVG = SVG
+  const NEW_PNG = Buffer.from(
+    // 1x1 transparent PNG
+    '89504e470d0a1a0a0000000d494844520000000100000001080600000' +
+      '01f15c4890000000a49444154789c6360000002000100ffff03000006' +
+      '0005579259de0000000049454e44ae426082',
+    'hex',
+  )
+
+  it('rewrites content/checksum/fileSize/mimeType when the stored asset name is reused for different bytes', async () => {
+    const oldMeta = await parseAssetMeta({
+      buffer: OLD_SVG,
+      originalFilename: 'example-icon.svg',
+    })
+    const newMeta = await parseAssetMeta({
+      buffer: NEW_PNG,
+      originalFilename: 'example-icon.png',
+    })
+
+    const { prisma, update } = fakePrisma({
+      id: 'existing',
+      mimeType: oldMeta.mimeType,
+      checksum: oldMeta.checksum,
+    })
+
+    const id = await upsertAsset({
+      prisma,
+      buffer: NEW_PNG,
+      name: 'example-icon',
+      originalFilename: 'example-icon.png',
+      assetType: 'icon',
+    })
+
+    expect(id).toBe('existing')
+    expect(update).toHaveBeenCalledWith({
+      where: { id: 'existing' },
+      data: {
+        mimeType: 'image/png',
+        content: new Uint8Array(NEW_PNG),
+        checksum: newMeta.checksum,
+        fileSize: newMeta.fileSize,
+        width: newMeta.width,
+        height: newMeta.height,
+      },
+    })
+  })
+
+  it('does not call update when the same bytes are re-synced (checksum unchanged)', async () => {
+    const meta = await parseAssetMeta({
+      buffer: OLD_SVG,
+      originalFilename: 'example-icon.svg',
+    })
+
+    const { prisma, update } = fakePrisma({
+      id: 'existing',
+      mimeType: meta.mimeType,
+      checksum: meta.checksum,
+    })
+
+    await upsertAsset({
+      prisma,
+      buffer: OLD_SVG,
+      name: 'example-icon',
+      originalFilename: 'example-icon.svg',
+      assetType: 'icon',
+    })
+
+    expect(update).not.toHaveBeenCalled()
+  })
+})

package/src/__tests__/freshness.test.ts

@@ -9,55 +9,94 @@ const iso = (msFromNow: number) => new Date(NOW + msFromNow).toISOString()
 const DAY = 24 * 60 * 60 * 1000
 
 describe('computeFreshness', () => {
-  it('returns null date and not-stale when never checked', () => {
-    expect(computeFreshness(null, null, NOW)).toEqual({
+  it('returns null dates and not-stale when never checked', () => {
+    expect(computeFreshness({}, NOW)).toEqual({
       lastCheckedAt: null,
+      lastContentChangeAt: null,
       isStale: false,
     })
     // nextCheckAfter present but never checked → still nothing to show
-    expect(computeFreshness(null, iso(-30 * DAY), NOW)).toEqual({
+    expect(computeFreshness({ nextCheckAfter: iso(-30 * DAY) }, NOW)).toEqual({
       lastCheckedAt: null,
+      lastContentChangeAt: null,
       isStale: false,
     })
   })
 
   it('is fresh when the next check is still in the future', () => {
-    const r = computeFreshness(iso(-DAY), iso(DAY), NOW)
+    const r = computeFreshness(
+      { lastCheckedAt: iso(-DAY), nextCheckAfter: iso(DAY) },
+      NOW,
+    )
     expect(r.isStale).toBe(false)
     expect(r.lastCheckedAt).toBe(iso(-DAY))
   })
 
   it('is fresh when overdue but within the grace period', () => {
     // due 3 days ago, grace is 7 days → not stale yet
-    expect(computeFreshness(iso(-10 * DAY), iso(-3 * DAY), NOW).isStale).toBe(
-      false,
-    )
+    expect(
+      computeFreshness(
+        { lastCheckedAt: iso(-10 * DAY), nextCheckAfter: iso(-3 * DAY) },
+        NOW,
+      ).isStale,
+    ).toBe(false)
   })
 
   it('is stale once past due by more than the grace period', () => {
     // due 8 days ago > 7-day grace → stale
-    expect(computeFreshness(iso(-15 * DAY), iso(-8 * DAY), NOW).isStale).toBe(
-      true,
-    )
+    expect(
+      computeFreshness(
+        { lastCheckedAt: iso(-15 * DAY), nextCheckAfter: iso(-8 * DAY) },
+        NOW,
+      ).isStale,
+    ).toBe(true)
   })
 
   it('treats exactly-grace as not yet stale (strictly greater than)', () => {
-    const dueAt = iso(-0) // due now
-    // now - due === 0; push due back exactly grace → boundary is not stale
     const atBoundary = computeFreshness(
-      iso(-8 * DAY),
-      new Date(NOW - STALE_GRACE_MS).toISOString(),
+      {
+        lastCheckedAt: iso(-8 * DAY),
+        nextCheckAfter: new Date(NOW - STALE_GRACE_MS).toISOString(),
+      },
       NOW,
     )
     expect(atBoundary.isStale).toBe(false)
-    void dueAt
   })
 
   it('is not stale when nextCheckAfter is missing (cannot judge overdue)', () => {
-    expect(computeFreshness(iso(-100 * DAY), null, NOW).isStale).toBe(false)
+    expect(
+      computeFreshness({ lastCheckedAt: iso(-100 * DAY) }, NOW).isStale,
+    ).toBe(false)
   })
 
   it('ignores an unparseable nextCheckAfter', () => {
-    expect(computeFreshness(iso(-DAY), 'not-a-date', NOW).isStale).toBe(false)
+    expect(
+      computeFreshness(
+        { lastCheckedAt: iso(-DAY), nextCheckAfter: 'not-a-date' },
+        NOW,
+      ).isStale,
+    ).toBe(false)
+  })
+
+  it('passes through when the content last actually changed', () => {
+    // The UI shows this instead of lastCheckedAt: a source re-read 20 times
+    // without changing was still "Updated" 90 days ago.
+    const r = computeFreshness(
+      {
+        lastCheckedAt: iso(-DAY),
+        nextCheckAfter: iso(DAY),
+        lastContentChangeAt: iso(-90 * DAY),
+      },
+      NOW,
+    )
+    expect(r.lastContentChangeAt).toBe(iso(-90 * DAY))
+    expect(r.lastCheckedAt).toBe(iso(-DAY))
+  })
+
+  it('leaves lastContentChangeAt null for entries predating the field', () => {
+    // Older rows have no content-change timestamp; the frontend falls back to
+    // lastCheckedAt rather than showing nothing.
+    const r = computeFreshness({ lastCheckedAt: iso(-DAY) }, NOW)
+    expect(r.lastContentChangeAt).toBeNull()
   })
 })

package/src/db/syncAppCatalog.ts

@@ -296,6 +296,8 @@ export async function syncAppCatalog(
         screenshotIds: resource.screenshotIds ?? [],
         deprecated: resource.deprecated ?? null,
         aiPrompt: resource.aiPrompt ?? null,
+        // aiMemory intentionally excluded from bulk sync — it is AI-owned and
+        // preserved across restarts. Static-config values are seeded below (if DB is null).
         urlIssues: resource.urlIssues ?? [],
         tiers: resource.tiers ?? null,
         // Fields from former SubResource
@@ -313,6 +315,9 @@ export async function syncAppCatalog(
         nextCheckAfter: resource.nextCheckAfter
           ? new Date(resource.nextCheckAfter)
           : null,
+        lastContentChangeAt: resource.lastContentChangeAt
+          ? new Date(resource.lastContentChangeAt)
+          : null,
       }
     })
 
@@ -362,6 +367,26 @@ export async function syncAppCatalog(
       ...TABLE_SYNC_MAGAZINE.SourceReference,
     }).sync(allSourceRefs)
 
+    // Seed aiMemory only for resources where the static config provides an initial value
+    // and the DB currently has none. This preserves AI-written updates across restarts.
+    const resourcesWithAiMemorySeed = sortedResources.filter(
+      (r) => r.aiMemory != null && r.aiMemory.trim() !== '',
+    )
+    if (resourcesWithAiMemorySeed.length > 0) {
+      for (const resource of resourcesWithAiMemorySeed) {
+        const slug =
+          resource.slug ||
+          resource.displayName
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, '-')
+            .replace(/^-+|-+$/g, '')
+        await prisma.dbResource.updateMany({
+          where: { slug, aiMemory: null },
+          data: { aiMemory: resource.aiMemory },
+        })
+      }
+    }
+
     // Get actual synced data to calculate stats
     const actual = result.getActual()