bitfab 0.64.13 → 0.64.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 44a3233601b36a74eec1e40a2ebcea100a0501f5cbb94a3009862c4ee0b05923
-  data.tar.gz: be71d868cd14c69b00ee6be5de3a92e67c50202ae1dac3321cf3ba6f96e0a570
+  metadata.gz: 4ae38a6da8055dd696639f719a5fd0910e97818aee2f1ec0e74c0d918beb8a3a
+  data.tar.gz: 6004d03970985aa1381ef57ae4c7481195c50c904bc672677155b786e0f060f5
 SHA512:
-  metadata.gz: 6452180b7db74604f10a57611036bf787308a491126c3159311f6eb5402e5c647b6d89b8cf24d242e3c76466e59959e16964a70ec68e5b94a9a39dfc873b2b66
-  data.tar.gz: d29e63513f3e2e0002b06e24848664858cf40853b69e36d8ab434e26a975e49a7edf3d4411bb9d3d36f93dca21a7602f40ecdbbd7c16eebf2e4c25c45afb0423
+  metadata.gz: 6c7bc1dcf702f9d3c831df3a68a566c7186f352247bf7faa157d164237257874692d4334ade0da3ab90c3ec23293769a7610ed982527993173cd9c1d8622806e
+  data.tar.gz: 54fa2229794f023b7eaaae39be309c474a5e561baf55e7e63b2e2545c7279ec2859d6753e5a7658f69fd6c1a2bc40a6a13cc30202ccdca01fe8bba374e4cf51a

data/lib/bitfab/client.rb

@@ -69,9 +69,6 @@ module Bitfab
       CommitRef.start_resolution
     end
 
-    # The configured API key (a proc is resolved on read). Reflects what was
-    # passed to the client; the ENV["BITFAB_API_KEY"] fallback applied during
-    # actual tracing is not surfaced here, and reading this never warns.
     def api_key
       @api_key_config.respond_to?(:call) ? @api_key_config.call : @api_key_config
     end
@@ -788,28 +785,27 @@ module Bitfab
       @api_key_config.respond_to?(:call) || @api_key_config.to_s.strip.empty?
     end
 
-    # Resolve the API key lazily, the first time a span actually needs it.
-    #
-    # The key is intentionally NOT read at construction: a client built when a
-    # file is required can run before the app loads its env, so the key would be
-    # empty at construction even though it is set moments later. Resolution
-    # order: the configured value (a proc is called while still unresolved),
-    # then a fallback read of ENV["BITFAB_API_KEY"]. Once a non-empty key is
-    # found it is cached.
-    def resolve_api_key
-      return @resolved_api_key unless @resolved_api_key.nil?
+    def lookup_api_key
+      replay_key = ENV[REPLAY_API_KEY_ENV]
+      return replay_key unless blank_api_key?(replay_key)
+
+      @resolved_api_key ||= configured_or_env_api_key
+    end
 
+    def configured_or_env_api_key
       from_config = @api_key_config.respond_to?(:call) ? @api_key_config.call : @api_key_config
-      candidate = if from_config && !from_config.to_s.strip.empty?
-        from_config
-      else
-        ENV["BITFAB_API_KEY"]
-      end
-      key = (candidate && !candidate.to_s.strip.empty?) ? candidate : nil
-      if key
-        @resolved_api_key = key
-        return key
-      end
+      candidate = blank_api_key?(from_config) ? ENV["BITFAB_API_KEY"] : from_config
+      blank_api_key?(candidate) ? nil : candidate
+    end
+
+    def blank_api_key?(value)
+      !value || value.to_s.strip.empty?
+    end
+
+    def resolve_api_key
+      key = lookup_api_key
+      return key if key
+
       if @strict
         raise "Bitfab: no API key resolved. Set BITFAB_API_KEY or pass api_key: to " \
           "Bitfab.configure. If a script loads env later, load it before the first " \

data/lib/bitfab/cloudReplay.py

@@ -36,6 +36,16 @@ SDK_LANGUAGE_ENV = "BITFAB_SDK_LANGUAGE"
 CHECK_COMMAND_ENV = "BITFAB_REPLAY_CHECK"
 EXECUTION_TARGET_ENV = "BITFAB_REPLAY_EXECUTION_TARGET"
 HOSTED_EXECUTION_TARGET = "hosted"
