@homeflare/alchemy 0.19.1 → 0.21.0

package/src/release/fake-deploy.ts

@@ -0,0 +1,87 @@
+/**
+ * Release.Binary and HostDirectory deployed through Alchemy's OWN Plan and Apply
+ * (openbao/fake-stack.ts, in-memory state), over a fake host (linux/fake-linux-host.ts) and a fake
+ * server holding the synthetic vmutils archive at its real URL. `events` is every host change and
+ * request, in order; `serving = false` answers every request 404.
+ *
+ * ⛔ TEST-ONLY, like fake-release.ts: no provider imports it and it is not on the barrel.
+ */
+import { renamedFrom } from 'alchemy/Rename';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as HttpClient from 'effect/unstable/http/HttpClient';
+import * as HttpClientResponse from 'effect/unstable/http/HttpClientResponse';
+import { type HostRunner, hostRunnerLayer } from '../launchd/runner.ts';
+import { HostDirectory, HostDirectoryProvider } from '../linux/directory.ts';
+import { fakeLinuxHost } from '../linux/fake-linux-host.ts';
+import { fakeStack } from '../openbao/fake-stack.ts';
+import type { ReleaseBinaryProps } from './binary-form.ts';
+import { ReleaseBinary, makeReleaseBinaryProvider } from './binary.ts';
+import { catalogBinary } from './catalog.ts';
+import { VMALERT_REQUEST, VMUTILS_URL, bytesOf, syntheticRelease } from './fake-release.ts';
+
+export const ROOT = '/opt/example/bin';
+export const DIR = `${ROOT}/vmutils-1.151.0`;
+export const PATH = `${DIR}/vmalert`;
+export const THEIRS = bytesOf('#!someone else built this vmalert\n');
+
+/** One fake host (with DIR already there when `dirExists`), one fake server, one stack. */
+export const deployHarness = (dirExists: boolean) => {
+  const release = syntheticRelease();
+  const pins = catalogBinary(release.catalog, VMALERT_REQUEST);
+  const fake = fakeLinuxHost({
+    dirs: dirExists ? { [DIR]: 0, [ROOT]: 0 } : { [ROOT]: 0 },
+    euid: 0,
+  });
+  const events: string[] = [];
+  const server = { serving: true };
+  const base = fake.runner;
+  const runner: HostRunner = {
+    ...base,
+    exec: (argv) => {
+      events.push(argv.filter((arg) => arg !== '--').join(' '));
+      return base.exec(argv);
+    },
+    removeFile: (path) => {
+      events.push(`remove ${path}`);
+      return base.removeFile(path);
+    },
+    writeFileAtomic: (path, bytes, options) => {
+      events.push(`write ${path}`);
+      return base.writeFileAtomic(path, bytes, options);
+    },
+  };
+  const client = HttpClient.make((request, url) => {
+    events.push(`GET ${url.toString()}`);
+    const found = server.serving && url.toString() === VMUTILS_URL;
+    const body = found ? new Blob([release.vmutils.slice()]) : null;
+    return Effect.succeed(
+      HttpClientResponse.fromWeb(request, new Response(body, { status: found ? 200 : 404 })),
+    );
+  });
+  const providers = Layer.mergeAll(makeReleaseBinaryProvider(), HostDirectoryProvider()).pipe(
+    Layer.provide(
+      Layer.mergeAll(hostRunnerLayer(runner), Layer.succeed(HttpClient.HttpClient, client)),
+    ),
+  );
+  const place = (bytes: Uint8Array, mode = 0o755, kind: 'file' | 'symlink' = 'file') =>
+    fake.files.set(PATH, { bytes, gid: 0, kind, mode, uid: 0 });
+  /** The binary declared with the directory as a literal, so Alchemy probes it. */
+  const literal = ReleaseBinary('vmalert', { ...pins, directory: DIR });
+  /** The documented shape: the directory is HostDirectory's `path`, an Output at a first plan. */
+  const wired = (
+    id = 'vmalert',
+    dirMode = 0o755,
+    formerId?: string,
+    more: Partial<ReleaseBinaryProps> = {},
+  ) =>
+    Effect.gen(function* () {
+      const dir = yield* HostDirectory('dir', { mode: dirMode, path: DIR });
+      const binary = ReleaseBinary(id, { ...pins, ...more, directory: dir.path });
+      yield* formerId === undefined ? binary : binary.pipe(renamedFrom(formerId));
+    });
+  /** The directory alone: the binary's declaration removed. */
+  const dirOnly = HostDirectory('dir', { mode: 0o755, path: DIR });
+  const stack = fakeStack(providers, {}, 'ReleaseStack');
+  return { dirOnly, events, fake, literal, place, server, stack, wired };
+};

