@scarn/sdk 0.0.0-stage → 0.8.0

package/dist/chunk-4ggr8af6.js

@@ -0,0 +1,30 @@
+// @bun
+import {
+  exports_external
+} from "./chunk-skzxcba3.js";
+
+// src/devcontainer-config-path.ts
+var MAX_DEVCONTAINER_CONFIG_PATH_LENGTH = 255;
+var DEVCONTAINER_CONFIG_BASENAMES = [
+  "devcontainer.json",
+  ".devcontainer.json"
+];
+var LEADING_CURRENT_DIR = /^(?:\.\/)+/;
+var DRIVE_LETTER = /^[A-Za-z]:/;
+function normalizeDevcontainerConfigPath(path) {
+  return path.replace(LEADING_CURRENT_DIR, "");
+}
+function basenameOf(path) {
+  return path.slice(Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\")) + 1);
+}
+var devcontainerConfigPathSchema = exports_external.string().max(MAX_DEVCONTAINER_CONFIG_PATH_LENGTH).overwrite(normalizeDevcontainerConfigPath).refine((path) => !path.includes("\\"), {
+  message: "must use forward slashes, not backslashes"
+}).refine((path) => !path.startsWith("/") && !DRIVE_LETTER.test(path), {
+  message: "must be relative to the repository root, not absolute"
+}).refine((path) => !path.split("/").includes(".."), {
+  message: 'must not contain a ".." segment'
+}).refine((path) => DEVCONTAINER_CONFIG_BASENAMES.includes(basenameOf(path)), {
+  message: 'must end in "devcontainer.json" or ".devcontainer.json"'
+});
+
+export { MAX_DEVCONTAINER_CONFIG_PATH_LENGTH, DEVCONTAINER_CONFIG_BASENAMES, normalizeDevcontainerConfigPath, devcontainerConfigPathSchema };

package/dist/chunk-5zsavw98.js

@@ -0,0 +1,91 @@
+// @bun
+import {
+  exports_external
+} from "./chunk-skzxcba3.js";
+
+// src/env-vars.ts
+var ENV_VAR_NAME_PATTERN = /^[A-Z_][A-Z0-9_]*$/;
+var RESERVED_ENV_VAR_NAMES = [
+  "HOME",
+  "XDG_CONFIG_HOME",
+  "XDG_DATA_HOME",
+  "OPENCODE_CONFIG_CONTENT",
+  "npm_config_cache"
+];
+var RESERVED_ENV_VAR_PREFIX = "SCARN_";
+var MAX_ENV_VARS = 64;
+var MAX_ENV_VAR_NAME_LENGTH = 128;
+var MAX_ENV_VAR_VALUE_LENGTH = 4096;
+var INPUT_TOKEN_PATTERN = /\{\{input\.[^}]+\}\}/;
+function containsInputToken(value) {
+  return INPUT_TOKEN_PATTERN.test(value);
+}
+function isReservedEnvVarName(name) {
+  return name.startsWith(RESERVED_ENV_VAR_PREFIX) || RESERVED_ENV_VAR_NAMES.includes(name);
+}
+var envVarNameSchema = exports_external.string().max(MAX_ENV_VAR_NAME_LENGTH).regex(ENV_VAR_NAME_PATTERN, "must match /^[A-Z_][A-Z0-9_]*$/").refine((name) => !isReservedEnvVarName(name), {
+  message: `is reserved (SCARN_*, ${RESERVED_ENV_VAR_NAMES.join(", ")})`
+});
+var envVarValueSchema = exports_external.string().max(MAX_ENV_VAR_VALUE_LENGTH);
+var envVarAppliesValues = ["agent", "setup", "both"];
+var envVarAppliesSchema = exports_external.enum(envVarAppliesValues).default("agent");
+function appliesToAgent(applies) {
+  return applies !== "setup";
+}
+function appliesToSetup(applies) {
+  return applies === "setup" || applies === "both";
+}
+function isUninheritableWorkerEnvVarName(name) {
+  return name.toUpperCase().startsWith(RESERVED_ENV_VAR_PREFIX);
+}
+var valueEnvVarSchema = exports_external.object({
+  name: envVarNameSchema,
+  source: exports_external.literal("value"),
+  value: envVarValueSchema,
+  secret: exports_external.boolean(),
+  applies: envVarAppliesSchema
+}).strict().refine((entry) => !entry.secret || containsInputToken(entry.value), {
+  path: ["value"],
+  message: "a secret value must contain an {{input.\u2026}} token; a static secret would be stored in plaintext. Use Env.inherit({ secret: true }) instead"
+});
+var inheritEnvVarSchema = exports_external.object({
+  name: envVarNameSchema,
+  source: exports_external.literal("inherit"),
+  from: exports_external.string().max(MAX_ENV_VAR_NAME_LENGTH).regex(/^[A-Za-z_][A-Za-z0-9_]*$/, "must be a valid environment variable name").refine((from) => !isUninheritableWorkerEnvVarName(from), {
+    message: `cannot read worker variables starting with ${RESERVED_ENV_VAR_PREFIX}`
+  }),
+  secret: exports_external.boolean(),
+  optional: exports_external.boolean(),
+  default: envVarValueSchema.optional(),
+  mcp: exports_external.string().min(1).optional(),
+  applies: envVarAppliesSchema
+}).strict().refine((entry) => !(entry.secret && entry.default !== undefined), {
+  path: ["default"],
+  message: "a secret cannot carry a default; it would be stored in plaintext"
+});
+var envVarSpecSchema = exports_external.discriminatedUnion("source", [
+  valueEnvVarSchema,
+  inheritEnvVarSchema
+]);
+var envVarsSchema = exports_external.array(envVarSpecSchema).max(MAX_ENV_VARS).refine((entries) => new Set(entries.map((entry) => entry.name)).size === entries.length, { message: "environment variable names must be unique" });
+var storedEnvVarsSchema = exports_external.array(exports_external.discriminatedUnion("source", [
+  exports_external.object({
+    name: exports_external.string(),
+    source: exports_external.literal("value"),
+    value: exports_external.string(),
+    secret: exports_external.boolean(),
+    applies: exports_external.enum(envVarAppliesValues).default("agent")
+  }),
+  exports_external.object({
+    name: exports_external.string(),
+    source: exports_external.literal("inherit"),
+    from: exports_external.string(),
+    secret: exports_external.boolean(),
+    optional: exports_external.boolean(),
+    default: exports_external.string().optional(),
+    mcp: exports_external.string().optional(),
+    applies: exports_external.enum(envVarAppliesValues).default("agent")
+  })
+]));
+
+export { ENV_VAR_NAME_PATTERN, RESERVED_ENV_VAR_NAMES, RESERVED_ENV_VAR_PREFIX, MAX_ENV_VARS, MAX_ENV_VAR_NAME_LENGTH, MAX_ENV_VAR_VALUE_LENGTH, containsInputToken, isReservedEnvVarName, envVarAppliesValues, appliesToAgent, appliesToSetup, isUninheritableWorkerEnvVarName, envVarSpecSchema, envVarsSchema, storedEnvVarsSchema };

