kit

build_coord.c (58191B)

---

 #include <kit/build_coord.h>
 #include <kit/cas.h>
 #include <kit/core.h>
 
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "dist_host.h"
 #include "driver.h"
 #include "env.h"
 #include "env_build.h"
 
 #define BUILD_TOOL "build"
 #define BUILD_DEFAULT_DEF "BUILD.kit"
 #define BUILD_MAX_CONFIG 128u
 #define BUILD_MAX_CONFIG_KEY 64u
 #define BUILD_MAX_ARGS 128u
 
 typedef enum BuildClientFormat {
   BUILD_CLIENT_FORMAT_PATH = 0,
   BUILD_CLIENT_FORMAT_ID = 1,
   BUILD_CLIENT_FORMAT_ID_PATH = 2,
 } BuildClientFormat;
 
 typedef struct BuildCli {
   const char* store;
   const char* root;
   const char* def;
   const char* profile;
   const char* target;
   const char* config_default;
   KitBuildKV config[BUILD_MAX_CONFIG];
   char config_keys[BUILD_MAX_CONFIG][BUILD_MAX_CONFIG_KEY];
   size_t nconfig;
   KitSlice args[BUILD_MAX_ARGS];
   size_t nargs;
   int verify;
   int stats;
   int trace;
   int test_mode;
   int has_config_default;
   int source_optional;
   int has_format;
   BuildClientFormat format;
 } BuildCli;
 
 typedef struct BuildListTarget {
   char label[KIT_BUILD_TARGET_MAX];
 } BuildListTarget;
 
 void driver_help_build(void) {
   driver_printf(
       "kit build - content-addressed build coordinator\n"
       "\n"
       "USAGE\n"
       "  kit build [--store DIR] [--root DIR] [--def FILE] [--profile NAME]\n"
       "            [--config K=V|env.NAME]... [--env NAME[=V]]...\n"
       "            [--verify] [--stats] [--trace] TARGET [-- ARG...]\n"
       "  kit build test [--store DIR] [--root DIR] [--def FILE] [--profile NAME]\n"
       "            [--config K=V|env.NAME]... [--env NAME[=V]]...\n"
       "            [--verify] [--stats] [--trace] TARGET [-- ARG...]\n"
       "  kit build [--root DIR] [--def FILE] list [--scan-do] [//PACKAGE[/...]]\n"
       "  kit build [--root DIR] repo add NAME URL\n"
       "            [--format tar.gz|kpkg] [--strip-prefix DIR]\n"
       "  kit build [--root DIR] repo fetch NAME\n"
       "  kit build [--root DIR] repo list\n"
       "  kit build [--root DIR] workspace package [--format tar.gz] -o OUT\n"
       "  kit build config-get [--default VALUE] KEY # inside a build recipe\n"
       "  kit build source [--optional] [--format path|id|id-path] PATH\n"
       "                                            # inside a build recipe\n"
       "  kit build fetch [--format path|id|id-path] BLOB URL...\n"
       "                                            # inside a build recipe\n"
       "  kit build depfile [--lines] FILE          # inside a build recipe\n"
       "  kit build glob PATTERN                    # inside a build recipe\n"
       "  kit build export-set VAR -- VALUE...      # inside a build recipe\n"
       "  kit build export-get TARGET VAR           # inside a build recipe\n"
       "  kit build export-collect VAR TARGET...    # inside a build recipe\n"
       "  kit build need [--format path|id|id-path]\n"
       "                 [--config K=V|env.NAME]... [--env NAME[=V]]...\n"
       "                 TARGET [-- ARG...]\n"
       "                                            # inside a build recipe\n"
       "  kit build need-submit [--config K=V|env.NAME]... [--env NAME[=V]]...\n"
       "                        TARGET [-- ARG...]\n"
       "                                            # inside a build recipe\n"
       "  kit build need-await [--format path|id|id-path] TOKEN\n"
       "                                            # inside a build recipe\n"
       "\n"
       "BUILD DEFINITIONS AND LABELS\n"
       "  The default package definition is BUILD.kit under --root (or the\n"
       "  basename selected by WORKSPACE.kit). A minimal definition is:\n"
       "\n"
       "    kit-build 1\n"
       "    [target copy]\n"
       "    recipe recipes/copy.sh\n"
       "\n"
       "  The command-line TARGET names a [target NAME] in the current package.\n"
       "  `copy` at the workspace root is rendered canonically as `//:copy` in\n"
       "  traces. Package paths are resolved relative to --root; recipes and\n"
       "  source paths are package-relative. Arguments after -- participate in\n"
       "  the target key and are available to the recipe protocol.\n"
       "\n");
   driver_printf(
       "RECIPE PROTOCOL\n"
       "  A recipe is an executable that writes its output tree below\n"
       "  $KIT_BUILD_OUT. It receives a clean environment containing\n"
       "  KIT_BUILD_SOCK, KIT_BUILD_OUT, KIT_BUILD_TARGET, KIT_BUILD_REPO,\n"
       "  KIT_BUILD_PACKAGE, and KIT_BUILD_LOCAL, plus values explicitly\n"
       "  propagated with --env/--config env.NAME.\n"
       "\n"
       "  Recipe-only `source` records a source dependency and prints its\n"
       "  workspace path or requested id form. `need` records another\n"
       "  target dependency; need-submit/need-await permit parallel requests.\n"
       "  config-get, fetch, depfile, and glob also require KIT_BUILD_SOCK and\n"
       "  are rejected outside a running recipe. export-set publishes ordered\n"
       "  metadata in the output tree; export-get/collect read it through need\n"
       "  dependencies. Use `kit build --client VERB ...` to select recipe\n"
       "  client mode explicitly.\n"
       "\n"
       "WORKSPACE COMMANDS\n"
       "  list prints targets in one package; a trailing /... scans packages\n"
       "  recursively. --scan-do lists Redo-style do/*.do rules instead. repo\n"
       "  add hashes a local path or file:// archive and records the pinned\n"
       "  entry in WORKSPACE.kit. repo fetch validates that a configured name\n"
       "  exists; external content is fetched and materialized when its label is\n"
       "  resolved. repo list prints the configured names, formats, and ids.\n"
       "  workspace package writes the workspace as a tar.gz using the hosted\n"
       "  system tar. Signed kpkg creation is provided by `kit pkg create`.\n"
       "\n"
       "OPTIONS\n"
       "  --store DIR     Build store root (default: Kit platform cache/build)\n"
       "  --root DIR      Workspace root (default: .)\n"
       "  --def FILE      Package build-file basename (alias: --def-name;\n"
       "                  default: WORKSPACE def-name or BUILD.kit)\n"
       "  --profile NAME  Apply WORKSPACE.kit [config NAME] after [config default]\n"
       "  --config K=V    Seed propagated configuration\n"
       "  --config env.N  Seed env.N from current $N\n"
       "  --env N[=V]     Shorthand for --config env.N[=V]\n"
       "  --verify        Verify the returned output tree in the CAS\n"
       "  --trace         Print target-level resolution decisions to stderr\n"
       "  --stats         Print build-resolution counters to stderr\n"
       "  -h, --help      Show this help and exit\n"
       "  --version       Show Kit version and exit\n"
       "\n"
       "OUTPUT AND CACHING\n"
       "  A successful top-level build prints `TREE_ID MATERIALIZED_PATH` to\n"
       "  stdout. --trace/--stats write diagnostics and counters to stderr. The\n"
       "  recipe output tree is content-addressed; an unchanged definition,\n"
       "  configuration, arguments, and recorded dependencies may produce a\n"
       "  deep cache hit with recipes_run=0. --verify checks the returned tree.\n");
   driver_printf(
       "\n"
       "EXAMPLES\n"
       "  mkdir -p demo/recipes\n"
       "  printf '%%s\\n' 'kit-build 1' '[target copy]' \\\n"
       "    'recipe recipes/copy.sh' > demo/BUILD.kit\n"
       "  printf '%%s\\n' '#!/bin/sh' 'set -eu' \\\n"
       "    'printf \"%%s\\n\" built > \"$KIT_BUILD_OUT/result.txt\"' \\\n"
       "    > demo/recipes/copy.sh\n"
       "  chmod +x demo/recipes/copy.sh\n"
       "  kit build --root \"$PWD/demo\" \\\n"
       "    --verify --stats copy\n"
       "  # Repeat the same command to observe a cache hit.\n"
       "\n"
       "EXIT CODES\n"
       "  0   success    1   resolution/recipe/CAS/I/O error    2   bad usage\n");
 }
 
 static const char* build_status_name(KitStatus st) {
   switch (st) {
     case KIT_OK: return "ok";
     case KIT_ERR: return "error";
     case KIT_NOMEM: return "out of memory";
     case KIT_INVALID: return "invalid input";
     case KIT_UNSUPPORTED: return "unsupported";
     case KIT_MALFORMED: return "malformed input";
     case KIT_IO: return "I/O error";
     case KIT_NOT_FOUND: return "not found";
     case KIT_AMBIGUOUS: return "ambiguous input";
   }
   return "error";
 }
 
 static int build_join_path(char* out, size_t cap, const char* a,
                            const char* b) {
   size_t na, nb;
   int sep;
   if (!out || cap == 0u || !a || !b) return 1;
   na = driver_strlen(a);
   nb = driver_strlen(b);
   sep = na > 0u && a[na - 1u] != '/' && a[na - 1u] != '\\';
   if (na + (sep ? 1u : 0u) + nb + 1u > cap) return 1;
   memcpy(out, a, na);
   if (sep) out[na++] = '/';
   memcpy(out + na, b, nb);
   out[na + nb] = '\0';
   return 0;
 }
 
 static int build_def_name_valid(const char* s) {
   size_t i;
   if (!s || !s[0]) return 0;
   for (i = 0; s[i]; ++i) {
     unsigned char c = (unsigned char)s[i];
     if (c == '/' || c == '\\' || c == ':' || c == '\n' || c == '\r')
       return 0;
   }
   return 1;
 }
 
 static int build_load_file(DriverEnv* env, const char* path, DriverLoad* load,
                            KitSlice* bytes) {
   return driver_load_bytes(&env->file_io, BUILD_TOOL, path, load, bytes);
 }
 
 static int build_load_workspace(DriverEnv* env, const char* root,
                                 KitBuildWorkspace* ws, int* present) {
   char path[KIT_BUILD_PATH_MAX];
   DriverLoad load;
   KitSlice bytes;
   char err[256];
   if (present) *present = 0;
   if (build_join_path(path, sizeof path, root, "WORKSPACE.kit") != 0) return 1;
   if (!driver_path_exists(path)) {
     kit_build_workspace_init(ws);
     return 0;
   }
   if (present) *present = 1;
   if (build_load_file(env, path, &load, &bytes) != 0) return 1;
   if (kit_build_workspace_parse(bytes.data, bytes.len, ws, err, sizeof err) !=
       KIT_OK) {
     driver_errf(BUILD_TOOL, "bad WORKSPACE.kit: %s", err);
     driver_release_bytes(&env->file_io, &load);
     return 1;
   }
   driver_release_bytes(&env->file_io, &load);
   return 0;
 }
 
 static int build_file_write(DriverEnv* env, const char* path, const char* text) {
   KitWriter* w = NULL;
   size_t n;
   if (!env || !path || !text) return 1;
   if (env->file_io.open_writer(env->file_io.user, path, &w) != KIT_OK || !w)
     return 1;
   n = driver_strlen(text);
   if ((n && kit_writer_write(w, text, n) != KIT_OK) ||
       kit_writer_status(w) != KIT_OK) {
     kit_writer_close(w);
     return 1;
   }
   kit_writer_close(w);
   return 0;
 }
 
 static int build_file_append(DriverEnv* env, const char* path,
                              const char* text) {
   DriverLoad load;
   KitSlice old = KIT_SLICE_NULL;
   KitWriter* w = NULL;
   size_t n;
   int had_old = 0;
   if (!env || !path || !text) return 1;
   if (driver_path_exists(path)) {
     if (build_load_file(env, path, &load, &old) != 0) return 1;
     had_old = 1;
   }
   if (env->file_io.open_writer(env->file_io.user, path, &w) != KIT_OK || !w) {
     if (had_old) driver_release_bytes(&env->file_io, &load);
     return 1;
   }
   n = driver_strlen(text);
   if ((old.len && kit_writer_write(w, old.data, old.len) != KIT_OK) ||
       (n && kit_writer_write(w, text, n) != KIT_OK) ||
       kit_writer_status(w) != KIT_OK) {
     kit_writer_close(w);
     if (had_old) driver_release_bytes(&env->file_io, &load);
     return 1;
   }
   kit_writer_close(w);
   if (had_old) driver_release_bytes(&env->file_io, &load);
   return 0;
 }
 
 static int build_file_url_path(const char* url, const char** out) {
   if (!url || !out || !driver_strneq(url, "file://", 7u)) return 1;
   *out = url + 7u;
   return 0;
 }
 
 static int build_list_cmp(const void* a, const void* b) {
   const BuildListTarget* la = (const BuildListTarget*)a;
   const BuildListTarget* lb = (const BuildListTarget*)b;
   return strcmp(la->label, lb->label);
 }
 
 static int build_list_add(BuildListTarget* out, size_t* n, size_t cap,
                           const char* label) {
   size_t i;
   if (!out || !n || !label || !label[0]) return 1;
   for (i = 0; i < *n; ++i)
     if (driver_streq(out[i].label, label)) return 0;
   if (*n >= cap || driver_strlen(label) >= sizeof out[0].label) return 1;
   snprintf(out[*n].label, sizeof out[*n].label, "%s", label);
   ++*n;
   return 0;
 }
 
 static void build_pkg_label(char* out, size_t cap, const char* pkg,
                             const char* local) {
   if (pkg && pkg[0])
     snprintf(out, cap, "//%s:%s", pkg, local);
   else
     snprintf(out, cap, "//:%s", local);
 }
 
 static int build_line_next(KitSlice bytes, size_t* pos, KitSlice* line) {
   size_t start = *pos;
   size_t end = start;
   while (end < bytes.len && bytes.s[end] != '\n') ++end;
   if (start >= bytes.len) return 1;
   line->s = bytes.s + start;
   line->len = end - start;
   *pos = end < bytes.len ? end + 1u : end;
   return 0;
 }
 
 static int build_slice_starts(KitSlice s, const char* prefix) {
   size_t n = driver_strlen(prefix);
   return s.len >= n && memcmp(s.s, prefix, n) == 0;
 }
 
 static void build_copy_slice0(char* out, size_t cap, KitSlice s) {
   size_t n = s.len < cap - 1u ? s.len : cap - 1u;
   if (n) memcpy(out, s.s, n);
   out[n] = '\0';
 }
 
 static int build_list_generated_from_projection(DriverEnv* env,
                                                 const char* root,
                                                 const char* pkg,
                                                 KitSlice line,
                                                 BuildListTarget* out,
                                                 size_t* n, size_t cap) {
   char pat[KIT_BUILD_PATH_MAX], tmpl[KIT_BUILD_TARGET_MAX];
   char dir_rel[KIT_BUILD_PATH_MAX], dir_abs[KIT_BUILD_PATH_MAX];
   char prefix[128], suffix[128], label[KIT_BUILD_TARGET_MAX], local[KIT_BUILD_TARGET_MAX];
   DriverDirHandle* dh;
   size_t i, arrow = (size_t)-1, star = (size_t)-1, slash = (size_t)-1;
   if (!build_slice_starts(line, "list ")) return 0;
   line.s += 5u;
   line.len -= 5u;
   for (i = 0; i + 3u <= line.len; ++i) {
     if (line.s[i] == ' ' && line.s[i + 1u] == '-' && line.s[i + 2u] == '>' &&
         line.s[i + 3u] == ' ') {
       arrow = i;
       break;
     }
   }
   if (arrow == (size_t)-1) return 0;
   build_copy_slice0(pat, sizeof pat, (KitSlice){.s = line.s, .len = arrow});
   build_copy_slice0(tmpl, sizeof tmpl,
                     (KitSlice){.s = line.s + arrow + 4u,
                                .len = line.len - arrow - 4u});
   for (i = 0; pat[i]; ++i) {
     if (pat[i] == '*') star = i;
     if (pat[i] == '/') slash = i;
   }
   if (star == (size_t)-1) return 0;
   if (slash != (size_t)-1) {
     snprintf(dir_rel, sizeof dir_rel, "%s/%.*s", pkg,
              (int)slash, pat);
     snprintf(prefix, sizeof prefix, "%.*s", (int)(star - slash - 1u),
              pat + slash + 1u);
   } else {
     snprintf(dir_rel, sizeof dir_rel, "%s", pkg);
     snprintf(prefix, sizeof prefix, "%.*s", (int)star, pat);
   }
   snprintf(suffix, sizeof suffix, "%s", pat + star + 1u);
   if (build_join_path(dir_abs, sizeof dir_abs, root, dir_rel) != 0) return 1;
   dh = driver_open_dir(env, dir_abs);
   if (!dh) return 0;
   for (i = 0;; ++i) {
     const char* name;
     uint32_t name_len;
     uint64_t ino, size, mtime;
     uint8_t ftype;
     size_t pn = driver_strlen(prefix), sn = driver_strlen(suffix);
     char stem[KIT_BUILD_TARGET_MAX];
     if (driver_read_dir_entry(dh, i, &name, &name_len, &ino, &size, &mtime,
                               &ftype) != 0)
       break;
     (void)ino;
     (void)size;
     (void)mtime;
     if (ftype != 4u || name_len < pn + sn ||
         memcmp(name, prefix, pn) != 0 ||
         (sn && memcmp(name + name_len - sn, suffix, sn) != 0))
       continue;
     snprintf(stem, sizeof stem, "%.*s", (int)(name_len - pn - sn),
              name + pn);
     if (driver_streq(tmpl, "{stem}.o"))
       snprintf(local, sizeof local, "%s.o", stem);
     else
       snprintf(local, sizeof local, "%s", stem);
     build_pkg_label(label, sizeof label, pkg, local);
     if (build_list_add(out, n, cap, label) != 0) {
       driver_close_dir(env, dh);
       return 1;
     }
   }
   driver_close_dir(env, dh);
   return 0;
 }
 
 static int build_list_package(DriverEnv* env, const char* root,
                               const char* def_name, const char* pkg,
                               int recursive, BuildListTarget* out, size_t* n,
                               size_t cap) {
   char pkg_dir[KIT_BUILD_PATH_MAX], def_path[KIT_BUILD_PATH_MAX];
   DriverLoad load;
   KitSlice bytes, line;
   size_t pos = 0;
   int in_targets = 0;
   if (build_join_path(pkg_dir, sizeof pkg_dir, root, pkg) != 0 ||
       build_join_path(def_path, sizeof def_path, pkg_dir, def_name) != 0)
     return 1;
   if (driver_path_exists(def_path) &&
       build_load_file(env, def_path, &load, &bytes) == 0) {
     while (build_line_next(bytes, &pos, &line) == 0) {
       if (build_slice_starts(line, "[target ") && line.len > 9u &&
           line.s[line.len - 1u] == ']') {
         char local[KIT_BUILD_TARGET_MAX], label[KIT_BUILD_TARGET_MAX];
         build_copy_slice0(local, sizeof local,
                           (KitSlice){.s = line.s + 8u,
                                      .len = line.len - 9u});
         build_pkg_label(label, sizeof label, pkg, local);
         if (build_list_add(out, n, cap, label) != 0) {
           driver_release_bytes(&env->file_io, &load);
           return 1;
         }
         in_targets = 0;
       } else if (build_slice_starts(line, "[targets ")) {
         in_targets = 1;
       } else if (line.len && line.s[0] == '[') {
         in_targets = 0;
       } else if (in_targets) {
         if (build_list_generated_from_projection(env, root, pkg, line, out, n,
                                                  cap) != 0) {
           driver_release_bytes(&env->file_io, &load);
           return 1;
         }
       }
     }
     driver_release_bytes(&env->file_io, &load);
   }
   if (recursive) {
     DriverDirHandle* dh = driver_open_dir(env, pkg_dir);
     uint64_t idx;
     if (!dh) return 0;
     for (idx = 0;; ++idx) {
       const char* name;
       uint32_t name_len;
       uint64_t ino, size, mtime;
       uint8_t ftype;
       char child_pkg[KIT_BUILD_PATH_MAX], child_dir[KIT_BUILD_PATH_MAX],
           child_def[KIT_BUILD_PATH_MAX];
       if (driver_read_dir_entry(dh, idx, &name, &name_len, &ino, &size, &mtime,
                                 &ftype) != 0)
         break;
       (void)ino;
       (void)size;
       (void)mtime;
       if (ftype != 3u) continue;
       if (pkg && pkg[0])
         snprintf(child_pkg, sizeof child_pkg, "%s/%.*s", pkg, (int)name_len,
                  name);
       else
         snprintf(child_pkg, sizeof child_pkg, "%.*s", (int)name_len, name);
       if (build_join_path(child_dir, sizeof child_dir, root, child_pkg) != 0 ||
           build_join_path(child_def, sizeof child_def, child_dir, def_name) != 0)
         continue;
       if (driver_path_exists(child_def)) {
         if (build_list_package(env, root, def_name, child_pkg, 1, out, n,
                                cap) != 0) {
           driver_close_dir(env, dh);
           return 1;
         }
       }
     }
     driver_close_dir(env, dh);
   }
   return 0;
 }
 
 static int build_add_config(BuildCli* cli, KitSlice key, KitSlice value) {
   if (!cli || !key.s || key.len == 0u || cli->nconfig >= BUILD_MAX_CONFIG)
     return 1;
   cli->config[cli->nconfig].key = key;
   cli->config[cli->nconfig].value = value;
   ++cli->nconfig;
   return 0;
 }
 
 static int build_env_name_valid(const char* name, size_t len) {
   size_t i;
   if (!name || len == 0u) return 0;
   for (i = 0; i < len; ++i) {
     unsigned char c = (unsigned char)name[i];
     if (c == '\0' || c == '=' || c == '\n' || c == '\r') return 0;
   }
   return 1;
 }
 
 static int build_add_env_config(BuildCli* cli, const char* name, size_t name_len,
                                 const char* value) {
   char* key;
   if (!cli || !build_env_name_valid(name, name_len) || !value ||
       cli->nconfig >= BUILD_MAX_CONFIG ||
       sizeof(KIT_BUILD_ENV_PREFIX) - 1u + name_len >= BUILD_MAX_CONFIG_KEY)
     return 1;
   key = cli->config_keys[cli->nconfig];
   memcpy(key, KIT_BUILD_ENV_PREFIX, sizeof(KIT_BUILD_ENV_PREFIX) - 1u);
   memcpy(key + sizeof(KIT_BUILD_ENV_PREFIX) - 1u, name, name_len);
   key[sizeof(KIT_BUILD_ENV_PREFIX) - 1u + name_len] = '\0';
   return build_add_config(cli, kit_slice_cstr(key), kit_slice_cstr(value));
 }
 
 static int build_parse_config(BuildCli* cli, const char* text) {
   const char* eq;
   size_t env_prefix_len = sizeof(KIT_BUILD_ENV_PREFIX) - 1u;
   if (!cli || !text) return 1;
   eq = driver_strchr(text, '=');
   if (!eq) {
     const char* value;
     if (!driver_strneq(text, KIT_BUILD_ENV_PREFIX, env_prefix_len) ||
         text[env_prefix_len] == '\0')
       return 1;
     value = driver_getenv(text + env_prefix_len);
     if (!value) return 1;
     return build_add_config(cli, kit_slice_cstr(text), kit_slice_cstr(value));
   }
   if (eq == text) return 1;
   return build_add_config(cli, (KitSlice){.s = text, .len = (size_t)(eq - text)},
                           kit_slice_cstr(eq + 1));
 }
 
 static int build_parse_env(BuildCli* cli, const char* text) {
   const char* eq;
   if (!cli || !text) return 1;
   eq = driver_strchr(text, '=');
   if (!eq) {
     const char* value = driver_getenv(text);
     if (!value) return 1;
     return build_add_env_config(cli, text, driver_strlen(text), value);
   }
   return build_add_env_config(cli, text, (size_t)(eq - text), eq + 1);
 }
 
 static int build_client_glob_print(void* user, KitSlice path) {
   (void)user;
   driver_printf("%.*s\n", KIT_SLICE_ARG(path));
   return 0;
 }
 
 static int build_client_parse_format(const char* s, BuildClientFormat* out) {
   if (!s || !out) return 1;
   if (driver_streq(s, "path")) {
     *out = BUILD_CLIENT_FORMAT_PATH;
     return 0;
   }
   if (driver_streq(s, "id")) {
     *out = BUILD_CLIENT_FORMAT_ID;
     return 0;
   }
   if (driver_streq(s, "id-path")) {
     *out = BUILD_CLIENT_FORMAT_ID_PATH;
     return 0;
   }
   return 1;
 }
 
 static void build_client_print_value(BuildClientFormat fmt,
                                      const uint8_t id[KIT_BUILD_HASH_LEN],
                                      KitSlice path) {
   char hex[2u * KIT_BUILD_HASH_LEN + 1u];
   if (fmt == BUILD_CLIENT_FORMAT_PATH) {
     driver_printf("%.*s\n", KIT_SLICE_ARG(path));
     return;
   }
   kit_hex_encode(hex, id, KIT_BUILD_HASH_LEN);
   if (fmt == BUILD_CLIENT_FORMAT_ID) {
     driver_printf("%s\n", hex);
     return;
   }
   driver_printf("%s %.*s\n", hex, KIT_SLICE_ARG(path));
 }
 
 static int build_client_verb(const char* s) {
   return driver_streq(s, "config-get") || driver_streq(s, "source") ||
          driver_streq(s, "fetch") || driver_streq(s, "depfile") ||
          driver_streq(s, "glob") || driver_streq(s, "export-set") ||
          driver_streq(s, "export-get") || driver_streq(s, "export-collect") ||
          driver_streq(s, "need") ||
          driver_streq(s, "need-submit") || driver_streq(s, "need-await");
 }
 
 static int build_parse_u64(const char* s, uint64_t* out) {
   uint64_t v = 0;
   size_t i;
   if (!s || !s[0] || !out) return 1;
   for (i = 0; s[i]; ++i) {
     unsigned c = (unsigned char)s[i];
     if (c < '0' || c > '9') return 1;
     if (v > (UINT64_MAX - (uint64_t)(c - '0')) / 10u) return 1;
     v = v * 10u + (uint64_t)(c - '0');
   }
   *out = v;
   return 0;
 }
 
 static int build_client_need_parse(BuildCli* cli, int argc, char** argv,
                                    int first_arg) {
   int i;
   memset(cli, 0, sizeof *cli);
   for (i = first_arg; i < argc; ++i) {
     const char* a = argv[i];
     if (driver_streq(a, "--config") && i + 1 < argc) {
       if (build_parse_config(cli, argv[++i]) != 0) {
         driver_errf(BUILD_TOOL, "bad --config, expected K=V or env.NAME");
         return 2;
       }
     } else if (driver_streq(a, "--env") && i + 1 < argc) {
       if (build_parse_env(cli, argv[++i]) != 0) {
         driver_errf(BUILD_TOOL, "bad --env, expected NAME or NAME=VALUE");
         return 2;
       }
     } else if (driver_streq(a, "--format") && i + 1 < argc) {
       if (build_client_parse_format(argv[++i], &cli->format) != 0) {
         driver_errf(BUILD_TOOL, "bad --format, expected path, id, or id-path");
         return 2;
       }
       cli->has_format = 1;
     } else if (driver_streq(a, "--")) {
       if (!cli->target) {
         driver_errf(BUILD_TOOL, "missing client target before --");
         return 2;
       }
       while (++i < argc) {
         if (cli->nargs >= BUILD_MAX_ARGS) {
           driver_errf(BUILD_TOOL, "too many recipe arguments");
           return 2;
         }
         cli->args[cli->nargs++] = kit_slice_cstr(argv[i]);
       }
       break;
     } else if (driver_streq(a, "--arg") && i + 1 < argc) {
       if (cli->nargs >= BUILD_MAX_ARGS) {
         driver_errf(BUILD_TOOL, "too many --arg values");
         return 2;
       }
       cli->args[cli->nargs++] = kit_slice_cstr(argv[++i]);
     } else if (a[0] == '-') {
       driver_errf(BUILD_TOOL, "unexpected client option: %s", a);
       return 2;
     } else if (!cli->target) {
       cli->target = a;
     } else {
       driver_errf(BUILD_TOOL, "unexpected client argument: %s", a);
       return 2;
     }
   }
   if (!cli->target) {
     driver_errf(BUILD_TOOL, "missing client target");
     return 2;
   }
   return 0;
 }
 
 static int build_export_set(DriverEnv* env, int argc, char** argv,
                             int first_arg) {
   const char* out_dir = driver_getenv(KIT_BUILD_ENV_OUT);
   char kit_dir[KIT_BUILD_PATH_MAX], exports_path[KIT_BUILD_PATH_MAX];
   size_t i;
   if (!out_dir || argc < first_arg + 3 ||
       !driver_streq(argv[first_arg + 1], "--")) {
     driver_errf(BUILD_TOOL, "usage: kit build export-set VAR -- VALUE...");
     return 2;
   }
   if (build_join_path(kit_dir, sizeof kit_dir, out_dir, ".kit") != 0 ||
       build_join_path(exports_path, sizeof exports_path, kit_dir, "exports") !=
           0) {
     driver_errf(BUILD_TOOL, "export path too long");
     return 1;
   }
   if (driver_mkdir_p(env, kit_dir) != 0) {
     driver_errf(BUILD_TOOL, "failed to create exports directory");
     return 1;
   }
   if (!driver_path_exists(exports_path) &&
       build_file_write(env, exports_path, "kit-build-exports 1\n") != 0) {
     driver_errf(BUILD_TOOL, "failed to write exports file");
     return 1;
   }
   {
     char line[KIT_BUILD_VAL_MAX + 32u];
     snprintf(line, sizeof line, "[var %s]\n", argv[first_arg]);
     if (build_file_append(env, exports_path, line) != 0) {
       driver_errf(BUILD_TOOL, "failed to append exports variable");
       return 1;
     }
   }
   for (i = (size_t)first_arg + 2u; i < (size_t)argc; ++i) {
     char line[KIT_BUILD_VAL_MAX + 2u];
     snprintf(line, sizeof line, "%s\n", argv[i]);
     if (build_file_append(env, exports_path, line) != 0) {
       driver_errf(BUILD_TOOL, "failed to append exports value");
       return 1;
     }
   }
   return 0;
 }
 
 static int build_exports_print_var(DriverEnv* env, const char* path,
                                    const char* var) {
   DriverLoad load;
   KitSlice bytes, line;
   size_t pos = 0;
   int active = 0, found = 0;
   if (build_load_file(env, path, &load, &bytes) != 0) return 1;
   while (build_line_next(bytes, &pos, &line) == 0) {
     if (line.len >= 6u && build_slice_starts(line, "[var ") &&
         line.s[line.len - 1u] == ']') {
       KitSlice name = {.s = line.s + 5u, .len = line.len - 6u};
       active = name.len == driver_strlen(var) &&
                memcmp(name.s, var, name.len) == 0;
       if (active) found = 1;
     } else if (active && line.len && line.s[0] != '[') {
       driver_printf("%.*s\n", KIT_SLICE_ARG(line));
     }
   }
   driver_release_bytes(&env->file_io, &load);
   return found ? 0 : 1;
 }
 
 static int build_export_get_one(DriverEnv* env, KitBuildClient* client,
                                 const char* target, const char* var) {
   KitBuildRequest req;
   KitBuildResult result;
   KitStatus st;
   char exports_path[KIT_BUILD_PATH_MAX], kit_dir[KIT_BUILD_PATH_MAX];
   memset(&req, 0, sizeof req);
   req.target = kit_slice_cstr(target);
   st = kit_build_client_need(client, &req, &result);
   if (st != KIT_OK) {
     driver_errf(BUILD_TOOL, "export-get need failed: %s", build_status_name(st));
     return 1;
   }
   if (build_join_path(kit_dir, sizeof kit_dir, result.path, ".kit") != 0 ||
       build_join_path(exports_path, sizeof exports_path, kit_dir, "exports") !=
           0 ||
       build_exports_print_var(env, exports_path, var) != 0) {
     driver_errf(BUILD_TOOL, "export variable not found: %s", var);
     return 1;
   }
   return 0;
 }
 
 static int build_client_mode(int argc, char** argv, int verb_index) {
   DriverEnv env;
   DriverBuildHost bh;
   KitContext ctx;
   KitBuildClient* client = NULL;
   KitStatus st;
   int rc = 1;
   const char* verb;
   int first_arg = verb_index + 1;
   if (argc <= verb_index) {
     driver_errf(BUILD_TOOL, "missing client command");
     return 2;
   }
   verb = argv[verb_index];
   driver_env_init(&env);
   ctx = driver_env_to_context(&env);
   if (driver_streq(verb, "export-set")) {
     rc = build_export_set(&env, argc, argv, first_arg);
     goto out_env;
   }
   if (driver_build_host_init(&bh, &env) != 0) {
     driver_errf(BUILD_TOOL, "hosted build adapter is unavailable");
     goto out_env;
   }
   st = kit_build_client_open(&ctx, &bh.transport, &client);
   if (st != KIT_OK) {
     driver_errf(BUILD_TOOL, "failed to connect to build coordinator: %s",
                 build_status_name(st));
     goto out_host;
   }
   if (driver_streq(verb, "config-get")) {
     KitSlice value;
     int present = 0;
     BuildCli cli;
     int i;
     memset(&cli, 0, sizeof cli);
     for (i = first_arg; i < argc; ++i) {
       if (driver_streq(argv[i], "--default") && i + 1 < argc) {
         cli.has_config_default = 1;
         cli.config_default = argv[++i];
       } else if (argv[i][0] == '-') {
         driver_errf(BUILD_TOOL, "unexpected config-get option: %s", argv[i]);
         rc = 2;
         goto out_client;
       } else if (!cli.target) {
         cli.target = argv[i];
       } else {
         driver_errf(BUILD_TOOL, "unexpected config-get argument: %s", argv[i]);
         rc = 2;
         goto out_client;
       }
     }
     if (!cli.target) {
       driver_errf(BUILD_TOOL, "usage: kit build config-get [--default VALUE] KEY");
       rc = 2;
       goto out_client;
     }
     st = kit_build_client_config_get(
         client, kit_slice_cstr(cli.target),
         cli.has_config_default ? kit_slice_cstr(cli.config_default)
                                : KIT_SLICE_NULL,
         cli.has_config_default, &value, &present);
     if (st != KIT_OK) {
       driver_errf(BUILD_TOOL, "config-get failed: %s", build_status_name(st));
       goto out_client;
     }
     if (!present) {
       if (value.s) {
         driver_printf("%.*s\n", KIT_SLICE_ARG(value));
         rc = 0;
         goto out_client;
       }
       rc = 1;
       goto out_client;
     }
     driver_printf("%.*s\n", KIT_SLICE_ARG(value));
     rc = 0;
   } else if (driver_streq(verb, "source")) {
     uint8_t blob[KIT_BUILD_HASH_LEN];
     KitSlice path;
     BuildCli cli;
     int i;
     memset(&cli, 0, sizeof cli);
     for (i = first_arg; i < argc; ++i) {
       if (driver_streq(argv[i], "--optional")) {
         cli.source_optional = 1;
       } else if (driver_streq(argv[i], "--format") && i + 1 < argc) {
         if (build_client_parse_format(argv[++i], &cli.format) != 0) {
           driver_errf(BUILD_TOOL, "bad --format, expected path, id, or id-path");
           rc = 2;
           goto out_client;
         }
       } else if (argv[i][0] == '-') {
         driver_errf(BUILD_TOOL, "unexpected source option: %s", argv[i]);
         rc = 2;
         goto out_client;
       } else if (!cli.target) {
         cli.target = argv[i];
       } else {
         driver_errf(BUILD_TOOL, "unexpected source argument: %s", argv[i]);
         rc = 2;
         goto out_client;
       }
     }
     if (!cli.target) {
       driver_errf(BUILD_TOOL,
                   "usage: kit build source [--optional] "
                   "[--format path|id|id-path] PATH");
       rc = 2;
       goto out_client;
     }
     st = kit_build_client_source(client, kit_slice_cstr(cli.target), blob, &path);
     if (st == KIT_NOT_FOUND && cli.source_optional) {
       rc = 0;
       goto out_client;
     }
     if (st != KIT_OK) {
       driver_errf(BUILD_TOOL, "source failed: %s", build_status_name(st));
       goto out_client;
     }
     build_client_print_value(cli.format, blob, path);
     rc = 0;
   } else if (driver_streq(verb, "fetch")) {
     uint8_t blob[KIT_BUILD_HASH_LEN];
     KitSlice urls[BUILD_MAX_ARGS];
     KitSlice path;
     size_t nurls = 0;
     int i;
     BuildCli cli;
     int blob_arg = 0;
     memset(&cli, 0, sizeof cli);
     for (i = first_arg; i < argc; ++i) {
       if (driver_streq(argv[i], "--format") && i + 1 < argc) {
         if (build_client_parse_format(argv[++i], &cli.format) != 0) {
           driver_errf(BUILD_TOOL, "bad --format, expected path, id, or id-path");
           rc = 2;
           goto out_client;
         }
       } else if (!blob_arg) {
         blob_arg = i;
       } else {
         if (nurls >= BUILD_MAX_ARGS) {
           driver_errf(BUILD_TOOL, "too many fetch URLs");
           rc = 2;
           goto out_client;
         }
         urls[nurls++] = kit_slice_cstr(argv[i]);
       }
     }
     if (!blob_arg || nurls == 0u ||
         driver_strlen(argv[blob_arg]) != 2u * KIT_BUILD_HASH_LEN ||
         kit_hex_decode(blob, argv[blob_arg], KIT_BUILD_HASH_LEN) != KIT_OK) {
       driver_errf(BUILD_TOOL,
                   "usage: kit build fetch [--format path|id|id-path] BLOB URL...");
       rc = 2;
       goto out_client;
     }
     st = kit_build_client_fetch(client, blob, urls, nurls, &path);
     if (st != KIT_OK) {
       driver_errf(BUILD_TOOL, "fetch failed: %s", build_status_name(st));
       goto out_client;
     }
     build_client_print_value(cli.format, blob, path);
     rc = 0;
   } else if (driver_streq(verb, "depfile")) {
     DriverLoad load;
     KitSlice depfile;
     uint32_t depfile_flags = KIT_BUILD_DEPFILE_DEFAULT;
     int file_arg = first_arg;
     if (argc == first_arg + 2 && driver_streq(argv[first_arg], "--lines")) {
       depfile_flags = KIT_BUILD_DEPFILE_LINES;
       file_arg = first_arg + 1;
     } else if (argc != first_arg + 1) {
       driver_errf(BUILD_TOOL, "usage: kit build depfile [--lines] FILE");
       rc = 2;
       goto out_client;
     }
     if (driver_load_bytes(&env.file_io, BUILD_TOOL, argv[file_arg], &load,
                           &depfile) != 0) {
       rc = 1;
       goto out_client;
     }
     st = kit_build_client_depfile_ex(client, depfile, depfile_flags);
     driver_release_bytes(&env.file_io, &load);
     if (st != KIT_OK) {
       driver_errf(BUILD_TOOL, "depfile failed: %s", build_status_name(st));
       goto out_client;
     }
     rc = 0;
   } else if (driver_streq(verb, "glob")) {
     if (argc != first_arg + 1) {
       driver_errf(BUILD_TOOL, "usage: kit build glob PATTERN");
       rc = 2;
       goto out_client;
     }
     st = kit_build_client_glob(client, kit_slice_cstr(argv[first_arg]),
                                build_client_glob_print, NULL);
     if (st != KIT_OK) {
       driver_errf(BUILD_TOOL, "glob failed: %s", build_status_name(st));
       goto out_client;
     }
     rc = 0;
   } else if (driver_streq(verb, "need")) {
     BuildCli cli;
     KitBuildRequest req;
     KitBuildResult result;
     rc = build_client_need_parse(&cli, argc, argv, first_arg);
     if (rc != 0) goto out_client;
     memset(&req, 0, sizeof req);
     req.target = kit_slice_cstr(cli.target);
     req.config = cli.config;
     req.nconfig = cli.nconfig;
     req.argv = cli.args;
     req.argc = cli.nargs;
     st = kit_build_client_need(client, &req, &result);
     if (st != KIT_OK) {
       driver_errf(BUILD_TOOL, "need failed: %s", build_status_name(st));
       rc = 1;
       goto out_client;
     }
     build_client_print_value(cli.format, result.output_tree,
                              kit_slice_cstr(result.path));
     rc = 0;
   } else if (driver_streq(verb, "need-submit")) {
     BuildCli cli;
     KitBuildRequest req;
     KitBuildNeedToken token;
     rc = build_client_need_parse(&cli, argc, argv, first_arg);
     if (rc != 0) goto out_client;
     if (cli.has_format) {
       driver_errf(BUILD_TOOL, "need-submit does not support --format");
       rc = 2;
       goto out_client;
     }
     memset(&req, 0, sizeof req);
     req.target = kit_slice_cstr(cli.target);
     req.config = cli.config;
     req.nconfig = cli.nconfig;
     req.argv = cli.args;
     req.argc = cli.nargs;
     st = kit_build_client_need_submit(client, &req, &token);
     if (st != KIT_OK) {
       driver_errf(BUILD_TOOL, "need-submit failed: %s",
                   build_status_name(st));
       rc = 1;
       goto out_client;
     }
     driver_printf("%llu\n", (unsigned long long)token.id);
     rc = 0;
   } else if (driver_streq(verb, "need-await")) {
     KitBuildNeedToken token;
     KitBuildResult result;
     BuildCli cli;
     const char* token_arg = NULL;
     int i;
     memset(&cli, 0, sizeof cli);
     for (i = first_arg; i < argc; ++i) {
       if (driver_streq(argv[i], "--format") && i + 1 < argc) {
         if (build_client_parse_format(argv[++i], &cli.format) != 0) {
           driver_errf(BUILD_TOOL, "bad --format, expected path, id, or id-path");
           rc = 2;
           goto out_client;
         }
       } else if (argv[i][0] == '-') {
         driver_errf(BUILD_TOOL, "unexpected need-await option: %s", argv[i]);
         rc = 2;
         goto out_client;
       } else if (!token_arg) {
         token_arg = argv[i];
       } else {
         driver_errf(BUILD_TOOL, "unexpected need-await argument: %s", argv[i]);
         rc = 2;
         goto out_client;
       }
     }
     if (!token_arg || build_parse_u64(token_arg, &token.id) != 0) {
       driver_errf(BUILD_TOOL,
                   "usage: kit build need-await [--format path|id|id-path] TOKEN");
       rc = 2;
       goto out_client;
     }
     st = kit_build_client_need_await(client, token, &result);
     if (st != KIT_OK) {
       driver_errf(BUILD_TOOL, "need-await failed: %s", build_status_name(st));
       rc = 1;
       goto out_client;
     }
     build_client_print_value(cli.format, result.output_tree,
                              kit_slice_cstr(result.path));
     rc = 0;
   } else if (driver_streq(verb, "export-get")) {
     if (argc != first_arg + 2) {
       driver_errf(BUILD_TOOL, "usage: kit build export-get TARGET VAR");
       rc = 2;
       goto out_client;
     }
     rc = build_export_get_one(&env, client, argv[first_arg],
                               argv[first_arg + 1]);
   } else if (driver_streq(verb, "export-collect")) {
     int i;
     if (argc < first_arg + 2) {
       driver_errf(BUILD_TOOL, "usage: kit build export-collect VAR TARGET...");
       rc = 2;
       goto out_client;
     }
     rc = 0;
     for (i = first_arg + 1; i < argc; ++i) {
       if (build_export_get_one(&env, client, argv[i], argv[first_arg]) != 0)
         rc = 1;
     }
   } else {
     driver_errf(BUILD_TOOL, "unknown client command: %s", verb);
     rc = 2;
   }
 
 out_client:
   kit_build_client_close(client);
 out_host:
   driver_build_host_fini(&bh);
 out_env:
   driver_env_fini(&env);
   return rc;
 }
 
 static int build_parse_args(BuildCli* cli, int argc, char** argv, int first_arg,
                             int test_mode) {
   int i;
   memset(cli, 0, sizeof *cli);
   cli->root = ".";
   cli->test_mode = test_mode;
   for (i = first_arg; i < argc; ++i) {
     const char* a = argv[i];
     if (driver_streq(a, "--store") && i + 1 < argc) {
       cli->store = argv[++i];
     } else if (driver_streq(a, "--root") && i + 1 < argc) {
       cli->root = argv[++i];
     } else if ((driver_streq(a, "--def") || driver_streq(a, "--def-name")) &&
                i + 1 < argc) {
       cli->def = argv[++i];
     } else if (driver_streq(a, "--profile") && i + 1 < argc) {
       cli->profile = argv[++i];
     } else if (driver_streq(a, "--config") && i + 1 < argc) {
       const char* opt = argv[++i];
       if (build_parse_config(cli, opt) != 0) {
         driver_errf(BUILD_TOOL,
                     "bad --config '%s', expected K=V or env.NAME", opt);
         return 2;
       }
     } else if (driver_streq(a, "--env") && i + 1 < argc) {
       const char* opt = argv[++i];
       if (build_parse_env(cli, opt) != 0) {
         driver_errf(BUILD_TOOL, "bad --env '%s', expected NAME or NAME=VALUE",
                     opt);
         return 2;
       }
     } else if (driver_streq(a, "--")) {
       if (!cli->target) {
         driver_errf(BUILD_TOOL, "missing target before --");
         return 2;
       }
       while (++i < argc) {
         if (cli->nargs >= BUILD_MAX_ARGS) {
           driver_errf(BUILD_TOOL, "too many recipe arguments");
           return 2;
         }
         cli->args[cli->nargs++] = kit_slice_cstr(argv[i]);
       }
       break;
     } else if (driver_streq(a, "--arg") && i + 1 < argc) {
       if (cli->nargs >= BUILD_MAX_ARGS) {
         driver_errf(BUILD_TOOL, "too many --arg values");
         return 2;
       }
       cli->args[cli->nargs++] = kit_slice_cstr(argv[++i]);
     } else if (driver_streq(a, "--stats")) {
       cli->stats = 1;
     } else if (driver_streq(a, "--trace")) {
       cli->trace = 1;
     } else if (driver_streq(a, "--verify")) {
       cli->verify = 1;
     } else if (a[0] == '-') {
       driver_errf(BUILD_TOOL, "unexpected option: %s", a);
       return 2;
     } else if (!cli->target) {
       cli->target = a;
     } else {
       driver_errf(BUILD_TOOL, "unexpected argument: %s", a);
       return 2;
     }
   }
   if (!cli->target) {
     driver_errf(BUILD_TOOL, "missing target");
     return 2;
   }
   if (cli->def && !build_def_name_valid(cli->def)) {
     driver_errf(BUILD_TOOL, "bad def-name: %s", cli->def);
     return 2;
   }
   return 0;
 }
 
 static void build_trace_stderr(void* user, KitSlice line) {
   (void)user;
   driver_errf(BUILD_TOOL, "trace %.*s", KIT_SLICE_ARG(line));
 }
 
 static void build_print_stats(const KitBuildStats* s) {
   if (!s) return;
   driver_errf(BUILD_TOOL,
               "stats deep_hits=%llu shallow_hits=%llu recipes_run=%llu "
               "materialize_misses=%llu object_fetches=%llu trace_pulls=%llu "
               "test_runs=%llu test_cache_hits=%llu test_failures=%llu",
               (unsigned long long)s->deep_hits,
               (unsigned long long)s->shallow_hits,
               (unsigned long long)s->recipes_run,
               (unsigned long long)s->materialize_misses,
               (unsigned long long)s->object_fetches,
               (unsigned long long)s->trace_pulls,
               (unsigned long long)s->test_runs,
               (unsigned long long)s->test_cache_hits,
               (unsigned long long)s->test_failures);
 }
 
 static int build_verify_tree(DriverEnv* env, const char* store,
                              const uint8_t tree[KIT_BUILD_HASH_LEN]) {
   KitContext ctx = driver_env_to_context(env);
   KitCasHost cas_host = driver_cas_host(env);
   KitCas* cas = NULL;
   char cas_root[KIT_BUILD_PATH_MAX];
   KitStatus st;
   if (build_join_path(cas_root, sizeof cas_root, store, "cas") != 0) {
     driver_errf(BUILD_TOOL, "store path is too long");
     return 1;
   }
   st = kit_cas_open(&ctx, &cas_host, cas_root, &cas);
   if (st == KIT_OK) st = kit_cas_verify_tree(cas, tree);
   if (cas) kit_cas_close(cas);
   if (st != KIT_OK) {
     driver_errf(BUILD_TOOL, "output tree verification failed: %s",
                 build_status_name(st));
     return 1;
   }
   return 0;
 }
 
 static int build_find_top_command(int argc, char** argv) {
   int i;
   for (i = 1; i < argc; ++i) {
     if ((driver_streq(argv[i], "--store") || driver_streq(argv[i], "--root") ||
          driver_streq(argv[i], "--def") || driver_streq(argv[i], "--def-name") ||
          driver_streq(argv[i], "--profile") || driver_streq(argv[i], "--config") ||
          driver_streq(argv[i], "--env")) &&
         i + 1 < argc) {
       ++i;
       continue;
     }
     if (driver_streq(argv[i], "--stats") || driver_streq(argv[i], "--trace") ||
         driver_streq(argv[i], "--verify"))
       continue;
     if (driver_streq(argv[i], "list") || driver_streq(argv[i], "repo") ||
         driver_streq(argv[i], "workspace"))
       return i;
     return -1;
   }
   return -1;
 }
 
 static void build_global_option_defaults(int argc, char** argv, int cmd_index,
                                          const char** root,
                                          const char** def_name,
                                          const char** store) {
   int i;
   (void)argc;
   *root = ".";
   *def_name = BUILD_DEFAULT_DEF;
   *store = NULL;
   for (i = 1; i < cmd_index; ++i) {
     if (driver_streq(argv[i], "--root") && i + 1 < cmd_index) {
       *root = argv[++i];
     } else if ((driver_streq(argv[i], "--def") ||
                 driver_streq(argv[i], "--def-name")) &&
                i + 1 < cmd_index) {
       *def_name = argv[++i];
     } else if (driver_streq(argv[i], "--store") && i + 1 < cmd_index) {
       *store = argv[++i];
     } else if ((driver_streq(argv[i], "--profile") ||
                 driver_streq(argv[i], "--config") ||
                 driver_streq(argv[i], "--env")) &&
                i + 1 < cmd_index) {
       ++i;
     }
   }
 }
 
 static int build_cmd_list(int argc, char** argv, int cmd_index) {
   DriverEnv env;
   const char *root, *def_name, *store_ignored;
   const char* pattern = "//...";
   int scan_do = 0;
   int i, recursive = 0;
   char pkg[KIT_BUILD_PATH_MAX];
   BuildListTarget targets[512];
   size_t ntargets = 0, j;
   (void)store_ignored;
   build_global_option_defaults(argc, argv, cmd_index, &root, &def_name,
                                &store_ignored);
   if (!build_def_name_valid(def_name)) {
     driver_errf(BUILD_TOOL, "bad def-name");
     return 2;
   }
   for (i = cmd_index + 1; i < argc; ++i) {
     if (driver_streq(argv[i], "--scan-do")) {
       scan_do = 1;
     } else if (argv[i][0] == '-') {
       driver_errf(BUILD_TOOL, "unexpected list option: %s", argv[i]);
       return 2;
     } else {
       pattern = argv[i];
     }
   }
   memset(pkg, 0, sizeof pkg);
   if (!driver_strneq(pattern, "//", 2u)) {
     driver_errf(BUILD_TOOL, "list pattern must be //pkg or //pkg/...");
     return 2;
   }
   {
     const char* body = pattern + 2u;
     size_t len = driver_strlen(body);
     if (len >= 4u && driver_streq(body + len - 4u, "/...")) {
       recursive = 1;
       len -= 4u;
     }
     if (len >= sizeof pkg) return 2;
     memcpy(pkg, body, len);
     pkg[len] = '\0';
   }
   driver_env_init(&env);
   if (scan_do) {
     char pkg_dir[KIT_BUILD_PATH_MAX], do_dir[KIT_BUILD_PATH_MAX];
     DriverDirHandle* dh;
     if (build_join_path(pkg_dir, sizeof pkg_dir, root, pkg) != 0 ||
         build_join_path(do_dir, sizeof do_dir, pkg_dir, "do") != 0) {
       driver_env_fini(&env);
       return 1;
     }
     dh = driver_open_dir(&env, do_dir);
     if (dh) {
       uint64_t idx;
       for (idx = 0;; ++idx) {
         const char* name;
         uint32_t name_len;
         uint64_t ino, size, mtime;
         uint8_t ftype;
         if (driver_read_dir_entry(dh, idx, &name, &name_len, &ino, &size,
                                   &mtime, &ftype) != 0)
           break;
         (void)ino;
         (void)size;
         (void)mtime;
         if (ftype == 4u && name_len > 3u &&
             memcmp(name + name_len - 3u, ".do", 3u) == 0)
           driver_printf("//%s:%.*s %.*s\n", pkg, (int)name_len, name,
                         (int)name_len, name);
       }
       driver_close_dir(&env, dh);
     }
   } else if (build_list_package(&env, root, def_name, pkg, recursive, targets,
                                 &ntargets,
                                 sizeof targets / sizeof targets[0]) != 0) {
     driver_env_fini(&env);
     return 1;
   }
   qsort(targets, ntargets, sizeof targets[0], build_list_cmp);
   for (j = 0; j < ntargets; ++j) driver_printf("%s\n", targets[j].label);
   driver_env_fini(&env);
   return 0;
 }
 
 static int build_cmd_repo(int argc, char** argv, int cmd_index) {
   DriverEnv env;
   const char *root, *def_name_ignored, *store_ignored;
   KitBuildWorkspace ws;
   int present = 0;
   size_t i;
   (void)def_name_ignored;
   (void)store_ignored;
   if (argc <= cmd_index + 1) {
     driver_errf(BUILD_TOOL, "usage: kit build repo {add|fetch|list}");
     return 2;
   }
   build_global_option_defaults(argc, argv, cmd_index, &root, &def_name_ignored,
                                &store_ignored);
   driver_env_init(&env);
   if (build_load_workspace(&env, root, &ws, &present) != 0) {
     driver_env_fini(&env);
     return 1;
   }
   if (driver_streq(argv[cmd_index + 1], "list")) {
     for (i = 0; i < ws.n_externals; ++i) {
       char hex[KIT_BUILD_HEX_LEN];
       const char* fmt = ws.externals[i].format == KIT_BUILD_WS_EXT_TREE
                             ? "tree"
                             : ws.externals[i].format == KIT_BUILD_WS_EXT_TARGZ
                                   ? "tar.gz"
                                   : "kpkg";
       kit_hex_encode(hex, ws.externals[i].archive, KIT_BUILD_HASH_LEN);
       driver_printf("%s %s %s\n", ws.externals[i].name, fmt, hex);
     }
   } else if (driver_streq(argv[cmd_index + 1], "fetch")) {
     if (argc <= cmd_index + 2) {
       driver_errf(BUILD_TOOL, "usage: kit build repo fetch NAME");
       driver_env_fini(&env);
       return 2;
     }
     if (!kit_build_workspace_external_find(&ws, kit_slice_cstr(argv[cmd_index + 2]))) {
       driver_errf(BUILD_TOOL, "unknown external repo: %s", argv[cmd_index + 2]);
       driver_env_fini(&env);
       return 1;
     }
     driver_printf("%s\n", argv[cmd_index + 2]);
   } else if (driver_streq(argv[cmd_index + 1], "add")) {
     const char* name;
     const char* url;
     const char* src;
     const char* format = "tar.gz";
     const char* strip = NULL;
     char ws_path[KIT_BUILD_PATH_MAX], line[2048], hex[KIT_BUILD_HEX_LEN];
     DriverLoad load;
     KitSlice bytes;
     KitBlobInfo bi;
     int a;
     if (argc <= cmd_index + 3) {
       driver_errf(BUILD_TOOL, "usage: kit build repo add NAME URL");
       driver_env_fini(&env);
       return 2;
     }
     name = argv[cmd_index + 2];
     url = argv[cmd_index + 3];
     for (a = cmd_index + 4; a < argc; ++a) {
       if (driver_streq(argv[a], "--format") && a + 1 < argc) {
         format = argv[++a];
       } else if (driver_streq(argv[a], "--strip-prefix") && a + 1 < argc) {
         strip = argv[++a];
       }
     }
     if (build_file_url_path(url, &src) != 0 ||
         build_load_file(&env, src, &load, &bytes) != 0) {
       driver_env_fini(&env);
       return 1;
     }
     kit_blob_info(&bi, bytes.data, bytes.len);
     driver_release_bytes(&env.file_io, &load);
     kit_hex_encode(hex, bi.id, KIT_BUILD_HASH_LEN);
     if (build_join_path(ws_path, sizeof ws_path, root, "WORKSPACE.kit") != 0) {
       driver_env_fini(&env);
       return 1;
     }
     snprintf(line, sizeof line,
              "\n[external %s]\nformat %s\narchive %s\nurl %s\n", name, format,
              hex, url);
     if (build_file_append(&env, ws_path, line) != 0 ||
         (strip && (snprintf(line, sizeof line, "strip-prefix %s\n", strip),
                    build_file_append(&env, ws_path, line) != 0))) {
       driver_env_fini(&env);
       return 1;
     }
     driver_printf("%s %s\n", name, hex);
   } else {
     driver_errf(BUILD_TOOL, "unknown repo command: %s", argv[cmd_index + 1]);
     driver_env_fini(&env);
     return 2;
   }
   driver_env_fini(&env);
   return 0;
 }
 
 static int build_cmd_workspace(int argc, char** argv, int cmd_index) {
   DriverEnv env;
   DriverBuildHost bh;
   const char *root, *def_name_ignored, *store_ignored;
   const char* out = NULL;
   const char* format = "tar.gz";
   const char* tar_paths[] = {"/usr/bin/tar", "/bin/tar"};
   KitBuildKV envv[1];
   KitBuildProc* proc = NULL;
   int exit_code = 127;
   int ran = 0;
   int i;
   (void)def_name_ignored;
   (void)store_ignored;
   if (argc <= cmd_index + 1 || !driver_streq(argv[cmd_index + 1], "package")) {
     driver_errf(BUILD_TOOL, "usage: kit build workspace package -o OUT");
     return 2;
   }
   build_global_option_defaults(argc, argv, cmd_index, &root, &def_name_ignored,
                                &store_ignored);
   for (i = cmd_index + 2; i < argc; ++i) {
     if (driver_streq(argv[i], "--format") && i + 1 < argc)
       format = argv[++i];
     else if (driver_streq(argv[i], "-o") && i + 1 < argc)
       out = argv[++i];
   }
   if (!out || !driver_streq(format, "tar.gz")) {
     driver_errf(BUILD_TOOL, "workspace package supports --format tar.gz -o OUT");
     return 2;
   }
   driver_env_init(&env);
   if (driver_build_host_init(&bh, &env) != 0) {
     driver_env_fini(&env);
     return 1;
   }
   envv[0].key = kit_slice_cstr("COPYFILE_DISABLE");
   envv[0].value = kit_slice_cstr("1");
   for (i = 0; i < (int)(sizeof tar_paths / sizeof tar_paths[0]); ++i) {
     KitSlice tar_argv[6];
     tar_argv[0] = kit_slice_cstr(tar_paths[i]);
     tar_argv[1] = kit_slice_cstr("--format");
     tar_argv[2] = kit_slice_cstr("ustar");
     tar_argv[3] = kit_slice_cstr("-czf");
     tar_argv[4] = kit_slice_cstr(out);
     tar_argv[5] = kit_slice_cstr(".");
     proc = NULL;
     {
       KitExecOpts eo;
       memset(&eo, 0, sizeof eo);
       eo.argv = tar_argv;
       eo.argc = 6u;
       eo.env = envv;
       eo.nenv = 1u;
       eo.cwd = kit_slice_cstr(root);
       if (bh.exec.spawn(bh.exec.user, &eo, &proc) != 0) continue;
     }
     ran = 1;
     if (bh.exec.wait(bh.exec.user, proc, &exit_code, NULL, NULL) != 0) {
       driver_build_host_fini(&bh);
       driver_env_fini(&env);
       return 1;
     }
     if (exit_code != 127) break;
   }
   driver_build_host_fini(&bh);
   driver_env_fini(&env);
   if (!ran || exit_code != 0) {
     driver_errf(BUILD_TOOL, "workspace package failed");
     return 1;
   }
   driver_printf("%s\n", out);
   return 0;
 }
 
 int driver_build(int argc, char** argv) {
   DriverEnv env;
   DriverBuildHost bh;
   BuildCli cli;
   KitContext ctx;
   KitBuildOptions opts;
   KitBuildRequest req;
   KitBuildResult result;
   KitBuildTestResult test_result;
   KitBuildCoordinator* coord = NULL;
   KitStatus st;
   char* default_store = NULL;
   size_t default_store_size = 0;
   char* abs_store = NULL;
   char* abs_root = NULL;
   size_t abs_store_size = 0;
   size_t abs_root_size = 0;
   char hex[2u * KIT_BUILD_HASH_LEN + 1u];
   int rc;
 
   if (argc < 2 || driver_argv_wants_help(argc, argv, 1)) {
     driver_help_build();
     return 0;
   }
   if (argc >= 2 && driver_streq(argv[1], "--client"))
     return build_client_mode(argc, argv, 2);
   if (argc >= 2 && driver_getenv(KIT_BUILD_ENV_SOCK) &&
       build_client_verb(argv[1]))
     return build_client_mode(argc, argv, 1);
   {
     int cmd_index = build_find_top_command(argc, argv);
     if (cmd_index >= 0) {
       if (driver_streq(argv[cmd_index], "list"))
         return build_cmd_list(argc, argv, cmd_index);
       if (driver_streq(argv[cmd_index], "repo"))
         return build_cmd_repo(argc, argv, cmd_index);
       if (driver_streq(argv[cmd_index], "workspace"))
         return build_cmd_workspace(argc, argv, cmd_index);
     }
   }
 
   rc = build_parse_args(&cli, argc, argv,
                         argc >= 2 && driver_streq(argv[1], "test") ? 2 : 1,
                         argc >= 2 && driver_streq(argv[1], "test"));
   if (rc != 0) return rc;
 
   driver_env_init(&env);
   if (!cli.store) {
     default_store = driver_path_join(&env, env.cache_dir, "build",
                                      &default_store_size);
     if (!default_store) {
       driver_errf(BUILD_TOOL, "out of memory");
       driver_env_fini(&env);
       return 1;
     }
     cli.store = default_store;
   }
 
   ctx = driver_env_to_context(&env);
   if (driver_build_host_init(&bh, &env) != 0) {
     driver_errf(BUILD_TOOL, "hosted build adapter is unavailable");
     rc = 1;
     goto out_env;
   }
   abs_store = driver_build_host_abs_path(&env, cli.store, &abs_store_size);
   abs_root = driver_build_host_abs_path(&env, cli.root, &abs_root_size);
   if (!abs_store || !abs_root) {
     driver_errf(BUILD_TOOL, "failed to resolve build paths");
     rc = 1;
     goto out_host_only;
   }
 
   memset(&opts, 0, sizeof opts);
   opts.workspace_root = kit_slice_cstr(abs_root);
   opts.build_def_path = cli.def ? kit_slice_cstr(cli.def) : KIT_SLICE_NULL;
   opts.profile = cli.profile ? kit_slice_cstr(cli.profile) : KIT_SLICE_NULL;
   opts.jobs = 1;
   opts.verify = cli.verify;
   if (cli.trace) opts.trace = build_trace_stderr;
 
   st = kit_build_coordinator_open(&ctx, &bh.host, kit_slice_cstr(abs_store),
                                   &opts, &coord);
   if (st != KIT_OK) {
     driver_errf(BUILD_TOOL, "failed to open coordinator: %s",
                 build_status_name(st));
     rc = st == KIT_INVALID || st == KIT_MALFORMED ? 2 : 1;
     goto out;
   }
 
   memset(&req, 0, sizeof req);
   req.target = kit_slice_cstr(cli.target);
   req.config = cli.config;
   req.nconfig = cli.nconfig;
   req.argv = cli.args;
   req.argc = cli.nargs;
   memset(&result, 0, sizeof result);
   memset(&test_result, 0, sizeof test_result);
   st = cli.test_mode ? kit_build_test(coord, &req, &test_result)
                      : kit_build(coord, &req, &result);
   if (st != KIT_OK) {
     driver_errf(BUILD_TOOL, "%s failed: %s",
                 cli.test_mode ? "build test" : "build",
                 build_status_name(st));
     rc = 1;
     goto out;
   }
   if (cli.stats) {
     KitBuildStats stats;
     kit_build_stats(coord, &stats);
     build_print_stats(&stats);
   }
 
   if (cli.verify &&
       build_verify_tree(&env, abs_store,
                         cli.test_mode ? test_result.result_tree
                                       : result.output_tree) != 0) {
     rc = 1;
     goto out;
   }
 
   if (cli.test_mode) {
     kit_hex_encode(hex, test_result.result_tree, KIT_BUILD_HASH_LEN);
     driver_printf("%s %s %s\n",
                   test_result.status == KIT_TEST_PASS ? "PASS" : "FAIL", hex,
                   test_result.path);
     rc = test_result.status == KIT_TEST_PASS ? 0 : 1;
   } else {
     kit_hex_encode(hex, result.output_tree, KIT_BUILD_HASH_LEN);
     driver_printf("%s %s\n", hex, result.path);
     rc = 0;
   }
 
 out:
   if (coord) kit_build_coordinator_close(coord);
 out_host_only:
   if (abs_store) driver_free(&env, abs_store, abs_store_size);
   if (abs_root) driver_free(&env, abs_root, abs_root_size);
   driver_build_host_fini(&bh);
 out_env:
   if (default_store) driver_free(&env, default_store, default_store_size);
   driver_env_fini(&env);
   return rc;
 }