+API_KEY_ENV = "BITFAB_REPLAY_BITFAB_API_KEY"
+PRINT_API_KEY_FLAG = "--print-api-key"
+API_KEY_LINE = "@@bitfab:api-key "
+KEY_INPUT = "key_id"
+KEY_SECRET_PREFIX = "BITFAB_REPLAY_KEY_"
+KEY_SECRET_REFERENCE = (
+    "${{ secrets[format('" + KEY_SECRET_PREFIX + "{0}', inputs." + KEY_INPUT + ")] }}"
+)
+API_KEY_PROBE_SECONDS = 120
+RUN_NAME = "Bitfab replay ${{ inputs.execution_id || github.ref_name }}"
 REQUEST_VERSION = 4
 PLAIN_REQUEST_VERSION = 3
 OLDEST_DISPATCHED_VERSION = 2
@@ -95,7 +105,7 @@ ENVIRONMENT_SETTING = re.compile(
 PUSH_TRIGGER = re.compile(
     r"^[ \t]*\"?(?:on\"?[ \t]*:.*\bpush\b|push\"?[ \t]*:)", re.MULTILINE
 )
-DISPATCH_INPUTS = ("execution_id", "request")
+DISPATCH_INPUTS = ("execution_id", "request", KEY_INPUT)
 BRANCH_NAME = re.compile(r"[A-Za-z0-9][A-Za-z0-9._/-]*")
 ENV_NAME = re.compile(r"[A-Za-z_][A-Za-z0-9_]*")
 RESERVED_ENV_PREFIXES = ("GITHUB_", "RUNNER_", "ACTIONS_", "BITFAB_REPLAY_")
@@ -204,6 +214,14 @@ values --cloud-env sets. version and id are optional: version names the request
 format (4 when env is set, otherwise 3; 2 is still accepted), and id is the
 execution UUID, which must match an execution_id input when the workflow has one.
 
+The replay runs with the Bitfab API key it would use on your machine, so the
+experiment is recorded as yours. Before dispatch, the replay's registry is loaded
+locally to read its client's key, which the GitHub CLI stores as a GitHub secret
+named for this execution and deletes once the replay starts. Without the GitHub
+CLI, without permission to manage the repository's Actions secrets, with no key
+resolved locally, or with a workflow that declares no key_id input, the run uses
+the workflow's BITFAB_API_KEY secret instead.
+
 The runner's job exits with the replay's exit code, so the Actions run fails when
 the replay does. Traces that errored fail it only under --fail-on-error.
 
@@ -216,7 +234,10 @@ Set up once:
   --cloud-init [--secret NAME ...] [--environment NAME] [--run COMMAND]
                [--runs-on LABEL] [--secret-prefix PREFIX] [--check COMMAND]
       Writes .github/workflows/bitfab-replay.yml, the only file cloud replay keeps
-      in the repository, and lists what is left to do.
+      in the repository, and lists what is left to do. On an existing workflow it
+      adds only the lines a newer SDK needs and lists what it changed.
+  --cloud-update [same options]
+      The same command as --cloud-init, for bringing an existing setup up to date.
   --cloud-secrets --env-file FILE [NAME ...] [--environment NAME] [--dry-run]
       Copies local values into the GitHub secrets the workflow reads.
 
@@ -1189,6 +1210,7 @@ def print_outcome(found):
 
 
 def cleanup(root, record):
+    remove_key(record)
     if record.get("cleaned"):
         return
     if record.get("snapshot") is False:
@@ -1335,10 +1357,110 @@ def submit(root, repo, workflow, parsed, path):
         ) from error
     record["state"] = "dispatch_unknown"
     save(path, record)
