zooid 0.12.0 → 0.14.0

package/src/version.test.ts

@@ -0,0 +1,67 @@
+import { describe, it, expect } from 'vitest'
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { readFileSync } from 'node:fs'
+import { CLI_VERSION, readCliVersion } from './version.js'
+
+const manifestVersion = (
+  JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')) as {
+    version: string
+  }
+).version
+
+describe('readCliVersion', () => {
+  it('reports the version from the package manifest', () => {
+    expect(readCliVersion()).toBe(manifestVersion)
+  })
+
+  // The regression this exists for: `cli.version()` was a hardcoded '0.0.1'
+  // from the first release through 0.12.0, so every published build claimed
+  // to be a version that was never released.
+  it('is not a hardcoded placeholder', () => {
+    expect(CLI_VERSION).toBe(manifestVersion)
+    expect(CLI_VERSION).not.toBe('0.0.1')
+    expect(CLI_VERSION).toMatch(/^\d+\.\d+\.\d+/)
+  })
+
+  // dist/bin.js and src/bin.ts are the same depth from package.json, so the
+  // single '../package.json' has to work from either. Simulate the built
+  // bundle's location rather than trusting that they stay in step.
+  it('resolves from a sibling directory the way dist/ does', () => {
+    const root = mkdtempSync(join(tmpdir(), 'zooid-version-'))
+    try {
+      writeFileSync(join(root, 'package.json'), JSON.stringify({ version: '9.9.9' }))
+      const fromDist = pathToFileURL(join(root, 'dist', 'bin.js')).href
+      expect(readCliVersion(fromDist)).toBe('9.9.9')
+      const fromSrc = pathToFileURL(join(root, 'src', 'bin.ts')).href
+      expect(readCliVersion(fromSrc)).toBe('9.9.9')
+    } finally {
+      rmSync(root, { recursive: true, force: true })
+    }
+  })
+
+  it('falls back to "unknown" rather than throwing when the manifest is missing', () => {
+    const root = mkdtempSync(join(tmpdir(), 'zooid-version-'))
+    try {
+      const url = pathToFileURL(join(root, 'dist', 'bin.js')).href
+      expect(readCliVersion(url)).toBe('unknown')
+    } finally {
+      rmSync(root, { recursive: true, force: true })
+    }
+  })
+
+  it('falls back to "unknown" on a manifest with no usable version', () => {
+    const root = mkdtempSync(join(tmpdir(), 'zooid-version-'))
+    try {
+      writeFileSync(join(root, 'package.json'), JSON.stringify({ name: 'zooid' }))
+      const url = pathToFileURL(join(root, 'dist', 'bin.js')).href
+      expect(readCliVersion(url)).toBe('unknown')
+      writeFileSync(join(root, 'package.json'), '{not json')
+      expect(readCliVersion(url)).toBe('unknown')
+    } finally {
+      rmSync(root, { recursive: true, force: true })
+    }
+  })
+})

package/src/version.ts

@@ -0,0 +1,30 @@
+import { readFileSync } from 'node:fs'
+
+/**
+ * The CLI's own version, read from the package manifest at startup.
+ *
+ * Never hardcode this. A literal goes stale on the very next release, and
+ * `zooid --version` then lies about which build is installed — which is
+ * exactly what it did from the first release through 0.12.0, where it
+ * reported `0.0.1` forever.
+ *
+ * `dist/bin.js` (the published bundle) and `src/bin.ts` (a source run under
+ * tsx) sit at the same depth relative to package.json, so a single
+ * `../package.json` works for both without a build-time define.
+ *
+ * `url` is overridable for tests.
+ */
+export function readCliVersion(url: string = import.meta.url): string {
+  try {
+    const manifest = new URL('../package.json', url)
+    const raw = JSON.parse(readFileSync(manifest, 'utf8')) as { version?: unknown }
+    if (typeof raw.version === 'string' && raw.version) return raw.version
+    return 'unknown'
+  } catch {
+    // A missing or malformed manifest must never stop the CLI from running —
+    // `--version` is the least important thing it does.
+    return 'unknown'
+  }
+}
+
+export const CLI_VERSION = readCliVersion()

package/src/web/static.test.ts

@@ -48,4 +48,26 @@ describe('webStatic', () => {
     const r = await app.request('/assets/nope.js')
     expect(r.status).toBe(404)
   })
+
+  it('serves push_gateway_url and vapid_public_key when configured', async () => {
+    const app = webStatic({
+      webRoot: dir,
+      homeserverUrl: 'http://localhost:8448',
+      pushGatewayUrl: 'http://host.docker.internal:9000/_matrix/push/v1/notify',
+      vapidPublicKey: 'BPk',
+    })
+    const res = await app.request('/config.json')
+    expect(await res.json()).toEqual({
+      homeserver_url: 'http://localhost:8448',
+      push_gateway_url: 'http://host.docker.internal:9000/_matrix/push/v1/notify',
+      vapid_public_key: 'BPk',
+    })
+  })
+
+  it('omits both when unconfigured, so the client falls back instead of half-subscribing', async () => {
+    const app = webStatic({ webRoot: dir, homeserverUrl: 'http://localhost:8448' })
+    expect(await (await app.request('/config.json')).json()).toEqual({
+      homeserver_url: 'http://localhost:8448',
+    })
+  })
 })

package/src/web/static.ts

@@ -5,6 +5,8 @@ import { Hono } from 'hono'
 export interface WebStaticOpts {
   webRoot: string
   homeserverUrl: string
+  pushGatewayUrl?: string
+  vapidPublicKey?: string
 }
 
 const MIME: Record<string, string> = {
@@ -28,7 +30,13 @@ function isAssetPath(p: string): boolean {
 export function webStatic(opts: WebStaticOpts): Hono {
   const app = new Hono()
 
-  app.get('/config.json', (c) => c.json({ homeserver_url: opts.homeserverUrl }))
+  app.get('/config.json', (c) =>
+    c.json({
+      homeserver_url: opts.homeserverUrl,
+      ...(opts.pushGatewayUrl ? { push_gateway_url: opts.pushGatewayUrl } : {}),
+      ...(opts.vapidPublicKey ? { vapid_public_key: opts.vapidPublicKey } : {}),
+    }),
+  )
 
   app.get('*', (c) => {
     const url = new URL(c.req.url)