@scarn/sdk 0.0.0-stage → 0.0.0

package/dist/chunk-eg1hcvhb.js

@@ -0,0 +1,300 @@
+// @bun
+// src/pipelines/source.ts
+var FRAME = /\(?((?:file:\/\/)?[^\s()]+):(\d+):(\d+)\)?\s*$/;
+function sdkRoot() {
+  const here = new URL(import.meta.url).pathname;
+  const parts = here.split("/");
+  return parts.slice(0, -2).join("/") + "/";
+}
+var SDK_ROOT = sdkRoot();
+function toPath(file) {
+  return file.startsWith("file://") ? new URL(file).pathname : file;
+}
+function parseFrame(frame) {
+  const match = FRAME.exec(frame.trim());
+  if (match === null) {
+    return null;
+  }
+  const [, file, line, column] = match;
+  if (file === undefined || line === undefined || column === undefined) {
+    return null;
+  }
+  return { file: toPath(file), line: Number(line), column: Number(column) };
+}
+function captureSite(stack = new Error().stack) {
+  for (const frame of (stack ?? "").split(`
+`).slice(1)) {
+    const site = parseFrame(frame);
+    if (site !== null && !site.file.startsWith(SDK_ROOT) && !site.file.startsWith("node:") && site.file.includes("/")) {
+      return site;
+    }
+  }
+  return null;
+}
+function cwd() {
+  const proc = globalThis.process;
+  return typeof proc?.cwd === "function" ? proc.cwd() : null;
+}
+function formatSite(site) {
+  if (site === null) {
+    return "<unknown>";
+  }
+  const base = cwd();
+  const file = base !== null && site.file.startsWith(`${base}/`) ? site.file.slice(base.length + 1) : site.file;
+  return `${file}:${String(site.line)}`;
+}
+
+// src/pipelines/errors.ts
+function formatIssue2(issue) {
+  return `${formatSite(issue.site)} (${issue.pointer === "" ? "/" : issue.pointer}): ${issue.message}`;
+}
+
+class PipelineBuildError2 extends Error {
+  issues;
+  constructor(key, issues) {
+    super(`Pipeline "${key}" has ${String(issues.length)} build error${issues.length === 1 ? "" : "s"}:
+${issues.map((issue) => `  ${formatIssue2(issue)}`).join(`
+`)}`);
+    this.name = "PipelineBuildError";
+    this.issues = issues;
+  }
+}
+
+class AuthoringError extends Error {
+  site;
+  constructor(message, site = captureSite()) {
+    super(message);
+    this.name = "AuthoringError";
+    this.site = site;
+  }
+}
+
+// src/pipelines/model.ts
+function emptyChain(node) {
+  return {
+    node,
+    settings: {},
+    retry: [],
+    catch: [],
+    next: undefined,
+    site: captureSite()
+  };
+}
+
+// src/pipelines/registry.ts
+var nodes = new WeakMap;
+var targets = new WeakMap;
+var eaches = new WeakMap;
+var chains = new WeakMap;
+var pendingChains = new Set;
+function registerNode(value, node) {
+  nodes.set(value, node);
+  return value;
+}
+function registerTarget(value, target) {
+  targets.set(value, target);
+  return value;
+}
+function registerEach(value, each) {
+  eaches.set(value, each);
+  return value;
+}
+function registerChain(value, chain) {
+  chains.set(value, chain);
+  if (chain.next !== undefined) {
+    pendingChains.add(chain);
+  }
+  return value;
+}
+function isObject(value) {
+  return (typeof value === "object" || typeof value === "function") && value !== null;
+}
+function nodeOf(value) {
+  return isObject(value) ? nodes.get(value) : undefined;
+}
+function targetOf(value) {
+  return isObject(value) ? targets.get(value) : undefined;
+}
+function eachOf(value) {
+  return isObject(value) ? eaches.get(value) : undefined;
+}
+function chainOf(value) {
+  return isObject(value) ? chains.get(value) : undefined;
+}
+function requireNode(value, what) {
+  const node = nodeOf(value);
+  if (node === undefined) {
+    throw new AuthoringError(`${what} must be a step, decision or reply handle`);
+  }
+  return node;
+}
+
+// src/pipelines/chain.ts
+function next(data, change) {
+  return chainValue({ ...data, ...change, site: captureSite() });
+}
+function assertOpen(data, method) {
+  if (data.next !== undefined) {
+    throw new AuthoringError(`.${method}() can't follow .next(): the chain for "${data.node.id}" is already finished`);
+  }
+}
+function isTargetSpec(value) {
+  return typeof value === "function" || nodeOf(value) !== undefined || targetOf(value) !== undefined || eachOf(value) !== undefined || chainOf(value) !== undefined;
+}
+function nextData(id, arg) {
+  const site = captureSite();
+  if (isTargetSpec(arg) || !("routes" in arg)) {
+    return {
+      match: undefined,
+      routes: [{ when: undefined, target: arg }],
+      otherwise: undefined,
+      site
+    };
+  }
+  const options = arg;
+  if (options.match !== undefined && options.match !== "first" && options.match !== "all") {
+    throw new AuthoringError(`.next() for "${id}": match "${options.match}" isn't supported; use "first" or "all"`);
+  }
+  if (options.routes === undefined || options.routes.length === 0) {
+    throw new AuthoringError(`.next() for "${id}" needs at least one route in "routes"`);
+  }
+  const routes = options.routes.map((route, index) => {
+    if (route.to === undefined) {
+      throw new AuthoringError(`.next() for "${id}": route ${String(index)} has no "to"`);
+    }
+    return { when: route.when, target: route.to };
+  });
+  return {
+    match: options.match === "all" ? "all" : undefined,
+    routes,
+    otherwise: options.otherwise,
+    site
+  };
+}
+function chainMethods(data) {
+  return {
+    settings: (settings) => {
+      const current = data();
+      assertOpen(current, "settings");
+      return next(current, { settings: { ...settings } });
+    },
+    retry: (options) => {
+      const current = data();
+      assertOpen(current, "retry");
+      if (current.node.kind !== "step") {
+        throw new AuthoringError(`"${current.node.id}" is a wait and can't retry`);
+      }
+      return next(current, {
+        retry: [
+          ...current.retry,
+          { on: [...options.on], maxAttempts: options.maxAttempts }
+        ]
+      });
+    },
+    catch: (on, target) => {
+      const current = data();
+      assertOpen(current, "catch");
+      return next(current, {
+        catch: [...current.catch, { on: [...on], target, site: captureSite() }]
+      });
+    },
+    next: (arg) => {
+      const current = data();
+      assertOpen(current, "next");
+      return next(current, { next: nextData(current.node.id, arg) });
+    }
+  };
+}
+function chainValue(data) {
+  return registerChain(Object.freeze({
+    _tag: "pipeline_chain",
+    node: data.node.id,
+    ...chainMethods(() => data)
+  }), data);
+}
+var HANDLE_METHODS = ["settings", "retry", "catch", "next"];
+function attachChainMethods(handle, node) {
+  const methods = chainMethods(() => emptyChain(node));
+  for (const name of HANDLE_METHODS) {
+    if (node.kind !== "step" && name === "retry") {
+      continue;
+    }
+    Object.defineProperty(handle, name, {
+      value: methods[name],
+      enumerable: false,
+      configurable: true
+    });
+  }
+}
+
+// src/pipelines/handles.ts
+function checkArgs(node, args) {
+  if (args !== undefined && (typeof args !== "object" || args === null)) {
+    throw new AuthoringError(`args for "${node.id}" must be an object`);
+  }
+}
+function targetFn(node) {
+  return (args) => {
+    checkArgs(node, args);
+    return registerTarget(Object.freeze({ _tag: "pipeline_target", to: node.id }), { node, args, site: captureSite() });
+  };
+}
+function partialFn(node) {
+  return (args) => {
+    checkArgs(node, args);
+    return registerTarget(Object.freeze({ _tag: "pipeline_partial", to: node.id }), { node, args, site: captureSite(), partial: true });
+  };
+}
+function makeHandle(handle, node) {
+  attachChainMethods(handle, node);
+  registerNode(handle, node);
+  Object.defineProperty(handle, "partial", {
+    value: partialFn(node),
+    enumerable: false,
+    configurable: true
+  });
+  if (node.kind === "step") {
+    Object.defineProperty(handle, "as", {
+      value: (id) => stepHandleFor({ ...node, id, site: captureSite() }),
+      enumerable: false,
+      configurable: true
+    });
+  }
+  return handle;
+}
+function stepHandleFor(node) {
+  const handle = targetFn(node);
+  if (node.kind === "step") {
+    Object.defineProperties(handle, {
+      key: { value: node.step, enumerable: true },
+      inputSchemaJson: { value: node.inputSchema, enumerable: true },
+      resultSchemaJson: { value: node.resultSchema, enumerable: true },
+      errors: { value: node.errors, enumerable: true }
+    });
+  }
+  return makeHandle(handle, node);
+}
+function stepNode(source, local = true) {
+  return {
+    kind: "step",
+    id: source.key,
+    step: source.key,
+    local,
+    inputSchema: source.inputSchemaJson ?? null,
+    resultSchema: source.resultSchemaJson ?? null,
+    conversation: local && source.kind !== "code" && source.resultSchemaJson === null,
+    errors: [...source.errors ?? []],
+    site: captureSite()
+  };
+}
+function stepCall(node) {
+  return targetFn(node);
+}
+function waitHandle(node) {
+  return makeHandle(targetFn(node), node);
+}
+function bareStepHandle(source, local) {
+  return stepHandleFor(stepNode(source, local));
+}
+
+export { captureSite, formatIssue2, PipelineBuildError2, AuthoringError, pendingChains, registerNode, registerTarget, registerEach, nodeOf, targetOf, eachOf, chainOf, requireNode, makeHandle, stepNode, stepCall, waitHandle, bareStepHandle };

