@kitman-sh/cli 0.9.0 → 0.10.53

package/dist/chunk-jagzz148.js

@@ -0,0 +1,527 @@
+// @bun
+import {
+  isString2,
+  hasProperty,
+  isTagged,
+  Reference,
+  all3,
+  forEach,
+  succeed6,
+  gen,
+  fail7,
+  flatMap3,
+  map8,
+  catchTags,
+  mapError2,
+  orDie,
+  ignore,
+  orElseSucceed,
+  provide3,
+  scoped,
+  acquireRelease,
+  encode2,
+  decodeUnknownEffect2,
+  decodeEffect,
+  optionalKey,
+  String4,
+  Struct,
+  Record,
+  Union,
+  fromJsonString,
+  TaggedError2,
+  toCodecJson,
+  Json,
+  encodePrettyJsonString
+} from "./chunk-mbctzx7e.js";
+import"./chunk-arvwar2c.js";
+import {
+  canonicalJson,
+  digestSha256,
+  schemaBodyJson,
+  filterStatusOk,
+  get2,
+  layer2,
+  kitmanMcpServer,
+  RunnerRpcProtocolVersion
+} from "./chunk-wh1pa2aa.js";
+import {
+  decodeText,
+  mkString,
+  FileSystem,
+  Path,
+  withDefault,
+  String2
+} from "./chunk-11p4wf6n.js";
+import {
+  Packument,
+  tarballMatches
+} from "./chunk-g5bs3f6z.js";
+import"./chunk-pp1p3g6e.js";
+import"./chunk-ctasxxz5.js";
+import {
+  AgentDeclaration,
+  KitDeclarations
+} from "./chunk-txwt6r25.js";
+import {
+  describeFlag,
+  Described
+} from "./chunk-jfvq7s24.js";
+import"./chunk-x9dhxfts.js";
+import {
+  ChildProcessSpawner,
+  make7
+} from "./chunk-3bj7sc3v.js";
+import"./chunk-1mc9vgcr.js";
+import"./chunk-z821b2gp.js";
+
+// packages/sdk/src/build/index.ts
+class DependencyInstallFailed extends TaggedError2()("DependencyInstallFailed", {
+  reason: String4
+}) {
+  get message() {
+    return `Dependencies do not install from the lockfile: ${this.reason}`;
+  }
+}
+
+class BundleFailed extends TaggedError2()("BundleFailed", { reason: String4 }) {
+  get message() {
+    return `The Kit does not bundle: ${this.reason}`;
+  }
+}
+
+class DeclarationsInvalid extends TaggedError2()("DeclarationsInvalid", {
+  reason: String4
+}) {
+  get message() {
+    return `The Kit's declarations are invalid: ${this.reason}`;
+  }
+}
+
+class SourceFetchFailed extends TaggedError2()("SourceFetchFailed", {
+  reason: String4
+}) {
+  get message() {
+    return `A setup source does not fetch: ${this.reason}`;
+  }
+}
+var RepositoryText = Union([String4, Struct({ file: String4 })]);
+var ConfigAgents = Record(String4, Struct({
+  ...AgentDeclaration.fields,
+  instructions: optionalKey(RepositoryText)
+}));
+var run = (command, args, cwd) => gen(function* () {
+  const spawner = yield* ChildProcessSpawner;
+  const handle = yield* spawner.spawn(make7(command, args, { cwd, stdin: "ignore" }));
+  const [stdout, stderr, exitCode] = yield* all3([
+    mkString(decodeText(handle.stdout)),
+    mkString(decodeText(handle.stderr)),
+    handle.exitCode
+  ], { concurrency: 3 });
+  return { stdout, stderr, ok: exitCode === 0 };
+}).pipe(scoped);
+var failure = (result) => (result.stderr.trim() || result.stdout.trim()).slice(-2000);
+var provenance = (directory) => gen(function* () {
+  const git = (...args) => run("git", args, directory).pipe(map8((result) => result.ok ? result.stdout.trim() : undefined), orElseSucceed(() => {
+    return;
+  }));
+  const repository = yield* git("remote", "get-url", "origin");
+  const commit = yield* git("rev-parse", "HEAD");
+  const status = yield* git("status", "--porcelain");
+  return {
+    ...repository ? { repository } : undefined,
+    ...commit ? { commit } : undefined,
+    clean: commit !== undefined && status === ""
+  };
+});
+var inKit = (directory, file, what) => gen(function* () {
+  const path = yield* Path;
+  const resolved = path.resolve(directory, file);
+  if (path.relative(directory, resolved).startsWith(".."))
+    return yield* new DeclarationsInvalid({ reason: `${what} ${file} is outside the Kit` });
+  return resolved;
+});
+var readText = (directory, text, what) => gen(function* () {
+  if (isString2(text))
+    return text;
+  const fs = yield* FileSystem;
+  const file = yield* inKit(directory, text.file, what);
+  return yield* fs.readFileString(file).pipe(mapError2(() => new DeclarationsInvalid({ reason: `${what} ${text.file} does not read` })));
+});
+var readAgents = (directory, agents) => forEach(Object.entries(agents), ([id, { instructions, ...agent }]) => instructions === undefined ? succeed6([id, agent]) : map8(readText(directory, instructions, `Agent "${id}" instructions`), (text) => [id, { ...agent, instructions: text.trim() }])).pipe(map8(Object.fromEntries));
+var utf8 = new TextDecoder("utf-8", { fatal: true });
+var setupFile = (bytes) => {
+  try {
+    const text = utf8.decode(bytes);
+    return text.includes("\x00") ? { base64: encode2(bytes) } : { utf8: text };
+  } catch {
+    return { base64: encode2(bytes) };
+  }
+};
+var confined = (boundary, file, what) => gen(function* () {
+  const fs = yield* FileSystem;
+  const path = yield* Path;
+  const unreadable = () => new DeclarationsInvalid({ reason: `${what} does not read` });
+  const real = yield* fs.realPath(path.join(boundary, file)).pipe(mapError2(unreadable));
+  if (path.relative(yield* fs.realPath(boundary).pipe(mapError2(unreadable)), real).startsWith(".."))
+    return yield* new DeclarationsInvalid({ reason: `${what}: ${file} links outside its source` });
+  return real;
+});
+var readTree = (root, what, fetched = false) => gen(function* () {
+  const fs = yield* FileSystem;
+  const path = yield* Path;
+  const unreadable = () => new DeclarationsInvalid({ reason: `${what} does not read` });
+  const entries = yield* fs.readDirectory(root, { recursive: true }).pipe(mapError2(unreadable));
+  const files = {};
+  for (const entry of entries.toSorted()) {
+    const relative = entry.split(path.sep).join("/");
+    if (relative === ".git" || relative.startsWith(".git/"))
+      continue;
+    const file = fetched ? yield* confined(root, entry, what) : path.join(root, entry);
+    if ((yield* fs.stat(file).pipe(mapError2(unreadable))).type !== "File")
+      continue;
+    files[relative] = yield* fs.readFile(file).pipe(mapError2(unreadable));
+  }
+  return files;
+});
+var licenseFiles = ["LICENSE", "LICENSE.md", "LICENSE.txt", "COPYING"];
+var fetchedTree = (root, path, what) => gen(function* () {
+  const fs = yield* FileSystem;
+  const paths = yield* Path;
+  const tree = yield* readTree(path === undefined ? root : yield* confined(root, path, what), what, true);
+  if (path === undefined)
+    return tree;
+  for (const license of licenseFiles)
+    if (tree[license] === undefined && (yield* fs.exists(paths.join(root, license))))
+      return { ...tree, [license]: yield* fs.readFile(yield* confined(root, license, what)).pipe(orDie) };
+  return tree;
+});
+var GitSourceLocation = Reference("kitman/sdk/build/GitSourceLocation", { defaultValue: () => (declared) => declared });
+var fetchGit = (declared, what) => gen(function* () {
+  const fs = yield* FileSystem;
+  const { url, ref } = (yield* GitSourceLocation)(declared);
+  const checkout = yield* fs.makeTempDirectoryScoped({ prefix: "kitman-git-" });
+  for (const args of [
+    ["init", "--quiet"],
+    ["fetch", "--quiet", "--depth", "1", "--", url, ref ?? "HEAD"],
+    ["checkout", "--quiet", "FETCH_HEAD"]
+  ]) {
+    const result = yield* run("git", args, checkout);
+    if (!result.ok)
+      return yield* new SourceFetchFailed({
+        reason: `${what}: git ${url}${ref === undefined ? "" : ` at ${ref}`}: ${failure(result)}`
+      });
+  }
+  return checkout;
+});
+var fetchNpm = (name, wanted, what) => gen(function* () {
+  const fs = yield* FileSystem;
+  const path = yield* Path;
+  const registry = yield* String2("NPM_CONFIG_REGISTRY").pipe(withDefault("https://registry.npmjs.org"), orDie);
+  const failed = (reason) => new SourceFetchFailed({ reason: `${what}: npm ${name}@${wanted}: ${reason}` });
+  const packument = yield* get2(`${registry.replace(/\/+$/, "")}/${name.replace("/", "%2F")}`).pipe(flatMap3(filterStatusOk), flatMap3(schemaBodyJson(Packument)), mapError2((error) => failed(error.message)));
+  const dist = packument.versions[packument["dist-tags"][wanted] ?? wanted]?.dist;
+  if (dist === undefined)
+    return yield* failed("npm has no such version or dist-tag");
+  const tarball = yield* get2(dist.tarball).pipe(flatMap3(filterStatusOk), flatMap3((response) => response.arrayBuffer), map8((buffer) => new Uint8Array(buffer)), mapError2((error) => failed(error.message)));
+  if (!tarballMatches(tarball, dist))
+    return yield* failed(`the tarball does not match its integrity ${dist.integrity ?? `sha1 ${dist.shasum}`}`);
+  const directory = yield* fs.makeTempDirectoryScoped({ prefix: "kitman-npm-" });
+  yield* fs.writeFile(path.join(directory, "package.tgz"), tarball).pipe(orDie);
+  const extracted = yield* run("tar", ["-xzf", "package.tgz"], directory);
+  if (!extracted.ok)
+    return yield* failed(`the tarball does not extract: ${failure(extracted)}`);
+  return yield* confined(directory, "package", what);
+}).pipe(provide3(layer2));
+var sourceTree = (directory, source, what, checkouts) => gen(function* () {
+  switch (source.kind) {
+    case "local_path":
+      return yield* readTree(yield* inKit(directory, source.path, what), what);
+    case "git": {
+      const key = `${source.url}#${source.ref ?? ""}`;
+      const checkout = checkouts.get(key) ?? (yield* fetchGit({ url: source.url, ref: source.ref }, what));
+      checkouts.set(key, checkout);
+      return yield* fetchedTree(checkout, "path" in source ? source.path : undefined, what);
+    }
+    case "package":
+      return yield* fetchedTree(yield* fetchNpm(source.packageName, source.version ?? "latest", what), "path" in source ? source.path : undefined, what);
+    default:
+      return yield* new DeclarationsInvalid({
+        reason: `${what} comes from a ${source.kind} source, which a build cannot copy in; use a local path, git or npm`
+      });
+  }
+});
+var setupArchive = (directory, kit, setup, checkouts) => gen(function* () {
+  const fs = yield* FileSystem;
+  const files = {};
+  const place = (prefix, tree) => {
+    for (const [file, bytes] of Object.entries(tree))
+      files[`${prefix}/${file}`] = setupFile(bytes);
+    return { kind: "local_path", path: prefix };
+  };
+  if (setup.instructions !== undefined) {
+    const what = `Kit ${kit} instructions`;
+    const file = yield* inKit(directory, setup.instructions, what);
+    files["instructions.md"] = setupFile(yield* fs.readFile(file).pipe(mapError2(() => new DeclarationsInvalid({ reason: `${what} do not read` }))));
+  }
+  const skills = setup.skills === undefined ? undefined : yield* forEach(setup.skills, (skill) => map8(sourceTree(directory, skill.source, `Kit ${kit} skill ${skill.name}`, checkouts), (tree) => ({
+    ...skill,
+    source: place(`skills/${skill.name}`, tree)
+  })));
+  const plugins = setup.plugins === undefined ? undefined : yield* forEach(setup.plugins, (plugin) => map8(sourceTree(directory, plugin.sources[0], `Kit ${kit} plugin ${plugin.name}`, checkouts), (tree) => ({
+    ...plugin,
+    sources: [place(`plugins/${plugin.name}`, tree)]
+  })));
+  const archive = {
+    setup: {
+      ...setup,
+      ...setup.instructions === undefined ? undefined : { instructions: "instructions.md" },
+      ...skills === undefined ? undefined : { skills },
+      ...plugins === undefined ? undefined : { plugins }
+    },
+    files
+  };
+  const bytes = new TextEncoder().encode(canonicalJson(archive));
+  return { digest: digestSha256(bytes, "hex"), archive: bytes };
+});
+var PackageJson = fromJsonString(Struct({
+  name: String4,
+  version: optionalKey(String4),
+  dependencies: optionalKey(Record(String4, String4))
+}));
+var readPackageJson = (directory) => gen(function* () {
+  const fs = yield* FileSystem;
+  const path = yield* Path;
+  return yield* fs.readFileString(path.join(directory, "package.json")).pipe(flatMap3(decodeEffect(PackageJson)), mapError2(() => new DeclarationsInvalid({ reason: `${directory}/package.json has no name` })));
+});
+var identityOf = (manifest) => ({
+  name: manifest.name,
+  version: manifest.version ?? "0.0.0"
+});
+var installedPackage = (name, directory) => gen(function* () {
+  const fs = yield* FileSystem;
+  const path = yield* Path;
+  for (let at = directory;; at = path.dirname(at)) {
+    const candidate = path.join(at, "node_modules", name);
+    if (yield* fs.exists(path.join(candidate, "package.json")))
+      return yield* fs.realPath(candidate);
+    if (path.dirname(at) === at)
+      return;
+  }
+});
+var importedFile = (file, specifier) => gen(function* () {
+  const fs = yield* FileSystem;
+  const path = yield* Path;
+  const target = path.resolve(path.dirname(file), specifier);
+  for (const candidate of [target, `${target}.ts`, path.join(target, "kitman.config.ts")])
+    if (yield* fs.stat(candidate).pipe(map8((info) => info.type === "File"), orElseSucceed(() => false)))
+      return candidate;
+  return;
+});
+var packageDirectory = (file) => gen(function* () {
+  const fs = yield* FileSystem;
+  const path = yield* Path;
+  for (let at = path.dirname(file);; at = path.dirname(at)) {
+    if (yield* fs.exists(path.join(at, "package.json")).pipe(orElseSucceed(() => false)))
+      return at;
+    if (path.dirname(at) === at)
+      return;
+  }
+});
+var kitModules = (root) => gen(function* () {
+  const fs = yield* FileSystem;
+  const path = yield* Path;
+  const found = [];
+  const visited = new Set;
+  const packages = new Set([root]);
+  const known = (directory) => packages.has(directory);
+  const visitPackage = (directory) => gen(function* () {
+    for (const name of Object.keys((yield* readPackageJson(directory)).dependencies ?? {})) {
+      const installed = yield* installedPackage(name, directory).pipe(orElseSucceed(() => {
+        return;
+      }));
+      const module = installed === undefined ? undefined : path.join(installed, "kitman.config.ts");
+      if (installed === undefined || module === undefined || known(installed))
+        continue;
+      if (!(yield* fs.exists(module).pipe(orElseSucceed(() => false))))
+        continue;
+      packages.add(installed);
+      found.push({ directory: installed, module, identity: identityOf(yield* readPackageJson(installed)) });
+      yield* visitPackage(installed);
+      yield* visitImports(module);
+    }
+  });
+  const visitImports = (file) => gen(function* () {
+    if (visited.has(file))
+      return;
+    visited.add(file);
+    const transpiled = yield* run("bun", ["build", "--no-bundle", file], root).pipe(map8((result) => result.ok ? result.stdout : ""), orElseSucceed(() => ""));
+    for (const [, specifier] of transpiled.matchAll(/\b(?:from|import)\s*"(\.{1,2}\/[^"]+)"/gu)) {
+      const module = specifier === undefined ? undefined : yield* importedFile(file, specifier);
+      if (module === undefined || visited.has(module))
+        continue;
+      const directory = yield* packageDirectory(module);
+      if (directory !== undefined && directory !== root) {
+        found.push({ directory, module, identity: identityOf(yield* readPackageJson(directory)) });
+        if (!known(directory)) {
+          packages.add(directory);
+          yield* visitPackage(directory);
+        }
+      }
+      yield* visitImports(module);
+    }
+  });
+  yield* visitPackage(root);
+  yield* visitImports(path.join(root, "kitman.config.ts"));
+  return found;
+});
+var buildEntry = (identity, modules) => [
+  "import config from './kitman.config.ts'",
+  "import { runKit } from '@kitman-sh/sdk/program'",
+  ...modules.map((kit, index) => `import * as kit${index} from ${JSON.stringify(kit.module)}`),
+  "",
+  `runKit(config, ${JSON.stringify(identity)}, [${modules.map((kit, index) => `[kit${index}.default, ${JSON.stringify(kit.identity)}]`).join(", ")}])`,
+  ""
+].join(`
+`);
+var renamedKey = (declarations, what, from, to) => {
+  const key = Object.keys(declarations ?? {}).find((key) => hasProperty(declarations?.[key], from));
+  return key === undefined ? undefined : new DeclarationsInvalid({ reason: `${what} "${key}" names \`${from}\`, which is now \`${to}\`` });
+};
+var resolveNames = (names) => {
+  const winners = new Map;
+  const overrides = [];
+  for (const named of names) {
+    const key = `${named.what}\x00${named.name}`;
+    const winner = winners.get(key);
+    if (winner === undefined)
+      winners.set(key, named.kit);
+    else if (winner === named.kit)
+      return new DeclarationsInvalid({ reason: `Kit ${named.kit} names ${named.what} ${named.name} twice` });
+    else
+      overrides.push({ what: named.what, name: named.name, winner, replaced: named.kit });
+  }
+  return { wins: (named) => winners.get(`${named.what}\x00${named.name}`) === named.kit, overrides };
+};
+var buildKit = (directory, options = {}) => gen(function* () {
+  const fs = yield* FileSystem;
+  const path = yield* Path;
+  const root = path.resolve(directory);
+  const source = yield* provenance(root);
+  const identity = { ...identityOf(yield* readPackageJson(root)), ...options };
+  const installed = yield* run("bun", ["install", "--frozen-lockfile", "--ignore-scripts"], root).pipe(mapError2((error) => new DependencyInstallFailed({ reason: error.message })));
+  if (!installed.ok)
+    return yield* new DependencyInstallFailed({ reason: failure(installed) });
+  const packages = yield* kitModules(root);
+  const entry = path.join(root, ".kitman-build-entry.ts");
+  yield* acquireRelease(fs.writeFileString(entry, buildEntry(identity, packages)), () => ignore(fs.remove(entry)));
+  const out = yield* fs.makeTempDirectoryScoped({ prefix: "kitman-kit-" });
+  const bundleFile = path.join(out, "bundle.js");
+  const bundled = yield* run("bun", ["build", entry, "--target=bun", "--format=esm", "--outfile", bundleFile], root);
+  if (!bundled.ok)
+    return yield* failure(bundled).includes('"defineConfig"') ? new DeclarationsInvalid({
+      reason: "defineConfig is now defineKit; import defineKit from @kitman-sh/sdk/loop"
+    }) : new BundleFailed({ reason: failure(bundled) });
+  const described = yield* run("bun", [bundleFile, describeFlag], out);
+  if (!described.ok)
+    return yield* new BundleFailed({ reason: `the bundle does not load: ${failure(described)}` });
+  const result = yield* decodeEffect(fromJsonString(toCodecJson(Described)))(described.stdout).pipe(mapError2((error) => new BundleFailed({ reason: `the bundle described itself wrongly: ${error.message}` })));
+  if (isTagged(result, "Refused"))
+    return yield* result.error;
+  const [own] = result.kits;
+  if (own === undefined)
+    return yield* new BundleFailed({ reason: "the bundle described no Kit" });
+  const renamed = renamedKey(own.schedules, "Schedule", "project", "team") ?? renamedKey(own.schedules, "Schedule", "codebase", "team");
+  if (renamed !== undefined)
+    return yield* renamed;
+  const directories = new Map([
+    [`${identity.name}@${identity.version}`, root],
+    ...packages.map((kit) => [`${kit.identity.name}@${kit.identity.version}`, kit.directory])
+  ]);
+  const kits = yield* forEach(result.kits, (kit) => gen(function* () {
+    const at = directories.get(`${kit.name}@${kit.version}`) ?? root;
+    const invalid = (error) => new DeclarationsInvalid({ reason: `Kit ${kit.name}: ${error.message}` });
+    const agents = yield* decodeUnknownEffect2(ConfigAgents)(kit.agents).pipe(mapError2(invalid));
+    return { ...kit, directory: at, agents: yield* readAgents(at, agents), setup: kit.setup ?? {} };
+  }));
+  const named = kits.flatMap((kit) => [
+    ...kit.loops.map((loop) => ({ kit: kit.name, what: "Loop", name: loop.id })),
+    ...Object.keys(kit.agents).map((agent) => ({ kit: kit.name, what: "Agent", name: agent })),
+    ...(kit.setup.skills ?? []).map((skill) => ({ kit: kit.name, what: "skill", name: skill.name })),
+    ...(kit.setup.plugins ?? []).map((plugin) => ({ kit: kit.name, what: "plugin", name: plugin.name })),
+    ...(kit.setup.mcpServers ?? []).map((server) => ({ kit: kit.name, what: "MCP server", name: server.name }))
+  ]);
+  const kitman = named.find((entry) => entry.what === "MCP server" && entry.name === kitmanMcpServer);
+  if (kitman !== undefined)
+    return yield* new DeclarationsInvalid({
+      reason: `Kit ${kitman.kit} declares an MCP server named ${kitmanMcpServer}, which Kitman provides`
+    });
+  const names = resolveNames(named);
+  if (isTagged(names, "DeclarationsInvalid"))
+    return yield* names;
+  const winning = kits.map((kit) => ({
+    ...kit,
+    loops: kit.loops.filter((loop) => names.wins({ kit: kit.name, what: "Loop", name: loop.id })),
+    agents: Object.fromEntries(Object.entries(kit.agents).filter(([agent]) => names.wins({ kit: kit.name, what: "Agent", name: agent })))
+  }));
+  const checkouts = new Map;
+  const archives = yield* forEach(kits, (kit) => setupArchive(kit.directory, kit.name, kit.setup, checkouts));
+  const carried = winning.map((kit, index) => ({
+    name: kit.name,
+    version: kit.version,
+    setup: archives[index]?.digest ?? "",
+    loops: kit.loops.map((loop) => loop.id),
+    agents: Object.keys(kit.agents)
+  }));
+  const declarations = yield* decodeUnknownEffect2(KitDeclarations)({
+    loops: winning.flatMap((kit) => kit.loops),
+    agents: Object.assign({}, ...winning.map((kit) => kit.agents)),
+    ...own.schedules === undefined ? undefined : { schedules: own.schedules },
+    carried
+  }).pipe(mapError2((error) => new DeclarationsInvalid({ reason: error.message })));
+  const bundle = yield* fs.readFile(bundleFile).pipe(mapError2((error) => new BundleFailed({ reason: error.message })));
+  return {
+    ...identity,
+    bundle,
+    digest: digestSha256(bundle, "hex"),
+    declarations,
+    setupArchives: archives,
+    protocolVersion: RunnerRpcProtocolVersion,
+    provenance: source,
+    overrides: names.overrides
+  };
+}).pipe(scoped, catchTags({
+  PlatformError: (error) => fail7(new BundleFailed({ reason: error.message }))
+}));
+var writeKit = (directory, built, out) => gen(function* () {
+  const fs = yield* FileSystem;
+  const path = yield* Path;
+  const inKit = (file) => path.relative(directory, path.join(out, file));
+  const setup = {};
+  yield* fs.makeDirectory(path.join(out, "setup"), { recursive: true });
+  yield* fs.writeFile(path.join(out, "bundle.js"), built.bundle);
+  yield* fs.writeFileString(path.join(out, "declarations.json"), yield* encodePrettyJsonString(built.declarations));
+  for (const { digest, archive } of built.setupArchives) {
+    yield* fs.writeFile(path.join(out, "setup", `${digest}.json`), archive);
+    setup[digest] = inKit(`setup/${digest}.json`);
+  }
+  const manifestPath = path.join(directory, "package.json");
+  const manifest = yield* fs.readFileString(manifestPath).pipe(flatMap3(decodeEffect(fromJsonString(Record(String4, Json)))));
+  const kitman = {
+    bundle: inKit("bundle.js"),
+    digest: built.digest,
+    protocolVersion: built.protocolVersion,
+    declarations: inKit("declarations.json"),
+    setup
+  };
+  yield* fs.writeFileString(manifestPath, `${yield* encodePrettyJsonString({ ...manifest, kitman })}
+`);
+});
+export {
+  BundleFailed,
+  DeclarationsInvalid,
+  DependencyInstallFailed,
+  GitSourceLocation,
+  SourceFetchFailed,
+  buildKit,
+  writeKit
+};

