@kitman-sh/sdk 0.6.0 → 0.7.0

package/dist/build/index.js

@@ -4,12 +4,12 @@ import {
   KitInstallationDeclaration,
   KitAssignmentDeclaration,
   PackageDeclarations
-} from "../chunk-jnxc0c54.js";
+} from "../chunk-zp7s46pz.js";
 import {
   RunnerRpcProtocolVersion,
   describeFlag2,
   Described2
-} from "../chunk-f3d6cvkg.js";
+} from "../chunk-7hwhxthh.js";
 
 // packages/core/src/crypto.ts
 import { createHash, createHmac, createSign, randomBytes, timingSafeEqual } from "crypto";

package/dist/{chunk-f3d6cvkg.js → chunk-7hwhxthh.js}

@@ -1,9 +1,9 @@
 // @bun
 import {
+  AgentSandboxNetwork,
   guard,
   Id,
   Timestamp,
-  AgentSandboxNetwork,
   LoopStepOutput,
   StepBrief,
   LoopManifest,
@@ -19,7 +19,7 @@ import {
   executeLoop2,
   LoopCheckError2,
   checkLoop2
-} from "./chunk-jnxc0c54.js";
+} from "./chunk-zp7s46pz.js";
 // packages/core/src/repo-binding.ts
 import * as Schema from "effect/Schema";
 var RepoBindingPathPrefixPattern = "^(?!/)(?!.*\\\\)(?!.*(?:^|/)\\.\\.?(?:/|$))(?!.*//)\\S+$";
@@ -64,6 +64,10 @@ var RepoBinding = Schema.Struct({
   expectedCommitSha: Schema.optionalKey(Schema.String.check(Schema.isMinLength(1))),
   credentialRefs: Schema.Array(RepoBindingCredentialRef),
   status: RepoBindingStatus,
+  webhook: Schema.optionalKey(Schema.Struct({
+    status: Schema.Literals(["active", "missing"]),
+    message: Schema.optionalKey(Schema.String.check(Schema.isMaxLength(240)))
+  })),
   createdAt: Timestamp,
   updatedAt: Timestamp
 });
