@vzn/vx-history 0.0.649 → 0.0.651

package/README.md

@@ -19,7 +19,7 @@ import { vxHistory } from '@vzn/vx-history'
 export default { plugins: [vxHistory()] }
 ```
 
-`vxHistory({ window?, assume?, file?, url?, issuer?, repository?, headers?, resources?, memory?, reservations? })` learns from the last `window` invocations (default 20) through core's `LocalHistoryProvider` over the cache's own SQLite handle. With one worker and two chains of identical shape, the chain history says is slow starts first; with no history yet, the scheduler's structural order stands.
+`vxHistory({ window?, assume?, file?, url?, issuer?, repository?, headers?, resources?, memory?, reservations? })` learns from the last `window` invocations (default 20) through core's `localHistory(cache)`, which reads the cache's index and returns rows; the plugin never touches cache.db. With one worker and two chains of identical shape, the chain history says is slow starts first; with no history yet, the scheduler's structural order stands.
 
 `assume` is for the run that has no history: a fresh CI runner. It names durations (task id → ms) for tasks the history has not seen, so a long leaf task — a docs build, a cross-compile — starts first instead of last:
 
@@ -47,6 +47,8 @@ for its tasks' numbers, by task definition, in the refs the run reads,
 as a remote cache does: its branch's, the branch it merges into, then
 the default branch's (`baseBranch`, else git's or the CI's). A run
 that reads no ref (a detached HEAD with no default branch) asks nothing.
+A ref over the 512 characters a server takes is said and not read;
+the run reads the others.
 The run starts on its local history and re-ranks the tasks not yet
 started when they land; it never waits for them. At its end it sends the
 timings of the tasks it ran, once: under DTE that is the orchestrator,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx-history",
-  "version": "0.0.649",
+  "version": "0.0.651",
   "license": "MIT",
   "description": "History-based scheduling for vx — a `schedule` plugin that orders ready tasks by their expected remaining critical path, learned from the local run history.",
   "keywords": [
@@ -37,7 +37,7 @@
     "access": "public"
   },
   "peerDependencies": {
-    "@vzn/vx": "^0.0.649"
+    "@vzn/vx": "^0.0.651"
   },
   "repository": {
     "type": "git",

package/src/history-server.ts

@@ -181,7 +181,8 @@ export class HistoryServer {
       u.searchParams.set('audience', new URL(this.url).origin)
       const res = await this.askGithub(u, signal)
       if (!res.ok) throw new Error(`GitHub's OIDC endpoint: ${(await refusal(res)).message}`)
-      const jwt = ((await res.json()) as { value?: unknown }).value
+      // quiet: a body that is not JSON holds no token, said below
+      const jwt = ((await res.json().catch(() => null)) as { value?: unknown } | null)?.value
       if (typeof jwt !== 'string' || jwt === '') throw new Error("GitHub's OIDC endpoint: no token")
       return { jwt, exp: expiryOf(jwt) }
     })()

package/src/index.ts

