@frontera-sdk/cli 1.52.38 → 1.52.40

package/src/local/local-test-runs.ts

@@ -1,11 +1,13 @@
 import type { LocalProject } from './local-project'
 import { readState } from './local-state'
-import { findCaseFiles, runCases, type CaseResult } from './local-test-runner'
+import { recordRun } from './local-test-baseline'
+import { caseCount, runCases, selectCaseFiles, type CaseFile, type CaseResult } from './local-test-runner'
 
 /**
  * Test runs started from Studio: the same runner as `frontera local test`,
  * run in the supervisor so the page can follow progress. Kept in memory,
- * newest first; the case files in the solution are the record that matters.
+ * newest first; each case's outcome is also kept as its last run, as
+ * `frontera local test` keeps it.
  */
 
 export interface TestRun {
@@ -35,13 +37,13 @@ export function createTestRuns(project: LocalProject, serviceUrl: string) {
       if (runs.some((r) => r.status === 'running')) return { error: 'a test run is already running', status: 409 }
       const creds = readState(project)?.credentials
       if (!creds?.session) return { error: 'the runtime is not seeded yet', status: 409 }
-      let files: ReturnType<typeof findCaseFiles>
+      let files: CaseFile[]
       try {
-        files = findCaseFiles(project.root, args.agent)
+        files = selectCaseFiles(project.root, { agent: args.agent })
       } catch (err) {
         return { error: `a case file could not be read: ${(err as Error).message}`, status: 422 }
       }
-      const total = files.reduce((n, f) => n + f.cases.length, 0)
+      const total = caseCount(files)
       if (total === 0) return { error: 'no test cases to run', status: 400 }
 
       const run: TestRun = {
@@ -61,6 +63,12 @@ export function createTestRuns(project: LocalProject, serviceUrl: string) {
       void runCases({ serviceUrl, creds, files, live: run.live, onResult: (r) => run.results.push(r) })
         .then((results) => {
           run.status = results.every((r) => r.passed) ? 'passed' : 'failed'
+          // Each case's last run, as `frontera local test` keeps it: Forge's home marks the evaluations from it.
+          try {
+            recordRun(project, results)
+          } catch (err) {
+            console.error(`[local-test-runs] could not keep the results: ${(err as Error).message}`)
+          }
         })
         .catch((err: Error) => {
           run.status = 'error'

package/src/local/local-vendored-sdk.ts

@@ -0,0 +1,183 @@
+import { createHash } from 'node:crypto'
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+
+import { AUTOMATION_SDK_FILES } from '../automation-template'
+import vendored from '../vendor/sdk-sources.json'
+import { compareVersions } from './local-app-sdk'
+import { readSnapshot } from './local-sync-snapshot'
+
+/**
+ * The Functions SDK a project keeps in `vendor/frontera/` (what its Function
+ * tests and typecheck resolve `@frontera-sdk/functions` to), against this
+ * CLI's copy.
+ *
+ * The CLI writes those files (`local init`, a pull), so they are the CLI's to
+ * keep current — but a person may have edited one, and an edit is never
+ * overwritten unasked. So the CLI records what it wrote: the manifest
+ * `vendor/frontera/.frontera-sdk.json` holds each file's hash as written.
+ * A file still at that hash is the CLI's copy, unmodified, and `local dev`
+ * replaces it with this CLI's when they differ. A file that differs from the
+ * hash was edited and is kept; `frontera local sdk-refresh --force` replaces
+ * it. A project from a CLI that wrote no manifest cannot tell the two apart,
+ * so it is only told; `frontera local sdk-refresh` replaces the files that
+ * differ and keeps a copy of each one it replaces.
+ *
+ * Which way a difference points is said only when something records it: the
+ * manifest's version (a newer CLI wrote the copy), or, with no manifest, the
+ * platform release the project was pulled from (`.frontera/sync/remote.json`
+ * `platformVersion`) when it is newer than this CLI: its Functions were
+ * written against a newer SDK, so this CLI's copy would be a step back.
+ * Neither replaces a newer copy without `--force`; the advice is to update
+ * the CLI. With nothing to go by, the copy only "differs".
+ */
+
+export const SDK_MANIFEST = 'vendor/frontera/.frontera-sdk.json'
+
+interface SdkManifest {
+  version: string
+  files: Record<string, string>
+}
+
+const sha = (text: string) => createHash('sha256').update(text).digest('hex')
+
+function cliFiles(): Record<string, string> {
+  const files = vendored.files as Record<string, string>
+  return Object.fromEntries(AUTOMATION_SDK_FILES.flatMap((rel) => (files[rel] === undefined ? [] : [[`vendor/${rel}`, files[rel]!]])))
+}
+
+function readManifest(root: string): SdkManifest | null {
+  try {
+    const doc = JSON.parse(readFileSync(join(root, SDK_MANIFEST), 'utf8')) as Partial<SdkManifest>
+    return typeof doc.version === 'string' && doc.files && typeof doc.files === 'object' ? (doc as SdkManifest) : null
+  } catch {
+    return null
+  }
+}
+
+/** The manifest for the files as this CLI writes them: what `writeSolutionScaffold` and a refresh leave beside them. */
+export function sdkManifestText(files: Record<string, string> = cliFiles()): string {
+  return `${JSON.stringify({ version: vendored.sdkVersion, files: Object.fromEntries(Object.entries(files).map(([rel, text]) => [rel, sha(text)])) }, null, 2)}\n`
+}
+
+export interface VendoredSdkState {
+  /** The project keeps the SDK in vendor/frontera/. */
+  vendored: boolean
+  /** The SDK version the manifest says, or null without one. */
+  version: string | null
+  /** Files that differ from this CLI's copy and are the CLI's unmodified copy: safe to replace. */
+  outdated: string[]
+  /** Files that differ from this CLI's copy and were edited since the CLI wrote them (or, with no manifest, can't be told). */
+  edited: string[]
+  /** Files this CLI vendors that the project lacks. */
+  missing: string[]
+  /** No manifest: nothing records which SDK wrote the folder (a CLI from before manifests, or a hand-made copy). */
+  unknown: boolean
+  /**
+   * The copy is known or likely to be newer than this CLI's, so replacing it would go back:
+   * `manifest`, a newer CLI wrote it; `pull`, no manifest, and the project was pulled from a
+   * newer platform release. Null when nothing says so.
+   */
+  newer: { by: 'manifest' | 'pull'; version: string } | null
+}
+
+/** This CLI's SDK version (`1.52.28`). */
+export const CLI_SDK = vendored.sdkVersion
+
+/** The platform release the project was last pulled from, when a pull recorded it. */
+function pulledFromVersion(root: string): string | null {
+  const v = readSnapshot(root)?.platformVersion
+  return typeof v === 'string' && /^\d+\.\d+/.test(v) ? v : null
+}
+
+/** How the project's vendored SDK compares with this CLI's. */
+export function vendoredSdkState(root: string): VendoredSdkState {
+  const mine = cliFiles()
+  const vendoredHere = existsSync(join(root, 'vendor', 'frontera'))
+  const manifest = readManifest(root)
+  const state: VendoredSdkState = { vendored: vendoredHere, version: manifest?.version ?? null, outdated: [], edited: [], missing: [], unknown: vendoredHere && !manifest, newer: null }
+  if (!vendoredHere) return state
+  for (const [rel, text] of Object.entries(mine)) {
+    const path = join(root, rel)
+    if (!existsSync(path)) {
+      state.missing.push(rel)
+      continue
+    }
+    const here = readFileSync(path, 'utf8')
+    if (here === text) continue
+    const written = manifest?.files[rel]
+    if (written && sha(here) === written) state.outdated.push(rel)
+    else state.edited.push(rel)
+  }
+  if (state.outdated.length || state.edited.length) {
+    if (manifest && compareVersions(manifest.version, CLI_SDK) > 0) state.newer = { by: 'manifest', version: manifest.version }
+    else if (!manifest) {
+      const pulled = pulledFromVersion(root)
+      if (pulled && compareVersions(pulled, CLI_SDK) > 0) state.newer = { by: 'pull', version: pulled }
+    }
+  }
+  return state
+}
+
+/**
+ * Bring the vendored SDK to this CLI's copy: the files the CLI wrote and
+ * nobody changed, and the missing ones; with `force`, the edited ones too.
+ * Without a manifest every differing file counts as replaceable (nothing
+ * tells an edit apart) and a copy of each is kept under
+ * `.frontera/local/sdk-backup/`. Writes the manifest. Returns what changed.
+ */
+export function refreshVendoredSdk(root: string, opts: { force?: boolean; backupAll?: boolean; now?: Date } = {}): { replaced: string[]; added: string[]; kept: string[]; backup: string | null } {
+  const state = vendoredSdkState(root)
+  const mine = cliFiles()
+  const replaceEdited = opts.force === true || (state.unknown && opts.backupAll === true)
+  const replace = [...state.outdated, ...(replaceEdited ? state.edited : [])]
+  const kept = replaceEdited ? [] : state.edited
+  let backup: string | null = null
+  const toBackUp = replaceEdited ? state.edited : []
+  if (toBackUp.length) {
+    backup = join('.frontera', 'local', 'sdk-backup', (opts.now ?? new Date()).toISOString().replace(/[:.]/g, '-'))
+    for (const rel of toBackUp) {
+      const to = join(root, backup, rel)
+      mkdirSync(dirname(to), { recursive: true })
+      writeFileSync(to, readFileSync(join(root, rel)))
+    }
+  }
+  for (const rel of [...replace, ...state.missing]) {
+    mkdirSync(dirname(join(root, rel)), { recursive: true })
+    writeFileSync(join(root, rel), mine[rel]!)
+  }
+  // The manifest records what the CLI wrote; a kept edit keeps the hash it was written at, so it stays "edited".
+  const previous = readManifest(root)?.files ?? {}
+  const recorded = Object.fromEntries(Object.entries(mine).map(([rel, text]) => [rel, kept.includes(rel) && previous[rel] ? previous[rel]! : sha(text)]))
+  mkdirSync(dirname(join(root, SDK_MANIFEST)), { recursive: true })
+  writeFileSync(join(root, SDK_MANIFEST), `${JSON.stringify({ version: vendored.sdkVersion, files: recorded }, null, 2)}\n`)
+  return { replaced: replace, added: state.missing, kept, backup }
+}
+
+/**
+ * What `local dev` and `local check` say when the vendored SDK is not this
+ * CLI's, with the command that refreshes it; null when it is.
+ */
+export function vendoredSdkLine(state: VendoredSdkState): string | null {
+  if (!state.vendored) return null
+  const names = (list: string[]) => `${list.slice(0, 3).map((f) => f.replace(/^vendor\//, '')).join(', ')}${list.length > 3 ? ', …' : ''}`
+  const differs = (list: string[]) => `vendor/frontera/ (the Functions SDK the project's tests and typecheck use) differs from this CLI's copy (${CLI_SDK}) in ${list.length} file${list.length === 1 ? '' : 's'} (${names(list)})`
+  const changed = [...state.outdated, ...state.edited]
+  if (state.newer?.by === 'manifest') {
+    return `${differs(changed)}: a newer CLI wrote it (SDK ${state.newer.version}), so this CLI's copy would be a step back. It is kept: upgrade the Frontera CLI to ${state.newer.version} or later rather than refreshing (\`frontera local sdk-refresh --force\` replaces it with this CLI's older copy, keeping a copy of each file)`
+  }
+  if (state.unknown && state.newer?.by === 'pull' && state.edited.length) {
+    return `${differs(state.edited)}. Nothing records which SDK wrote it (no vendor/frontera/.frontera-sdk.json), and the project was pulled from platform ${state.newer.version}, newer than this CLI: refreshing would replace what may be a newer copy with an older one. Upgrade the Frontera CLI to ${state.newer.version} or later, then \`frontera local sdk-refresh\` (\`--force\` refreshes with this CLI's copy anyway, keeping a copy of each file under .frontera/local/sdk-backup/)`
+  }
+  if (state.unknown && state.edited.length) {
+    return `${differs(state.edited)}. Nothing records which SDK wrote it (no vendor/frontera/.frontera-sdk.json), so it may be older or newer than this CLI's. If the project's tests or typecheck fail inside vendor/frontera/, \`frontera local sdk-refresh\` replaces those files with this CLI's copy and keeps a copy of each under .frontera/local/sdk-backup/`
+  }
+  if (state.edited.length) {
+    return `vendor/frontera/ has ${state.edited.length} file${state.edited.length === 1 ? '' : 's'} edited since the CLI wrote ${state.edited.length === 1 ? 'it' : 'them'} (${names(state.edited)}), which differ from this CLI's SDK (${vendored.sdkVersion}): kept. \`frontera local sdk-refresh --force\` replaces them and keeps a copy`
+  }
+  if (state.missing.length || state.outdated.length) {
+    const behind = state.version && compareVersions(state.version, CLI_SDK) < 0
+    return `vendor/frontera/ ${behind ? `is behind this CLI's SDK (it was written for ${state.version}; this CLI's is ${CLI_SDK})` : `differs from this CLI's SDK (${CLI_SDK})`}: \`frontera local sdk-refresh\` brings it to this CLI's copy`
+  }
+  return null
+}

package/src/local/local-workflow-state.ts

@@ -107,11 +107,11 @@ async function setEnabled(serviceUrl: string, creds: LocalCredentials, slug: str
 }
 
 /**
- * After a push: promote and switch triggers as in the workspace, for a
+ * After a push (as `version`): promote and switch triggers as in the workspace, for a
  * workflow the lock says is live there. Returns lines for the apply's output;
  * a `warning:` line is an adaptation in the build.
  */
-export async function mirrorWorkflowState(project: LocalProject, slug: string, file: string, serviceUrl: string, creds: LocalCredentials): Promise<string[]> {
+export async function mirrorWorkflowState(project: LocalProject, slug: string, file: string, serviceUrl: string, creds: LocalCredentials, version?: number): Promise<string[]> {
   const state = readLock(project.root)?.items[`workflow/${slug}`]?.state
   if (!state?.live || !creds.workspaceKey) return []
   let doc: unknown = null
@@ -121,7 +121,7 @@ export async function mirrorWorkflowState(project: LocalProject, slug: string, f
     return []
   }
   const lines: string[] = []
-  const promoted = await promoteWorkflow(serviceUrl, creds, slug)
+  const promoted = await promoteWorkflow(serviceUrl, creds, slug, version)
   if (promoted) lines.push(`  promoted workflow ${slug} v${promoted}: it is live in the workspace`)
   const want = localTriggersOn(doc, state.enabled)
   const failed = await setEnabled(serviceUrl, creds, slug, want.on)
@@ -129,3 +129,16 @@ export async function mirrorWorkflowState(project: LocalProject, slug: string, f
   else if (want.why) lines.push(`  warning: ${want.why}`)
   return lines
 }
+
+/**
+ * After a push (as `version`) of a workflow that already has a live version
+ * here (an Agent's binding promoted it, or it is live in the workspace): the
+ * pushed version is promoted too. An Agent, a webhook and a schedule start the
+ * live version, and on this runtime that has to be what the file says, not
+ * the push before it. A workflow that is only drafts stays drafts.
+ */
+export async function keepLiveCurrent(serviceUrl: string, creds: LocalCredentials, slug: string, version: number | undefined): Promise<string[]> {
+  if (!version) return []
+  const promoted = await promoteWorkflow(serviceUrl, creds, slug, version, { onlyIfLive: true })
+  return promoted ? [`  promoted workflow ${slug} v${promoted}: it has a live version here, which Agents, webhooks and schedules start, and that now matches the file`] : []
+}