package/dist/{chunk-1d4316hp.js → chunk-jfvq7s24.js}

@@ -2,21 +2,20 @@
 import {
   getOrElse,
   TaggedError,
-  currentTimeMillis,
   forEach,
   tryPromise,
-  sync,
+  sync2,
   gen,
-  flatMap2,
-  andThen,
-  map3,
+  flatMap3,
+  andThen2,
+  map8,
   scoped,
-  runForEach,
-  FileSystem,
+  makeFormatterStandardSchemaV1,
   is,
   encodeEffect,
   optionalKey,
-  String2,
+  String4,
+  Struct,
   Record,
   ArraySchema,
   Union,
@@ -24,8 +23,10 @@ import {
   fromJsonString,
   TaggedError2,
   toCodecJson,
-  Json,
-  guard,
+  Json
+} from "./chunk-mbctzx7e.js";
+import {
+  currentTimeMillis,
   ProgramWorkUnit,
   RunFileRefused,
   runFileContentType,
@@ -35,15 +36,23 @@ import {
   bodyUint8Array,
   filterStatusOk,
   HttpClient,
+  KitSetup,
   RunnerRpcError
-} from "./chunk-3gxahgnq.js";
+} from "./chunk-wh1pa2aa.js";
+import {
+  guard
+} from "./chunk-pp1p3g6e.js";
+import {
+  runForEach,
+  FileSystem
+} from "./chunk-11p4wf6n.js";
 import {
   LoopManifest,
   ManifestInvalid,
-  make,
+  make14,
   Suspended,
   LoopCheckError
-} from "./chunk-kdb1cbnx.js";
+} from "./chunk-txwt6r25.js";
 
 // packages/sdk/src/program/engine.ts
 class JournalWriteFailed extends TaggedError("JournalWriteFailed") {
@@ -51,12 +60,13 @@ class JournalWriteFailed extends TaggedError("JournalWriteFailed") {
     return `Journal write failed: ${this.cause.message}`;
   }
 }
