@pome-sh/cli 0.4.0 → 0.7.0

package/dist/src/cli/embedded-wiring.js

@@ -1,443 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// FDRS-661 — the terminal diff gate: run the wiring agent headless in a
-// SHADOW copy of the repo, collect its edits as one git diff, render the
-// moment-02 file list + unified diff in pome's own terminal, and touch the
-// real working tree only after an explicit [y].
-//
-// Why a shadow workspace instead of canUseTool-deny-and-record: a denied
-// Edit looks like a failure to the agent, which then retries; letting the
-// edits land in an isolated copy keeps the session self-consistent (its
-// Reads see its own writes) and the diff comes from git afterwards, exact
-// and binary-safe. canUseTool still runs on every call — it confines all
-// file paths to the shadow root (a live probe caught the model reaching
-// for $HOME on turn one) and refuses tools outside the whitelist.
-//
-// The user's `.claude/` is deliberately NOT copied into the shadow:
-// settings-file allow rules would shadow the canUseTool gate (the SDK
-// warns about exactly this), and the only skill the session needs is the
-// pome-setup skill pome injects itself.
-import { execFile } from "node:child_process";
-import { existsSync, realpathSync } from "node:fs";
-import { cp, lstat, mkdir, mkdtemp, readdir, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { isAbsolute, join, relative, resolve, sep } from "node:path";
-import { promisify } from "node:util";
-const execFileAsync = promisify(execFile);
-/** Tools the staging session may use. Everything else — Bash above all —
- *  is refused: package installs and verification are pome's job, after
- *  the diff is approved. NOTE: never mirror these into `allowedTools`;
- *  bare allowedTools entries auto-approve before canUseTool is consulted. */
-export const STAGING_TOOLS = ["Read", "Edit", "Write", "Glob", "Grep"];
-/** First message of the headless session. The pome-setup skill (injected
- *  into the shadow's .claude/skills) carries the wiring knowledge; this
- *  adapts its interactive contract to staging: edits land automatically,
- *  the human approves ONE combined diff in pome's terminal afterwards. */
-export const EMBEDDED_KICKOFF_PROMPT = [
-    "Use the pome-setup skill to wire this repository to pome (adapter-first:",
-    "withPome() + env-injected base URL). You are running non-interactively",
-    "inside a staged copy of the repo:",
-    "- There is no user to ask questions mid-session. Where the skill says to",
-    "  pause and confirm, proceed with the best-evidence interpretation and",
-    "  note the assumption in your final summary.",
-    "- Your edits are staged automatically; pome renders the combined diff for",
-    "  the user's approval after this session. That is the skill's diff-approval",
-    "  gate — do not wait for per-edit approval.",
-    "- Do not run package installs or shell commands: add dependencies by",
-    "  editing package.json only. pome runs the install after the diff is",
-    "  applied.",
-    "- Do not run pome doctor — pome verifies the wiring itself after applying.",
-    "When the wiring edits are complete, end the session with a one-line",
-    "summary. If you cannot produce the wiring, make no edits and end with a",
-    "short explanation of why.",
-].join("\n");
-export async function runEmbeddedWiring(options) {
-    const log = options.log ?? ((line) => console.error(line));
-    const shadow = await mkdtemp(join(tmpdir(), "pome-install-staging-"));
-    try {
-        const skippedLinks = await populateShadow(options.cwd, shadow);
-        if (skippedLinks.length > 0) {
-            log(`(symlinks stay out of the staged copy: ${skippedLinks.slice(0, 3).join(", ")}${skippedLinks.length > 3 ? ` +${skippedLinks.length - 3} more` : ""})`);
-        }
-        await mkdir(join(shadow, ".claude", "skills"), { recursive: true });
-        await cp(options.skillSourceDir, join(shadow, ".claude", "skills", "pome-setup"), {
-            recursive: true,
-        });
-        await gitIn(shadow, ["init", "-q"]);
-        await gitIn(shadow, ["add", "-A"]);
-        await gitIn(shadow, ["commit", "-q", "-m", "pome staging baseline"]);
-        const session = await runStagingSession(options, shadow, log);
-        if (session.kind === "session-error")
-            return session;
-        // Everything the session staged, as one diff — the injected .claude/
-        // (skill + any settings the agent might have written) never leaves
-        // the shadow.
-        await gitIn(shadow, ["add", "-A"]);
-        const exclude = [".", `:(exclude).claude`];
-        const { stdout: nameStatus } = await gitIn(shadow, [
-            "diff",
-            "--staged",
-            "--name-status",
-            "-M",
-            "--",
-            ...exclude,
-        ]);
-        const changes = parseNameStatus(nameStatus);
-        if (changes.length === 0) {
-            return {
-                kind: "no-diff",
-                reason: session.summary || "the agent session ended without staging any edits",
-            };
-        }
-        const { stdout: numstat } = await gitIn(shadow, [
-            "diff",
-            "--staged",
-            "--numstat",
-            "-M",
-            "--",
-            ...exclude,
-        ]);
-        const { stdout: patch } = await gitIn(shadow, [
-            "diff",
-            "--staged",
-            "--binary",
-            "-M",
-            "--",
-            ...exclude,
-        ]);
-        log("");
-        log("here's what it will change:");
-        log("");
-        for (const line of renderFileList(changes, parseNumstat(numstat)))
-            log(line);
-        log("");
-        for (const line of renderUnifiedDiff(patch))
-            log(line);
-        log("");
-        if (!(await options.confirm("apply these changes? [y/N] "))) {
-            return { kind: "declined" };
-        }
-        const patchFile = join(shadow, ".pome-staged.patch");
-        await writeFile(patchFile, patch);
-        await execFileAsync("git", ["apply", "--whitespace=nowarn", patchFile], {
-            cwd: options.cwd,
-        });
-        log(`✓ wrote ${changes.length} file${changes.length === 1 ? "" : "s"}`);
-        return {
-            kind: "applied",
-            files: changes.length,
-            // Any package.json in the tree, not just the root — in a workspace the
-            // wiring may add the adapter to a nested package's manifest.
-            packageJsonChanged: changes.some((c) => c.path === "package.json" || c.path.endsWith("/package.json")),
-        };
-    }
-    finally {
-        await rm(shadow, { recursive: true, force: true });
-    }
-}
-// ---------------------------------------------------------------------------
-// Shadow population
-/** Copy the repo into the shadow: tracked + untracked-but-not-ignored files
- *  when git is available, a filtered walk otherwise. `.git` and `.claude`
- *  never cross (see module header), and neither do SYMLINKS: a tracked link
- *  copied verbatim would carry a pointer out of the shadow that the agent's
- *  Read/Write could follow past the canUseTool path fence. Skipped links
- *  are returned so the caller can say so instead of silently dropping them.
- */
-async function populateShadow(cwd, shadow) {
-    const skippedLinks = [];
-    let files = null;
-    try {
-        const { stdout } = await execFileAsync("git", ["ls-files", "-co", "--exclude-standard", "-z"], { cwd, maxBuffer: 64 * 1024 * 1024 });
-        files = stdout.split("\0").filter(Boolean);
-    }
-    catch {
-        files = null; // not a git repo (or no git) — fall through to the walk
-    }
-    if (files) {
-        for (const file of files) {
-            if (file === ".claude" || file.startsWith(`.claude${sep}`) || file.startsWith(".claude/")) {
-                continue;
-            }
-            const from = join(cwd, file);
-            let stat;
-            try {
-                stat = await lstat(from);
-            }
-            catch {
-                continue; // ls-files can list deleted-but-tracked paths
-            }
-            if (stat.isSymbolicLink()) {
-                skippedLinks.push(file);
-                continue;
-            }
-            if (!stat.isFile())
-                continue;
-            const to = join(shadow, file);
-            await mkdir(join(to, ".."), { recursive: true });
-            await cp(from, to, { recursive: false, verbatimSymlinks: true });
-        }
-        return skippedLinks;
-    }
-    const SKIP = new Set([".git", ".claude", "node_modules"]);
-    const walk = async (rel) => {
-        const entries = await readdir(join(cwd, rel), { withFileTypes: true });
-        for (const entry of entries) {
-            if (SKIP.has(entry.name))
-                continue;
-            const childRel = rel ? join(rel, entry.name) : entry.name;
-            if (entry.isSymbolicLink()) {
-                // Dirent methods don't dereference — mirror the git branch: skip
-                // links (whether they point at files or directories) and say so.
-                skippedLinks.push(childRel);
-            }
-            else if (entry.isDirectory()) {
-                await mkdir(join(shadow, childRel), { recursive: true });
-                await walk(childRel);
-            }
-            else if (entry.isFile()) {
-                await mkdir(join(shadow, childRel, ".."), { recursive: true });
-                await cp(join(cwd, childRel), join(shadow, childRel));
-            }
-        }
-    };
-    await walk("");
-    return skippedLinks;
-}
-function gitIn(cwd, args) {
-    return execFileAsync("git", [
-        // The shadow is throwaway: never touch the user's git identity/config.
-        "-c",
-        "user.email=install@pome.sh",
-        "-c",
-        "user.name=pome install",
-        "-c",
-        "commit.gpgsign=false",
-        "-c",
-        "core.autocrlf=false",
-        ...args,
-    ], { cwd, maxBuffer: 64 * 1024 * 1024 });
-}
-// ---------------------------------------------------------------------------
-// The staging session
-async function runStagingSession(options, shadow, log) {
-    const canUseTool = buildStagingCanUseTool(shadow, log);
-    let summary = "";
-    let sessionError = null;
-    const iterator = options.query({
-        prompt: EMBEDDED_KICKOFF_PROMPT,
-        options: {
-            cwd: shadow,
-            pathToClaudeCodeExecutable: options.claudePath,
-            permissionMode: "default",
-            systemPrompt: { type: "preset", preset: "claude_code" },
-            // Load the injected pome-setup skill from the shadow's .claude/skills.
-            settingSources: ["project"],
-            skills: "all",
-            tools: [...STAGING_TOOLS],
-            maxTurns: 80,
-            canUseTool,
-        },
-    });
-    try {
-        for await (const message of iterator) {
-            const type = message.type;
-            if (type === "assistant") {
-                for (const line of assistantTextLines(message))
-                    log(dim(`  ${line}`));
-            }
-            else if (type === "result") {
-                const subtype = message.subtype;
-                if (subtype === "success") {
-                    summary = typeof message.result === "string" ? message.result.trim() : "";
-                }
-                else {
-                    const errors = Array.isArray(message.errors) ? message.errors.join("; ") : subtype;
-                    sessionError = `agent session ended without finishing: ${errors ?? "unknown error"}`;
-                }
-            }
-        }
-    }
-    catch (err) {
-        // The SDK's iterator throws after error results (max turns, process
-        // exit). The result message above is the source of truth when we got
-        // one; otherwise surface the thrown reason.
-        if (!sessionError && !summary) {
-            sessionError = `agent session failed: ${err instanceof Error ? err.message : String(err)}`;
-        }
-    }
-    if (sessionError)
-        return { kind: "session-error", reason: sessionError };
-    return { kind: "ok", summary };
-}
-/** Path-confining permission gate. Exported for direct unit tests. */
-export function buildStagingCanUseTool(shadowRoot, log) {
-    const allowed = new Set(STAGING_TOOLS);
-    const resolvedRoot = resolve(shadowRoot);
-    // Compare in canonical (symlink-resolved) space on both sides — on macOS
-    // the tmpdir shadow itself sits behind /var → /private/var. For paths that
-    // don't exist yet (a Write creating a file), canonicalize the nearest
-    // existing ancestor and re-append the remainder.
-    const canonicalize = (abs) => {
-        let probe = abs;
-        while (!existsSync(probe)) {
-            const parent = resolve(probe, "..");
-            if (parent === probe)
-                break;
-            probe = parent;
-        }
-        return join(realpathSync(probe), relative(probe, abs));
-    };
-    const root = existsSync(resolvedRoot) ? realpathSync(resolvedRoot) : resolvedRoot;
-    const contained = (abs) => {
-        const rel = relative(root, abs);
-        return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel));
-    };
-    const insideShadow = (p) => {
-        if (typeof p !== "string" || p.length === 0)
-            return true; // no path arg — cwd-scoped
-        const abs = isAbsolute(p) ? resolve(p) : resolve(resolvedRoot, p);
-        // Defense in depth: symlinks never cross into the shadow (populateShadow
-        // skips them), but canonicalizing means a link that appears anyway can't
-        // smuggle the operation outside.
-        try {
-            return contained(canonicalize(abs));
-        }
-        catch {
-            return false;
-        }
-    };
-    return async (toolName, input) => {
-        if (!allowed.has(toolName)) {
-            return {
-                behavior: "deny",
-                message: `${toolName} is not available in this pome staging session. ` +
-                    "Make wiring edits with Read/Edit/Write only; pome runs installs and " +
-                    "verification after the diff is approved.",
-            };
-        }
-        for (const key of ["file_path", "notebook_path", "path"]) {
-            if (key in input && !insideShadow(input[key])) {
-                return {
-                    behavior: "deny",
-                    message: `${String(input[key])} is outside the repository being wired. ` +
-                        "Only files inside the working directory may be read or edited.",
-                };
-            }
-        }
-        if (toolName === "Edit" || toolName === "Write") {
-            const p = String(input.file_path ?? "");
-            const abs = isAbsolute(p) ? resolve(p) : resolve(resolvedRoot, p);
-            let rel;
-            try {
-                rel = relative(root, canonicalize(abs));
-            }
-            catch {
-                rel = p;
-            }
-            log(dim(`  staged ${rel}`));
-        }
-        return { behavior: "allow", updatedInput: input };
-    };
-}
-function assistantTextLines(message) {
-    const inner = message.message;
-    if (!inner || !Array.isArray(inner.content))
-        return [];
-    const lines = [];
-    for (const block of inner.content) {
-        if (block && typeof block === "object" && block.type === "text") {
-            const text = block.text ?? "";
-            for (const line of text.split("\n")) {
-                if (line.trim())
-                    lines.push(line.trimEnd());
-            }
-        }
-    }
-    return lines;
-}
-function parseNameStatus(out) {
-    const changes = [];
-    for (const line of out.split("\n")) {
-        if (!line.trim())
-            continue;
-        const parts = line.split("\t");
-        const code = parts[0] ?? "";
-        if (code.startsWith("R")) {
-            changes.push({ status: "renamed", from: parts[1], path: parts[2] ?? "" });
-        }
-        else if (code === "A") {
-            changes.push({ status: "new file", path: parts[1] ?? "" });
-        }
-        else if (code === "D") {
-            changes.push({ status: "deleted", path: parts[1] ?? "" });
-        }
-        else {
-            changes.push({ status: "modified", path: parts[1] ?? "" });
-        }
-    }
-    return changes;
-}
-function parseNumstat(out) {
-    const stats = new Map();
-    for (const line of out.split("\n")) {
-        if (!line.trim())
-            continue;
-        const [added, removed, ...rest] = line.split("\t");
-        let path = rest.join("\t");
-        // Renames appear as "old => new" or "prefix{old => new}suffix" — key by
-        // the new path, matching name-status.
-        const arrow = path.match(/^(.*)\{(.*) => (.*)\}(.*)$/);
-        if (arrow)
-            path = `${arrow[1]}${arrow[3]}${arrow[4]}`;
-        else if (path.includes(" => "))
-            path = path.split(" => ")[1] ?? path;
-        stats.set(path, {
-            added: added === "-" ? 0 : Number(added),
-            removed: removed === "-" ? 0 : Number(removed),
-        });
-    }
-    return stats;
-}
-function renderFileList(changes, stats) {
-    const width = Math.max(...changes.map((c) => c.status.length));
-    return changes.map((c) => {
-        const stat = stats.get(c.path);
-        const counts = stat
-            ? [stat.added > 0 ? `+${stat.added}` : "", stat.removed > 0 ? `−${stat.removed}` : ""]
-                .filter(Boolean)
-                .join(" ")
-            : "";
-        const name = c.status === "renamed" && c.from ? `${c.from} → ${c.path}` : c.path;
-        return `  ${c.status.padEnd(width)}  ${name}${counts ? `  ${counts}` : ""}`;
-    });
-}
-function useColor() {
-    return Boolean(process.stderr.isTTY && !process.env.NO_COLOR);
-}
-function dim(s) {
-    return useColor() ? `\x1b[2m${s}\x1b[0m` : s;
-}
-function renderUnifiedDiff(patch) {
-    const color = useColor();
-    const paint = (line) => {
-        if (!color)
-            return line;
-        if (line.startsWith("+++") || line.startsWith("---") || line.startsWith("diff --git")) {
-            return `\x1b[1m${line}\x1b[0m`;
-        }
-        if (line.startsWith("@@"))
-            return `\x1b[36m${line}\x1b[0m`;
-        if (line.startsWith("+"))
-            return `\x1b[32m${line}\x1b[0m`;
-        if (line.startsWith("-"))
-            return `\x1b[31m${line}\x1b[0m`;
-        if (line.startsWith("index ") || line.startsWith("new file") || line.startsWith("deleted")) {
-            return `\x1b[2m${line}\x1b[0m`;
-        }
-        return line;
-    };
-    return patch
-        .split("\n")
-        .filter((line, i, arr) => !(line === "" && i === arr.length - 1))
-        .map(paint);
-}