package/dist/chunk-63f90zky.js

@@ -0,0 +1,39 @@
+// @bun
+import {
+  exports_external
+} from "./chunk-skzxcba3.js";
+
+// src/health-checks.ts
+var healthCheckSeverityValues = ["required", "warn"];
+var healthCheckBaseSchema = exports_external.object({
+  name: exports_external.string().trim().min(1).optional(),
+  severity: exports_external.enum(healthCheckSeverityValues).default("required"),
+  timeoutSeconds: exports_external.number().gt(0).max(3600).default(15),
+  serialGroup: exports_external.string().trim().min(1).optional()
+});
+var toolHealthCheckSchema = healthCheckBaseSchema.extend({
+  kind: exports_external.literal("tool").default("tool"),
+  tool: exports_external.string().trim().min(1),
+  mcp: exports_external.string().trim().min(1).optional(),
+  args: exports_external.record(exports_external.string(), exports_external.unknown()).optional()
+}).strict();
+var cliHealthCheckSchema = healthCheckBaseSchema.extend({
+  kind: exports_external.literal("cli"),
+  command: exports_external.array(exports_external.string().min(1)).min(1),
+  expectExitCode: exports_external.int().default(0)
+}).strict();
+function injectDefaultKind(value) {
+  if (typeof value === "object" && value !== null && !("kind" in value)) {
+    return { ...value, kind: "tool" };
+  }
+  return value;
+}
+var healthCheckSchema = exports_external.preprocess(injectDefaultKind, exports_external.discriminatedUnion("kind", [toolHealthCheckSchema, cliHealthCheckSchema]));
+var healthChecksSchema = exports_external.array(healthCheckSchema);
+var stepToolHealthCheckSchema = toolHealthCheckSchema.omit({ mcp: true }).strict();
+var stepHealthChecksInputSchema = exports_external.array(exports_external.preprocess(injectDefaultKind, exports_external.discriminatedUnion("kind", [
+  stepToolHealthCheckSchema,
+  cliHealthCheckSchema
+])));
+
+export { healthCheckSeverityValues, toolHealthCheckSchema, cliHealthCheckSchema, healthCheckSchema, healthChecksSchema, stepToolHealthCheckSchema, stepHealthChecksInputSchema };

