astrocode-workflow 0.0.1

package/src/config/schema.ts

@@ -0,0 +1,236 @@
+import { z } from "zod";
+
+export const PermissionValueSchema = z.enum(["ask", "allow", "deny"]);
+export type PermissionValue = z.infer<typeof PermissionValueSchema>;
+
+const StageKeySchema = z.enum([
+  "frame",
+  "plan",
+  "spec",
+  "implement",
+  "review",
+  "verify",
+  "close",
+]);
+export type StageKey = z.infer<typeof StageKeySchema>;
+
+const InjectionModeSchema = z.enum(["visible", "silent"]);
+
+const TruncationPolicySchema = z
+  .object({
+  enabled: z.boolean().default(true),
+  truncate_all_tool_outputs: z.boolean().default(false),
+  max_chars_default: z.number().int().positive().default(200_000),
+  max_chars_webfetch: z.number().int().positive().default(40_000),
+  max_chars_diff: z.number().int().positive().default(120_000),
+  persist_truncated_outputs: z.boolean().default(true),
+  })
+  .partial()
+  .default({});
+
+const ContextCompactionSchema = z
+  .object({
+  enabled: z.boolean().default(true),
+  snapshot_after_stage_count: z.number().int().positive().default(2),
+  snapshot_max_lines: z.number().int().positive().default(60),
+  baton_summary_max_lines: z.number().int().positive().default(25),
+  inject_max_chars: z.number().int().positive().default(18_000),
+  })
+  .partial()
+  .default({});
+
+const ContinuationSchema = z
+  .object({
+  enabled: z.boolean().default(true),
+  injection_mode: InjectionModeSchema.default("visible"),
+
+  inject_on_session_idle: z.boolean().default(true),
+  session_idle_ms: z.number().int().positive().default(12_000),
+
+  inject_on_tool_done_if_run_active: z.boolean().default(true),
+  inject_on_message_done_if_run_active: z.boolean().default(true),
+
+  dedupe_window_ms: z.number().int().positive().default(20_000),
+  max_same_directive_repeats: z.number().int().positive().default(1),
+
+  auto_continue: z.boolean().default(false),
+  auto_continue_delay_ms: z.number().int().positive().default(1500),
+  max_auto_steps_per_session: z.number().int().positive().default(50),
+  })
+  .partial()
+  .default({});
+
+const ToastsSchema = z
+  .object({
+  enabled: z.boolean().default(true),
+  throttle_ms: z.number().int().positive().default(1500),
+  show_run_started: z.boolean().default(true),
+  show_stage_started: z.boolean().default(true),
+  show_stage_completed: z.boolean().default(true),
+  show_stage_failed: z.boolean().default(true),
+  show_run_completed: z.boolean().default(true),
+  show_auto_continue: z.boolean().default(true),
+  })
+  .partial()
+  .default({});
+
+const DbSchema = z
+  .object({
+    path: z.string().default(".astro/astro.db"),
+    busy_timeout_ms: z.number().int().positive().default(5000),
+    pragmas: z
+      .object({
+        journal_mode: z.enum(["WAL", "DELETE"]).default("WAL"),
+        synchronous: z.enum(["NORMAL", "FULL", "OFF"]).default("NORMAL"),
+        foreign_keys: z.boolean().default(true),
+        temp_store: z.enum(["DEFAULT", "MEMORY", "FILE"]).default("MEMORY"),
+      })
+      // Why: Zod's .default({}) requires the *type* to accept an empty object.
+      //       We still want runtime defaults for each key, so we make keys optional.
+      .partial()
+      .default({}),
+    schema_version_required: z.number().int().positive().default(2),
+    allow_auto_migrate: z.boolean().default(true),
+    fail_on_downgrade: z.boolean().default(true),
+  })
+  // Why: allow "db: {}" (or missing db) while still applying defaults.
+  .partial()
+  .default({});
+
+const WorkflowSchema = z.object({
+  pipeline: z.array(StageKeySchema).default([
+    "frame",
+    "plan",
+    "spec",
+    "implement",
+    "review",
+    "verify",
+    "close",
+  ]),
+
+  default_mode: z.enum(["step", "loop"]).default("step"),
+  default_max_steps: z.number().int().positive().default(1),
+  loop_max_steps_hard_cap: z.number().int().positive().default(200),
+
+  plan_max_tasks: z.number().int().positive().default(7),
+  plan_max_lines: z.number().int().positive().default(80),
+
+  forbid_prompt_narration: z.boolean().default(true),
+  single_active_run_per_repo: z.boolean().default(true),
+  lock_timeout_ms: z.number().int().positive().default(4000),
+
+  role_first_subagents: z.boolean().default(true),
+
+  evidence_required: z
+    .object({
+      verify: z.boolean().default(true),
+      implement: z.boolean().default(false),
+    })
+    // NOTE: We want callers to be able to omit the whole object ("{}")
+    // while still receiving per-field defaults at parse time.
+    .partial()
+    .default({}),
+}).partial().default({});
+
+const ArtifactsSchema = z.object({
+  root_dir: z.string().default(".astro"),
+  runs_dir: z.string().default(".astro/runs"),
+  spec_path: z.string().default(".astro/spec.md"),
+
+  write_full_baton_md: z.boolean().default(true),
+  write_baton_summary_md: z.boolean().default(true),
+  write_baton_output_json: z.boolean().default(true),
+
+  baton_filename: z.string().default("baton.md"),
+  baton_summary_filename: z.string().default("baton.summary.md"),
+  baton_json_filename: z.string().default("baton.json"),
+}).partial().default({});
+
+const AgentsSchema = z.object({
+  // Display name for the *primary* agent tab.
+  orchestrator_name: z.string().default("Astro"),
+
+  // Display names for the stage sub-agents.
+  stage_agent_names: z
+    .object({
+      frame: z.string().default("Astro — Frame"),
+      plan: z.string().default("Astro — Plan"),
+      spec: z.string().default("Astro — Spec"),
+      implement: z.string().default("Astro — Implement"),
+      review: z.string().default("Astro — Review"),
+      verify: z.string().default("Astro — Verify"),
+      close: z.string().default("Astro — Close"),
+    })
+    .partial()
+    .default({}),
+
+  librarian_name: z.string().default("Astro — Librarian"),
+  explore_name: z.string().default("Astro — Explore"),
+
+  agent_variant_overrides: z
+    .record(
+      z.string(),
+      z.object({
+        variant: z.string().optional(),
+        model: z.string().optional(),
+      })
+    )
+    .default({}),
+}).partial().default({});
+
+const PermissionsSchema = z.object({
+  enforce_task_tool_restrictions: z.boolean().default(true),
+  deny_delegate_task_in_subagents: z.boolean().default(true),
+}).partial().default({});
+
+const GitSchema = z.object({
+  enabled: z.boolean().default(true),
+  allow_dirty_start: z.boolean().default(true),
+  auto_branch: z.boolean().default(true),
+  branch_prefix: z.string().default("astro/"),
+  auto_commit: z.boolean().default(false),
+  commit_message_template: z.string().default("astro: {{story_key}} {{title}}"),
+  persist_diff_artifacts: z.boolean().default(true),
+}).partial().default({});
+
+const UiSchema = z
+  .object({
+    toasts: ToastsSchema,
+    continue_prompt: z
+      .object({
+        enabled: z.boolean().default(true),
+        mode: z.enum(["toast_button", "popup", "chat_only"]).default("toast_button"),
+        idle_prompt_ms: z.number().int().positive().default(20_000),
+      })
+      .partial()
+      .default({}),
+  })
+  .partial()
+  .default({});
+
+export const AstrocodeConfigSchema = z.object({
+  disabled_hooks: z.array(z.string()).default([]),
+  disabled_agents: z.array(z.string()).default([]),
+  disabled_commands: z.array(z.string()).default([]),
+
+  determinism: z
+    .object({
+      mode: z.enum(["on", "off"]).default("on"),
+      strict_stage_order: z.boolean().default(true),
+    })
+    .partial()
+    .default({}),
+
+  db: DbSchema,
+  workflow: WorkflowSchema,
+  continuation: ContinuationSchema,
+  truncation: TruncationPolicySchema,
+  context_compaction: ContextCompactionSchema,
+  artifacts: ArtifactsSchema,
+  agents: AgentsSchema,
+  permissions: PermissionsSchema,
+  git: GitSchema,
+  ui: UiSchema,
+}).partial().default({});
+
+export type AstrocodeConfig = z.infer<typeof AstrocodeConfigSchema>;