package/src/release/fake-engine.ts

@@ -0,0 +1,50 @@
+/**
+ * Release.Binary through Alchemy's own Plan and Apply (openbao/fake-stack.ts) over the REAL
+ * localRunner, for tests that need what a fake host cannot model: two spellings of one file, and
+ * the engine's order across resources. The HTTP server is a fake serving the synthetic vmutils.
+ *
+ * ⛔ TEST-ONLY, like fake-release.ts: no provider imports it and it is not on the barrel. Every
+ *   directory a test passes must be under its own `mkdtemp`; nothing here chooses a path.
+ */
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as HttpClient from 'effect/unstable/http/HttpClient';
+import * as HttpClientResponse from 'effect/unstable/http/HttpClientResponse';
+import { localRunner } from '../launchd/local-runner.ts';
+import { hostRunnerLayer } from '../launchd/runner.ts';
+import { fakeStack } from '../openbao/fake-stack.ts';
+import { ReleaseBinary, makeReleaseBinaryProvider } from './binary.ts';
+import { catalogBinary } from './catalog.ts';
+import { BINARY, VMALERT_REQUEST, VMUTILS_URL, syntheticRelease } from './fake-release.ts';
+
+/** vmalert's bytes as text, to compare with what a test reads off the disk. */
+export const VMALERT_TEXT = new TextDecoder().decode(BINARY.vmalert);
+
+/** One stack over localRunner; `deploy` takes logical id → directory; `gets` counts downloads. */
+export const realEngine = () => {
+  const { catalog, vmutils } = syntheticRelease();
+  const gets: string[] = [];
+  const client = HttpClient.make((request, url) => {
+    gets.push(url.toString());
+    const body = url.toString() === VMUTILS_URL ? new Blob([vmutils.slice()]) : null;
+    return Effect.succeed(
+      HttpClientResponse.fromWeb(request, new Response(body, { status: body ? 200 : 404 })),
+    );
+  });
+  const providers = makeReleaseBinaryProvider().pipe(
+    Layer.provide(
+      Layer.mergeAll(hostRunnerLayer(localRunner()), Layer.succeed(HttpClient.HttpClient, client)),
+    ),
+  );
+  const stack = fakeStack(providers, {}, 'RealEngineStack');
+  const pins = catalogBinary(catalog, VMALERT_REQUEST);
+  const deploy = (binaries: Readonly<Record<string, string>>) =>
+    stack.deploy(
+      Effect.gen(function* () {
+        for (const [id, directory] of Object.entries(binaries)) {
+          yield* ReleaseBinary(id, { ...pins, directory });
+        }
+      }),
+    );
+  return { deploy, gets };
+};

package/src/release/fake-install.ts

