imprint-mcp 0.2.0

package/src/imprint/cron.ts

@@ -0,0 +1,312 @@
+/**
+ * `imprint cron <site>` — polling daemon for a generated tool. Loads
+ * <IMPRINT_HOME>/<site>/<toolName>/cron.json, schedules via node-cron, runs the tool
+ * through the configured backend ladder per tick, and pushes via
+ * notify.ts on failure (or on a notifyWhen predicate match).
+ *
+ * One process per schedule by design — matches how systemd timers /
+ * launchd are organized and keeps failure isolation clean.
+ */
+
+import { existsSync } from 'node:fs';
+import { resolve as pathResolve } from 'node:path';
+import cron from 'node-cron';
+import { resolveLadder, runWithLadder } from './backend-ladder.ts';
+import { loadJsonFile } from './load-json.ts';
+import { createLog, isDebug } from './log.ts';
+import { evaluateNotifyWhen, notify } from './notify.ts';
+import { imprintHomeDir } from './paths.ts';
+import { loadBackendsCache } from './probe-backends.ts';
+import { checkSiteCredentialsReady } from './runtime.ts';
+import { availableSitesHint } from './sites.ts';
+import type { StealthFetch } from './stealth-fetch.ts';
+import { type ResolvedTool, buildZodValidator, discoverTools } from './tool-loader.ts';
+import { selectGeneratedTool } from './tool-selection.ts';
+import {
+  type ConcreteBackend,
+  type CronConfig,
+  CronConfigSchema,
+  type NotifyWhen,
+  type ToolResult,
+} from './types.ts';
+
+interface RunCronOptions {
+  site: string;
+  /** Override generated asset root. Defaults to IMPRINT_HOME (~/.imprint). */
+  assetRoot?: string;
+  /** Override config path. Defaults to <assetRoot>/<site>/<toolName>/cron.json. */
+  configPath?: string;
+  /** Select a specific generated tool when a site has more than one. */
+  toolName?: string;
+  /** Run a single tick and exit. Mutually exclusive with runNow. */
+  once?: boolean;
+  /** Run immediately on startup AND continue scheduling. */
+  runNow?: boolean;
+  /** Suppress info logs on success — failures still go to stderr.
+   *  Implementation note: temporarily sets IMPRINT_QUIET=1 for the
+   *  lifetime of this call (restored on exit) so other code in the
+   *  same process isn't affected. */
+  quiet?: boolean;
+  /** Inject for tests; defaults to global fetch. Used by Pushover/ntfy notifications. */
+  notifyFetchImpl?: typeof fetch;
+}
+
+const log = createLog('cron');
+
+function loadCronConfig(configPath: string): CronConfig {
+  return loadJsonFile(
+    configPath,
+    CronConfigSchema,
+    {
+      notFound:
+        '→ create one with: {"schedule":"0 9 * * *","params":{},"replayBackend":"auto"}\n→ see docs/getting-started.md for full schema.',
+      notJson: '→ check for a stray comma or unquoted key.',
+      badSchema:
+        '→ minimum required: {"schedule":"0 9 * * *","params":{}}\n→ full schema: docs/getting-started.md (look for "Schedule it").',
+    },
+    'cron.json',
+  );
+}
+
+/** One tool tick: walk the ladder, log, push notification on result. */
+async function runOnce(
+  tool: ResolvedTool,
+  params: Record<string, string | number | boolean>,
+  notifyFetchImpl: typeof fetch | undefined,
+  notifyWhen: NotifyWhen | undefined,
+  ladder: ConcreteBackend[],
+  assetRoot: string,
+  stealthCache: Map<string, StealthFetch>,
+): Promise<ToolResult> {
+  const startedAt = new Date();
+  log(
+    `${startedAt.toISOString()} ${tool.workflow.toolName} starting (ladder: ${ladder.join(' → ')})`,
+  );
+  const t0 = Date.now();
+
+  const { result, usedBackend, attempts } = await runWithLadder(
+    ladder,
+    tool,
+    params,
+    assetRoot,
+    stealthCache,
+  );
+
+  const elapsed = Date.now() - t0;
+  for (const a of attempts) {
+    if (a.outcome === 'escalate') log(`  ${a.backend} → ${a.detail} (escalating)`);
+  }
+
+  if (result.ok) {
+    const data = typeof result.data === 'string' ? result.data : JSON.stringify(result.data);
+    // Cap the inline preview at ~500 chars; full payload available via
+    // IMPRINT_DEBUG=1. Long-running daemons flood stderr otherwise.
+    const preview =
+      isDebug() || data.length <= 500
+        ? data
+        : `${data.slice(0, 500)}…(${data.length - 500} more chars; set IMPRINT_DEBUG=1 to log full payload)`;
+    log(`  OK in ${elapsed}ms via ${usedBackend}: ${preview}`);
+    if (notifyWhen) {
+      try {
+        const decision = evaluateNotifyWhen(notifyWhen, result.data, tool.workflow.toolName);
+        if (decision.notify) {
+          log(`  notifyWhen ${notifyWhen.type}: matched → pushing`);
+          await notify(
+            decision.title ?? `imprint: ${tool.workflow.toolName}`,
+            decision.message ?? '(no message)',
+            notifyFetchImpl,
+          );
+        } else {
+          // Silent no-match used to confuse users ("did the predicate
+          // even fire?"). Surface a one-liner so they can confirm.
+          log(`  notifyWhen ${notifyWhen.type}: no match (predicate ran, threshold not crossed)`);
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        log(`  notifyWhen evaluation failed: ${msg}`);
+      }
+    }
+  } else {
+    // Failures must surface even in --quiet mode — that's the whole point
+    // (cron runs silently on success, mails on failure). Bypass createLog's
+    // quiet-aware path and write directly to stderr.
+    process.stderr.write(
+      `[imprint cron]   FAILED [${result.error}] via ${usedBackend} in ${elapsed}ms: ${result.message}\n`,
+    );
+    if (result.error === 'STATE_MISSING' && result.missing?.length) {
+      for (const item of result.missing) {
+        process.stderr.write(
+          `[imprint cron]   - ${item.name}: ${item.failure} (${item.capability})${item.message ? ` — ${item.message}` : ''}\n`,
+        );
+      }
+    }
+    if (result.remediation) {
+      process.stderr.write(`[imprint cron]   → ${result.remediation}\n`);
+    }
+    await notify(
+      `imprint: ${tool.workflow.toolName} failed`,
+      `[${result.error}] ${result.message}${result.remediation ? `\n→ ${result.remediation}` : ''}`,
+      notifyFetchImpl,
+    );
+  }
+  return result;
+}
+
+export async function runCron(opts: RunCronOptions): Promise<void> {
+  if (opts.once && opts.runNow) {
+    throw new Error('cannot combine --once with --run-now (use one or the other)');
+  }
+
+  // Scope the IMPRINT_QUIET env mutation to this call only — restore on
+  // exit so other code in the same process (e.g. an in-process MCP server,
+  // or test harnesses) isn't silenced by a leaked env var.
+  const prevQuiet = process.env.IMPRINT_QUIET;
+  if (opts.quiet) process.env.IMPRINT_QUIET = '1';
+  try {
+    return await runCronImpl(opts);
+  } finally {
+    if (opts.quiet) {
+      if (prevQuiet === undefined) {
+        // biome-ignore lint/performance/noDelete: env restoration needs real deletion
+        delete process.env.IMPRINT_QUIET;
+      } else {
+        process.env.IMPRINT_QUIET = prevQuiet;
+      }
+    }
+  }
+}
+
+async function runCronImpl(opts: RunCronOptions): Promise<void> {
+  const assetRoot = opts.assetRoot ?? imprintHomeDir();
+  // Discover tool first so we know the workflow directory.
+  const discovered = await discoverTools(assetRoot, opts.site, '[imprint cron]');
+  const tool = selectGeneratedTool({
+    site: opts.site,
+    tools: discovered,
+    purpose: 'cron',
+    toolName: opts.toolName,
+    pathHint: opts.configPath,
+    pathHintLabel: '--config',
+  });
+  if (!tool) {
+    throw new Error(
+      `No generated tool found for site "${opts.site}".\n${availableSitesHint(assetRoot, opts.site)}\n→ run \`imprint teach ${opts.site}\` or \`imprint emit ~/.imprint/${opts.site}/<toolName>/workflow.json\` first.`,
+    );
+  }
+  const configPath = opts.configPath ?? pathResolve(tool.dir, 'cron.json');
+  if (!existsSync(configPath)) {
+    throw new Error(
+      `cron.json not found at ${configPath}\n${availableSitesHint(assetRoot, opts.site)}\n→ create one with: {"schedule":"0 9 * * *","params":{},"replayBackend":"auto"}\n→ see docs/getting-started.md for full schema.`,
+    );
+  }
+  const config = loadCronConfig(configPath);
+  log(`config: ${configPath}`);
+
+  if (!cron.validate(config.schedule)) {
+    throw new Error(
+      `Invalid cron expression in ${configPath}: "${config.schedule}"\n→ format: "min hour dom month dow" (e.g., "0 9 * * *" = 9am daily)\n→ test expressions at https://crontab.guru`,
+    );
+  }
+
+  const replayBackend = config.replayBackend ?? 'auto';
+  const playbookPath = pathResolve(tool.dir, 'playbook.yaml');
+  if (replayBackend === 'playbook' && !existsSync(playbookPath)) {
+    throw new Error(
+      `replayBackend="playbook" but ${playbookPath} doesn't exist. Run \`imprint compile-playbook\` first.`,
+    );
+  }
+
+  // Pre-flight: cron runs unattended, so a missing credential at runtime
+  // means a silent failure (or a noisy failure mid-tick). Fail loud at
+  // startup with the exact set/import commands the user needs.
+  const credCheck = await checkSiteCredentialsReady(opts.site);
+  if (!credCheck.ok) {
+    throw new Error(
+      `cron cannot start for "${opts.site}" — credentials are missing.\n\n${credCheck.message}`,
+    );
+  }
+
+  // Probe cache reorders the 'auto' ladder to start with the empirically
+  // cheapest known-working backend.
+  const cached = loadBackendsCache(opts.site, assetRoot, tool.dir);
+  if (cached) {
+    log(
+      `backends.json: probed ${cached.probedAt}, preferred order: ${cached.preferredOrder.join(' → ')}`,
+    );
+  }
+
+  // Validate params against the API workflow only when API replay
+  // is in the ladder; playbook has its own param schema with different names.
+  const ladder = resolveLadder(replayBackend, cached?.preferredOrder);
+  let params: Record<string, string | number | boolean>;
+  if (
+    ladder.includes('fetch') ||
+    ladder.includes('fetch-bootstrap') ||
+    ladder.includes('stealth-fetch')
+  ) {
+    const validator = buildZodValidator(tool.workflow.parameters);
+    const parsed = validator.safeParse(config.params);
+    if (!parsed.success) {
+      const issues = parsed.error.errors.map((e) => `${e.path.join('.')}: ${e.message}`).join('; ');
+      throw new Error(`cron.json params invalid for ${tool.workflow.toolName}: ${issues}`);
+    }
+    params = parsed.data;
+  } else {
+    params = config.params;
+  }
+
+  log(`tool: ${tool.workflow.toolName} (${tool.workflow.parameters.length} param(s))`);
+  log(`schedule: ${config.schedule}`);
+  if (config.notifyWhen) log(`notifyWhen: ${config.notifyWhen.type}`);
+  log(
+    `replayBackend: ${replayBackend}${ladder.length > 1 ? ` (ladder: ${ladder.join(' → ')})` : ''}`,
+  );
+
+  // Per-site stealth-fetch cache — bootstrap cost paid once per process.
+  const stealthCache = new Map<string, StealthFetch>();
+
+  const tickArgs = [
+    tool,
+    params,
+    opts.notifyFetchImpl,
+    config.notifyWhen,
+    ladder,
+    assetRoot,
+    stealthCache,
+  ] as const;
+
+  if (opts.once) {
+    await runOnce(...tickArgs);
+    return;
+  }
+
+  if (opts.runNow) {
+    await runOnce(...tickArgs);
+  }
+
+  // node-cron's callbacks are sync; we kick off the async work and let it
+  // run, swallowing the promise locally (errors are already logged in
+  // runOnce). Two ticks could theoretically overlap if the workflow takes
+  // longer than the schedule period — fine for v0.1, callers picking
+  // sub-second cadences should handle their own concurrency.
+  const task = cron.schedule(config.schedule, () => {
+    void runOnce(...tickArgs);
+  });
+  task.start();
+  log('scheduled — Ctrl-C to stop');
+
+  await new Promise<void>((resolve) => {
+    const shutdown = (sig: NodeJS.Signals): void => {
+      log(`received ${sig}, stopping schedule`);
+      task.stop();
+      // Clean up StealthFetch instances (no-op currently, but future-
+      // proof for if we add long-lived browser support).
+      for (const sf of stealthCache.values()) {
+        void sf.close();
+      }
+      resolve();
+    };
+    process.once('SIGINT', () => shutdown('SIGINT'));
+    process.once('SIGTERM', () => shutdown('SIGTERM'));
+  });
+}

package/src/imprint/doctor.ts

@@ -0,0 +1,223 @@
+/** `imprint doctor` — check that the environment can actually run imprint.
+ *  Reports pass/fail per prerequisite plus a one-line fix when failed. */
+
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join as pathJoin } from 'node:path';
+import { findChromium } from './chromium.ts';
+import { getProviderStatuses } from './llm.ts';
+import { VERSION } from './version.ts';
+
+export interface CheckResult {
+  name: string;
+  ok: boolean;
+  detail: string;
+  fix?: string;
+}
+
+export function doctor(): CheckResult[] {
+  return [
+    checkBun(),
+    checkChromium(),
+    checkPlaywrightChromium(),
+    checkLLMProvider(),
+    checkPushOptional(),
+    checkClaudeCode(),
+    checkHermes(),
+    checkOpenClaw(),
+  ];
+}
+
+function checkBun(): CheckResult {
+  const v = process.versions.bun;
+  if (!v) {
+    return {
+      name: 'Bun runtime',
+      ok: false,
+      detail: 'not detected (process.versions.bun is undefined)',
+      fix: 'install Bun ≥ 1.3 from https://bun.sh',
+    };
+  }
+  return { name: 'Bun runtime', ok: true, detail: `v${v}` };
+}
+
+function checkChromium(): CheckResult {
+  try {
+    const path = findChromium();
+    return { name: 'Chromium binary', ok: true, detail: path };
+  } catch (err) {
+    return {
+      name: 'Chromium binary',
+      ok: false,
+      detail: err instanceof Error ? (err.message.split('\n')[0] ?? '') : String(err),
+      fix: 'run: bunx playwright install chromium',
+    };
+  }
+}
+
+function checkPlaywrightChromium(): CheckResult {
+  // Playwright's bundled "Chrome for Testing" lives under ms-playwright/.
+  // findChromium() prefers it, so this is mostly a duplicate signal — but
+  // useful as a separate line so users see whether the Playwright path
+  // specifically is set up (matters for stealth-fetch + playbook backends).
+  const cacheRoots = [
+    pathJoin(homedir(), 'Library/Caches/ms-playwright'),
+    pathJoin(homedir(), '.cache/ms-playwright'),
+  ];
+  for (const root of cacheRoots) {
+    if (!existsSync(root)) continue;
+    try {
+      const dirs = readdirSync(root).filter((d) => /^chromium-\d+$/.test(d));
+      if (dirs.length > 0) {
+        return {
+          name: 'Playwright Chromium',
+          ok: true,
+          detail: `${dirs.length} install(s) at ${root}`,
+        };
+      }
+    } catch {
+      // ignore
+    }
+  }
+  return {
+    name: 'Playwright Chromium',
+    ok: false,
+    detail: 'no chromium-* install under ~/Library/Caches/ms-playwright or ~/.cache/ms-playwright',
+    fix: 'run: bunx playwright install chromium  (needed for stealth-fetch + playbook)',
+  };
+}
+
+function checkLLMProvider(): CheckResult {
+  const statuses = getProviderStatuses();
+  const detected = statuses.filter((s) => s.detected);
+  const teachCompatible = detected.filter((s) => s.availableForTeach);
+
+  if (teachCompatible.length > 0) {
+    const names = detected
+      .map((s) => `${s.name}${s.availableForTeach ? '' : ' (not teach-compatible)'}`)
+      .join(', ');
+    return { name: 'LLM provider', ok: true, detail: `detected: ${names}` };
+  }
+
+  if (detected.length > 0) {
+    return {
+      name: 'LLM provider',
+      ok: false,
+      detail: `detected: ${detected.map((s) => s.name).join(', ')}; none are compatible with teach compile`,
+      fix: 'install Claude Code / Codex CLI, or set ANTHROPIC_API_KEY',
+    };
+  }
+
+  return {
+    name: 'LLM provider',
+    ok: false,
+    detail: 'no provider detected',
+    fix: 'install Claude Code / Codex / Cursor CLI, or set ANTHROPIC_API_KEY',
+  };
+}
+
+function checkPushOptional(): CheckResult {
+  const pushover = !!(process.env.PUSHOVER_TOKEN && process.env.PUSHOVER_USER);
+  const ntfy = !!process.env.NTFY_URL;
+  if (pushover || ntfy) {
+    const which = [pushover && 'Pushover', ntfy && 'ntfy'].filter(Boolean).join(' + ');
+    return { name: 'Push notifications', ok: true, detail: which };
+  }
+  return {
+    name: 'Push notifications',
+    ok: true, // optional — not a failure
+    detail: 'none configured (cron will only push to stderr)',
+    fix: 'set PUSHOVER_TOKEN+PUSHOVER_USER or NTFY_URL — see docs/notifications.md',
+  };
+}
+
+function checkClaudeCode(): CheckResult {
+  // Look for ~/.claude/settings.json
+  const configPath = pathJoin(homedir(), '.claude', 'settings.json');
+  if (!existsSync(configPath)) {
+    return {
+      name: 'Claude Code',
+      ok: true,
+      detail: 'not detected',
+      fix: 'install Claude Code, then run `imprint teach <site>` to connect',
+    };
+  }
+  // Check if any imprint-* MCP servers are registered
+  try {
+    const config = JSON.parse(readFileSync(configPath, 'utf8'));
+    const servers = config?.mcpServers ?? {};
+    const imprintServers = Object.keys(servers).filter((k) => k.startsWith('imprint-'));
+    if (imprintServers.length > 0) {
+      return {
+        name: 'Claude Code',
+        ok: true,
+        detail: `${imprintServers.length} imprint tool(s): ${imprintServers.join(', ')}`,
+      };
+    }
+    return {
+      name: 'Claude Code',
+      ok: true,
+      detail: 'installed, no imprint tools registered',
+      fix: 'run `imprint teach <site>` to record a workflow and connect it',
+    };
+  } catch {
+    return {
+      name: 'Claude Code',
+      ok: true,
+      detail: 'installed (could not parse settings)',
+    };
+  }
+}
+
+function checkHermes(): CheckResult {
+  const configPath = pathJoin(homedir(), '.hermes', 'config.yaml');
+  if (!existsSync(configPath)) {
+    return {
+      name: 'Hermes Agent',
+      ok: true,
+      detail: 'not detected',
+    };
+  }
+  return {
+    name: 'Hermes Agent',
+    ok: true,
+    detail: `config at ${configPath}`,
+    fix: 'run `imprint teach <site>` and select Hermes to connect',
+  };
+}
+
+function checkOpenClaw(): CheckResult {
+  const configPath = pathJoin(homedir(), '.openclaw', 'openclaw.json');
+  if (!existsSync(configPath)) {
+    return {
+      name: 'OpenClaw',
+      ok: true,
+      detail: 'not detected',
+    };
+  }
+  return {
+    name: 'OpenClaw',
+    ok: true,
+    detail: `config at ${configPath}`,
+    fix: 'run `imprint teach <site>` and select OpenClaw to connect',
+  };
+}
+
+export function reportDoctor(checks: CheckResult[]): { ok: boolean; lines: string[] } {
+  const lines: string[] = [`imprint v${VERSION} doctor`, ''];
+  let allOk = true;
+  for (const c of checks) {
+    const mark = c.ok ? '✓' : '✗';
+    lines.push(`  ${mark} ${c.name.padEnd(22)} ${c.detail}`);
+    if (!c.ok) {
+      allOk = false;
+      if (c.fix) lines.push(`      → ${c.fix}`);
+    } else if (c.fix) {
+      // Optional check that's not configured; advise but don't fail.
+      lines.push(`      hint: ${c.fix}`);
+    }
+  }
+  lines.push('');
+  lines.push(allOk ? 'All required checks passed.' : 'Some required checks failed — fix above.');
+  return { ok: allOk, lines };
+}