package/dist/chunk-700xe701.js

@@ -0,0 +1,100 @@
+// @bun
+import {
+  ScarnClient,
+  TaskRuns,
+  createClient
+} from "./chunk-vfeytkqx.js";
+// src/task-plane-client.ts
+function unwrap(result) {
+  if (result.error)
+    throw new Error(JSON.stringify(result.error));
+  return result.data;
+}
+function createTaskPlaneClient(baseUrl, options) {
+  const client = createClient({ baseUrl, headers: options?.headers });
+  return buildTaskPlaneClient(new TaskRuns({ client }));
+}
+var buildTaskPlaneClient = (taskRuns) => {
+  return {
+    claimTaskRuns: async (input) => unwrap(await taskRuns.claimTaskRuns({ body: input })),
+    heartbeatTaskRun: async ({
+      taskRunId,
+      ...body
+    }) => {
+      unwrap(await taskRuns.heartbeatTaskRun({ path: { taskRunId }, body }));
+    },
+    getTaskRun: async ({ taskRunId }) => unwrap(await taskRuns.getTaskRun({ path: { taskRunId } })),
+    getTaskLogArchive: ({ taskRunId }) => taskRuns.getTaskLogArchive({ path: { taskRunId } }),
+    readTaskLogs: ({
+      taskRunId,
+      ...query
+    }) => taskRuns.readTaskLogs({ path: { taskRunId }, query }),
+    getTaskRunWorkerContext: async ({
+      taskRunId,
+      ...body
+    }) => unwrap(await taskRuns.getTaskRunWorkerContext({ path: { taskRunId }, body })),
+    completeTaskRun: async ({
+      taskRunId,
+      ...body
+    }) => {
+      unwrap(await taskRuns.completeTaskRun({
+        path: { taskRunId },
+        body: { ...body, status: "succeeded" }
+      }));
+    },
+    failTaskRun: async ({
+      taskRunId,
+      ...body
+    }) => {
+      unwrap(await taskRuns.completeTaskRun({
+        path: { taskRunId },
+        body: { ...body, status: "failed" }
+      }));
+    },
+    yieldTaskRun: async ({
+      taskRunId,
+      ...body
+    }) => {
+      unwrap(await taskRuns.yieldTaskRun({ path: { taskRunId }, body }));
+    },
+    appendTaskLogs: async ({
+      taskRunId,
+      ...body
+    }) => unwrap(await taskRuns.appendTaskLogs({ path: { taskRunId }, body })),
+    createArtifactUploadUrl: async ({
+      taskRunId,
+      ...body
+    }) => unwrap(await taskRuns.createArtifactUploadUrl({ path: { taskRunId }, body })),
+    createSessionUploadUrl: async ({
+      taskRunId,
+      ...body
+    }) => unwrap(await taskRuns.createSessionUploadUrl({ path: { taskRunId }, body })),
+    recordArtifact: async ({
+      taskRunId,
+      ...body
+    }) => {
+      unwrap(await taskRuns.recordTaskArtifact({ path: { taskRunId }, body }));
+    },
+    recordArtifactFailure: async ({
+      taskRunId,
+      ...body
+    }) => {
+      unwrap(await taskRuns.recordTaskArtifactFailure({ path: { taskRunId }, body }));
+    },
+    listTaskArtifacts: async ({ taskRunId }) => unwrap(await taskRuns.listTaskArtifacts({ path: { taskRunId } })),
+    getArtifactDownloadUrl: async ({
+      taskRunId,
+      artifactId
+    }) => unwrap(await taskRuns.getArtifactDownloadUrl({
+      path: { taskRunId, artifactId }
+    }))
+  };
+};
+
+// src/client.ts
+function createScarnClient(baseUrl) {
+  const client = createClient({ baseUrl });
+  return new ScarnClient({ client });
+}
+
+export { createTaskPlaneClient, createScarnClient };