@@ -0,0 +1,59 @@
+/**
+ * The install lifecycle's test bench: a fake host, a synthetic release served at the REAL URLs next
+ * to an `-enterprise` decoy, and `refused()`, which asserts a refusal left the host exactly as it
+ * was and wrote nothing.
+ *
+ * ⛔ TEST-ONLY, like fake-release.ts: no provider imports it and it is not on the barrel.
+ */
+import { expect } from 'bun:test';
+import type { ReleaseBinaryProps } from './binary-form.ts';
+import { reconcileBinary } from './binary-lifecycle.ts';
+import {
+  ENTERPRISE_URL,
+  TRACES_URL,
+  VMUTILS_DIR,
+  VMUTILS_ENTRIES,
+  VMUTILS_URL,
+  bytesOf,
+  fakeTransport,
+  gzip,
+  pathsOn,
+  releaseHost,
+  syntheticRelease,
+  tarOf,
+  vmalertProps,
+} from './fake-release.ts';
+
+export const PATH = `${VMUTILS_DIR}/vmalert`;
+export const writes = (fake: ReturnType<typeof releaseHost>) =>
+  fake.calls.filter((c) => c[0] === 'write');
+
+/** A host, a synthetic release served at the real URLs (plus an enterprise decoy), and a runner. */
+export const setup = (entries = VMUTILS_ENTRIES) => {
+  const { catalog, traces, vmutils } = syntheticRelease(entries);
+  const decoy = gzip(tarOf([{ bytes: bytesOf('#!enterprise\n'), name: 'vmalert-prod' }]));
+  const transport = fakeTransport({
+    [ENTERPRISE_URL]: decoy,
+    [TRACES_URL]: traces,
+    [VMUTILS_URL]: vmutils,
+  });
+  const fake = releaseHost();
+  const props = (more: Partial<ReleaseBinaryProps> = {}) => vmalertProps(catalog, more);
+  const install = (declared = props(), options = {}) =>
+    reconcileBinary(fake.runner, transport.fetch, declared, options);
+  return { fake, install, props, transport };
+};
+
+/** Run a refusal; return it, having checked the host is exactly as it was and nothing was written. */
+export const refused = async (s: ReturnType<typeof setup>, run: () => Promise<unknown>) => {
+  const before = pathsOn(s.fake);
+  const error = await run().then(
+    () => {
+      throw new Error('expected a refusal');
+    },
+    (cause: unknown) => cause,
+  );
+  expect(pathsOn(s.fake)).toEqual(before);
+  expect(writes(s.fake)).toEqual([]);
+  return error as Error;
+};

package/src/release/fake-provider.ts

@@ -0,0 +1,68 @@
+/**
+ * One Release.Binary provider over one fake host and one fake HTTP server, for the handler tests
+ * beside it: `requests` counts every URL asked, `notes` every `session.note`.
+ *
+ * ⛔ TEST-ONLY, like fake-release.ts: no provider imports it and it is not on the barrel.
+ */
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as HttpClient from 'effect/unstable/http/HttpClient';
+import * as HttpClientResponse from 'effect/unstable/http/HttpClientResponse';
+import { hostRunnerLayer } from '../launchd/runner.ts';
+import { ReleaseBinary, makeReleaseBinaryProvider } from './binary.ts';
+import {
+  VMUTILS_DIR,
+  VMUTILS_URL,
+  releaseHost,
+  syntheticRelease,
+  vmalertProps,
+} from './fake-release.ts';
+
+export const ids = { fqn: 'stack/vmalert', id: 'vmalert', instanceId: 'i-1' };
+export const call = { bindings: [] as never, newBindings: [] as never, oldBindings: [] as never };
+export const PATH = `${VMUTILS_DIR}/vmalert`;
+
+export type Service = Effect.Success<typeof ReleaseBinary.Provider>;
+
+/** One provider over one fake host and one fake HTTP server; `requests` counts every URL asked. */
+export const harness = () => {
+  const release = syntheticRelease();
+  const VMALERT = vmalertProps(release.catalog);
+  const fake = releaseHost();
+  const requests: string[] = [];
+  const notes: string[] = [];
+  const client = HttpClient.make((request, url) => {
+    requests.push(url.toString());
+    const body = url.toString() === VMUTILS_URL ? new Blob([release.vmutils.slice()]) : null;
+    return Effect.succeed(
+      HttpClientResponse.fromWeb(request, new Response(body, { status: body ? 200 : 404 })),
+    );
+  });
+  const layer = makeReleaseBinaryProvider().pipe(
+    Layer.provide(
+      Layer.mergeAll(hostRunnerLayer(fake.runner), Layer.succeed(HttpClient.HttpClient, client)),
+    ),
+  );
+  const session = { note: (m: string) => Effect.sync(() => void notes.push(m)) } as never;
+  const run = <A>(use: (p: Service) => Effect.Effect<A, unknown>) =>
+    Effect.runPromise(
+      Effect.gen(function* () {
+        return yield* use(yield* ReleaseBinary.Provider);
+      }).pipe(Effect.provide(layer)) as Effect.Effect<A>,
+    );
+  const reconcile = (p: Service, news: object, output?: unknown, olds?: object) =>
+    p.reconcile({
+      ...ids,
+      ...call,
+      news: news as never,
+      olds: olds as never,
+      output: output as never,
+      session,
+    });
+  return { VMALERT, fake, notes, reconcile, release, requests, run };
+};
+
+export const must = <F>(fn: F | undefined): F => {
+  if (fn === undefined) throw new Error('provider has no such handler');
+  return fn;
+};

