@camstack/server 0.1.5 → 0.1.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/server",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "private": false,
   "exports": {
     "./package.json": "./package.json",

package/src/__tests__/addon-upload.spec.ts

@@ -23,6 +23,7 @@ import type { AddonBridgeService } from '../core/addon-bridge/addon-bridge.servi
 import type { AuthService } from '../core/auth/auth.service.js'
 import type { MoleculerService } from '../core/moleculer/moleculer.service.js'
 import type { AddonRegistryService } from '../core/addon/addon-registry.service.js'
+import type { AddonPackageService } from '../core/addon/addon-package.service.js'
 import type { IScopedLogger } from '@camstack/types'
 
 /**
@@ -129,6 +130,14 @@ function makeAddonRegistry(): AddonRegistryService {
   } as unknown as AddonRegistryService
 }
 
+function makeAddonPackageService(): AddonPackageService {
+  // `restartServer` is exercised only by the framework-package branch; the
+  // default happy-path tests deploy a regular addon and never call it.
+  return {
+    restartServer: vi.fn((_requestedBy?: string) => {}),
+  } as unknown as AddonPackageService
+}
+
 function makeLogger(): IScopedLogger {
   return {
     debug: vi.fn(),
@@ -145,6 +154,7 @@ async function makeServer(opts: {
   bridge: AddonBridgeService
   moleculer: MoleculerService
   addonRegistry?: AddonRegistryService
+  addonPackageService?: AddonPackageService
   logger?: IScopedLogger
 }): Promise<FastifyInstance> {
   const fastify = Fastify({ logger: false })
@@ -154,6 +164,7 @@ async function makeServer(opts: {
     opts.auth,
     opts.moleculer,
     opts.addonRegistry ?? makeAddonRegistry(),
+    opts.addonPackageService ?? makeAddonPackageService(),
     opts.logger ?? makeLogger(),
   )
   await fastify.ready()
@@ -258,6 +269,53 @@ describe('POST /api/addons/upload', () => {
     }
   })
 
+  it('restarts the server (not an in-process reload) when a framework package is deployed', async () => {
+    // @camstack/core ships hub builtins that can't hot-reload in place — the
+    // upload path must call restartServer() and SKIP the per-addon restartAddon.
+    const tmpRoot = await import('node:fs/promises').then(fs => fs.mkdtemp('/tmp/camstack-upload-fw-'))
+    const previous = process.env['CAMSTACK_DATA']
+    process.env['CAMSTACK_DATA'] = tmpRoot
+    const fsSync = await import('node:fs')
+    fsSync.mkdirSync(`${tmpRoot}/addons/@camstack/core`, { recursive: true })
+
+    try {
+      const restartServer = vi.fn((_requestedBy?: string) => {})
+      const restartAddon = vi.fn(async (_id: string) => ({ success: true }))
+      const registry = {
+        listAddons: vi.fn(() => [{ manifest: { id: 'sqlite-settings', packageName: '@camstack/core' } }]),
+        loadNewAddons: vi.fn(async () => ({ loaded: [] as string[], failed: [] as string[] })),
+        restartAddon,
+        getCapabilityRegistry: vi.fn(() => ({ getSingleton: vi.fn((_n: string) => null) })),
+      } as unknown as AddonRegistryService
+      const pkgSvc = { restartServer } as unknown as AddonPackageService
+
+      fastify = await makeServer({
+        auth: makeAuth('admin'),
+        bridge: makeAddonBridge({ name: '@camstack/core', version: '9.9.9' }),
+        moleculer: makeMoleculer(vi.fn()),
+        addonRegistry: registry,
+        addonPackageService: pkgSvc,
+      })
+      const res = await fastify.inject({
+        method: 'POST',
+        url: '/api/addons/upload',
+        headers: { 'content-type': `multipart/form-data; boundary=${TGZ_BOUNDARY}`, authorization: 'Bearer t' },
+        payload: buildMultipart(TGZ_BOUNDARY, {
+          file: { filename: 'camstack-core-9.9.9.tgz', content: buildValidTarball({ name: '@camstack/core', version: '9.9.9' }) },
+        }),
+      })
+      expect(res.statusCode).toBe(200)
+      expect(res.json()).toMatchObject({ success: true, requiresRestart: true, restarting: true })
+      expect(restartServer).toHaveBeenCalledOnce()
+      // Critical: the in-process restart that breaks builtins must NOT run.
+      expect(restartAddon).not.toHaveBeenCalled()
+    } finally {
+      if (previous === undefined) delete process.env['CAMSTACK_DATA']
+      else process.env['CAMSTACK_DATA'] = previous
+      fsSync.rmSync(tmpRoot, { recursive: true, force: true })
+    }
+  })
+
   it('routes to $agent.deploy when nodeId is provided', async () => {
     const call = vi.fn(async () => ({ success: true, addonId: 'addon-x', path: '/agent/addons/addon-x' }))
     fastify = await makeServer({

package/src/__tests__/bulk-update-coordinator.spec.ts

@@ -0,0 +1,286 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import {
+  BulkUpdateCoordinator,
+  type BulkUpdateCoordinatorDeps,
+} from '../api/core/bulk-update-coordinator.js'
+import { EventCategory, type BulkUpdateState } from '@camstack/types'
+
+interface TestRig {
+  readonly coordinator: BulkUpdateCoordinator
+  readonly events: BulkUpdateState[]
+  readonly updateAddon: ReturnType<typeof vi.fn>
+  readonly updateFrameworkPackage: ReturnType<typeof vi.fn>
+  readonly restartServer: ReturnType<typeof vi.fn>
+  readonly now: () => number
+}
+
+function makeRig(opts?: { failItems?: ReadonlySet<string> }): TestRig {
+  const events: BulkUpdateState[] = []
+  const fail = opts?.failItems ?? new Set<string>()
+  let clock = 1_000_000
+
+  const updateAddon = vi.fn(async (input: { name: string; version: string }) => {
+    if (fail.has(input.name)) throw new Error(`mock fail ${input.name}`)
+  })
+  const updateFrameworkPackage = vi.fn(async (input: { packageName: string; version: string; deferRestart: boolean }) => {
+    if (fail.has(input.packageName)) throw new Error(`mock fail fw ${input.packageName}`)
+  })
+  const restartServer = vi.fn(async () => {
+    // simulates the real restartServer: in a real run the process dies
+  })
+
+  const deps: BulkUpdateCoordinatorDeps = {
+    eventBus: {
+      emit: (category, payload) => {
+        if (category === EventCategory.AddonsBulkUpdateProgress) {
+          events.push(structuredClone(payload as BulkUpdateState))
+        }
+      },
+    } as unknown as BulkUpdateCoordinatorDeps['eventBus'],
+    updateAddon,
+    updateFrameworkPackage,
+    restartServer,
+    logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() } as unknown as BulkUpdateCoordinatorDeps['logger'],
+    clock: () => clock++,
+  }
+
+  return {
+    coordinator: new BulkUpdateCoordinator(deps),
+    events,
+    updateAddon,
+    updateFrameworkPackage,
+    restartServer,
+    now: () => clock,
+  }
+}
+
+describe('BulkUpdateCoordinator', () => {
+  beforeEach(() => { vi.useFakeTimers() })
+  afterEach(() => { vi.useRealTimers() })
+
+  it('regular-only happy path: processes 3 addons in order, no restart', async () => {
+    const rig = makeRig()
+    const { id } = rig.coordinator.start({
+      nodeId: 'hub',
+      items: [
+        { name: '@camstack/addon-a', version: '1.0.1', isSystem: false },
+        { name: '@camstack/addon-b', version: '2.0.1', isSystem: false },
+        { name: '@camstack/addon-c', version: '3.0.1', isSystem: false },
+      ],
+    })
+
+    await vi.runAllTimersAsync()
+
+    const final = rig.coordinator.get(id)!
+    expect(final.completed).toBe(3)
+    expect(final.failed).toBe(0)
+    expect(final.phase).toBe('finalizing')
+    expect(final.items.every(i => i.status === 'done')).toBe(true)
+    expect(rig.restartServer).not.toHaveBeenCalled()
+    expect(rig.updateAddon).toHaveBeenCalledTimes(3)
+  })
+
+  it('mixed happy path: regular first, system after, single restart at end', async () => {
+    const rig = makeRig()
+    const { id } = rig.coordinator.start({
+      nodeId: 'hub',
+      items: [
+        { name: '@camstack/addon-a', version: '1.0.1', isSystem: false },
+        { name: '@camstack/types', version: '0.1.40', isSystem: true },
+        { name: '@camstack/addon-b', version: '2.0.1', isSystem: false },
+        { name: '@camstack/kernel', version: '0.1.30', isSystem: true },
+      ],
+    })
+
+    await vi.runAllTimersAsync()
+
+    const final = rig.coordinator.get(id)!
+    expect(final.completed).toBe(4)
+    expect(rig.updateAddon).toHaveBeenCalledTimes(2)
+    expect(rig.updateFrameworkPackage).toHaveBeenCalledTimes(2)
+    expect(rig.updateFrameworkPackage).toHaveBeenCalledWith(expect.objectContaining({ deferRestart: true }))
+    expect(rig.restartServer).toHaveBeenCalledOnce()
+
+    // Verify ordering via event sequence: regular items reach 'updating' before any system item
+    const updatingNames = rig.events
+      .map(s => s.current)
+      .filter((n): n is string => n !== null)
+    const firstSystemIdx = updatingNames.findIndex(n => n === '@camstack/types' || n === '@camstack/kernel')
+    const lastRegularIdx = updatingNames.findLastIndex(n => n === '@camstack/addon-a' || n === '@camstack/addon-b')
+    expect(firstSystemIdx).toBeGreaterThan(lastRegularIdx)
+  })
+
+  it('failure isolation: failed item does not block others', async () => {
+    const rig = makeRig({ failItems: new Set(['@camstack/addon-b']) })
+    const { id } = rig.coordinator.start({
+      nodeId: 'hub',
+      items: [
+        { name: '@camstack/addon-a', version: '1.0.1', isSystem: false },
+        { name: '@camstack/addon-b', version: '2.0.1', isSystem: false },
+        { name: '@camstack/addon-c', version: '3.0.1', isSystem: false },
+      ],
+    })
+
+    await vi.runAllTimersAsync()
+
+    const final = rig.coordinator.get(id)!
+    expect(final.failed).toBe(1)
+    expect(final.items.find(i => i.name === '@camstack/addon-b')?.status).toBe('failed')
+    expect(final.items.find(i => i.name === '@camstack/addon-b')?.error).toContain('mock fail')
+    expect(final.items.find(i => i.name === '@camstack/addon-a')?.status).toBe('done')
+    expect(final.items.find(i => i.name === '@camstack/addon-c')?.status).toBe('done')
+  })
+
+  it('cancel pre-restart: loop exits, no restart, queued items remain queued', async () => {
+    const rig = makeRig()
+    rig.updateAddon.mockImplementation(async () => {
+      // Slow enough that cancel fires before item 2
+      await new Promise<void>(resolve => { setTimeout(resolve, 50) })
+    })
+
+    const { id } = rig.coordinator.start({
+      nodeId: 'hub',
+      items: [
+        { name: '@camstack/addon-a', version: '1.0.1', isSystem: false },
+        { name: '@camstack/addon-b', version: '2.0.1', isSystem: false },
+        { name: '@camstack/addon-c', version: '3.0.1', isSystem: false },
+      ],
+    })
+
+    // Advance time so item 1 starts updating
+    await vi.advanceTimersByTimeAsync(10)
+    const cancel = rig.coordinator.cancel(id)
+    expect(cancel.cancelled).toBe(true)
+    await vi.runAllTimersAsync()
+
+    const final = rig.coordinator.get(id)!
+    expect(final.cancelled).toBe(true)
+    expect(rig.restartServer).not.toHaveBeenCalled()
+    // At least one item should still be queued (we cancelled before item 2 ran)
+    expect(final.items.filter(i => i.status === 'queued').length).toBeGreaterThanOrEqual(1)
+  })
+
+  it('cancel ignored during restarting phase', async () => {
+    const rig = makeRig()
+    rig.restartServer.mockImplementation(async () => {
+      // Hang briefly so we can attempt cancel during restart
+      await new Promise<void>(resolve => { setTimeout(resolve, 50) })
+    })
+
+    const { id } = rig.coordinator.start({
+      nodeId: 'hub',
+      items: [
+        { name: '@camstack/types', version: '0.1.40', isSystem: true },
+      ],
+    })
+
+    // Let it reach restarting
+    await vi.advanceTimersByTimeAsync(10)
+    const state = rig.coordinator.get(id)
+    if (state?.phase === 'restarting') {
+      const cancel = rig.coordinator.cancel(id)
+      expect(cancel.cancelled).toBe(false)
+    }
+
+    await vi.runAllTimersAsync()
+  })
+
+  it('restart failure: pending-restart items get promoted to done with caveat error', async () => {
+    const rig = makeRig()
+    rig.restartServer.mockRejectedValueOnce(new Error('restart crashed'))
+
+    const { id } = rig.coordinator.start({
+      nodeId: 'hub',
+      items: [
+        { name: '@camstack/types', version: '0.1.40', isSystem: true },
+      ],
+    })
+
+    await vi.runAllTimersAsync()
+
+    const final = rig.coordinator.get(id)!
+    const typesItem = final.items.find(i => i.name === '@camstack/types')!
+    expect(typesItem.status).toBe('done')
+    expect(typesItem.error).toContain('Restart failed')
+  })
+
+  it('concurrent start for same nodeId is rejected', () => {
+    const rig = makeRig()
+    rig.coordinator.start({
+      nodeId: 'hub',
+      items: [{ name: '@camstack/addon-a', version: '1.0.1', isSystem: false }],
+    })
+
+    expect(() => rig.coordinator.start({
+      nodeId: 'hub',
+      items: [{ name: '@camstack/addon-b', version: '2.0.1', isSystem: false }],
+    })).toThrow(/already in progress/i)
+  })
+
+  it('auto-cleanup: state purged 5 min after completedAt', async () => {
+    const rig = makeRig()
+    const { id } = rig.coordinator.start({
+      nodeId: 'hub',
+      items: [{ name: '@camstack/addon-a', version: '1.0.1', isSystem: false }],
+    })
+
+    await vi.runAllTimersAsync()
+    expect(rig.coordinator.get(id)).not.toBeNull()
+
+    await vi.advanceTimersByTimeAsync(5 * 60 * 1000 + 100)
+    expect(rig.coordinator.get(id)).toBeNull()
+  })
+
+  it('list excludes stale states after cleanup window (lazy cleanup symmetry)', async () => {
+    const rig = makeRig()
+    const { id } = rig.coordinator.start({
+      nodeId: 'hub',
+      items: [{ name: '@camstack/addon-a', version: '1.0.1', isSystem: false }],
+    })
+
+    await vi.runAllTimersAsync()
+
+    // Right after completion: both get() and list() see the state
+    expect(rig.coordinator.get(id)).not.toBeNull()
+    expect(rig.coordinator.list()).toHaveLength(1)
+
+    // After cleanup window: both should agree that the state is gone
+    await vi.advanceTimersByTimeAsync(5 * 60 * 1000 + 100)
+    expect(rig.coordinator.get(id)).toBeNull()
+    expect(rig.coordinator.list()).toHaveLength(0)
+    expect(rig.coordinator.list('hub')).toHaveLength(0)
+  })
+
+  it('list filters by nodeId', () => {
+    const rig = makeRig()
+    rig.coordinator.start({
+      nodeId: 'hub',
+      items: [{ name: '@camstack/addon-a', version: '1.0.1', isSystem: false }],
+    })
+    expect(rig.coordinator.list('hub')).toHaveLength(1)
+    expect(rig.coordinator.list('agent-1')).toHaveLength(0)
+    expect(rig.coordinator.list()).toHaveLength(1)
+  })
+
+  it('emits AddonsBulkUpdateProgress event on every status transition', async () => {
+    const rig = makeRig()
+    rig.coordinator.start({
+      nodeId: 'hub',
+      items: [
+        { name: '@camstack/addon-a', version: '1.0.1', isSystem: false },
+        { name: '@camstack/addon-b', version: '2.0.1', isSystem: false },
+      ],
+    })
+
+    await vi.runAllTimersAsync()
+
+    // At minimum: phase transition + 2 items × 2 transitions (updating → done)
+    expect(rig.events.length).toBeGreaterThanOrEqual(5)
+    // Every payload must be a complete BulkUpdateState (not a partial diff)
+    for (const evt of rig.events) {
+      expect(evt.id).toBeDefined()
+      expect(evt.nodeId).toBe('hub')
+      expect(Array.isArray(evt.items)).toBe(true)
+    }
+  })
+})