package/src/imprint/emit.ts

@@ -0,0 +1,154 @@
+/** `imprint emit` — generate <assetRoot>/<site>/<toolName>/index.ts: a thin wrapper
+ *  around runtime.executeWorkflow with the workflow JSON embedded inline. */
+
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { basename, dirname, join as pathJoin, resolve as pathResolve } from 'node:path';
+import { loadJsonFile } from './load-json.ts';
+import { ensureImprintRuntimeLink } from './runtime-link.ts';
+import { type Workflow, WorkflowSchema } from './types.ts';
+
+interface EmitOptions {
+  /** Path to workflow.json */
+  workflowPath: string;
+  /** Output dir; defaults to dirname(workflowPath). File: <outDir>/index.ts. */
+  outDir?: string;
+  /** Overwrite an existing index.ts. Default false. */
+  force?: boolean;
+}
+
+interface EmitResult {
+  workflowPath: string;
+  outPath: string;
+  toolName: string;
+  /** Summary of the parameters the generated tool accepts. */
+  parameters: Workflow['parameters'];
+}
+
+export function emit(opts: EmitOptions): EmitResult {
+  const workflow = loadJsonFile(
+    opts.workflowPath,
+    WorkflowSchema,
+    {
+      notFound: '→ run `imprint generate <session>` to create one.',
+      badSchema:
+        '→ regenerate with `imprint generate <session>` (the LLM may have produced bad output).',
+    },
+    'workflow.json',
+  );
+
+  const outDir = opts.outDir ?? defaultOutDir(opts.workflowPath, workflow);
+
+  mkdirSync(outDir, { recursive: true });
+  const outPath = pathJoin(outDir, 'index.ts');
+
+  if (existsSync(outPath) && !opts.force) {
+    throw new Error(
+      `${outPath} already exists. Pass --force to overwrite, or move/delete the existing file first.`,
+    );
+  }
+
+  // Ensure IMPRINT_HOME has a node_modules/imprint symlink so generated
+  // tools can `import 'imprint/runtime'` via standard module resolution.
+  // discoverTools also calls this at runtime so dangling links self-heal
+  // without re-emitting.
+  ensureImprintRuntimeLink(pathResolve(outDir, '..', '..'));
+
+  const source = renderModule(workflow);
+  writeFileSync(outPath, source, 'utf8');
+
+  return {
+    workflowPath: opts.workflowPath,
+    outPath,
+    toolName: workflow.toolName,
+    parameters: workflow.parameters,
+  };
+}
+
+function defaultOutDir(workflowPath: string, workflow: Workflow): string {
+  const workflowDir = pathResolve(dirname(workflowPath));
+  if (basename(workflowDir) === workflow.toolName) return workflowDir;
+  return pathJoin(workflowDir, workflow.toolName);
+}
+
+function renderModule(workflow: Workflow): string {
+  const paramTypeFields = workflow.parameters
+    .map((p) => {
+      const optional = p.default !== undefined ? '?' : '';
+      return `  /** ${escapeJsdoc(p.description)} */\n  ${p.name}${optional}: ${p.type};`;
+    })
+    .join('\n');
+
+  const defaultsBlock = workflow.parameters
+    .filter((p) => p.default !== undefined)
+    .map((p) => `    ${p.name}: input.${p.name} ?? ${JSON.stringify(p.default)},`)
+    .join('\n');
+
+  const requiredCopies = workflow.parameters
+    .filter((p) => p.default === undefined)
+    .map((p) => `    ${p.name}: input.${p.name},`)
+    .join('\n');
+
+  const workflowJson = JSON.stringify(workflow, null, 2);
+
+  return `/**
+ * GENERATED by \`imprint emit\` — DO NOT EDIT BY HAND.
+ *
+ * Tool: ${workflow.toolName}
+ * Site: ${workflow.site}
+ * Intent: ${workflow.intent.description}
+ *
+ * To regenerate: imprint emit ~/.imprint/${workflow.site}/${workflow.toolName}/workflow.json --force
+ */
+
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import {
+  executeWorkflow,
+  type CredentialStore,
+} from 'imprint/runtime';
+import type { ToolResult, Workflow } from 'imprint/types';
+
+const WORKFLOW: Workflow = ${workflowJson};
+
+export interface ${pascalCase(workflow.toolName)}Input {
+${paramTypeFields}
+}
+
+export async function ${camelCase(workflow.toolName)}(
+  ${workflow.parameters.length === 0 ? '_input' : 'input'}: ${pascalCase(workflow.toolName)}Input,
+  opts: { credentials?: CredentialStore; fetchImpl?: typeof fetch; initialState?: Record<string, unknown> } = {},
+): Promise<ToolResult> {
+  const __dirname = dirname(fileURLToPath(import.meta.url));
+  const params: Record<string, string | number | boolean> = {
+${defaultsBlock || requiredCopies || '    // (no parameters)'}
+${defaultsBlock && requiredCopies ? requiredCopies : ''}
+  };
+  return executeWorkflow({
+    workflow: WORKFLOW,
+    params,
+    credentials: opts.credentials,
+    fetchImpl: opts.fetchImpl,
+    initialState: opts.initialState,
+    workflowPath: join(__dirname, 'workflow.json'),
+  });
+}
+
+export { WORKFLOW };
+`;
+}
+
+function pascalCase(s: string): string {
+  return s
+    .split(/[_-]+/)
+    .map((p) => p.charAt(0).toUpperCase() + p.slice(1).toLowerCase())
+    .join('');
+}
+
+function camelCase(s: string): string {
+  const pc = pascalCase(s);
+  return pc.charAt(0).toLowerCase() + pc.slice(1);
+}
+
+function escapeJsdoc(s: string): string {
+  return s.replace(/\*\//g, '*\\/');
+}