package/src/release/fake-release.ts

@@ -0,0 +1,185 @@
+/**
+ * Synthetic release archives for the tests beside it: a tar writer, gzip, a catalog pinned to what
+ * they build, a counting transport, and a host with the versioned directories in place.
+ *
+ * ⛔ TEST-ONLY. No provider imports this file, it is not on the barrel, and nothing here reaches a
+ *   network or a real filesystem. The catalog is synthetic because a test cannot build bytes that
+ *   hash to the vendor's pins; victoria.test.ts holds the REAL data set to the vendor's own files.
+ * ★ THE ASSET NAMES AND URLS ARE THE REAL ONES, so a test that serves the `-enterprise` sibling
+ *   next to the plain archive proves the provider asks for exactly one of them.
+ */
+import { fakeRunner } from '../launchd/fake-runner.ts';
+import { sha256Hex } from '../launchd/job-form.ts';
+import { type ReleaseBinaryProps, releaseUrl } from './binary-form.ts';
+import { type PinnedArchive, type ReleaseCatalog, catalogBinary } from './catalog.ts';
+import type { FetchArchive } from './download.ts';
+import { DownloadFailed } from './refused.ts';
+import { VICTORIA_RELEASES } from './victoria.ts';
+
+export type TarEntry = {
+  readonly name: string;
+  readonly bytes?: Uint8Array;
+  /** The typeflag: '0' regular (default), '1' hard link, '2' symlink, '5' directory, 'L', 'x', … */
+  readonly type?: string;
+  readonly format?: 'gnu' | 'posix';
+  readonly prefix?: string;
+  /** Size field written as GNU base-256. */
+  readonly base256?: boolean;
+  readonly corruptChecksum?: boolean;
+};
+
+const put = (block: Uint8Array, at: number, text: string) =>
+  block.set(new TextEncoder().encode(text), at);
+const octal = (value: number, width: number) => `${value.toString(8).padStart(width - 1, '0')}\0`;
+
+export const tarHeader = (entry: TarEntry): Uint8Array => {
+  const block = new Uint8Array(512);
+  const size = entry.bytes?.length ?? 0;
+  put(block, 0, entry.name);
+  put(block, 100, octal(0o755, 8));
+  put(block, 108, octal(1000, 8));
+  put(block, 116, octal(1000, 8));
+  if (entry.base256 === true) block.set([0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, size], 124);
+  else put(block, 124, octal(size, 12));
+  put(block, 136, octal(1_750_000_000, 12));
+  block.fill(0x20, 148, 156);
+  put(block, 156, entry.type ?? '0');
+  put(block, 257, entry.format === 'posix' ? 'ustar\u000000' : 'ustar  \u0000');
+  if (entry.prefix !== undefined) put(block, 345, entry.prefix);
+  const sum = block.reduce((total, byte) => total + byte, 0) + (entry.corruptChecksum ? 1 : 0);
+  put(block, 148, `${sum.toString(8).padStart(6, '0')}\0 `);
+  return block;
+};
+
+/** A tar: each header, its data padded to 512, then the two zero blocks. */
+export const tarOf = (entries: readonly TarEntry[], end = 1024): Uint8Array => {
+  const blocks: Uint8Array[] = [];
+  for (const entry of entries) {
+    blocks.push(tarHeader(entry));
+    const bytes = entry.bytes ?? new Uint8Array();
+    const padded = new Uint8Array(Math.ceil(bytes.length / 512) * 512);
+    padded.set(bytes);
+    blocks.push(padded);
+  }
+  blocks.push(new Uint8Array(end));
+  const out = new Uint8Array(blocks.reduce((total, block) => total + block.length, 0));
+  let at = 0;
+  for (const block of blocks) {
+    out.set(block, at);
+    at += block.length;
+  }
+  return out;
+};
+
+export const gzip = (bytes: Uint8Array): Uint8Array => Bun.gzipSync(bytes.slice());
+
+export const bytesOf = (text: string): Uint8Array => new TextEncoder().encode(text);
+
+/** Stand-ins for the vendor binaries: distinct bytes, so each digest is distinct. */
+export const BINARY = {
+  vmagent: bytesOf('#!fake vmagent 1.151.0\n'),
+  vmalert: bytesOf('#!fake vmalert 1.151.0\n'),
+  vmauth: bytesOf('#!fake vmauth 1.151.0\n'),
+  'victoria-traces': bytesOf('#!fake victoria-traces 0.10.0\n'),
+};
+
+const present = (archive: PinnedArchive | undefined): PinnedArchive => {
+  if (archive === undefined) throw new Error('the data set lost a pinned archive');
+  return archive;
+};
+const REAL = VICTORIA_RELEASES.packages;
+export const VMUTILS = present(REAL.vmutils?.versions['1.151.0']?.['darwin-arm64']);
+export const TRACES = present(REAL['victoria-traces']?.versions['0.10.0']?.['darwin-arm64']);
+export const urlOf = (archive: PinnedArchive): string =>
+  releaseUrl(archive.repo, archive.tag, archive.asset);
+export const VMUTILS_URL = urlOf(VMUTILS);
+export const TRACES_URL = urlOf(TRACES);
+export const ENTERPRISE_URL = VMUTILS_URL.replace('.tar.gz', '-enterprise.tar.gz');
+
+export const VMUTILS_ENTRIES: readonly TarEntry[] = [
+  { bytes: BINARY.vmagent, name: 'vmagent-prod' },
+  { bytes: BINARY.vmalert, name: 'vmalert-prod' },
+  { bytes: BINARY.vmauth, name: 'vmauth-prod' },
+];
+
+/** Pin an archive the way victoria.ts pins a vendor one, from the bytes themselves. */
+export const pinned = (
+  real: PinnedArchive,
+  archive: Uint8Array,
+  members: Readonly<Record<string, Uint8Array>>,
+): PinnedArchive => ({
+  ...real,
+  members: Object.fromEntries(Object.entries(members).map(([n, b]) => [n, sha256Hex(b)])),
+  sha256: sha256Hex(archive),
+  size: archive.length,
+});
+
+/** The real data set with vmutils 1.151.0 and victoria-traces 0.10.0 re-pinned to synthetic bytes. */
+export const syntheticRelease = (vmutilsEntries: readonly TarEntry[] = VMUTILS_ENTRIES) => {
+  const vmutils = gzip(tarOf(vmutilsEntries));
+  const traces = gzip(tarOf([{ bytes: BINARY['victoria-traces'], name: 'victoria-traces-prod' }]));
+  // ★ vmalert-prod is always pinned, as the vendor file lists it — so an archive built WITHOUT it
+  //   models "the checksum file names a member the archive does not hold".
+  const memberBytes = {
+    'vmalert-prod': BINARY.vmalert,
+    ...Object.fromEntries(vmutilsEntries.map((e) => [e.name, e.bytes ?? new Uint8Array()])),
+  };
+  const tracesPin = pinned(TRACES, traces, { 'victoria-traces-prod': BINARY['victoria-traces'] });
+  const catalog: ReleaseCatalog = {
+    ...VICTORIA_RELEASES,
+    packages: {
+      ...REAL,
+      'victoria-traces': {
+        binaries: { 'victoria-traces': 'victoria-traces-prod' },
+        versions: { '0.10.0': { 'darwin-arm64': tracesPin } },
+      },
+      vmutils: {
+        binaries: REAL.vmutils?.binaries ?? {},
+        versions: { '1.151.0': { 'darwin-arm64': pinned(VMUTILS, vmutils, memberBytes) } },
+      },
+    },
+  };
+  return { catalog, traces, vmutils };
+};
+
+/** A transport over a URL → bytes table that records every request, in order. */
+export const fakeTransport = (served: Readonly<Record<string, Uint8Array>>) => {
+  const requests: string[] = [];
+  const fetch: FetchArchive = async (url) => {
+    requests.push(url);
+    const bytes = served[url];
+    if (bytes === undefined)
+      throw new DownloadFailed({ message: `${url}: HTTP 404`, retryable: false });
+    return bytes;
+  };
+  return { fetch, requests };
+};
+
+export const ROOT = '/opt/example/bin';
+export const VMUTILS_DIR = `${ROOT}/vmutils-1.151.0`;
+export const TRACES_DIR = `${ROOT}/victoria-traces-0.10.0`;
+
+/** A host deploying as root, with the two versioned directories already declared. */
+export const releaseHost = () =>
+  fakeRunner({ dirs: { [ROOT]: 0, [TRACES_DIR]: 0, [VMUTILS_DIR]: 0 }, euid: 0 });
+
+export const VMALERT_REQUEST = {
+  binary: 'vmalert',
+  package: 'vmutils',
+  platform: 'darwin-arm64',
+  version: '1.151.0',
+} as const;
+
+/** vmalert's props out of `catalog` (the synthetic one, normally), in its versioned directory. */
+export const vmalertProps = (
+  catalog: ReleaseCatalog,
+  more: Partial<ReleaseBinaryProps> = {},
+): ReleaseBinaryProps => ({
+  ...catalogBinary(catalog, VMALERT_REQUEST),
+  directory: VMUTILS_DIR,
+  ...more,
+});
+
+/** Every path on the fake host, sorted — equal before and after means nothing was left behind. */
+export const pathsOn = (fake: ReturnType<typeof fakeRunner>): string[] =>
+  [...fake.files.keys()].sort();

