mirab 0.0.0 → 0.2.0

package/types/runner/index.d.ts

@@ -0,0 +1,13 @@
+export * from './define';
+export { buildSteps, cachedRunnerImage, runnerImage, runnerImageKey, runnerImagesDir, runnerRecipe, } from './image';
+export type { RunnerImage, RunnerImageMeta, RunnerRecipe } from './image';
+export { admission, hostLabel, jobEnv, redact, runnersDir, serveRunners, startRunnerVm, stepArgv, } from './serve';
+export type { RunnerState, ServeDeps, ServeOptions, SlotPhase, SlotState, } from './serve';
+export { resolveTools, TOOL_CACHE } from './toolsets';
+/** The VM this host runs runners on: the published guest image (fetched on
+ *  first use) and the backend's settings from <config dir>/isolation.json. */
+export { requireVm as runnerHostVm } from '../isolation';
+/** This copy's package version: with the commit a package pins mirab at, it
+ *  names that commit's canary (`<version>-canary-<sha7>`) for runnerHostVm. */
+export { MIRAB_VERSION } from '../isolation/image';
+export type { ResolvedTool } from './toolsets';

package/types/runner/serve.d.ts

@@ -0,0 +1,69 @@
+import { type VmConfig } from '../isolation';
+import type { Isolation } from '../isolation/session';
+import { hostRunnerPlatform, type RunnerDefinition, type RunnerPlatform, type RunnerStep } from './define';
+import { type RunnerImage, type RunnerRecipe } from './image';
+export declare const runnersDir: (configDir: string) => string;
+export type SlotPhase = 'image' | 'booting' | 'waiting' | 'busy' | 'stopping';
+export interface SlotState {
+    vmName: string;
+    phase: SlotPhase;
+    since: string;
+}
+export interface RunnerState {
+    name: string;
+    host: string;
+    forge: string;
+    image?: string;
+    slots: SlotState[];
+    jobs: number;
+    lastError?: {
+        at: string;
+        message: string;
+    };
+}
+/** Things serveRunners does to the world; tests pass their own. */
+export interface ServeDeps {
+    startVm: (vm: VmConfig, vmDir: string, log: (line: string) => void) => Promise<Isolation>;
+    image: (def: RunnerDefinition, recipe: RunnerRecipe) => Promise<RunnerImage>;
+    recipe: (def: RunnerDefinition) => Promise<RunnerRecipe>;
+    sleep: (ms: number, signal: AbortSignal) => Promise<void>;
+    now: () => Date;
+    /** How long a minute is (the job and idle timers); tests shorten it. */
+    minuteMs: number;
+}
+export interface ServeOptions {
+    configDir: string;
+    vm: VmConfig;
+    /** Names registrations `<host>-<name>-<random>`. */
+    host?: string;
+    /** RAM all slots together may use (default: host RAM − 3 GiB). */
+    budgetMiB?: number;
+    signal?: AbortSignal;
+    log?: (line: string) => void;
+    deps?: Partial<ServeDeps>;
+}
+/** A runner's VM: nothing of the host's inside (no work share or drive) and
+ *  no guest-to-host port. */
+export declare function startRunnerVm(vm: VmConfig, vmDir: string, log: (line: string) => void): Promise<Isolation>;
+/** A host name usable in a registration name. */
+export declare function hostLabel(name?: string): string;
+/** Replaces every secret value in `line` (the ticket's, while it lives). */
+export declare function redact(line: string, secrets: Iterable<string>): string;
+/** The env every job step gets: base, then the image's toolsets, then the
+ *  forge's job env, then the step's own (later wins). PATH is composed. */
+export declare function jobEnv(def: RunnerDefinition, image: Pick<RunnerImage['meta'], 'env' | 'path'>, job: Record<string, string>, step?: Record<string, string>): Record<string, string>;
+/** The argv mirab really execs for a step: as the runner user unless asRoot,
+ *  output lines cut to 4000 characters (the guest channel refuses a line over
+ *  32 KiB, which would end the job), the step's exit status kept. */
+export declare function stepArgv(step: RunnerStep): string[];
+/** Refuses a host that can't run these definitions safely. */
+export declare function admission(defs: RunnerDefinition[], o: {
+    configDir: string;
+    budgetMiB: number;
+    backend: 'vz' | 'firecracker';
+    filtered: boolean;
+    freeBytes: number;
+}): Promise<void>;
+export declare function serveRunners(defs: RunnerDefinition[], o: ServeOptions): Promise<void>;
+export { hostRunnerPlatform };
+export type { RunnerPlatform };

package/types/runner/toolsets.d.ts

@@ -0,0 +1,35 @@
+import type { RunnerPlatform, RunnerStep } from './define';
+export declare const TOOL_CACHE = "/opt/hostedtoolcache";
+export declare const RUST_HOME = "/opt/rust";
+export interface ResolvedTool {
+    tool: 'rust' | 'node' | 'go';
+    version: string;
+    url: string;
+    sha256: string;
+    /** Hosts the build VM fetches from. */
+    hosts: string[];
+}
+export type Fetcher = (url: string) => Promise<string>;
+/** `24` matches 24.x.y, `24.21` matches 24.21.y, `24.21.0` only itself. */
+export declare function versionMatches(spec: string, version: string): boolean;
+declare const nodeArch: (p: RunnerPlatform) => "arm64" | "x64";
+/** The tool cache's arch directory (setup-node and setup-go use these). */
+export declare const cacheArch: typeof nodeArch;
+export declare function resolveNode(spec: string, platform: RunnerPlatform, get?: Fetcher): Promise<ResolvedTool>;
+export declare function resolveGo(spec: string, platform: RunnerPlatform, get?: Fetcher): Promise<ResolvedTool>;
+/** Rust: rustup-init (checked by its published sha256) installs the toolchain
+ *  `spec`; rustup checks every component it downloads itself. */
+export declare function resolveRust(spec: string, platform: RunnerPlatform, get?: Fetcher): Promise<ResolvedTool>;
+export declare function resolveTools(tools: {
+    rust?: string;
+    node?: string;
+    go?: string;
+}, platform: RunnerPlatform, get?: Fetcher): Promise<ResolvedTool[]>;
+/** The build steps (root, in the build VM) for the resolved toolsets. */
+export declare function toolSteps(tools: ResolvedTool[], platform: RunnerPlatform): RunnerStep[];
+/** What a job's env needs to find the toolsets (merged into the base env). */
+export declare function toolEnv(tools: ResolvedTool[], platform: RunnerPlatform): {
+    env: Record<string, string>;
+    path: string[];
+};
+export {};

package/types/tools.d.ts

@@ -0,0 +1,2 @@
+export { defineTool } from './agent/define';
+export type { Tool } from './agent/define';

package/index.js

@@ -1 +0,0 @@
-throw new Error("mirab isn't released yet. This version reserves the name; watch https://addis.gg for the first release.")