@kitman-sh/cli 0.6.0 → 0.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kitman-sh/cli",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "type": "module",
   "license": "UNLICENSED",
   "bin": {

package/dist/chunk-hrvcz0m4.js

@@ -1,211 +0,0 @@
-// @bun
-import {
-  declare,
-  optionalKey,
-  Literal,
-  Null,
-  String2,
-  Boolean2,
-  Struct,
-  Record,
-  ArraySchema,
-  Union,
-  Literals,
-  makeFilter,
-  isPattern,
-  Finite,
-  isGreaterThanOrEqualTo,
-  isLessThanOrEqualTo2,
-  Int,
-  isMinLength,
-  isMaxLength,
-  toEquivalence,
-  Json,
-  guard,
-  relativePathPattern,
-  skillNamePattern,
-  SafeJson,
-  AgentEfforts,
-  LoopDataSchemaRef,
-  KitKinds
-} from "./chunk-txyq8r41.js";
-
-// packages/core/src/schedule.ts
-var ScheduleFrequency = ["daily", "weekly"];
-var ScheduleMisfirePolicies = ["skip", "fire_once", "catch_up"];
-var ScheduleOverlapPolicies = ["allow", "skip", "coalesce"];
-var ScheduleVersionStatuses = ["draft", "published", "disabled", "archived"];
-var ScheduleCalendarRule = Struct({
-  frequency: Literals(ScheduleFrequency),
-  hour: Int.check(isGreaterThanOrEqualTo(0), isLessThanOrEqualTo2(23)),
-  minute: Int.check(isGreaterThanOrEqualTo(0), isLessThanOrEqualTo2(59)),
-  second: optionalKey(Int.check(isGreaterThanOrEqualTo(0), isLessThanOrEqualTo2(59))),
-  daysOfWeek: optionalKey(ArraySchema(Int.check(isGreaterThanOrEqualTo(0), isLessThanOrEqualTo2(6))).check(isMinLength(1), isMaxLength(7)))
-});
-var ScheduleCronRule = Struct({
-  cron: String2.check(isMinLength(9), isMaxLength(200), isPattern(new RegExp("^[0-9*,/-]+( [0-9*,/-]+){4}$", "u")))
-});
-var ScheduleRule = Union([ScheduleCalendarRule, ScheduleCronRule]);
-var cronBounds = [
-  [0, 59],
-  [0, 23],
-  [1, 31],
-  [1, 12],
-  [0, 7]
-];
-function cronField(field, [min, max]) {
-  const values = new Set;
-  for (const part of field.split(",")) {
-    const match = /^(\*|(\d+)(?:-(\d+))?)(?:\/(\d+))?$/.exec(part);
-    if (match === null)
-      return;
-    const from = match[1] === "*" ? min : Number(match[2]);
-    const to = match[1] === "*" ? max : match[3] === undefined ? match[4] === undefined ? from : max : Number(match[3]);
-    const step = match[4] === undefined ? 1 : Number(match[4]);
-    if (from < min || to > max || from > to || step < 1)
-      return;
-    for (let value = from;value <= to; value += step)
-      values.add(value);
-  }
-  return values;
-}
-function parseCron(cron) {
-  const fields = cron.split(" ");
-  const [minutes, hours, days, months, weekdays] = fields.map((field, index) => cronField(field, cronBounds[index] ?? [0, 0]));
-  if (fields.length !== 5 || !minutes || !hours || !days || !months || !weekdays)
-    return;
-  return {
-    minutes,
-    hours,
-    days,
-    months,
-    weekdays: new Set([...weekdays].map((value) => value % 7)),
-    dayRestricted: !(fields[2] ?? "").startsWith("*"),
-    weekdayRestricted: !(fields[4] ?? "").startsWith("*")
-  };
-}
-function isScheduleRule(value) {
-  return guard(ScheduleRule)(value) && (!("cron" in value) || parseCron(value.cron) !== undefined);
-}
-var ScheduleVersion = Struct({
-  contractVersion: Literal("schedule.v1"),
-  id: String2.check(isMinLength(1)),
-  scheduleId: String2.check(isMinLength(1)),
-  workspaceId: String2.check(isMinLength(1)),
-  projectId: optionalKey(String2.check(isMinLength(1))),
-  loopId: optionalKey(String2.check(isMinLength(1))),
-  name: optionalKey(String2.check(isMinLength(1), isMaxLength(200))),
-  version: Int.check(isGreaterThanOrEqualTo(1)),
-  status: Literals(ScheduleVersionStatuses),
-  timezone: String2.check(isMinLength(1), isMaxLength(80)),
-  rule: ScheduleRule,
-  misfirePolicy: Literals(ScheduleMisfirePolicies),
-  overlapPolicy: Literals(ScheduleOverlapPolicies),
-  maxCatchUp: Int.check(isGreaterThanOrEqualTo(0), isLessThanOrEqualTo2(200)),
-  misfireGraceSeconds: optionalKey(Int.check(isGreaterThanOrEqualTo(0), isLessThanOrEqualTo2(604800))),
-  inputSchemaRef: optionalKey(LoopDataSchemaRef),
-  input: optionalKey(SafeJson),
-  createdAt: String2.check(isMinLength(1))
-});
-var zones = new Map;
-var resolvedLocalDateTimes = new Map;
-
-// packages/core/src/package-declarations.ts
-var LoopCapabilities = [
-  "agent_work",
-  "ask",
-  "call",
-  "verify",
-  "change_request",
-  "write_back",
-  "post_comment",
-  "create_tasks",
-  "merge_change_request",
-  "publish_release"
-];
-var JsonObject = Record(String2, Json);
-var recordKeyedBy = (pattern, value) => Record(String2, value).check(makeFilter((record) => {
-  const bad = Object.keys(record).find((key) => !new RegExp(pattern).test(key));
-  return bad === undefined ? true : `${JSON.stringify(bad)} is not a valid name or relative path`;
-}));
-var SecretName = String2.check(isPattern(/^[A-Za-z_][A-Za-z0-9_]{0,127}$/));
-var EventFilterValue = Union([String2, Finite, Boolean2, Null]);
-var LoopManifest = Struct({
-  id: String2,
-  title: String2,
-  input: JsonObject,
-  output: JsonObject,
-  outcome: optionalKey(Literals(["feature", "bug", "refactor", "investigation", "docs", "migration"])),
-  agents: Record(String2, String2),
-  checkout: Literals(["none", "read", "write"]),
-  when: ArraySchema(Struct({
-    event: String2,
-    filter: optionalKey(Record(String2, Union([EventFilterValue, ArraySchema(EventFilterValue)]))),
-    input: Record(String2, String2)
-  })),
-  offers: ArraySchema(Struct({ id: String2, title: String2, loop: String2 })),
-  capabilities: ArraySchema(Literals(LoopCapabilities)),
-  secrets: optionalKey(ArraySchema(SecretName))
-});
-var AgentDeclaration = Struct({
-  extends: optionalKey(String2),
-  instructions: optionalKey(String2),
-  harness: optionalKey(String2),
-  model: optionalKey(String2),
-  effort: optionalKey(Literals(AgentEfforts)),
-  kits: optionalKey(ArraySchema(String2)),
-  network: optionalKey(Union([Struct({ hosts: ArraySchema(String2) }), Literal("open")])),
-  sandbox: optionalKey(Literal("docker"))
-});
-var scheduleFields = {
-  name: String2.check(isMinLength(1)),
-  loop: String2,
-  project: optionalKey(String2),
-  input: optionalKey(JsonObject),
-  timezone: String2,
-  misfire: optionalKey(Literals(ScheduleMisfirePolicies)),
-  overlap: optionalKey(Literals(ScheduleOverlapPolicies))
-};
-var ScheduleDeclaration = Union([
-  Struct({
-    ...scheduleFields,
-    cron: String2.check(makeFilter((cron) => isScheduleRule({ cron }) || "five cron fields, each within its range"))
-  }),
-  Struct({
-    ...scheduleFields,
-    rule: declare((value) => isScheduleRule(value), {
-      expected: "a Schedule rule: frequency daily or weekly, hour, minute, and optionally second and daysOfWeek"
-    })
-  })
-]);
-var AuthoredKitDeclaration = Struct({
-  name: String2.check(isMinLength(1)),
-  kind: optionalKey(Literals(KitKinds)),
-  description: optionalKey(String2),
-  context: String2,
-  skills: optionalKey(recordKeyedBy(skillNamePattern, recordKeyedBy(relativePathPattern, String2)))
-});
-var KitInstallationDeclaration = Struct({
-  source: String2.check(isMinLength(1)),
-  version: optionalKey(String2)
-});
-var KitAssignmentDeclaration = Struct({
-  kit: String2.check(isMinLength(1)),
-  workspace: optionalKey(Literals(["default", "mandatory"])),
-  projects: optionalKey(ArraySchema(String2))
-});
-var KitDeclaration = Union([
-  KitInstallationDeclaration,
-  KitAssignmentDeclaration,
-  AuthoredKitDeclaration
-]);
-var PackageDeclarations = Struct({
-  loops: ArraySchema(LoopManifest),
-  agents: Record(String2, AgentDeclaration),
-  schedules: optionalKey(Record(String2, ScheduleDeclaration)),
-  kits: optionalKey(Record(String2, KitDeclaration))
-});
-var sameLoop = toEquivalence(LoopManifest);
-var sameAgent = toEquivalence(AgentDeclaration);
-
-export { LoopCapabilities, LoopManifest, AgentDeclaration, KitInstallationDeclaration, KitAssignmentDeclaration, PackageDeclarations };

package/dist/chunk-xdk488qp.js

@@ -1,364 +0,0 @@
-// @bun
-import {
-  build2,
-  provide2,
-  gen,
-  flatMap,
-  provideContext,
-  runForEach,
-  optionalKey,
-  optional,
-  Literal,
-  Null,
-  String2,
-  Boolean2,
-  Void,
-  Struct,
-  Record,
-  ArraySchema,
-  Union,
-  Literals,
-  UndefinedOr,
-  TaggedStruct,
-  Finite,
-  Int,
-  Uint8ArrayFromBase64,
-  TaggedError2,
-  Json,
-  WorkUnitRepoBinding,
-  WorkUnitClaimResult,
-  WorkUnitClaimInput,
-  WorkUnitHeartbeatInput,
-  WorkUnitHeartbeatResult,
-  WorkUnitReleaseInput,
-  WorkUnitCompletion
-} from "./chunk-txyq8r41.js";
-import {
-  layerWebSocketConstructorGlobal,
-  layerWebSocket,
-  make5,
-  make6,
-  layerJson,
-  make7,
-  withHeaders,
-  layerProtocolSocket,
-  Service
-} from "./chunk-hw7qkap1.js";
-
-// packages/live/src/rpc/runner-group.ts
-var RunnerHeaders = { runnerId: "x-kitman-runner-id", protocolVersion: "x-kitman-rpc-protocol" };
-var RunnerRpcProtocolVersion = 1;
-
-class RunnerRpcError extends TaggedError2()("RunnerRpcError", {
-  code: String2,
-  message: String2,
-  status: Finite
-}) {
-}
-
-class RunnerAuthentication extends Service()("RunnerAuthentication", {
-  error: RunnerRpcError
-}) {
-}
-var EventFilterValue = Union([String2, Finite, Boolean2, Null]);
-var WorkAvailable = TaggedStruct("WorkAvailable", {});
-var LeaseRevoked = TaggedStruct("LeaseRevoked", { workUnitId: String2 });
-var Settled = TaggedStruct("Settled", { workUnitId: String2 });
-var Canceled = TaggedStruct("Canceled", { workUnitId: String2 });
-var RunSettled = TaggedStruct("RunSettled", { runId: String2 });
-var Steer = TaggedStruct("Steer", {
-  workUnitId: String2,
-  messageId: String2,
-  text: String2
-});
-var SessionUpdated = TaggedStruct("SessionUpdated", { workUnitId: String2 });
-var RunnerSignal = Union([
-  WorkAvailable,
-  LeaseRevoked,
-  Settled,
-  Canceled,
-  RunSettled,
-  Steer,
-  SessionUpdated
-]);
-var ProgramLease = Struct({
-  workUnitId: String2,
-  leaseOwnerId: String2,
-  runnerReplicaId: String2,
-  leaseId: String2,
-  attempt: Int,
-  fencingToken: String2,
-  capacitySlot: String2
-});
-var CheckpointSession = Struct({
-  harness: String2,
-  id: String2,
-  name: String2,
-  content: Uint8ArrayFromBase64
-});
-var StepCheckpoint = Struct({
-  ref: optionalKey(String2),
-  revision: optionalKey(String2),
-  session: optionalKey(CheckpointSession)
-});
-var SuggestedVerification = Struct({
-  name: String2,
-  command: String2,
-  workingDirectory: optional(String2)
-});
-var ProgramOutcome = Union([
-  Struct({ status: Literal("completed"), output: Json }),
-  Struct({ status: Literal("failed"), failureSummary: String2 })
-]);
-
-class RunnerRpcs extends make6(make5("Claim", {
-  payload: WorkUnitClaimInput,
-  success: WorkUnitClaimResult,
-  error: RunnerRpcError
-}), make5("Heartbeat", {
-  payload: WorkUnitHeartbeatInput,
-  success: WorkUnitHeartbeatResult,
-  error: RunnerRpcError
-}), make5("Complete", {
-  payload: WorkUnitCompletion,
-  error: RunnerRpcError
-}), make5("Release", {
-  payload: WorkUnitReleaseInput,
-  error: RunnerRpcError
-}), make5("RecordActivity", {
-  payload: { lease: ProgramLease, name: String2, attempt: Int, exit: Json },
-  error: RunnerRpcError
-}), make5("DeferredDone", {
-  payload: { lease: ProgramLease, name: String2, exit: Json },
-  error: RunnerRpcError
-}), make5("ScheduleClock", {
-  payload: { lease: ProgramLease, name: String2, deferredName: String2, durationMillis: Int },
-  error: RunnerRpcError
-}), make5("PutQuestion", {
-  payload: {
-    lease: ProgramLease,
-    step: String2,
-    prompt: String2,
-    options: optional(ArraySchema(String2)),
-    verification: optional(SuggestedVerification),
-    deferredName: String2
-  },
-  success: Struct({ questionId: String2 }),
-  error: RunnerRpcError
-}), make5("StartAgentStep", {
-  payload: {
-    lease: ProgramLease,
-    step: String2,
-    deferredName: String2,
-    role: String2,
-    agentId: String2,
-    prompt: String2,
-    outputSchema: Json,
-    secrets: optionalKey(ArraySchema(String2))
-  },
-  success: Struct({ stepAttemptId: String2 }),
-  error: RunnerRpcError
-}), make5("StartVerification", {
-  payload: {
-    lease: ProgramLease,
-    step: String2,
-    deferredName: String2,
-    revision: optionalKey(String2),
-    checks: optional(ArraySchema(String2))
-  },
-  success: Struct({ verificationId: String2 }),
-  error: RunnerRpcError
-}), make5("KnownEvidence", {
-  payload: { lease: ProgramLease, trees: ArraySchema(String2) },
-  success: ArraySchema(Struct({ tree: String2, name: String2, command: String2 })),
-  error: RunnerRpcError
-}), make5("AwaitEvent", {
-  payload: {
-    lease: ProgramLease,
-    step: String2,
-    deferredName: String2,
-    event: String2,
-    filter: optional(Record(String2, Union([EventFilterValue, ArraySchema(EventFilterValue)]))),
-    timeoutMillis: Int
-  },
-  error: RunnerRpcError
-}), make5("AdmitChild", {
-  payload: {
-    lease: ProgramLease,
-    step: String2,
-    loop: String2,
-    input: Json,
-    deferredName: String2
-  },
-  success: Struct({ runId: String2 }),
-  error: RunnerRpcError
-}), make5("StoreArtifact", {
-  payload: {
-    lease: ProgramLease,
-    step: String2,
-    kind: String2,
-    title: String2,
-    text: String2,
-    data: optional(Json)
-  },
-  success: Struct({ artifactId: String2 }),
-  error: RunnerRpcError
-}), make5("RecordNote", {
-  payload: {
-    lease: ProgramLease,
-    step: String2,
-    text: String2,
-    artifactId: optional(String2)
-  },
-  error: RunnerRpcError
-}), make5("PerformHostEffect", {
-  payload: {
-    lease: ProgramLease,
-    step: String2,
-    effect: Union([
-      Struct({ kind: Literal("post_comment"), changeRequestId: String2, body: String2 }),
-      Struct({
-        kind: Literal("change_request"),
-        title: String2,
-        body: String2,
-        integration: optionalKey(String2)
-      }),
-      Struct({
-        kind: Literal("write_back"),
-        milestone: optionalKey(Literals(["started", "change_request_opened", "merged", "failed"])),
-        changeRequestUrl: optionalKey(String2)
-      })
-    ])
-  },
-  success: UndefinedOr(Struct({ id: String2, number: String2, url: String2 })),
-  error: RunnerRpcError
-}), make5("CreatePlanTasks", {
-  payload: {
-    lease: ProgramLease,
-    tickets: ArraySchema(Struct({
-      key: String2,
-      title: String2,
-      body: String2,
-      acceptanceCriteria: ArraySchema(String2),
-      blockedBy: ArraySchema(String2),
-      outcome: optionalKey(Literals(["feature", "bug", "refactor", "investigation", "docs", "migration"]))
-    }))
-  },
-  success: ArraySchema(Struct({ key: String2, taskId: String2 })),
-  error: RunnerRpcError
-}), make5("IntegrationBranch", {
-  payload: { lease: ProgramLease, repoBindingId: optionalKey(String2) },
-  success: Struct({ repoBindingId: String2, branch: String2, revision: String2 }),
-  error: RunnerRpcError
-}), make5("MergeChangeRequest", {
-  payload: { lease: ProgramLease, step: String2, changeRequestId: String2 },
-  success: Union([
-    Struct({ status: Literal("merged"), revision: String2 }),
-    Struct({ status: Literal("conflict") })
-  ]),
-  error: RunnerRpcError
-}), make5("PublishRelease", {
-  payload: {
-    lease: ProgramLease,
-    step: String2,
-    tag: String2,
-    revision: optionalKey(String2),
-    title: String2,
-    notes: String2
-  },
-  success: Struct({ tag: String2, revision: String2, url: String2 }),
-  error: RunnerRpcError
-}), make5("ReportSteer", {
-  payload: { workUnitId: String2, messageId: String2, delivered: Boolean2 },
-  success: Void,
-  error: RunnerRpcError
-}), make5("SaveCheckpoint", {
-  payload: { lease: ProgramLease, checkpoint: StepCheckpoint },
-  success: Void,
-  error: RunnerRpcError
-}), make5("ResumeCheckpoint", {
-  payload: { lease: ProgramLease },
-  success: UndefinedOr(StepCheckpoint),
-  error: RunnerRpcError
-}), make5("SettledCheckpoints", {
-  success: ArraySchema(Struct({
-    stepAttemptId: String2,
-    ref: optionalKey(String2),
-    repoBinding: optionalKey(WorkUnitRepoBinding)
-  })),
-  error: RunnerRpcError
-}), make5("ForgetCheckpoints", {
-  payload: { stepAttemptIds: ArraySchema(String2) },
-  success: Void,
-  error: RunnerRpcError
-}), make5("Bundle", {
-  payload: { digest: String2 },
-  success: Struct({ bundle: String2 }),
-  error: RunnerRpcError
-}), make5("SettledRuns", {
-  payload: { runIds: ArraySchema(String2) },
-  success: ArraySchema(String2),
-  error: RunnerRpcError
-}), make5("ProgramSecrets", {
-  payload: { lease: ProgramLease },
-  success: Record(String2, String2),
-  error: RunnerRpcError
-}), make5("Suspend", { payload: { lease: ProgramLease }, error: RunnerRpcError }), make5("FinishProgram", { payload: { lease: ProgramLease, outcome: ProgramOutcome }, error: RunnerRpcError }), make5("Signals", {
-  payload: { runnerReplicaId: String2 },
-  success: RunnerSignal,
-  error: RunnerRpcError,
-  stream: true
-})).middleware(RunnerAuthentication) {
-}
-
-// packages/live/src/rpc/runner-client.ts
-var runnerWebSocketProtocol2 = (url) => layerProtocolSocket({ retryTransientErrors: true }).pipe(provide2(layerWebSocket(url)), provide2(layerWebSocketConstructorGlobal), provide2(layerJson));
-function runnerRpcUrl2(apiUrl) {
-  const url = new URL("/v1/runners/rpc", apiUrl);
-  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
-  return url.toString();
-}
-var makeRunnerRpcClient2 = (options) => gen(function* () {
-  const protocol = yield* build2(options.protocol);
-  const client = yield* make7(RunnerRpcs).pipe(provideContext(protocol));
-  const authorized = (call) => flatMap(options.bearer, (token) => withHeaders(call, {
-    authorization: `Bearer ${token}`,
-    [RunnerHeaders.runnerId]: options.runnerId,
-    [RunnerHeaders.protocolVersion]: String(RunnerRpcProtocolVersion)
-  }));
-  return {
-    claim: (input) => authorized(client.Claim(input)),
-    heartbeat: (input) => authorized(client.Heartbeat(input)),
-    complete: (input) => authorized(client.Complete(input)),
-    release: (input) => authorized(client.Release(input)),
-    recordActivity: (input) => authorized(client.RecordActivity(input)),
-    deferredDone: (input) => authorized(client.DeferredDone(input)),
-    scheduleClock: (input) => authorized(client.ScheduleClock(input)),
-    putQuestion: (input) => authorized(client.PutQuestion(input)),
-    programSecrets: (input) => authorized(client.ProgramSecrets(input)),
-    suspend: (input) => authorized(client.Suspend(input)),
-    finishProgram: (input) => authorized(client.FinishProgram(input)),
-    startAgentStep: (input) => authorized(client.StartAgentStep(input)),
-    startVerification: (input) => authorized(client.StartVerification(input)),
-    knownEvidence: (input) => authorized(client.KnownEvidence(input)),
-    awaitEvent: (input) => authorized(client.AwaitEvent(input)),
-    admitChild: (input) => authorized(client.AdmitChild(input)),
-    storeArtifact: (input) => authorized(client.StoreArtifact(input)),
-    recordNote: (input) => authorized(client.RecordNote(input)),
-    performHostEffect: (input) => authorized(client.PerformHostEffect(input)),
-    createPlanTasks: (input) => authorized(client.CreatePlanTasks(input)),
-    integrationBranch: (input) => authorized(client.IntegrationBranch(input)),
-    mergeChangeRequest: (input) => authorized(client.MergeChangeRequest(input)),
-    publishRelease: (input) => authorized(client.PublishRelease(input)),
-    bundle: (digest) => authorized(client.Bundle({ digest })),
-    settledRuns: (runIds) => authorized(client.SettledRuns({ runIds })),
-    reportSteer: (input) => authorized(client.ReportSteer(input)),
-    saveCheckpoint: (input) => authorized(client.SaveCheckpoint(input)),
-    resumeCheckpoint: (input) => authorized(client.ResumeCheckpoint(input)),
-    settledCheckpoints: authorized(client.SettledCheckpoints()),
-    forgetCheckpoints: (stepAttemptIds) => authorized(client.ForgetCheckpoints({ stepAttemptIds })),
-    listen: (runnerReplicaId, onSignal) => authorized(runForEach(client.Signals({ runnerReplicaId }), onSignal))
-  };
-});
-
-export { RunnerRpcProtocolVersion, RunnerRpcError, RunSettled, runnerWebSocketProtocol2, runnerRpcUrl2, makeRunnerRpcClient2 };