@@ -171,6 +175,7 @@ var OrchestrationWorkUnit = Schema2.Struct({
   granted: Schema2.Array(Schema2.String),
   lease: WorkUnitLease,
   journal: RunJournal,
+  network: Schema2.optionalKey(AgentSandboxNetwork),
   program: Schema2.Struct({
     loopId: Schema2.String.check(Schema2.isMinLength(1)),
     credential: Schema2.String.check(Schema2.isMinLength(1))
@@ -837,7 +842,11 @@ import * as Layer2 from "effect/Layer";
 import * as Stream from "effect/Stream";
 import { RpcClient, RpcSerialization } from "effect/rpc";
 import * as Socket from "effect/socket/Socket";
-var runnerWebSocketProtocol = (url) => RpcClient.layerProtocolSocket({ retryTransientErrors: true }).pipe(Layer2.provide(Socket.layerWebSocket(url)), Layer2.provide(Socket.layerWebSocketConstructorGlobal), Layer2.provide(RpcSerialization.layerJson));
+var proxiedWebSocket = (proxy) => Layer2.succeed(Socket.WebSocketConstructor)((target) => {
+  const options = { proxy };
+  return Reflect.construct(globalThis.WebSocket, [target, options]);
+});
+var runnerWebSocketProtocol = (url, options = {}) => RpcClient.layerProtocolSocket({ retryTransientErrors: true }).pipe(Layer2.provide(Socket.layerWebSocket(url)), Layer2.provide(options.proxy === undefined ? Socket.layerWebSocketConstructorGlobal : proxiedWebSocket(options.proxy)), Layer2.provide(RpcSerialization.layerJson));
 function runnerRpcUrl(apiUrl) {
   const url = new URL("/v1/runners/rpc", apiUrl);
   url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
@@ -915,6 +924,81 @@ var programSecrets2 = (rpc, lease) => rpc.programSecrets({ lease }).pipe(Effect4
   lease,
   outcome: { status: "failed", failureSummary: `Kitman refused the Loop its Secrets: ${error.message}` }
 }), Option2.none())));
+var programHostsEnv2 = "KITMAN_PROGRAM_HOSTS";
+var undeclaredHostsEnv2 = "KITMAN_UNDECLARED_HOSTS";
+var allows = (hosts, host) => hosts.some((entry) => entry === host || entry.startsWith("*.") && host.endsWith(entry.slice(1)));
+var redirectStatuses = new Set([301, 302, 303, 307, 308]);
+var maxRedirects = 20;
+var requestBodyHeaders = [
+  "content-type",
+  "content-length",
+  "content-encoding",
+  "content-language",
+  "content-location"
+];
+var credentialHeaders = ["authorization", "cookie", "proxy-authorization"];
+var networkGuard2 = (input) => {
+  const warned = new Set;
+  let refused;
+  const refusalOf = (host) => {
+    if (allows(input.hosts, host))
+      return;
+    const undeclared = `The program called ${host}, a host its Loop does not declare. Add it to \`network\` in defineLoop`;
+    if (input.undeclared === "fail") {
+      refused ??= `${undeclared}.`;
+      return new Error(`${undeclared}.`);
+    }
+    if (!warned.has(host))
+      input.warn(`${undeclared}; a shared Runner refuses it.`);
+    warned.add(host);
+    return;
+  };
+  const follow = (first) => Effect4.gen(function* () {
+    let request = first;
+    for (let hops = 0;; hops++) {
+      const refusal = refusalOf(new URL(request.url).hostname);
+      if (refusal !== undefined)
+        return yield* Effect4.die(refusal);
+      const sent = request;
+      if (sent.redirect !== "follow")
+        return yield* Effect4.promise(() => input.fetch(sent));
+      const resend = sent.clone();
+      const response = yield* Effect4.promise(() => input.fetch(sent, { redirect: "manual" }));
+      const location = response.headers.get("location");
+      if (!redirectStatuses.has(response.status) || location === null)
+        return response;
+      if (hops === maxRedirects)
+        return yield* Effect4.die(new TypeError("The program followed too many redirects."));
+      response.body?.cancel();
+      const url = new URL(location, sent.url);
+      const asGet = response.status === 303 && sent.method !== "HEAD" || (response.status === 301 || response.status === 302) && sent.method === "POST";
+      const headers = new Headers(Array.from(resend.headers));
+      if (asGet)
+        for (const name of requestBodyHeaders)
+          headers.delete(name);
+      if (url.origin !== new URL(sent.url).origin)
+        for (const name of credentialHeaders)
+          headers.delete(name);
+      request = new Request(url.href, {
+        method: asGet ? "GET" : resend.method,
+        headers,
+        body: asGet || resend.body === null ? null : yield* Effect4.promise(() => resend.arrayBuffer()),
+        signal: sent.signal
+      });
+    }
+  });
+  const fetch = (resource, init) => Effect4.runPromise(Effect4.suspend(() => follow(resource instanceof Request ? new Request(resource, init) : new Request(resource instanceof URL ? resource.href : resource, init))));
+  const refusal = () => refused === undefined ? undefined : { status: "failed", failureSummary: refused };
+  const journal = (journal) => ({
+    ...journal,
+    suspend: Effect4.suspend(() => {
+      const failed = refusal();
+      return failed === undefined ? journal.suspend : journal.finish(failed);
+    }),
+    finish: (outcome) => Effect4.suspend(() => journal.finish(refusal() ?? outcome))
+  });
+  return { fetch, journal };
+};
 var describe = (config) => Effect4.gen(function* () {
   const loops = yield* Effect4.forEach(config.loops, loopManifest2);
   for (const loop of config.loops)
@@ -940,19 +1024,32 @@ var host = (config) => Effect4.gen(function* () {
   const loop = config.loops.find((candidate) => candidate.id === loopId);
   if (loop === undefined)
     return yield* new ProgramRefused({ reason: `The Package declares no Loop "${loopId}"` });
+  const hosts = yield* Config.option(Config.String(programHostsEnv2));
+  const undeclared = yield* Config.option(Config.Literals(["fail", "warn"], undeclaredHostsEnv2));
+  const proxy = yield* Config.option(Config.String("HTTPS_PROXY"));
   const rpc = yield* makeRunnerRpcClient({
     runnerId: work.lease.leaseOwnerId,
     bearer: Effect4.sync(() => Redacted2.value(credential)),
-    protocol: runnerWebSocketProtocol(runnerRpcUrl(apiUrl))
+    protocol: runnerWebSocketProtocol(runnerRpcUrl(apiUrl), Option2.isSome(proxy) ? { proxy: proxy.value } : {})
   });
   const secrets = (loop.secrets ?? []).length === 0 ? Option2.some({}) : yield* programSecrets2(rpc, programLease2(work));
   if (Option2.isNone(secrets))
     return 0;
-  return yield* runProgram2(loop, work, rpcProgramJournal2(rpc, work)).pipe(Effect4.provideService(ConfigProvider.ConfigProvider, ConfigProvider.fromUnknown(secrets.value)), Effect4.as(0), Effect4.catchTag("JournalWriteFailed", (error) => Effect4.as(Effect4.logError(error.message), 1)));
+  const guard = Option2.isNone(hosts) ? undefined : networkGuard2({
+    hosts: hosts.value.split(",").filter((host) => host.length > 0),
+    undeclared: Option2.getOrElse(undeclared, () => "warn"),
+    fetch: globalThis.fetch,
+    warn: (line) => void process.stderr.write(`${line}
+`)
+  });
+  if (guard !== undefined)
+    globalThis.fetch = Object.assign(guard.fetch, { preconnect: globalThis.fetch.preconnect });
+  const journal = rpcProgramJournal2(rpc, work);
+  return yield* runProgram2(loop, work, guard === undefined ? journal : guard.journal(journal)).pipe(Effect4.provideService(ConfigProvider.ConfigProvider, ConfigProvider.fromUnknown(secrets.value)), Effect4.as(0), Effect4.catchTag("JournalWriteFailed", (error) => Effect4.as(Effect4.logError(error.message), 1)));
 }).pipe(Effect4.scoped, Effect4.catch((error) => Effect4.as(Effect4.logError(error.message), 2)));
 var runPackage2 = (config) => {
   const program = process.argv.includes(describeFlag2) ? describe(config) : host(config);
   BunRuntime.runMain(program.pipe(Effect4.flatMap((code) => Effect4.sync(() => process.exit(code)))));
 };
 
-export { RunnerRpcProtocolVersion, JournalWriteFailed2, refusedStep2, runProgram2, programLease2, rpcProgramJournal2, describeFlag2, Described2, programSecrets2, runPackage2 };
+export { RunnerRpcProtocolVersion, JournalWriteFailed2, refusedStep2, runProgram2, programLease2, rpcProgramJournal2, describeFlag2, Described2, programSecrets2, programHostsEnv2, undeclaredHostsEnv2, networkGuard2, runPackage2 };