package/dist/chunk-ar6hcj1r.js

@@ -0,0 +1,35 @@
+// @bun
+// src/push/code-step-lookup.ts
+function isStepDefinitionSpec(value) {
+  if (typeof value !== "object" && typeof value !== "function")
+    return false;
+  if (value === null)
+    return false;
+  const obj = value;
+  return typeof obj["key"] === "string" && typeof obj["name"] === "string" && typeof obj["version"] === "number" && (obj["kind"] === "user_defined" || obj["kind"] === "code");
+}
+function stepsInModule(mod) {
+  const found = new Set;
+  for (const [exportName, value] of Object.entries(mod)) {
+    if (exportName !== "default" && isStepDefinitionSpec(value)) {
+      found.add(value);
+    }
+  }
+  return [...found];
+}
+function findCodeStepInModule(mod, key) {
+  const fns = new Set;
+  for (const spec of stepsInModule(mod)) {
+    if (spec.kind !== "code" || spec.key !== key)
+      continue;
+    const fn = spec.entrypoint?.fn;
+    if (typeof fn === "function")
+      fns.add(fn);
+  }
+  if (fns.size > 1) {
+    throw new Error(`Code step "${key}" is ambiguous: ${String(fns.size)} distinct functions are registered under that key in the same module.`);
+  }
+  return fns.values().next().value;
+}
+
+export { isStepDefinitionSpec, stepsInModule, findCodeStepInModule };

package/dist/chunk-cdanncng.js

@@ -0,0 +1,74 @@
+// @bun
+import {
+  exports_external
+} from "./chunk-skzxcba3.js";
+
+// src/repo-config.ts
+var MAX_REPO_COMMIT_MESSAGE_LENGTH = 500;
+var REPO_COMMIT_MESSAGE_TOKEN_ROOTS = [
+  "input",
+  "result"
+];
+var TOKEN_PATTERN = /\{\{([^}]+)\}\}/g;
+function findDisallowedCommitMessageTokenRoots(message) {
+  const disallowed = [];
+  for (const match of message.matchAll(TOKEN_PATTERN)) {
+    const root = (match[1] ?? "").split(".")[0] ?? "";
+    if (!REPO_COMMIT_MESSAGE_TOKEN_ROOTS.includes(root))
+      disallowed.push(root);
+  }
+  return disallowed;
+}
+var repoCommitMessageSchema = exports_external.string().max(MAX_REPO_COMMIT_MESSAGE_LENGTH).refine((message) => !/[\r\n]/.test(message), {
+  message: "must be a single line"
+}).refine((message) => findDisallowedCommitMessageTokenRoots(message).length === 0, {
+  message: `may only use {{${REPO_COMMIT_MESSAGE_TOKEN_ROOTS.join(".\u2026}}, {{")}.\u2026}} tokens`
+});
+var onPushFailureSchema = exports_external.enum(["fail", "warn"]);
+var repoConfigInputSchema = exports_external.discriminatedUnion("mode", [
+  exports_external.object({ mode: exports_external.literal("none") }).strict(),
+  exports_external.object({ mode: exports_external.literal("readOnly") }).strict(),
+  exports_external.object({
+    mode: exports_external.literal("readWrite"),
+    message: repoCommitMessageSchema.nullish(),
+    onPushFailure: onPushFailureSchema.optional()
+  }).strict()
+]);
+var repoConfigSchema = exports_external.discriminatedUnion("mode", [
+  exports_external.object({ mode: exports_external.literal("none") }).strict(),
+  exports_external.object({ mode: exports_external.literal("readOnly") }).strict(),
+  exports_external.object({
+    mode: exports_external.literal("readWrite"),
+    message: repoCommitMessageSchema.nullable(),
+    onPushFailure: onPushFailureSchema
+  }).strict()
+]);
+var REPO_RUNTIME_SUPPORT = {
+  workspace: {
+    modes: ["readOnly", "readWrite"],
+    default: "readWrite",
+    unsupportedBecause: "a devcontainer step reads its config from the clone"
+  },
+  no_workspace: {
+    modes: ["none"],
+    default: "none",
+    unsupportedBecause: "a host step has no clone"
+  }
+};
+function repoRuntimeMismatch(executionMode, mode) {
+  const support = REPO_RUNTIME_SUPPORT[executionMode];
+  return support.modes.includes(mode) ? null : support.unsupportedBecause;
+}
+function resolveRepoConfig(executionMode, input) {
+  const mode = input?.mode ?? REPO_RUNTIME_SUPPORT[executionMode].default;
+  if (mode !== "readWrite")
+    return { mode };
+  const readWrite = input?.mode === "readWrite" ? input : undefined;
+  return {
+    mode,
+    message: readWrite?.message ?? null,
+    onPushFailure: readWrite?.onPushFailure ?? "fail"
+  };
+}
+
+export { MAX_REPO_COMMIT_MESSAGE_LENGTH, REPO_COMMIT_MESSAGE_TOKEN_ROOTS, findDisallowedCommitMessageTokenRoots, repoCommitMessageSchema, repoConfigInputSchema, repoConfigSchema, REPO_RUNTIME_SUPPORT, repoRuntimeMismatch, resolveRepoConfig };