package/src/hooks/continuation-enforcer.ts

@@ -0,0 +1,217 @@
+import type { AstrocodeConfig } from "../config/schema";
+import type { SqliteDb } from "../state/db";
+import { buildContextSnapshot } from "../workflow/context";
+import { decideNextAction, getActiveRun } from "../workflow/state-machine";
+import { buildContinueDirective, type BuiltDirective } from "../workflow/directives";
+import { injectChatPrompt } from "../ui/inject";
+import { nowISO } from "../shared/time";
+import { createToastManager } from "../ui/toasts";
+
+type SessionState = {
+  lastHash: string | null;
+  lastAtMs: number;
+  repeats: number;
+  autoSteps: number;
+  idleTimer: NodeJS.Timeout | null;
+};
+
+type ToolExecuteAfterInput = {
+  tool: string;
+  sessionID?: string;
+};
+
+type ChatMessageInput = {
+  sessionID: string;
+  agent: string;
+};
+
+type EventInput = {
+  event: { type: string; properties: any };
+};
+
+function msFromIso(iso: string): number {
+  const t = Date.parse(iso);
+  return Number.isFinite(t) ? t : 0;
+}
+
+export function createContinuationEnforcer(opts: {
+  ctx: any;
+  config: AstrocodeConfig;
+  db: SqliteDb;
+}) {
+  const { ctx, config, db } = opts;
+
+  const toasts = createToastManager({ ctx, throttleMs: config.ui.toasts.throttle_ms });
+
+  const sessions = new Map<string, SessionState>();
+
+  function getState(sessionId: string): SessionState {
+    const cur = sessions.get(sessionId);
+    if (cur) return cur;
+    const state: SessionState = { lastHash: null, lastAtMs: 0, repeats: 0, autoSteps: 0, idleTimer: null };
+    sessions.set(sessionId, state);
+    return state;
+  }
+
+  function clearIdleTimer(sessionId: string) {
+    const s = getState(sessionId);
+    if (s.idleTimer) {
+      clearTimeout(s.idleTimer);
+      s.idleTimer = null;
+    }
+  }
+
+  function scheduleIdleInjection(sessionId: string) {
+    clearIdleTimer(sessionId);
+    if (!config.continuation.enabled) return;
+    if (!config.continuation.inject_on_session_idle) return;
+
+    const delay = config.continuation.session_idle_ms;
+
+    const s = getState(sessionId);
+    s.idleTimer = setTimeout(() => {
+      // Fire and forget
+      void maybeInjectContinue(sessionId, "idle_timer");
+    }, delay);
+  }
+
+  function shouldDedupe(sessionId: string, directive: BuiltDirective): boolean {
+    const s = getState(sessionId);
+    const now = Date.now();
+
+    // Memory window
+    if (s.lastHash === directive.hash && now - s.lastAtMs < config.continuation.dedupe_window_ms) {
+      if (s.repeats >= config.continuation.max_same_directive_repeats) return true;
+    }
+
+    // DB window (durable)
+    const cutoff = new Date(now - config.continuation.dedupe_window_ms).toISOString();
+    const row = db
+      .prepare(
+        "SELECT COUNT(*) as c FROM continuations WHERE session_id=? AND directive_hash=? AND created_at > ?"
+      )
+      .get(sessionId, directive.hash, cutoff) as { c: number } | undefined;
+
+    if ((row?.c ?? 0) >= config.continuation.max_same_directive_repeats) return true;
+
+    return false;
+  }
+
+  async function recordContinuation(sessionId: string, runId: string | null, directive: BuiltDirective, reason: string) {
+    db.prepare(
+      "INSERT INTO continuations (session_id, run_id, directive_hash, kind, reason, created_at) VALUES (?, ?, ?, ?, ?, ?)"
+    ).run(sessionId, runId, directive.hash, directive.kind, reason, nowISO());
+
+    const s = getState(sessionId);
+    const now = Date.now();
+    if (s.lastHash === directive.hash && now - s.lastAtMs < config.continuation.dedupe_window_ms) {
+      s.repeats += 1;
+    } else {
+      s.lastHash = directive.hash;
+      s.repeats = 1;
+    }
+    s.lastAtMs = now;
+  }
+
+  function formatNextAction(next: ReturnType<typeof decideNextAction>): string {
+    switch (next.kind) {
+      case "idle":
+        return "No approved stories. Queue/approve a story.";
+      case "start_run":
+        return `Start run for story ${next.story_key}.`;
+      case "delegate_stage":
+        return `Delegate stage ${next.stage_key}.`;
+      case "await_stage_completion":
+        return `Await stage ${next.stage_key} completion. If you have stage output, call astro_stage_complete.`;
+      case "complete_run":
+        return `Complete run ${next.run_id}.`;
+      case "failed":
+        return `Run failed at stage ${next.stage_key}: ${next.error_text}`;
+      default:
+        return "Continue.";
+    }
+  }
+
+  async function maybeInjectContinue(sessionId: string, reason: string) {
+    if (!config.continuation.enabled) return;
+
+    // Require active run
+    const active = getActiveRun(db);
+    if (!active) return;
+
+    const next = decideNextAction(db, config);
+
+    // If failed, don't auto-inject "continue" — surface via toast and stop.
+    if (next.kind === "failed") {
+      if (config.ui.toasts.enabled && config.ui.toasts.show_stage_failed) {
+        await toasts.show({ title: "Astrocode", message: `Run failed at ${next.stage_key}`, variant: "error" });
+      }
+      return;
+    }
+
+    const nextActionStr = formatNextAction(next);
+    const context = buildContextSnapshot({ db, config, run_id: active.run_id, next_action: nextActionStr });
+
+    const directive = buildContinueDirective({
+      config,
+      run_id: active.run_id,
+      stage_key: active.current_stage_key,
+      next_action: nextActionStr,
+      context_snapshot_md: context,
+    });
+
+    if (shouldDedupe(sessionId, directive)) return;
+
+    await recordContinuation(sessionId, active.run_id, directive, reason);
+
+    // Injection mode
+    if (config.continuation.injection_mode === "visible") {
+      await injectChatPrompt({ ctx, sessionId, text: directive.body });
+    } else {
+      // Silent mode is TODO: requires experimental.chat.messages.transform.
+      // For v2-alpha, we fall back to visible injection but mark it.
+      await injectChatPrompt({ ctx, sessionId, text: directive.body + "\n\n(Injected in silent mode fallback)" });
+    }
+
+    if (config.ui.toasts.enabled && config.ui.toasts.show_auto_continue) {
+      await toasts.show({ title: "Astrocode", message: "Continue directive injected", variant: "info" });
+    }
+  }
+
+  // Public hook handlers
+  return {
+    async onToolAfter(input: ToolExecuteAfterInput) {
+      const sessionId = input.sessionID ?? (ctx as any).sessionID;
+      if (!sessionId) return;
+      if (!config.continuation.inject_on_tool_done_if_run_active) return;
+
+      scheduleIdleInjection(sessionId);
+    },
+
+    async onChatMessage(_input: ChatMessageInput) {
+      if (!config.continuation.inject_on_message_done_if_run_active) return;
+      scheduleIdleInjection(_input.sessionID);
+    },
+
+    async onEvent(input: EventInput) {
+      const type = input.event.type;
+      const sessionId = input.event.properties?.sessionID;
+      if (!sessionId) return;
+
+      if (type === "session.idle") {
+        if (!config.continuation.inject_on_session_idle) return;
+        await maybeInjectContinue(sessionId, "session.idle");
+      }
+
+      if (type === "session.created") {
+        // When a session is created and there is an active run, nudge.
+        scheduleIdleInjection(sessionId);
+      }
+
+      if (type === "session.deleted") {
+        clearIdleTimer(sessionId);
+        sessions.delete(sessionId);
+      }
+    },
+  };
+}