package/dist/src/cli/scenarios-catalog.d.ts

@@ -1,25 +0,0 @@
-/**
- * Catalog of scenarios bundled with the CLI, grouped by twin.
- *
- * Single source of truth for `pome scenarios` (browse + copy). `pome init`
- * uses the GitHub twin entries from this catalog as its starter scaffold while
- * Stripe/Slack scenarios remain opt-in via `pome scenarios <twin> --copy`.
- *
- * `runnable: false` marks a seed-only reference document (not a scenario
- * to execute) — copy commands skip these.
- */
-export interface CatalogScenario {
-    filename: string;
-    title: string;
-    summary: string;
-    runnable: boolean;
-}
-export interface ScenarioTwin {
-    id: string;
-    label: string;
-    description: string;
-    scenarios: CatalogScenario[];
-}
-export declare const SCENARIO_TWINS: ScenarioTwin[];
-export declare function findTwin(id: string): ScenarioTwin | null;
-export declare function runnableScenarios(twin: ScenarioTwin): CatalogScenario[];

package/dist/src/cli/scenarios.d.ts

@@ -1,13 +0,0 @@
-import { type ScenarioTwin } from "./scenarios-catalog.js";
-export interface ScenariosCommandOptions {
-    copy?: boolean;
-    force?: boolean;
-    dest?: string;
-}
-export declare function runScenariosCommand(twinArg: string | undefined, opts: ScenariosCommandOptions): Promise<void>;
-interface CopyOptions {
-    destDir: string;
-    force: boolean;
-}
-export declare function copyTwinScenarios(twin: ScenarioTwin, opts: CopyOptions): Promise<void>;
-export {};