package/dist/chunk-dp86pa6m.js

@@ -0,0 +1,68 @@
+// @bun
+// src/contracts/pipeline-document/built-ins.ts
+var BUILT_IN_ERRORS = [
+  "Scarn.All",
+  "Scarn.StepFailed",
+  "Scarn.HealthCheckFailed",
+  "Scarn.Timeout",
+  "Scarn.HeartbeatTimeout",
+  "Scarn.MaxRunsExceeded",
+  "Scarn.MaxTurnsExceeded",
+  "Scarn.ConditionError",
+  "Scarn.ArgsError"
+];
+var WAIT_ERRORS = [
+  "Scarn.All",
+  "Scarn.MaxRunsExceeded",
+  "Scarn.ArgsError"
+];
+function decisionResultSchema(actions) {
+  const keys = [...new Set(actions.map((action) => action.key))];
+  return {
+    title: "DecisionResult",
+    type: "object",
+    properties: {
+      action: keys.length === 0 ? { type: "string" } : { type: "string", enum: keys },
+      body: { type: ["string", "null"] }
+    },
+    required: ["action", "body"],
+    additionalProperties: false
+  };
+}
+var REPLY_RESULT_SCHEMA = {
+  title: "ReplyResult",
+  type: "object",
+  properties: {
+    replied: { type: "boolean" },
+    body: { type: ["string", "null"] },
+    commentId: { type: ["string", "null"] }
+  },
+  required: ["replied", "body", "commentId"],
+  additionalProperties: false
+};
+var CONVERSATION_RESULT_SCHEMA = {
+  title: "ConversationResult",
+  type: "object",
+  properties: {
+    conversationId: { type: "string" },
+    summary: { type: "string" }
+  },
+  required: ["conversationId", "summary"],
+  additionalProperties: false
+};
+var REPLY_INPUT_SCHEMA = {
+  type: "array",
+  items: { type: "string" }
+};
+var ERROR_SCHEMA = {
+  title: "Error",
+  type: "object",
+  properties: {
+    name: { type: "string" },
+    message: { type: "string" },
+    cause: {}
+  },
+  required: ["name", "message"]
+};
+
+export { BUILT_IN_ERRORS, WAIT_ERRORS, decisionResultSchema, REPLY_RESULT_SCHEMA, CONVERSATION_RESULT_SCHEMA, REPLY_INPUT_SCHEMA, ERROR_SCHEMA };

package/dist/chunk-e1h021kq.js