package/src/hooks/tool-output-truncator.ts

@@ -0,0 +1,82 @@
+import path from "node:path";
+import type { AstrocodeConfig } from "../config/schema";
+import type { SqliteDb } from "../state/db";
+import { getAstroPaths, runDir, ensureDir, toPosix } from "../shared/paths";
+import { nowISO } from "../shared/time";
+import { putArtifact } from "../workflow/artifacts";
+import { sha256Hex } from "../shared/hash";
+import { clampChars } from "../shared/text";
+import { getActiveRun } from "../workflow/state-machine";
+
+type ToolExecuteAfterInput = {
+  tool: string;
+  sessionID?: string;
+};
+
+type ToolExecuteAfterOutput = {
+  title?: string;
+  output?: string;
+  metadata?: Record<string, any>;
+};
+
+function pickMaxChars(toolName: string, cfg: AstrocodeConfig): number {
+  if (toolName.includes("webfetch") || toolName.includes("web.run")) return cfg.truncation.max_chars_webfetch;
+  if (toolName.includes("diff")) return cfg.truncation.max_chars_diff;
+  return cfg.truncation.max_chars_default;
+}
+
+export function createToolOutputTruncatorHook(opts: {
+  ctx: any;
+  config: AstrocodeConfig;
+  db: SqliteDb;
+}) {
+  const { ctx, config, db } = opts;
+
+  return async function toolExecuteAfter(input: ToolExecuteAfterInput, output: ToolExecuteAfterOutput) {
+    if (!config.truncation.enabled) return;
+
+    const toolName = input.tool;
+    const text = output.output ?? "";
+    const maxChars = pickMaxChars(toolName, config);
+
+    if (!text || text.length <= maxChars) return;
+
+    const repoRoot = (ctx as any).directory as string;
+    const paths = getAstroPaths(repoRoot, config.db.path);
+    ensureDir(paths.toolOutputDir);
+
+    const active = getActiveRun(db);
+    const timestamp = nowISO().replace(/[:.]/g, "-");
+    const relBase =
+      active && config.truncation.persist_truncated_outputs
+        ? toPosix(path.join(".astro", "runs", active.run_id, "_tool_output"))
+        : toPosix(path.join(".astro", "tool_output"));
+
+    const relPath = toPosix(path.join(relBase, toolName.replace(/[^a-zA-Z0-9_-]/g, "_"), `${timestamp}.txt`));
+
+    const { artifact_id } = putArtifact({
+      repoRoot,
+      db,
+      run_id: active?.run_id ?? null,
+      stage_key: active?.current_stage_key ?? null,
+      type: "tool_output",
+      rel_path: relPath,
+      content: text,
+      meta: { tool: toolName, session_id: input.sessionID ?? null },
+    });
+
+    const digest = sha256Hex(text);
+    const head = clampChars(text, Math.min(maxChars, 4000));
+
+    output.output =
+      head +
+      `\n\n…(truncated; sha256=${digest})\n` +
+      `Full output saved: ${relPath}\n` +
+      `Artifact ID: ${artifact_id}`;
+
+    output.metadata = output.metadata ?? {};
+    output.metadata.truncated = true;
+    output.metadata.artifact_id = artifact_id;
+    output.metadata.full_output_path = relPath;
+  };
+}