package/src/release/fixtures/victoria/darwin-arm64-assets.txt

@@ -0,0 +1,22 @@
+victoria-logs-darwin-arm64-v1.52.0-enterprise.tar.gz
+victoria-logs-darwin-arm64-v1.52.0-enterprise_checksums.txt
+victoria-logs-darwin-arm64-v1.52.0.tar.gz
+victoria-logs-darwin-arm64-v1.52.0_checksums.txt
+victoria-metrics-darwin-arm64-v1.151.0-cluster.tar.gz
+victoria-metrics-darwin-arm64-v1.151.0-cluster_checksums.txt
+victoria-metrics-darwin-arm64-v1.151.0-enterprise-cluster.tar.gz
+victoria-metrics-darwin-arm64-v1.151.0-enterprise-cluster_checksums.txt
+victoria-metrics-darwin-arm64-v1.151.0-enterprise.tar.gz
+victoria-metrics-darwin-arm64-v1.151.0-enterprise_checksums.txt
+victoria-metrics-darwin-arm64-v1.151.0.tar.gz
+victoria-metrics-darwin-arm64-v1.151.0_checksums.txt
+victoria-traces-darwin-arm64-v0.10.0.tar.gz
+victoria-traces-darwin-arm64-v0.10.0_checksums.txt
+vlutils-darwin-arm64-v1.52.0-enterprise.tar.gz
+vlutils-darwin-arm64-v1.52.0-enterprise_checksums.txt
+vlutils-darwin-arm64-v1.52.0.tar.gz
+vlutils-darwin-arm64-v1.52.0_checksums.txt
+vmutils-darwin-arm64-v1.151.0-enterprise.tar.gz
+vmutils-darwin-arm64-v1.151.0-enterprise_checksums.txt
+vmutils-darwin-arm64-v1.151.0.tar.gz
+vmutils-darwin-arm64-v1.151.0_checksums.txt

