@kitman-sh/cli 0.9.0 → 0.10.53

package/dist/chunk-arvwar2c.js

@@ -0,0 +1,141 @@
+// @bun
+import {
+  isString2,
+  isNumber2,
+  isBoolean2,
+  isBigInt2,
+  isSymbol2,
+  isFunction2,
+  isUndefined2,
+  isObjectOrArray
+} from "./chunk-mbctzx7e.js";
+
+// packages/core/src/runtime-type.ts
+var UnsafeJsonObjectKeys = new Set(["__proto__", "constructor", "prototype"]);
+function jsonDataError() {
+  throw new TypeError("Value is not JSON data");
+}
+function parseJsonValue(value, ancestors) {
+  if (value === null)
+    return null;
+  if (value === undefined)
+    return jsonDataError();
+  if (isString(value))
+    return String(value);
+  if (isNumber(value))
+    return Number.isFinite(value) ? Number(value) : jsonDataError();
+  if (isBoolean(value))
+    return Boolean(value);
+  if (value instanceof Date) {
+    const timestamp = Date.prototype.getTime.call(value);
+    return Number.isNaN(timestamp) ? jsonDataError() : Date.prototype.toISOString.call(value);
+  }
+  if (!isObject(value))
+    return jsonDataError();
+  if (ancestors.has(value))
+    throw new TypeError("JSON data must not contain cycles");
+  const prototype = Object.getPrototypeOf(value);
+  if (Array.isArray(value)) {
+    ancestors.add(value);
+    try {
+      const keys = Object.keys(value);
+      const hasNamedProperty = keys.some((key, index) => key !== String(index)) || Object.getOwnPropertySymbols(value).some((symbol) => Object.getOwnPropertyDescriptor(value, symbol)?.enumerable);
+      if (hasNamedProperty)
+        throw new TypeError("JSON arrays must not contain named properties");
+      if (keys.length !== value.length)
+        throw new TypeError("JSON arrays must not contain sparse slots");
+      const result = [];
+      for (const key of keys) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (descriptor === undefined || !("value" in descriptor))
+          throw new TypeError("JSON array entries must be data properties");
+        result.push(parseJsonValue(descriptor.value, ancestors));
+      }
+      return result;
+    } finally {
+      ancestors.delete(value);
+    }
+  }
+  if (prototype !== Object.prototype && prototype !== null)
+    return jsonDataError();
+  ancestors.add(value);
+  try {
+    const result = Object.create(null);
+    for (const key of Object.keys(value)) {
+      if (UnsafeJsonObjectKeys.has(key))
+        throw new TypeError(`Unsafe JSON object key: ${key}`);
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (descriptor === undefined || !("value" in descriptor))
+        throw new TypeError("JSON object properties must be data properties");
+      if (descriptor.value !== undefined)
+        result[key] = parseJsonValue(descriptor.value, ancestors);
+    }
+    return result;
+  } finally {
+    ancestors.delete(value);
+  }
+}
+function toJsonValue(value) {
+  return parseJsonValue(value, new WeakSet);
+}
+function isJsonArray(value) {
+  return Array.isArray(value);
+}
+function isOneOf(values, value) {
+  return values.some((item) => Object.is(item, value));
+}
+function isKeyOf(record, key) {
+  return Object.hasOwn(record, key);
+}
+function toJsonObject(value) {
+  const parsed = toJsonValue(value);
+  if (parsed === null || isJsonArray(parsed) || !isObject(parsed))
+    throw new TypeError("Value is not a JSON object");
+  return parsed;
+}
+function isBigInt(value) {
+  return isBigInt2(value);
+}
+function isBoolean(value) {
+  return isBoolean2(value);
+}
+function isFunction(value) {
+  return isFunction2(value);
+}
+function isNumber(value) {
+  return isNumber2(value);
+}
+function isObject(value) {
+  return isObjectOrArray(value);
+}
+function isJsonObject(value) {
+  return isObject(value) && value !== null && !Array.isArray(value);
+}
+function isString(value) {
+  return isString2(value);
+}
+function isSymbol(value) {
+  return isSymbol2(value);
+}
+function isUndefined(value) {
+  return isUndefined2(value);
+}
+function kindOf(value) {
+  if (isString(value))
+    return "string";
+  if (isNumber(value))
+    return "number";
+  if (isBoolean(value))
+    return "boolean";
+  if (isBigInt(value))
+    return "bigint";
+  if (isSymbol(value))
+    return "symbol";
+  if (isUndefined(value))
+    return "undefined";
+  if (isFunction(value))
+    return "function";
+  return "object";
+}
+
+export { toJsonValue, isOneOf, isKeyOf, toJsonObject, isBigInt, isBoolean, isFunction, isNumber, isObject, isJsonObject, isString, isSymbol, isUndefined, kindOf };