package/src/index.ts

@@ -0,0 +1,131 @@
+import type { Plugin } from "@opencode-ai/plugin";
+import { loadAstrocodeConfig } from "./config/loader";
+import { createConfigHandler } from "./config/config-handler";
+import { openSqlite, configurePragmas, ensureSchema } from "./state/db";
+import { getAstroPaths, ensureAstroDirs } from "./shared/paths";
+import { createAstroTools } from "./tools";
+import { createContinuationEnforcer } from "./hooks/continuation-enforcer";
+import { createToolOutputTruncatorHook } from "./hooks/tool-output-truncator";
+import { createToastManager } from "./ui/toasts";
+import { info, warn } from "./shared/log";
+
+console.log("Astrocode plugin loading...");
+
+const Astrocode: Plugin = async (ctx) => {
+  const repoRoot = ctx.directory as string;
+
+  // Always load config first - this provides defaults even in limited mode
+  let pluginConfig = loadAstrocodeConfig(repoRoot);
+
+  // Always ensure .astro directories exist, even in limited mode
+  const paths = getAstroPaths(repoRoot, pluginConfig.db.path);
+  ensureAstroDirs(paths);
+
+  let db: any = null;
+  let tools: any = null;
+  let configHandler: any = null;
+  let continuation: any = null;
+  let truncatorHook: any = null;
+  let toasts: any = null;
+
+  try {
+
+    db = openSqlite(paths.dbPath, { busyTimeoutMs: pluginConfig.db.busy_timeout_ms });
+    configurePragmas(db, pluginConfig.db.pragmas);
+    ensureSchema(db, { allowAutoMigrate: pluginConfig.db.allow_auto_migrate, failOnDowngrade: pluginConfig.db.fail_on_downgrade });
+
+    // Database initialized successfully
+    configHandler = createConfigHandler({ pluginConfig });
+    tools = createAstroTools({ ctx, config: pluginConfig, db });
+    continuation = createContinuationEnforcer({ ctx, config: pluginConfig, db });
+    truncatorHook = createToolOutputTruncatorHook({ ctx, config: pluginConfig, db });
+    toasts = createToastManager({ ctx, throttleMs: pluginConfig.ui.toasts.throttle_ms });
+  } catch (e) {
+    // Database initialization failed - setup limited mode
+
+    // Reload config to ensure all defaults are present
+    pluginConfig = loadAstrocodeConfig(repoRoot);
+
+    // Modify config for limited mode
+    pluginConfig.disabled_hooks = [...(pluginConfig.disabled_hooks || []), "continuation-enforcer", "tool-output-truncator"];
+    pluginConfig.ui.toasts.enabled = false;
+
+    // Create limited functionality
+    db = null;
+    configHandler = createConfigHandler({ pluginConfig });
+    tools = createAstroTools({ ctx, config: pluginConfig, db });
+    continuation = null;
+    truncatorHook = null;
+    toasts = null;
+  }
+
+  return {
+    name: "Astrocode",
+
+    // Merge agents + slash commands into system config
+    config: configHandler,
+
+    // Register tools
+    tool: tools,
+
+    // Limit created subagents from spawning more subagents (OMO-style).
+    "tool.execute.before": async (input: any, output: any) => {
+      if (!pluginConfig.permissions.enforce_task_tool_restrictions) return;
+      if (input.tool !== "task") return;
+
+      output.args = output.args ?? {};
+
+      const toolsMap = { ...(output.args.tools ?? {}) };
+
+      if (pluginConfig.permissions.deny_delegate_task_in_subagents) {
+        toolsMap.delegate_task = false;
+      }
+
+      output.args.tools = toolsMap;
+    },
+
+    "tool.execute.after": async (input: any, output: any) => {
+      // Truncate huge tool outputs to artifacts
+      if (truncatorHook && !pluginConfig.disabled_hooks.includes("tool-output-truncator")) {
+        await truncatorHook(input, output);
+      }
+
+      // Schedule continuation (do not immediately spam)
+      if (continuation && !pluginConfig.disabled_hooks.includes("continuation-enforcer")) {
+        await continuation.onToolAfter(input);
+      }
+    },
+
+    "chat.message": async (input: any, output: any) => {
+      if (continuation && !pluginConfig.disabled_hooks.includes("continuation-enforcer")) {
+        await continuation.onChatMessage(input);
+      }
+      return output;
+    },
+
+    event: async (input: any) => {
+      if (continuation && !pluginConfig.disabled_hooks.includes("continuation-enforcer")) {
+        await continuation.onEvent(input);
+      }
+    },
+
+    // Best-effort cleanup
+    close: async () => {
+      try {
+        db.close();
+      } catch {
+        // ignore
+      }
+
+      if (toasts && pluginConfig.ui.toasts.enabled) {
+        try {
+          await toasts.show({ title: "Astrocode", message: "Plugin closed", variant: "info" });
+        } catch {
+          // ignore
+        }
+      }
+    },
+  };
+};
+
+export default Astrocode;

package/src/shared/deep-merge.ts

@@ -0,0 +1,28 @@
+export function isPlainObject(v: unknown): v is Record<string, unknown> {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+
+/**
+ * Deep merge:
+ * - objects merge recursively
+ * - arrays replace
+ * - primitives overwrite
+ */
+export function deepMerge<T>(base: T, patch: Partial<T>): T {
+  if (!isPlainObject(base) || !isPlainObject(patch)) {
+    return (patch as T) ?? base;
+  }
+
+  const out: Record<string, unknown> = { ...(base as Record<string, unknown>) };
+
+  for (const [k, v] of Object.entries(patch as Record<string, unknown>)) {
+    const cur = out[k];
+    if (isPlainObject(cur) && isPlainObject(v)) {
+      out[k] = deepMerge(cur, v);
+    } else {
+      out[k] = v;
+    }
+  }
+
+  return out as T;
+}

package/src/shared/hash.ts

@@ -0,0 +1,5 @@
+import { createHash } from "node:crypto";
+
+export function sha256Hex(input: string | Buffer): string {
+  return createHash("sha256").update(input).digest("hex");
+}