-var JournalEntries = Record(String2, Json);
+var JournalEntries = Record(String4, Json);
 var isSuspended = is(Suspended);
-var emptyWorkflow = make("kitman-loop/none", { payload: {}, idempotencyKey: () => "none" });
+var emptyWorkflow = make14("kitman-loop/none", { payload: {}, idempotencyKey: () => "none" });
 var replayStatuses = new Set([401, 403, 409, 429]);
 var isRunnerRpcError = is(RunnerRpcError);
 var isRunFileRefused = is(RunFileRefused);
+var issues = makeFormatterStandardSchemaV1();
 var put2 = (target, contentType, body) => gen(function* () {
   const response = yield* (yield* HttpClient).execute(put(target.url).pipe(bodyUint8Array(body, contentType), setHeaders(target.headers ?? {})));
   return (yield* filterStatusOk(response)).headers.etag ?? "";
@@ -77,7 +87,7 @@ var uploadRunFile = (files, file) => gen(function* () {
   const contentType = runFileContentType(file.name);
   const byteSize = Number((yield* fs.stat(file.path)).size);
   const hash = sha256Hasher();
-  yield* runForEach(fs.stream(file.path), (chunk) => sync(() => hash.update(chunk)));
+  yield* runForEach(fs.stream(file.path), (chunk) => sync2(() => hash.update(chunk)));
   const { file: slotted, upload } = yield* files.createRunFile({
     step: file.step,
     name: file.name,
@@ -88,7 +98,7 @@ var uploadRunFile = (files, file) => gen(function* () {
   });
   if (upload === undefined)
     return slotted;
-  return yield* upload.kind === "single" ? readRange(file.path, 0, byteSize).pipe(flatMap2((body) => put2(upload, contentType, body)), andThen(files.completeRunFile({ fileId: slotted.id }))) : flatMap2(uploadParts(files, file.path, contentType, slotted.id, upload), (parts) => files.completeRunFile({ fileId: slotted.id, parts }));
+  return yield* upload.kind === "single" ? readRange(file.path, 0, byteSize).pipe(flatMap3((body) => put2(upload, contentType, body)), andThen2(files.completeRunFile({ fileId: slotted.id }))) : flatMap3(uploadParts(files, file.path, contentType, slotted.id, upload), (parts) => files.completeRunFile({ fileId: slotted.id, parts }));
 });
 var programLease = (work) => ({
   workUnitId: work.id,
@@ -101,24 +111,27 @@ var programLease = (work) => ({
 });
 var rpcRunFiles = (rpc, lease) => ({
   createRunFile: (file) => rpc.createRunFile({ lease, ...file }),
-  runFileParts: (request) => map3(rpc.runFileParts({ lease, ...request, partNumbers: [...request.partNumbers] }), ({ parts }) => parts),
+  runFileParts: (request) => map8(rpc.runFileParts({ lease, ...request, partNumbers: [...request.partNumbers] }), ({ parts }) => parts),
   completeRunFile: ({ parts, ...request }) => rpc.completeRunFile({ lease, ...request, ...parts === undefined ? undefined : { parts: [...parts] } })
 });
 
 // packages/sdk/src/program/host.ts
 var describeFlag = "--kitman-describe";
+var DescribedKit = Struct({
+  name: String4,
+  version: String4,
+  loops: ArraySchema(LoopManifest),
+  agents: Record(String4, Json),
+  schedules: optionalKey(Record(String4, Json)),
+  setup: optionalKey(KitSetup)
+});
 var Described = Union([
-  TaggedStruct("Described", {
-    loops: ArraySchema(LoopManifest),
-    agents: Record(String2, Json),
-    schedules: optionalKey(Record(String2, Json)),
-    kits: optionalKey(Record(String2, Json))
-  }),
+  TaggedStruct("Described", { kits: ArraySchema(DescribedKit) }),
   TaggedStruct("Refused", { error: Union([ManifestInvalid, LoopCheckError]) })
 ]);
 var encodeDescribed = encodeEffect(fromJsonString(toCodecJson(Described)));
 
-class ProgramRefused extends TaggedError2()("ProgramRefused", { reason: String2 }) {
+class ProgramRefused extends TaggedError2()("ProgramRefused", { reason: String4 }) {
   get message() {
     return this.reason;
   }