push-worker.ts

scripts/push-worker.ts

1. #!/usr/bin/env tsx
2. /**
3. * Publish this morning's board to the deployed Worker.
4. *
5. * pnpm push push the current local artifacts
6. * pnpm push --dry-run say what would be pushed, touch nothing
7. *
8. * Why the laptop pushes at all: the only place a model is called is `analysis/brief.py`, which runs here. The
9. * Worker cannot author a briefing, only render one, so the written briefing has
10. * to travel. That is the chosen design: the laptop stays in the daily path, and
11. * nothing about the deployed Worker needs an ANTHROPIC_API_KEY.
12. *
13. * Why it sends the rendered pages and not only the briefings: KV holds pages
14. * the last cron rendered. Writing new briefings into KV does not change them:
15. * the board would show them only after the next cron. So the coherent page `pnpm morning` just built is what gets published,
16. * and the briefings are stored alongside it so the Worker's own later syncs can
17. * include them too.
18. *
19. * Everything here goes through `wrangler`, which uses the OAuth session from
20. * `wrangler login`. No Cloudflare credential is read, stored, or printed by this
21. * script.
22. */
24. import { readFile, stat } from 'node:fs/promises'
25. import { spawn } from 'node:child_process'
26. import { fileURLToPath } from 'node:url'
27. import { mkdtemp, writeFile, rm } from 'node:fs/promises'
28. import { tmpdir } from 'node:os'
29. import { join } from 'node:path'
30. import { checkPush } from '../apps/dashboard/src/push-guard.js'
31. import { readSnapshot } from '../apps/dashboard/src/snapshot-file.js'
32. import { readHistory } from '../apps/dashboard/src/history-file.js'
33. import { readBriefings } from '../apps/dashboard/src/briefings-file.js'
34. import { headline } from '../apps/dashboard/src/collect.js'
35. import { rowFrom } from '../apps/dashboard/src/history.js'
36. import { renderVariants } from '../apps/dashboard/src/variants.js'
37. import { errorMessage } from '@meridian/shared'
39. const ROOT = new URL('../', import.meta.url)
40. const WORKER_DIR = fileURLToPath(new URL('apps/worker/', ROOT))
41. const dryRun = process.argv.includes('--dry-run')
43. /** Must match KEY in apps/worker/src/index.ts. */
44. const KEYS = {
45. payload: 'dashboard:payload',
46. briefings: 'dashboard:briefings',
47. } as const
49. const path = (rel: string) => fileURLToPath(new URL(rel, ROOT))
51. async function readIfPresent(rel: string): Promise<string | null> {
52. try {
53. return await readFile(path(rel), 'utf8')
54. } catch {
55. return null
56. }
57. }
59. async function bytes(rel: string): Promise<number> {
60. try {
61. return (await stat(path(rel))).size
62. } catch {
63. return 0
64. }
65. }
67. /**
68. * Runs wrangler and resolves only on success.
69. *
70. * `stdio: inherit` on purpose: wrangler's own errors are better than anything
71. * this could paraphrase, and a push that half-worked needs to be visible rather
72. * than summarized.
73. */
74. function wrangler(args: string[]): Promise<void> {
75. return new Promise((resolve, reject) => {
76. const child = spawn('npx', ['wrangler', ...args], { cwd: WORKER_DIR, stdio: 'inherit' })
77. child.on('error', reject)
78. child.on('close', (code) =>
79. code === 0 ? resolve() : reject(new Error(`wrangler ${args[0]} ${args[1]} exited ${code}`)),
80. )
81. })
82. }
84. async function main(): Promise<void> {
85. const [payloadRaw, briefingsRaw] = await Promise.all([
86. readIfPresent('briefing-payload.json'),
87. readIfPresent('briefings.json'),
88. ])
90. if (!payloadRaw) {
91. console.error('No briefing-payload.json. Run `pnpm morning` (or `pnpm dashboard`) first.')
92. process.exit(1)
93. }
95. const payload = JSON.parse(payloadRaw) as { mode?: string; generatedAt?: string }
96. const briefings = briefingsRaw
97. ? (JSON.parse(briefingsRaw) as {
98. mode?: string
99. payloadGeneratedAt?: string
100. briefings?: Record<string, string>
101. })
102. : null
104. const verdict = checkPush({
105. payloadMode: payload.mode,
106. payloadGeneratedAt: payload.generatedAt,
107. htmlBytes: await bytes('dashboard.html'),
108. briefingsMode: briefings?.mode ?? null,
109. briefingsPayloadGeneratedAt: briefings?.payloadGeneratedAt ?? null,
110. briefingCount: briefings ? Object.keys(briefings.briefings ?? {}).length : 0,
111. })
113. for (const w of verdict.warnings) console.error(` warning: ${w}`)
114. if (!verdict.ok) {
115. console.error('\nRefusing to push:')
116. for (const r of verdict.refusals) console.error(` - ${r}`)
117. process.exit(1)
118. }
120. const briefingCount = briefings ? Object.keys(briefings.briefings ?? {}).length : 0
121. console.log(`Publishing the ${payload.generatedAt} sync`)
122. console.log(` page dashboard.html`)
123. console.log(` payload briefing-payload.json`)
124. console.log(` briefings ${briefingCount || 'none'}`)
126. if (dryRun) {
127. console.log('\n--dry-run: nothing was pushed.')
128. return
129. }
131. // --preview false is required, not decorative: with a preview namespace for
132. // `wrangler dev --remote`, the binding has two ids and wrangler refuses to
133. // guess which one a write means. Production is the explicit choice.
134. const put = (key: string, file: string) =>
135. wrangler(['kv', 'key', 'put', '--binding=DASHBOARD', '--preview', 'false', key, `--path=${path(file)}`])
137. // The pages go last. Each put is its own request, so a failure part-way leaves
138. // KV mixed. Writing the briefings first means the worst case is a board still
139. // showing yesterday's page: stale, correctly labelled, and consistent.
140. // Writing the page first would leave it referencing data that had not landed.
141. if (briefingsRaw) await put(KEYS.briefings, 'briefings.json')
142. await put(KEYS.payload, 'briefing-payload.json')
144. // One page per viewer, written last. Each contains only what that person may
145. // read, rendered here from the cached sync so the laptop and the Worker's own
146. // cron produce the same variants from the same code. `dashboard.html` stays a
147. // local artifact: it is the company view, useful to open on the laptop, and
148. // deliberately not uploaded: nothing serves it, and an unserved copy of client
149. // data in KV is only somewhere else to leak from.
150. const cached = await readSnapshot()
151. if (!cached.ok) {
152. console.error(`\nCannot render per-viewer pages: ${cached.reason}.`)
153. console.error('Run `pnpm dashboard` to cache the sync, then push again.')
154. console.error('The briefings and payload above were pushed; the pages were not,')
155. console.error('so the board still shows the previous sync rather than a partial one.')
156. process.exit(1)
157. }
158. const snap = cached.snap
159. const h = headline(snap)
160. const history = await readHistory()
161. const day = rowFrom(h, new Date(snap.syncedAt)).day
162. const variants = renderVariants(snap, h, history, day, await readBriefings())
164. const tmp = await mkdtemp(join(tmpdir(), 'meridian-variants-'))
165. try {
166. for (const [key, page] of variants) {
167. // Via a file, not an argv value: a rendered page is ~100KB and would blow
168. // past the command-line length limit as an argument.
169. const file = join(tmp, `${key.replace(/[^\w.-]+/g, '_')}.html`)
170. await writeFile(file, page, 'utf8')
171. await wrangler(['kv', 'key', 'put', '--binding=DASHBOARD', '--preview', 'false', `dashboard:html:${key}`, `--path=${file}`])
172. }
173. } finally {
174. await rm(tmp, { recursive: true, force: true })
175. }
177. console.log(`\nPushed ${variants.size} per-viewer page(s): ${[...variants.keys()].join(', ')}.`)
178. console.log('Check /health, then open the board.')
179. }
181. main().catch((err) => {
182. console.error(`\npush failed: ${errorMessage(err)}`)
183. process.exit(1)
184. })