package/src/release/fixtures/victoria/victoria-logs-darwin-arm64-v1.52.0_checksums.txt

@@ -0,0 +1,2 @@
+3157d4b6181d8a7e3e30918e2cbfcd4cc4cb66263e3ef21ea91e4f20f8980883  victoria-logs-darwin-arm64-v1.52.0.tar.gz
+9e48809e314902782959b3a4e683a3087476759d0293791a0564921c676ca7be  victoria-logs-prod

package/src/release/fixtures/victoria/victoria-metrics-darwin-arm64-v1.151.0_checksums.txt

@@ -0,0 +1,2 @@
+8792437c4c0b63719fed7b44ad18d4b4167bbe6861ab3e84c7bb010c922e7582  victoria-metrics-darwin-arm64-v1.151.0.tar.gz
+3c493a95ac1e9034a3261b230c4d62f3b186a04aafcdbacc99bfc110dc5de6a1  victoria-metrics-prod

package/src/release/fixtures/victoria/victoria-traces-darwin-arm64-v0.10.0_checksums.txt

@@ -0,0 +1,2 @@
+cbe83f1d409cbb85fbf1c890c4a9b7fd34c1d74acec4dce2e0ebe46fcb260e38  victoria-traces-darwin-arm64-v0.10.0.tar.gz
+4759ec89a466129b9eefc22244a111e1f489739340747805fd93b58fd0f7b2dd  victoria-traces-prod