package/dist/chunk-b6thzgc9.js

@@ -0,0 +1,32 @@
+// @bun
+import {
+  harnessesUnsupportedInSrt2,
+  compiled2,
+  pinnedSrtCommand2,
+  pinnedSrtStepCommand2,
+  runSrtCli2,
+  srtSettings2,
+  srtCacheEnvironment2,
+  srtInheritedEnv2,
+  inheritedEnvironment2,
+  withOnlyEnvironment2,
+  writeSrtSettings2,
+  srtStepArgv2,
+  srtArgv2
+} from "./chunk-11p4wf6n.js";
+import"./chunk-mbctzx7e.js";
+export {
+  compiled2 as compiled,
+  harnessesUnsupportedInSrt2 as harnessesUnsupportedInSrt,
+  inheritedEnvironment2 as inheritedEnvironment,
+  pinnedSrtCommand2 as pinnedSrtCommand,
+  pinnedSrtStepCommand2 as pinnedSrtStepCommand,
+  runSrtCli2 as runSrtCli,
+  srtArgv2 as srtArgv,
+  srtCacheEnvironment2 as srtCacheEnvironment,
+  srtInheritedEnv2 as srtInheritedEnv,
+  srtSettings2 as srtSettings,
+  srtStepArgv2 as srtStepArgv,
+  withOnlyEnvironment2 as withOnlyEnvironment,
+  writeSrtSettings2 as writeSrtSettings
+};

package/dist/{chunk-8bvf4fh4.js → chunk-ctasxxz5.js}

@@ -1,12 +1,16 @@
 // @bun
 import {
   build2,
-  succeed4,
+  succeed5,
   provide2,
   gen,
-  flatMap2,
-  provideContext,
-  runForEach,
+  flatMap3,
+  provideContext2
+} from "./chunk-mbctzx7e.js";
+import {
+  runForEach
+} from "./chunk-11p4wf6n.js";
+import {
   WebSocketConstructor,
   layerWebSocketConstructorGlobal,
   layerWebSocket,
@@ -15,16 +19,16 @@ import {
   RunnerReplicaRpcs,
   RunnerRunFileRpcs,
   ProgramRpcs
-} from "./chunk-3gxahgnq.js";
+} from "./chunk-wh1pa2aa.js";
 import {
   layerJson,
-  make4,
+  make,
   withHeaders,
   layerProtocolSocket
-} from "./chunk-8z5b6fpd.js";
+} from "./chunk-x9dhxfts.js";
 
 // packages/live/src/rpc/runner-client.ts