@@ -0,0 +1,86 @@
+// @bun
+import {
+  exports_external
+} from "./chunk-skzxcba3.js";
+
+// src/opencode-mcp.ts
+var nonEmptyStringSchema = exports_external.string().trim().min(1);
+var mcpStringMapSchema = exports_external.record(exports_external.string(), exports_external.string());
+var positiveIntSchema = exports_external.int().gt(0).max(Number.MAX_SAFE_INTEGER);
+var openCodeMcpTimeoutSchema = exports_external.object({
+  startup: positiveIntSchema.optional(),
+  catalog: positiveIntSchema.optional(),
+  execution: positiveIntSchema.optional()
+}).strict();
+var openCodeMcpProtocolSchema = exports_external.enum([
+  "legacy",
+  "auto",
+  "2026-07-28"
+]);
+var sharedServerFields = {
+  disabled: exports_external.boolean().optional(),
+  codemode: exports_external.boolean().optional(),
+  timeout: openCodeMcpTimeoutSchema.optional(),
+  protocol: openCodeMcpProtocolSchema.optional()
+};
+var openCodeMcpLocalConfigSchema = exports_external.object({
+  type: exports_external.literal("local"),
+  command: exports_external.array(nonEmptyStringSchema).min(1),
+  cwd: exports_external.string().optional(),
+  environment: mcpStringMapSchema.optional(),
+  ...sharedServerFields
+}).strict();
+var openCodeMcpOAuthConfigSchema = exports_external.object({
+  client_id: exports_external.string().optional(),
+  client_secret: exports_external.string().optional(),
+  scope: exports_external.string().optional(),
+  callback_port: positiveIntSchema.optional(),
+  redirect_uri: exports_external.string().optional(),
+  auth_server_metadata_url: exports_external.string().optional()
+}).strict();
+var openCodeMcpRemoteConfigSchema = exports_external.object({
+  type: exports_external.literal("remote"),
+  url: exports_external.string(),
+  headers: mcpStringMapSchema.optional(),
+  oauth: exports_external.union([openCodeMcpOAuthConfigSchema, exports_external.literal(false)]).optional(),
+  ...sharedServerFields
+}).strict();
+var openCodeMcpRefConfigSchema = exports_external.object({
+  type: exports_external.literal("ref"),
+  name: nonEmptyStringSchema.optional(),
+  ...sharedServerFields
+}).strict();
+var openCodeResolvedMcpServerConfigSchema = exports_external.discriminatedUnion("type", [openCodeMcpLocalConfigSchema, openCodeMcpRemoteConfigSchema]);
+var openCodeResolvedMcpServersSchema = exports_external.record(exports_external.string(), openCodeResolvedMcpServerConfigSchema);
+var openCodeMcpServerConfigSchema = exports_external.discriminatedUnion("type", [
+  openCodeMcpLocalConfigSchema,
+  openCodeMcpRemoteConfigSchema,
+  openCodeMcpRefConfigSchema
+]);
+var openCodeMcpServersSchema = exports_external.record(exports_external.string(), openCodeMcpServerConfigSchema);
+var ENV_PLACEHOLDER_PATTERN = /\{env:[A-Za-z_][A-Za-z0-9_]*\}/gu;
+var ENV_PLACEHOLDER_NAME_PATTERN = /\{env:([^}]+)\}/gu;
+var AUTH_SCHEME_PATTERN = /^(?:bearer|basic|token)\s+/iu;
+function isEnvPlaceholderValue(value) {
+  if (value.match(ENV_PLACEHOLDER_PATTERN) === null)
+    return false;
+  return value.trim().replace(AUTH_SCHEME_PATTERN, "").replace(ENV_PLACEHOLDER_PATTERN, "").trim() === "";
+}
+function collectEnvPlaceholderNames(value) {
+  const names = new Set;
+  const visit = (item) => {
+    if (typeof item === "string") {
+      for (const match of item.matchAll(ENV_PLACEHOLDER_NAME_PATTERN)) {
+        if (match[1] !== undefined)
+          names.add(match[1]);
+      }
+    } else if (typeof item === "object" && item !== null) {
+      for (const child of Object.values(item))
+        visit(child);
+    }
+  };
+  visit(value);
+  return [...names].sort();
+}
+
+export { openCodeMcpTimeoutSchema, openCodeMcpProtocolSchema, openCodeMcpLocalConfigSchema, openCodeMcpOAuthConfigSchema, openCodeMcpRemoteConfigSchema, openCodeMcpRefConfigSchema, openCodeResolvedMcpServerConfigSchema, openCodeResolvedMcpServersSchema, openCodeMcpServerConfigSchema, openCodeMcpServersSchema, isEnvPlaceholderValue, collectEnvPlaceholderNames };