@@ -14,7 +14,8 @@
 import {
   currentBranch,
   definePlugin,
-  LocalHistoryProvider,
+  type LocalHistory,
+  localHistory,
   machineMemoryBytes,
   Cache,
   type HistoryTable,
@@ -108,6 +109,9 @@ export interface VxHistoryOptions {
 // hint needs less and reads a 2.5× smaller slice of the run history.
 const DEFAULT_WINDOW = 20
 
+/** The longest ref a history server takes in a query (its PROTOCOL.md). */
+const REF_MAX = 512
+
 // Each option is read in ONE place that a run's hooks and `vx history`
 // share: two copies of each let either drift unseen (item 805).
 const windowOf = (options: VxHistoryOptions): number =>
@@ -193,7 +197,7 @@ const readHistory = (
   branch: string | null,
   defs: ReadonlyMap<string, string>,
 ): Promise<ReadonlyMap<string, TaskResources>> =>
-  new LocalHistoryProvider(cache.dbHandle(), windowOf(options), branch, defs).resourcesFor(ids)
+  localHistory(cache, { recent: windowOf(options), branch, defs }).resourcesFor(ids)
 
 /** What each task reserves: learned from the history unless `resources: false`, a declared reservation over either. */
 const reservationsFor = (
@@ -276,6 +280,11 @@ function namedOf(issuer: unknown, repository: unknown): Named {
   return { issuer: issuer.replace(/\/$/, ''), repository: repository.toLowerCase() }
 }
 
+/** `url` as a refusal may print it: a `user:pass@` would reach the CI log. */
+function shown(url: string): string {
+  return url.replace(/^([a-z][a-z0-9+.-]*:\/\/)[^/?#]*@/i, '$1***@')
+}
+
 /**
  * https, or http to this machine: every request carries the CI token, and
  * http:// to another host sent it in clear.
@@ -298,12 +307,12 @@ function serverUrlOf(
   const from = option === undefined ? 'VX_HISTORY_URL' : 'url'
   if (!secure(url))
     throw new UserError(
-      `vxHistory(): ${from} must be https (http only to 127.0.0.1, ::1 or localhost), got ${url}`,
+      `vxHistory(): ${from} must be https (http only to 127.0.0.1, ::1 or localhost), got ${shown(url)}`,
     )
   // Each route is the server's /v1/…: one that names /v1 asked /v1/v1/…, and every answer was a 404.
   if (url.endsWith('/v1'))
     throw new UserError(
-      `vxHistory(): ${from} is the server's base, without /v1: ${url.slice(0, -3)}`,
+      `vxHistory(): ${from} is the server's base, without /v1: ${shown(url.slice(0, -3))}`,
     )
   return url
 }
@@ -411,14 +420,13 @@ export function vxHistory(options: VxHistoryOptions = {}): VxPlugin {
       const ids: string[] = []
       for (const n of nodes.values()) if (n.config.exec?.command !== undefined) ids.push(n.id)
       let table: ReadonlyMap<string, TaskResources>
-      let provider: LocalHistoryProvider
+      let provider: LocalHistory
       try {
-        provider = new LocalHistoryProvider(
-          ctx.localCache.dbHandle(),
-          windowOf(options),
-          ctx.branch,
+        provider = localHistory(ctx.localCache, {
+          recent: windowOf(options),
+          branch: ctx.branch,
           defs,
-        )
+        })
         table = await provider.resourcesFor(ids)
       } catch (err) {
         // Failing open: a broken history read costs the ordering and the
@@ -440,14 +448,22 @@ export function vxHistory(options: VxHistoryOptions = {}): VxPlugin {
       // branch it merges into, the default branch (`baseBranch`). `main`
       // was assumed, so a `master` or `baseBranch: 'trunk'` repository
       // read no trunk's numbers; a run with none asks nothing.
-      const refs = ctx.refs
+      // A ref the server cannot name was a 400 for the whole query, and
+      // the run read no ref's numbers, its base branch's too.
+      const refs = [...new Set(ctx.refs)].filter((ref) => {
+        if (ref.length <= REF_MAX) return true
+        ctx.warn(
+          `[vx] vx-history: ${ref} is ${ref.length} characters, over the ${REF_MAX} a history server takes: the run does not read it`,
+        )
+        return false
+      })
       if (remote !== undefined && refs.length > 0) {
         const server = remote
         let late = false
         stopImport = () => (late = true)
         const weights = (async () => {
           const hashes = [...new Set(ids.flatMap((id) => defs.get(id) ?? []))]
-          const got = await server.query([...new Set(refs)], hashes)
+          const got = await server.query(refs, hashes)
           const timings = new Map<string, number>()
           const needs = new Map<string, TaskResources>()
           for (const id of ids) {
@@ -800,7 +816,7 @@ async function historyCmd(
     // A plugin verb owns its help; completions offer `--help` for every verb.
     if (a === '--help' || a === '-h') {
       ui.say('info', 'Usage: vx history [--format pretty|json]', 'out')
-      process.stdout.write('\n')
+      ui.print('out', ui.gap())
       ui.say(
         'info',
         'What vx-history learned per task (p50, peak RSS, CPU parallelism) and the reservation it packs.',
@@ -849,13 +865,12 @@ async function historyCmd(
     // Each task's rows of its definition as it is now, as `schedule` reads
     // them: read with every definition's, a task whose command changed
     // showed the old command's peak and a reservation no run packs.
-    table = await new LocalHistoryProvider(
-      cache.dbHandle(),
-      window,
-      currentBranch(ctx.workspaceRoot),
+    table = await localHistory(cache, {
+      recent: window,
+      branch: currentBranch(ctx.workspaceRoot),
       // As a run reads them: a task whose command changed has no rows yet.
-      taskDefinitions(tasks as TaskNode[]),
-    ).loadFor(ids)
+      defs: taskDefinitions(tasks as TaskNode[]),
+    }).loadFor(ids)
   } finally {
     cache.close()
   }
@@ -877,7 +892,7 @@ async function historyCmd(
     }
   })
   if (format === 'json') {
-    process.stdout.write(`${JSON.stringify({ window, budgets, tasks: rows })}\n`)
+    ui.data('out', `${JSON.stringify({ window, budgets, tasks: rows })}\n`)
     return 0
   }
   // The table's module loads with the verb, off every run's path.