package/dist/src/cli/skills.d.ts

@@ -1,8 +0,0 @@
-export interface SkillsInstallOptions {
-    copy?: boolean;
-    force?: boolean;
-    dest?: string;
-}
-/** Skills shipped with this CLI. Keep in sync with `skills/<name>/`. */
-export declare const BUNDLED_SKILLS: readonly ["pome-setup", "pome-test"];
-export declare function runSkillsInstall(opts: SkillsInstallOptions): Promise<void>;

package/dist/src/cli/skills.js

@@ -1,141 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-/**
- * `pome skills install` — install the bundled pome agent skills into the
- * user's Claude Code skills directory (`~/.claude/skills/`).
- *
- * Defaults to symlinking each skill folder to the canonical source inside
- * this pome package install, matching the `npx skills` industry convention:
- * an `npm i -g @pome-sh/cli@latest` automatically updates every linked skill.
- * Pass `--copy` to fall back to independent copies (CI, Windows without
- * symlink permission, or any environment where symlinks aren't suitable).
- */
-import { existsSync } from "node:fs";
-import { cp, lstat, mkdir, rm, symlink } from "node:fs/promises";
-import { homedir } from "node:os";
-import { join, resolve } from "node:path";
-import { resolvePackageRoot } from "./resolve-package-root.js";
-/** Skills shipped with this CLI. Keep in sync with `skills/<name>/`. */
-export const BUNDLED_SKILLS = ["pome-setup", "pome-test"];
-const CLAUDE_DOWNLOAD_URL = "https://claude.com/download";
-function useColor() {
-    return Boolean(process.stdout.isTTY && !process.env.NO_COLOR);
-}
-function dim(s) {
-    return useColor() ? `\x1b[2m${s}\x1b[0m` : s;
-}
-function bold(s) {
-    return useColor() ? `\x1b[1m${s}\x1b[0m` : s;
-}
-export async function runSkillsInstall(opts) {
-    const root = resolvePackageRoot(import.meta.url);
-    if (!root) {
-        console.error("Could not locate the installed pome package (package.json not found).");
-        process.exitCode = 2;
-        return;
-    }
-    const sourceDir = join(root, "skills");
-    if (!existsSync(sourceDir)) {
-        console.error(`Bundled skills directory missing from this pome install: ${sourceDir}`);
-        console.error("This is a packaging bug — please report at https://github.com/pome-sh/pome-twins/issues.");
-        process.exitCode = 2;
-        return;
-    }
-    const destDir = await resolveDestDir(opts.dest);
-    if (!destDir) {
-        // resolveDestDir already printed a friendly error.
-        process.exitCode = 2;
-        return;
-    }
-    await mkdir(destDir, { recursive: true });
-    const outcome = await installSkills({
-        sourceDir,
-        destDir,
-        copy: Boolean(opts.copy),
-        force: Boolean(opts.force),
-    });
-    const mode = opts.copy ? "copy" : "symlink";
-    console.log(bold(`Installed ${outcome.installed.length} pome skill${outcome.installed.length === 1 ? "" : "s"} to ${destDir} (${mode}).`));
-    for (const name of outcome.installed) {
-        const note = outcome.fellBackToCopy.includes(name)
-            ? dim(" (copied — symlink unavailable)")
-            : "";
-        console.log(`  ${dim("+")} ${name}${note}`);
-    }
-    for (const name of outcome.skipped) {
-        console.log(`  ${dim("-")} ${name} ${dim("(exists — pass --force to overwrite)")}`);
-    }
-    for (const name of outcome.missingSources) {
-        console.error(`  ${dim("!")} ${name} ${dim("(missing from this package install)")}`);
-    }
-    if (outcome.missingSources.length > 0) {
-        process.exitCode = 2;
-        return;
-    }
-    if (outcome.installed.length > 0) {
-        console.log("");
-        console.log("Invoke them from your agent:");
-        console.log(`  ${bold("/pome-setup")}   — wire your agent up to pome`);
-        console.log(`  ${bold("/pome-test")}    — run tasks for a registered agent`);
-    }
-}
-async function resolveDestDir(explicit) {
-    if (explicit) {
-        return resolve(explicit);
-    }
-    const claudeHome = join(homedir(), ".claude");
-    if (!existsSync(claudeHome)) {
-        console.error("Couldn't find Claude Code's home directory at ~/.claude/.");
-        console.error(`Install Claude Code first: ${CLAUDE_DOWNLOAD_URL}`);
-        console.error("Or pass --dest <dir> to install into a custom skills directory.");
-        return undefined;
-    }
-    return join(claudeHome, "skills");
-}
-async function installSkills(input) {
-    const outcome = {
-        installed: [],
-        skipped: [],
-        missingSources: [],
-        fellBackToCopy: [],
-    };
-    for (const name of BUNDLED_SKILLS) {
-        const src = join(input.sourceDir, name);
-        const dest = join(input.destDir, name);
-        if (!existsSync(join(src, "SKILL.md"))) {
-            outcome.missingSources.push(name);
-            continue;
-        }
-        if (await pathPresent(dest)) {
-            if (!input.force) {
-                outcome.skipped.push(name);
-                continue;
-            }
-            await rm(dest, { recursive: true, force: true });
-        }
-        if (input.copy) {
-            await cp(src, dest, { recursive: true });
-        }
-        else {
-            try {
-                await symlink(src, dest, "dir");
-            }
-            catch (err) {
-                // Windows without dev-mode, restricted FS, etc. Fall back transparently.
-                await cp(src, dest, { recursive: true });
-                outcome.fellBackToCopy.push(name);
-            }
-        }
-        outcome.installed.push(name);
-    }
-    return outcome;
-}
-/** lstat-based existence check — true for files, dirs, and dangling symlinks. */
-async function pathPresent(p) {
-    try {
-        await lstat(p);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}

package/dist/src/scenario/parseScenario.d.ts

@@ -1,9 +0,0 @@
-import { type Scenario } from "./scenarioSchema.js";
-export declare function parseScenarioFile(path: string): Promise<Scenario>;
-export declare function parseScenario(markdown: string, slug?: string, sidecarSeed?: unknown, scenarioPath?: string): Scenario;
-/** The flat seed a single twin boots from. Single-twin scenarios return the
- *  flat `seedState` as-is; multi-twin scenarios return that twin's slice of the
- *  per-twin envelope (decided from `config.twins`, per the envelope-iff-multi-twin
- *  rule). Used by the local runner to seed each twin harness. */
-export declare function seedStateForTwin(scenario: Scenario, twin: string): unknown;
-export declare function formatScenarioError(error: unknown, filePath: string): string;

package/node_modules/@pome-sh/twin-gmail/node_modules/@pome-sh/sdk/dist/admin-gate.d.ts

@@ -1,35 +0,0 @@
-import type { Context, MiddlewareHandler } from "hono";
-/** Context variable consulted first by getClientIp(). */
-export declare const CLIENT_IP_VAR = "pomeClientIp";
-/**
- * Explicitly record the peer address for this request. Alternate serving
- * bridges (or tests) call this from an upstream middleware so the gate never
- * reaches into runtime-private internals.
- *
- * SECURITY: the value passed here MUST be the transport-level peer address
- * (the socket's remote address as reported by the serving bridge). It takes
- * precedence over getConnInfo, so deriving it from any request-controlled
- * input — X-Forwarded-For or any other client-supplied header — would make
- * the loopback-only admin gate spoofable by whoever sets that header. If you
- * are behind a reverse proxy, use TWIN_ADMIN_TOKEN instead of trying to
- * recover the "real" client IP.
- */
-export declare function setClientIp(c: Context, ip: string): void;
-/**
- * Runtime-neutral client-IP accessor (FDRS-587). Resolution order:
- *   1. Explicit override set via setClientIp() (alternate bridges / tests).
- *   2. The node serving bridge's official getConnInfo helper.
- *   3. undefined — no live socket (e.g. app.request() in-process tests).
- */
-export declare function getClientIp(c: Context): Promise<string | undefined>;
-export declare function isLoopbackAddress(remote: string): boolean;
-export interface AdminGateOptions {
-    /** 403 response factory so each twin keeps its own error envelope. */
-    forbidden?: () => Response;
-}
-/**
- * Admin endpoint protection shared by every twin (FDRS-616). Each twin's
- * auth.ts wraps this with its own `forbidden` envelope. Semantics are
- * identical to the per-twin requireAdminAuth() copies this replaces.
- */
-export declare function createAdminGate(options?: AdminGateOptions): MiddlewareHandler;