-var proxiedWebSocket = (proxy) => succeed4(WebSocketConstructor)((target) => {
+var proxiedWebSocket = (proxy) => succeed5(WebSocketConstructor)((target) => {
   const options = { proxy };
   return Reflect.construct(globalThis.WebSocket, [target, options]);
 });
@@ -34,7 +38,7 @@ function runnerRpcUrl2(apiUrl) {
   url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
   return url.toString();
 }
-var authorizer = (options) => (call) => flatMap2(options.bearer, (token) => withHeaders(call, {
+var authorizer = (options) => (call) => flatMap3(options.bearer, (token) => withHeaders(call, {
   authorization: `Bearer ${token}`,
   [RunnerHeaders.runnerId]: options.runnerId,
   [RunnerHeaders.protocolVersion]: String(RunnerRpcProtocolVersion)
@@ -42,7 +46,7 @@ var authorizer = (options) => (call) => flatMap2(options.bearer, (token) => with
 var RunnerProcessRpcs = RunnerReplicaRpcs.merge(RunnerRunFileRpcs);
 var makeRunnerRpcClient2 = (options) => gen(function* () {
   const protocol = yield* build2(options.protocol);
-  const client = yield* make4(RunnerProcessRpcs).pipe(provideContext(protocol));
+  const client = yield* make(RunnerProcessRpcs).pipe(provideContext2(protocol));
   const authorized = authorizer(options);
   return {
     claim: (input) => authorized(client.Claim(input)),
@@ -64,12 +68,13 @@ var makeRunnerRpcClient2 = (options) => gen(function* () {
     resumeCheckpoint: (input) => authorized(client.ResumeCheckpoint(input)),
     settledCheckpoints: authorized(client.SettledCheckpoints()),
     forgetCheckpoints: (stepAttemptIds) => authorized(client.ForgetCheckpoints({ stepAttemptIds })),
+    gitCredential: (repoBindingId) => authorized(client.GitCredential({ repoBindingId })),
     listen: (runnerReplicaId, onSignal) => authorized(runForEach(client.Signals({ runnerReplicaId }), onSignal))
   };
 });
 var makeProgramRpcClient2 = (options) => gen(function* () {
   const protocol = yield* build2(options.protocol);
-  const client = yield* make4(ProgramRpcs).pipe(provideContext(protocol));
+  const client = yield* make(ProgramRpcs).pipe(provideContext2(protocol));
   const authorized = authorizer(options);
   return {
     recordActivity: (input) => authorized(client.RecordActivity(input)),
@@ -82,6 +87,7 @@ var makeProgramRpcClient2 = (options) => gen(function* () {
     startAgentStep: (input) => authorized(client.StartAgentStep(input)),
     startVerification: (input) => authorized(client.StartVerification(input)),
     awaitEvent: (input) => authorized(client.AwaitEvent(input)),
+    claimResource: (input) => authorized(client.ClaimResource(input)),
     admitChild: (input) => authorized(client.AdmitChild(input)),
     storeArtifact: (input) => authorized(client.StoreArtifact(input)),
     createRunFile: (input) => authorized(client.CreateRunFile(input)),
@@ -90,12 +96,21 @@ var makeProgramRpcClient2 = (options) => gen(function* () {
     recordNote: (input) => authorized(client.RecordNote(input)),
     performHostEffect: (input) => authorized(client.PerformHostEffect(input)),
     createPlanTasks: (input) => authorized(client.CreatePlanTasks(input)),
+    alertTask: (input) => authorized(client.AlertTask(input)),
     readTranscripts: (input) => authorized(client.ReadTranscripts(input)),
+    pipelineStatus: (input) => authorized(client.PipelineStatus(input)),
+    reportPipeline: (input) => authorized(client.ReportPipeline(input)),
+    reviewThreads: (input) => authorized(client.ReviewThreads(input)),
+    openChangeRequests: (input) => authorized(client.OpenChangeRequests(input)),
+    ownChangeRequests: (input) => authorized(client.OwnChangeRequests(input)),
     propose: (input) => authorized(client.Propose(input)),
     readProject: (input) => authorized(client.ReadProject(input)),
     draftUpdate: (input) => authorized(client.DraftUpdate(input)),
     integrationBranch: (input) => authorized(client.IntegrationBranch(input)),
     mergeChangeRequest: (input) => authorized(client.MergeChangeRequest(input)),
+    closeChangeRequest: (input) => authorized(client.CloseChangeRequest(input)),
+    approveChangeRequest: (input) => authorized(client.ApproveChangeRequest(input)),
+    rerunPipeline: (input) => authorized(client.RerunPipeline(input)),
     publishRelease: (input) => authorized(client.PublishRelease(input))
   };
 });