-    declared = declared_inputs(
-        within(root, f"{WORKFLOW_DIRECTORY}/{workflow}").read_text()
+    text = within(root, f"{WORKFLOW_DIRECTORY}/{workflow}").read_text()
+    declared = declared_inputs(text)
+    key_inputs = store_key(root, record, declared, text)
+    save(path, record)
+    return dispatch(
+        record,
+        {"execution_id": execution_id, "request": "-", **key_inputs},
+        declared,
     )
-    return dispatch(record, {"execution_id": execution_id, "request": "-"}, declared)
+
+
+def local_api_key(root, request):
+    try:
+        output = command(
+            [*replay_command(), *request["args"], PRINT_API_KEY_FLAG],
+            cwd=within(root, request["cwd"]),
+            timeout=API_KEY_PROBE_SECONDS,
+            input="",
+        )
+    except (ValueError, RuntimeError, OSError, subprocess.SubprocessError):
+        return None
+    for line in reversed(output.splitlines()):
+        if not line.startswith(API_KEY_LINE):
+            continue
+        try:
+            key = json.loads(line.removeprefix(API_KEY_LINE)).get("apiKey")
+        except (ValueError, AttributeError):
+            return None
+        return key if isinstance(key, str) and key.strip() else None
+    return None
+
+
+def store_key(root, record, declared, workflow_text):
+    shared = "so the run uses the workflow's BITFAB_API_KEY secret"
+    if KEY_INPUT not in declared:
+        progress(
+            f"The workflow takes no {KEY_INPUT} input, {shared}. To replay with your own Bitfab API key, run bitfab-replay --cloud-init, which adds the {KEY_INPUT} input and {API_KEY_ENV} to the workflow"
+        )
+        return {}
+    if shutil.which("gh") is None:
+        progress(
+            f"Replaying with your own Bitfab API key needs the GitHub CLI (https://cli.github.com) to store it as a GitHub secret, {shared}"
+        )
+        return {}
+    key = local_api_key(root, record["request"])
+    if key is None:
+        progress(
+            f"The replay's Bitfab client resolved no API key on this machine, {shared}"
+        )
+        return {}
+    key_id = record["id"].replace("-", "").upper()
+    name = KEY_SECRET_PREFIX + key_id
+    configured = ENVIRONMENT_SETTING.search(workflow_text)
+    environment = configured[1] if configured else None
+    try:
+        command(
+            [
+                "gh",
+                "secret",
+                "set",
+                name,
+                "--repo",
+                record["repository"],
+                *(["--env", environment] if environment else []),
+            ],
+            input=key,
+            env={**os.environ, "GH_TOKEN": github_access()["token"]},
+        )
+    except (ValueError, RuntimeError, OSError, subprocess.SubprocessError):
+        progress(
+            f"Could not store your Bitfab API key as the GitHub secret {name}, which needs permission to manage the repository's Actions secrets, {shared}"
+        )
+        return {}
+    record["keySecret"] = {"name": name, "environment": environment}
+    progress(
+        f"Replaying with the Bitfab API key from this machine, stored as the GitHub secret {name} until the replay starts"
+    )
+    return {KEY_INPUT: key_id}
+
+
+def remove_key(record):
+    secret = record.get("keySecret")
+    if not secret or secret.get("removed"):
+        return
+    try:
+        command(
+            [
+                "gh",
+                "secret",
+                "delete",
+                secret["name"],
+                "--repo",
+                record["repository"],
+                *(["--env", secret["environment"]] if secret["environment"] else []),
+            ],
+            env={**os.environ, "GH_TOKEN": github_access()["token"]},
+        )
+    except (ValueError, RuntimeError, OSError, subprocess.SubprocessError) as error:
+        if getattr(error, "http_status", None) != 404:
+            progress(
+                f"Could not delete the GitHub secret {secret['name']}; delete it at {secrets_page(record['repository'], secret['environment'])}"
+            )
+            return
+    secret["removed"] = True
 
 
 def declared_inputs(text):
@@ -1446,7 +1568,8 @@ def submit_as_is(root, repo, workflow, parsed, path):
     preflight(
         repo, workflow, pushes=False, full_output=request.get("fullOutput") is True
     )
-    declared = declared_inputs(branch_workflow(repo, workflow, sha))
+    text = branch_workflow(repo, workflow, sha)
+    declared = declared_inputs(text)
     if "request" not in declared:
         raise ValueError(
             f"{WORKFLOW_DIRECTORY}/{workflow} on {branch} declares no request input, so it cannot take a replay; add request (type: string, required: false) under on.workflow_dispatch.inputs and land it on {branch}"
@@ -1466,9 +1589,11 @@ def submit_as_is(root, repo, workflow, parsed, path):
     progress(
         f"Replaying {branch} at {sha[:12]} as it is on GitHub, without local changes. Execution {execution_id}; resume with --cloud-watch {execution_id}"
     )
+    key_inputs = store_key(root, record, declared, text)
+    save(path, record)
     return dispatch(
         record,
-        {"execution_id": execution_id, "request": json.dumps(request)},
+        {"execution_id": execution_id, "request": json.dumps(request), **key_inputs},
         declared,
         run_details=True,
     )
@@ -1477,10 +1602,11 @@ def submit_as_is(root, repo, workflow, parsed, path):
 def report_steps(record, shown):
     job = replay_job(record)
     for step in (job or {}).get("steps", []):
-        if (
-            step.get("status") in ("in_progress", "completed")
-            and step.get("name") not in shown
-        ):
+        if step.get("status") not in ("in_progress", "completed"):
+            continue
+        if "--cloud-execute" in (step.get("name") or ""):
+            remove_key(record)
+        if step.get("name") not in shown:
             shown.add(step.get("name"))
             progress(step.get("name"))
 
@@ -1701,6 +1827,11 @@ def execute():
     request = runner_request(root, commit)
     directory = within(root, request["cwd"])
     check_secrets(root)
+    if os.environ.get(API_KEY_ENV, "").strip():
+        print(
+            "Replaying with the Bitfab API key of the person who started this run",
+            flush=True,
+        )
     environment = request.get("env") or {}
     if environment:
         workflow_environment_conflicts(root, environment)
@@ -2376,12 +2507,13 @@ def workflow_document(steps, run, directory, env, *, runs_on, environment):
     ]
     return {
         "name": "Bitfab replay",
-        "run-name": "Bitfab replay ${{ inputs.execution_id || github.ref_name }}",
+        "run-name": RUN_NAME,
         "on": {
             "workflow_dispatch": {
                 "inputs": {
                     "execution_id": {"type": "string", "required": False},
                     "request": {"type": "string", "required": False},
+                    KEY_INPUT: {"type": "string", "required": False},
                 }
             }
         },
@@ -2390,10 +2522,141 @@ def workflow_document(steps, run, directory, env, *, runs_on, environment):
     }
 
 
-def initialize(argv):
+def indentation(line):
+    return len(line) - len(line.lstrip(" \t"))
+
+
+def block_end(lines, start, indent):
+    end = start + 1
+    while end < len(lines) and (
+        not lines[end].strip() or indentation(lines[end]) > indent
+    ):
+        end += 1
+    while end > start + 1 and not lines[end - 1].strip():
+        end -= 1
+    return end
+
+
+def add_input(lines, name):
+    for index, line in enumerate(lines):
+        if not re.fullmatch(r'[ \t]*"?request"?[ \t]*:[ \t]*', line):
+            continue
+        indent = indentation(line)
+        child = " " * (
+            indentation(lines[index + 1])
+            if block_end(lines, index, indent) > index + 1
+            else indent + 2
+        )
+        end = block_end(lines, index, indent - 1)
+        lines[end:end] = [
+            f"{line[:indent]}{name}:",
+            f"{child}type: string",
+            f"{child}required: false",
+        ]
+        return True
+    return False
+
+
+def add_run_name(lines):
+    named = next(
+        (
+            index
+            for index, line in enumerate(lines)
+            if re.match(r'"?name"?[ \t]*:', line)
+        ),
+        -1,
+    )
+    lines.insert(named + 1, f"run-name: {json.dumps(RUN_NAME)}")
+
+
+def replay_step_key(lines):
+    for index, line in enumerate(lines):
+        if "--cloud-execute" not in line:
+            continue
+        for above in range(index, -1, -1):
+            match = re.match(r"([ \t]*)(- +)?run[ \t]*:", lines[above])
+            if match and indentation(lines[above]) <= indentation(line):
+                return above, len(match[1]) + len(match[2] or "")
+    return None
+
+
+def add_key_env(lines):
+    found = replay_step_key(lines)
+    if found is None:
+        return False
+    run, key = found
+    start = run
+    while start > 0 and not re.match(r"[ \t]*- ", lines[start]):
+        start -= 1
+    end = block_end(lines, run, key - 1)
+    entry = f'{API_KEY_ENV}: "{KEY_SECRET_REFERENCE}"'
+    for index in range(start, end):
+        line = lines[index]
+        if not re.fullmatch(r"[ \t]*(- +)?env[ \t]*:[ \t]*", line):
+            continue
+        if len(line) - len(line.lstrip(" \t-")) != key:
+            continue
+        entries = block_end(lines, index, key)
+        child = indentation(lines[index + 1]) if entries > index + 1 else key + 2
+        lines.insert(entries, " " * child + entry)
+        return True
+    lines[end:end] = [" " * key + "env:", " " * (key + 2) + entry]
+    return True
+
+
+def update_workflow(root, path):
+    target = within(root, path)
+    text = target.read_text()
+    lines = text.split("\n")
+    updated, by_hand = [], []
+    declared = declared_inputs(text)
+    for name in ("execution_id", KEY_INPUT):
+        if name in declared:
+            continue
+        if add_input(lines, name):
+            updated.append(f"Added the {name} input")
+        else:
+            by_hand.append(
+                f"{name} (type: string, required: false) under on.workflow_dispatch.inputs"
+            )
+    if not re.search(r'^"?run-name"?[ \t]*:', text, re.MULTILINE):
+        add_run_name(lines)
+        updated.append("Named each run after its execution")
+    if API_KEY_ENV not in text:
+        if add_key_env(lines):
+            updated.append(f"Added {API_KEY_ENV} to the replay step's env")
+        else:
+            by_hand.append(
+                f'{API_KEY_ENV}: "{KEY_SECRET_REFERENCE}" in the replay step\'s env'
+            )
+    if updated:
+        target.write_text("\n".join(lines))
+    steps = []
+    if updated:
+        steps.append(
+            f"Commit {path}. A --cloud replay runs the workflow in its own snapshot, so the next one uses it; --cloud-ref replays need it on the branch they replay"
+        )
+    if by_hand:
+        steps.append(
+            "Cloud replay could not place these lines, so add them by hand: "
+            + "; ".join(by_hand)
+        )
+    if not steps:
+        steps.append(
+            "Already set up. Edit the workflow directly to change its install steps, secrets, runner, or Environment"
+        )
+    return {
+        "files": [path] if updated else [],
+        "workflow": path,
+        "updated": updated,
+        "next": steps,
+    }
+
+
+def initialize(argv, name="--cloud-init"):
     parser = argparse.ArgumentParser(
-        prog="bitfab-replay --cloud-init",
-        description="Write .github/workflows/bitfab-replay.yml, the only file cloud replay keeps in the repository, and list what is left to do. It detects the runtime, package manager, install command, and replay command from the directory you run it in. An existing workflow is left alone; edit it directly to change it.",
+        prog=f"bitfab-replay {name}",
+        description="Write .github/workflows/bitfab-replay.yml, the only file cloud replay keeps in the repository, and list what is left to do. It detects the runtime, package manager, install command, and replay command from the directory you run it in. On an existing workflow it only adds what a newer SDK needs (the execution_id and key_id inputs, the run name, and BITFAB_REPLAY_BITFAB_API_KEY) and lists what it changed; edit it directly for anything else.",
     )
     parser.add_argument(
         "--secret",
@@ -2425,13 +2688,7 @@ def initialize(argv):
     refuse_old_setup(root)
     existing = find_workflow(root)
     if existing is not None:
-        return {
-            "files": [],
-            "workflow": f"{WORKFLOW_DIRECTORY}/{existing}",
-            "next": [
-                "Already set up. Edit the workflow directly to change its install steps, secrets, runner, or Environment"
-            ],
-        }
+        return update_workflow(root, f"{WORKFLOW_DIRECTORY}/{existing}")
     prefix = args.secret_prefix
     if prefix and not re.fullmatch(r"[A-Z][A-Z0-9_]*_", prefix):
         raise ValueError(
@@ -2450,6 +2707,7 @@ def initialize(argv):
             'Pass --run with the command that starts your registry program on the runner, such as --run "go run ./cmd/registry"'
         )
     env = {name: "${{ secrets." + prefix + name + " }}" for name in names}
+    env[API_KEY_ENV] = KEY_SECRET_REFERENCE
     if args.check:
         env[CHECK_COMMAND_ENV] = args.check
     path = f"{WORKFLOW_DIRECTORY}/{WORKFLOW}"
@@ -2506,8 +2764,8 @@ def print_json(value):
 def main():
     argv = sys.argv[1:]
     try:
-        if argv[:1] == ["--cloud-init"]:
-            print_json(initialize(argv[1:]))
+        if argv[:1] in (["--cloud-init"], ["--cloud-update"]):
+            print_json(initialize(argv[1:], argv[0]))
             return 0
         if argv[:1] == ["--cloud-secrets"]:
             print_json(configure_secrets(argv[1:]))

data/lib/bitfab/constants.rb

@@ -3,6 +3,8 @@
 module Bitfab
   DEFAULT_SERVICE_URL = "https://bitfab.ai"
   CAPTURE_ENABLED_ENV = "BITFAB_CAPTURE_ENABLED"
+  REPLAY_API_KEY_ENV = "BITFAB_REPLAY_BITFAB_API_KEY"
+  BITFAB_API_KEY_PREFIX = "@@bitfab:api-key "
   REPLAY_CONTEXT_KEY = :__bitfab_replay_context
 
   # Wire prefix the Bitfab plugin scans for on stderr to report live progress

data/lib/bitfab/replay_cli.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "json"
 require "optparse"
 require_relative "cloud_replay_cli"
 
@@ -8,6 +9,7 @@ module Bitfab
   module ReplayCommand
     CHECK_ARGUMENTS_FLAG = "--check-arguments"
     USAGE = "Usage: bitfab-replay --registry <path> <pipeline> [replay options]"
+    PRINT_API_KEY_FLAG = "--print-api-key"
     HELP = "#{USAGE}\nRun bitfab-replay --registry <path> --help to list replay options.\n#{CloudReplayCli::HINT}"
 
     module_function
@@ -20,6 +22,9 @@ module Bitfab
         raise ArgumentError, "Expected one process assignment path" unless replay_argv.length == 2
         return ReplayProcesses.execute_assignment(registry, replay_argv[1], stderr:)
       end
+      if replay_argv.include?(PRINT_API_KEY_FLAG)
+        return print_api_key(registry, replay_argv - [PRINT_API_KEY_FLAG], stdout:)
+      end
       ReplayProcesses.with_registry(registry_path, replay_argv, stderr:) do
         ReplayCli.run(registry, argv: replay_argv, stdout:, stderr:)
       end
@@ -46,6 +51,13 @@ module Bitfab
       0
     end
 
+    def print_api_key(registry, replay_argv, stdout:)
+      pipeline = ReplayCli.parse(registry, replay_argv.dup).fetch(:pipeline)
+      key = registry.fetch(pipeline).client.send(:lookup_api_key)
+      stdout.puts "#{BITFAB_API_KEY_PREFIX}#{JSON.generate({apiKey: key&.to_s})}"
+      nil
+    end
+
     def parse(argv)
       values = argv.dup
       registry_index = values.index("--registry")

data/lib/bitfab/scenarios.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module Bitfab
+  class Traces
+    def get_scenario(trace_id)
+      @http_client.get(scenario_path(trace_id))["scenario"]
+    end
+
+    def save_scenario(trace_id, name: nil, description: nil, trigger: nil, data: nil, append_data: nil)
+      if !data.nil? && !append_data.nil?
+        raise ArgumentError, "Pass data or append_data, not both: data replaces the saved data whole."
+      end
+
+      payload = {}
+      payload["name"] = name unless name.nil?
+      payload["description"] = description unless description.nil?
+      payload["trigger"] = trigger unless trigger.nil?
+      payload["data"] = data unless data.nil?
+      payload["appendData"] = append_data unless append_data.nil?
+      if payload.empty?
+        raise ArgumentError, "Pass at least one of name, description, trigger, data, or append_data: there is nothing to save otherwise."
+      end
+
+      @http_client.request(scenario_path(trace_id), payload)["scenario"]
+    end
+
+    private
+
+    def scenario_path(trace_id)
+      "/api/sdk/traces/#{URI.encode_www_form_component(trace_id).gsub("+", "%20")}/scenario"
+    end
+  end
+end

data/lib/bitfab/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Bitfab
-  VERSION = "0.64.13"
+  VERSION = "0.64.15"
 end

data/lib/bitfab.rb

@@ -19,6 +19,7 @@ require_relative "bitfab/assertion_categories"
 require_relative "bitfab/organization_members"
 require_relative "bitfab/traces"
 require_relative "bitfab/assertions"
+require_relative "bitfab/scenarios"
 require_relative "bitfab/labels"
 require_relative "bitfab/graders"
 require_relative "bitfab/experiments"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bitfab
 version: !ruby/object:Gem::Version
-  version: 0.64.13
+  version: 0.64.15
 platform: ruby
 authors:
 - Harvest Team
@@ -188,6 +188,7 @@ files:
 - lib/bitfab/replay_memory.rb
 - lib/bitfab/replay_processes.rb
 - lib/bitfab/replay_registry.rb
+- lib/bitfab/scenarios.rb
 - lib/bitfab/seed.rb
 - lib/bitfab/seed_cli.rb
 - lib/bitfab/seed_context.rb