package/dist/chunk-g0rdnn0r.js

@@ -0,0 +1,95 @@
+// @bun
+import {
+  string,
+  int,
+  boolean,
+  array,
+  object,
+  union,
+  discriminatedUnion,
+  record,
+  _enum,
+  literal
+} from "./chunk-dnn39qt4.js";
+
+// src/opencode-mcp.ts
+var nonEmptyStringSchema = string().trim().min(1);
+var mcpStringMapSchema = record(string(), string());
+var positiveIntSchema = int().gt(0).max(Number.MAX_SAFE_INTEGER);
+var openCodeMcpTimeoutSchema2 = object({
+  startup: positiveIntSchema.optional(),
+  catalog: positiveIntSchema.optional(),
+  execution: positiveIntSchema.optional()
+}).strict();
+var openCodeMcpProtocolSchema2 = _enum([
+  "legacy",
+  "auto",
+  "2026-07-28"
+]);
+var sharedServerFields = {
+  disabled: boolean().optional(),
+  codemode: boolean().optional(),
+  timeout: openCodeMcpTimeoutSchema2.optional(),
+  protocol: openCodeMcpProtocolSchema2.optional()
+};
+var openCodeMcpLocalConfigSchema2 = object({
+  type: literal("local"),
+  command: array(nonEmptyStringSchema).min(1),
+  cwd: string().optional(),
+  environment: mcpStringMapSchema.optional(),
+  ...sharedServerFields
+}).strict();
+var openCodeMcpOAuthConfigSchema2 = object({
+  client_id: string().optional(),
+  client_secret: string().optional(),
+  scope: string().optional(),
+  callback_port: positiveIntSchema.optional(),
+  redirect_uri: string().optional(),
+  auth_server_metadata_url: string().optional()
+}).strict();
+var openCodeMcpRemoteConfigSchema2 = object({
+  type: literal("remote"),
+  url: string(),
+  headers: mcpStringMapSchema.optional(),
+  oauth: union([openCodeMcpOAuthConfigSchema2, literal(false)]).optional(),
+  ...sharedServerFields
+}).strict();
+var openCodeMcpRefConfigSchema2 = object({
+  type: literal("ref"),
+  name: nonEmptyStringSchema.optional(),
+  ...sharedServerFields
+}).strict();
+var openCodeResolvedMcpServerConfigSchema2 = discriminatedUnion("type", [openCodeMcpLocalConfigSchema2, openCodeMcpRemoteConfigSchema2]);
+var openCodeResolvedMcpServersSchema2 = record(string(), openCodeResolvedMcpServerConfigSchema2);
+var openCodeMcpServerConfigSchema2 = discriminatedUnion("type", [
+  openCodeMcpLocalConfigSchema2,
+  openCodeMcpRemoteConfigSchema2,
+  openCodeMcpRefConfigSchema2
+]);
+var openCodeMcpServersSchema2 = record(string(), openCodeMcpServerConfigSchema2);
+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 isEnvPlaceholderValue2(value) {
+  if (value.match(ENV_PLACEHOLDER_PATTERN) === null)
+    return false;
+  return value.trim().replace(AUTH_SCHEME_PATTERN, "").replace(ENV_PLACEHOLDER_PATTERN, "").trim() === "";
+}
+function collectEnvPlaceholderNames2(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 { openCodeMcpTimeoutSchema2, openCodeMcpProtocolSchema2, openCodeMcpLocalConfigSchema2, openCodeMcpOAuthConfigSchema2, openCodeMcpRemoteConfigSchema2, openCodeMcpRefConfigSchema2, openCodeResolvedMcpServerConfigSchema2, openCodeResolvedMcpServersSchema2, openCodeMcpServerConfigSchema2, openCodeMcpServersSchema2, isEnvPlaceholderValue2, collectEnvPlaceholderNames2 };

package/dist/chunk-h9yxx0hd.js

@@ -0,0 +1,116 @@
+// @bun
+// src/jsonc.ts
+var stripJsoncComments2 = (content) => {
+  let result = "";
+  let inString = false;
+  let escapeNextCharacter = false;
+  let lineComment = false;
+  let blockComment = false;
+  for (let index = 0;index < content.length; index += 1) {
+    const character = content.charAt(index);
+    const nextCharacter = content.charAt(index + 1);
+    if (lineComment) {
+      if (character === `
+`) {
+        lineComment = false;
+        result += character;
+      }
+      continue;
+    }
+    if (blockComment) {
+      if (character === "*" && nextCharacter === "/") {
+        blockComment = false;
+        index += 1;
+      }
+      continue;
+    }
+    if (inString) {
+      result += character;
+      if (escapeNextCharacter) {
+        escapeNextCharacter = false;
+        continue;
+      }
+      if (character === "\\") {
+        escapeNextCharacter = true;
+        continue;
+      }
+      if (character === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (character === '"') {
+      inString = true;
+      result += character;
+      continue;
+    }
+    if (character === "/" && nextCharacter === "/") {
+      lineComment = true;
+      index += 1;
+      continue;
+    }
+    if (character === "/" && nextCharacter === "*") {
+      blockComment = true;
+      index += 1;
+      continue;
+    }
+    result += character;
+  }
+  return result;
+};
+var stripTrailingCommas2 = (content) => {
+  let result = "";
+  let inString = false;
+  let escapeNextCharacter = false;
+  for (let index = 0;index < content.length; index += 1) {
+    const character = content.charAt(index);
+    if (inString) {
+      result += character;
+      if (escapeNextCharacter) {
+        escapeNextCharacter = false;
+        continue;
+      }
+      if (character === "\\") {
+        escapeNextCharacter = true;
+        continue;
+      }
+      if (character === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (character === '"') {
+      inString = true;
+      result += character;
+      continue;
+    }
+    if (character === ",") {
+      let lookaheadIndex = index + 1;
+      while (lookaheadIndex < content.length) {
+        const lookaheadCharacter = content.charAt(lookaheadIndex);
+        if (/\s/u.test(lookaheadCharacter)) {
+          lookaheadIndex += 1;
+          continue;
+        }
+        if (lookaheadCharacter === "}" || lookaheadCharacter === "]") {
+          break;
+        }
+        result += character;
+        break;
+      }
+      if (lookaheadIndex >= content.length) {
+        continue;
+      }
+      const lookaheadCharacter = content.charAt(lookaheadIndex);
+      if (lookaheadCharacter === "}" || lookaheadCharacter === "]") {
+        continue;
+      }
+      continue;
+    }
+    result += character;
+  }
+  return result;
+};
+var parseJsonc2 = (content) => JSON.parse(stripTrailingCommas2(stripJsoncComments2(content)));
+
+export { stripJsoncComments2, stripTrailingCommas2, parseJsonc2 };

package/dist/chunk-njd6npf0.js

@@ -0,0 +1,35 @@
+// @bun
+// src/push/code-step-lookup.ts
+function isStepDefinitionSpec2(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 stepsInModule2(mod) {
+  const found = new Set;
+  for (const [exportName, value] of Object.entries(mod)) {
+    if (exportName !== "default" && isStepDefinitionSpec2(value)) {
+      found.add(value);
+    }
+  }
+  return [...found];
+}
+function findCodeStepInModule2(mod, key) {
+  const fns = new Set;
+  for (const spec of stepsInModule2(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 { isStepDefinitionSpec2, stepsInModule2, findCodeStepInModule2 };