package/src/release/fixtures/victoria/vmutils-darwin-arm64-v1.151.0_checksums.txt

@@ -0,0 +1,8 @@
+27d68bac90e28929214091ed9d27f2e9fef25a080407e2c8661ea9b52dd6b183  vmutils-darwin-arm64-v1.151.0.tar.gz
+d3b6fa1f71ef48beac619f15f8adfa7610e76605caf37db1ebfbb379b6692329  vmagent-prod
+62845795167e9ff47890e83ac4ac5934693c105767db88591c95a08f3c4fb354  vmalert-prod
+cbffb9495e4bb1457c9d45e0a7064b3a3a29b2cfd1ae24bfe8f00ec327c26998  vmalert-tool-prod
+398df9e0f5b7035d037e39ee9ff66a10ddde5333d832602463aa4d2865fdb508  vmauth-prod
+1974a2ee211b49bf581287808e010846f6c47ff135276214c6da628567777b9e  vmbackup-prod
+fc824df7215b01b57921ed46afde7fea6b6698adf13d9ea8e3fe36e194ef8190  vmrestore-prod
+998b111eee206b98e6d25fdf2fbaa455ecc17c7f9e7c3b2373e127cef762459f  vmctl-prod

package/src/release/index.ts

@@ -0,0 +1,41 @@
+/**
+ * Release binaries for Alchemy — one binary out of a pinned release archive, installed onto a host
+ * and verified against digests the stack pins in code, plus the vendor data sets those pins come
+ * from (VictoriaMetrics' is the first).
+ *
+ * ⛔ THIS BARREL IS THE PUBLIC API, AND IT IS DELIBERATELY SMALLER THAN THE DIRECTORY. The tar
+ *   reader, the downloader, the checksum parser, the lifecycle and the test seams are internals; an
+ *   `export *` would publish them as API and make the next refactor a breaking change.
+ * ⛔ IT INSTALLS; IT NEVER STARTS. Run the binary with `LaunchdJob` (the launchd subpath) or a
+ *   systemd unit, putting `ReleaseBinary`'s `path` in its argv. See docs/release-binary.md.
+ * ★ THE SEAM IS SHARED, NOT COPIED. `HostRunner` is re-exported so a stack types its runner without
+ *   importing from another subpath.
+ */
+export type {
+  PinnedDownload,
+  ReleaseArchive,
+  ReleaseBinaryAttributes,
+  ReleaseBinaryProps,
+} from './binary-form.ts';
+export { releaseBinaryPath, releaseUrl } from './binary-form.ts';
+export { ReleaseBinary, ReleaseBinaryProvider } from './binary.ts';
+export type {
+  CatalogPackage,
+  CatalogRequest,
+  IdentifiedBinary,
+  PinnedArchive,
+  PinnedBinary,
+  ReleaseCatalog,
+} from './catalog.ts';
+export { catalogBinary, catalogDirectory, catalogProblems, identifyBinary } from './catalog.ts';
+export { releaseProviders } from './providers.ts';
+export { ArchiveRefused, BinaryRefused, ChecksumMismatch, DownloadFailed } from './refused.ts';
+export { VICTORIA_RELEASES } from './victoria.ts';
+export type {
+  ExecResult,
+  FileStat,
+  HostRunner,
+  HostUser,
+  WriteOptions,
+} from '../launchd/runner.ts';
+export { HostRunnerService, hostRunnerLayer } from '../launchd/runner.ts';