@thenavidm/slipway 0.1.0

package/dist/doctor.d.ts

@@ -0,0 +1,12 @@
+/**
+ * `doctor`: what someone types when nothing works yet.
+ *
+ * It answers in the order a person needs: is the runtime fine, is anything
+ * configured, do the settings say what they think, and does the service's own
+ * check pass. Each failure names its fix. Nothing it prints is a credential.
+ */
+import type { App, CliIO } from "./app.js";
+export declare function runDoctor(app: App, io: CliIO, options: {
+    network: boolean;
+    json: boolean;
+}): Promise<number>;

package/dist/doctor.js

@@ -0,0 +1,100 @@
+/**
+ * `doctor`: what someone types when nothing works yet.
+ *
+ * It answers in the order a person needs: is the runtime fine, is anything
+ * configured, do the settings say what they think, and does the service's own
+ * check pass. Each failure names its fix. Nothing it prints is a credential.
+ */
+import { accessSync, constants } from "node:fs";
+import { dirname } from "node:path";
+import { EXIT, NotConfiguredError, SlipwayError } from "./errors.js";
+import { policyEnvNames } from "./policy.js";
+export async function runDoctor(app, io, options) {
+    const checks = [];
+    const names = policyEnvNames(app.envPrefix);
+    const policy = app.policy(io.env);
+    const major = Number(process.versions.node.split(".")[0]);
+    checks.push({ name: "Node.js", ok: major >= 22, detail: `v${process.versions.node}`, ...(major >= 22 ? {} : { fix: "Install Node.js 22 or later." }) });
+    checks.push({ name: "Version", ok: true, detail: `${app.name} ${app.version}` });
+    const writes = policy.readOnly ? "off (read-only)" : policy.allowDestructive ? "on" : "on, irreversible ones refused";
+    checks.push({ name: "Writes", ok: true, detail: writes });
+    checks.push({
+        name: "Tools",
+        ok: true,
+        detail: `${app.tools(io.env).length} of ${app.allTools.length} on${policy.toolsets === "all" ? "" : ` (${names.toolsets}=${[...policy.toolsets].join(",")})`}`,
+    });
+    if (policy.auditLog) {
+        let writable = true;
+        try {
+            accessSync(dirname(policy.auditLog), constants.W_OK);
+        }
+        catch {
+            writable = false;
+        }
+        checks.push({
+            name: "Audit log",
+            ok: writable,
+            detail: policy.auditLog,
+            ...(writable ? {} : { fix: `The folder for ${names.auditLog} is missing or not writable.` }),
+        });
+    }
+    if (app.allTools.some((tool) => tool.cache || tool.sync)) {
+        const { dataDir, loadSqlite } = await import("./data.js");
+        const sqlite = await loadSqlite();
+        checks.push({
+            name: "Local data",
+            ok: Boolean(sqlite),
+            ...(sqlite ? {} : { warn: true }),
+            detail: sqlite ? `${dataDir(app.name, app.envPrefix, io.env)}${policy.cache ? "" : ` (cache off: ${names.cache}=0)`}` : "unavailable: this Node.js has no SQLite",
+            ...(sqlite ? {} : { fix: "Install Node.js 22.13 or later for the cache and offline search." }),
+        });
+    }
+    let configured = true;
+    let ctx;
+    try {
+        ctx = await app.context(io.env);
+    }
+    catch (error) {
+        configured = false;
+        const e = error instanceof SlipwayError ? error : new NotConfiguredError(String(error?.message ?? error));
+        checks.push({ name: "Setup", ok: false, detail: e.message, fix: e.hint ?? `Run \`${app.bins.cli} login\`.` });
+    }
+    if (ctx !== undefined && app.definition.configured) {
+        configured = await app.definition.configured(ctx);
+        checks.push({
+            name: "Credentials",
+            ok: configured,
+            detail: configured ? "configured" : "nothing configured",
+            ...(configured ? {} : { fix: `Run \`${app.bins.cli} login\` to see how to connect an account.` }),
+        });
+    }
+    if (ctx !== undefined && app.definition.doctor) {
+        try {
+            checks.push(...(await app.definition.doctor(ctx, { network: options.network })));
+        }
+        catch (error) {
+            checks.push({ name: "Service check", ok: false, detail: app.secrets.redact(error?.message ?? String(error)) });
+        }
+    }
+    if (!options.network && app.definition.doctor) {
+        checks.push({ name: "Network", ok: true, warn: true, detail: "not checked; run with --network to call the service" });
+    }
+    const failed = checks.filter((check) => !check.ok && !check.warn);
+    const code = !configured ? EXIT.notConfigured : failed.length ? EXIT.error : EXIT.ok;
+    if (options.json) {
+        io.stdout(`${JSON.stringify(app.secrets.redactDeep({ ok: code === EXIT.ok, exit_code: code, checks }), null, 2)}\n`);
+    }
+    else {
+        const width = Math.max(...checks.map((check) => check.name.length)) + 2;
+        const lines = [``, `${app.title} doctor`, ``];
+        for (const check of checks) {
+            const mark = check.ok ? (check.warn ? "-" : "✓") : check.warn ? "!" : "✗";
+            lines.push(`  ${mark} ${check.name.padEnd(width)}${app.secrets.redact(check.detail ?? "")}`);
+            if (!check.ok && check.fix)
+                lines.push(`    ${" ".repeat(width)}${check.fix}`);
+        }
+        lines.push(``, code === EXIT.ok ? "  Ready." : code === EXIT.notConfigured ? "  Nothing is configured yet." : "  Something needs fixing.", ``);
+        io.stdout(lines.join("\n"));
+    }
+    return code;
+}

package/dist/entry.d.ts

@@ -0,0 +1,11 @@
+/**
+ * One entry point, two binaries.
+ *
+ * `<name>-mcp` with no arguments is an MCP client starting a stdio server, and
+ * must stay silent on stdout. `<name>-cli` with no arguments is a person who
+ * wants to know what they can type. Any argument on either binary is a CLI
+ * command, so a typo is reported instead of starting a server that sits
+ * waiting on stdin and looks like a hang.
+ */
+import { type App } from "./app.js";
+export declare function main(app: App, argv: string[], invokedAs: string): Promise<void>;

package/dist/entry.js

@@ -0,0 +1,34 @@
+/**
+ * One entry point, two binaries.
+ *
+ * `<name>-mcp` with no arguments is an MCP client starting a stdio server, and
+ * must stay silent on stdout. `<name>-cli` with no arguments is a person who
+ * wants to know what they can type. Any argument on either binary is a CLI
+ * command, so a typo is reported instead of starting a server that sits
+ * waiting on stdin and looks like a hang.
+ */
+import { stderrLogger } from "./app.js";
+import { SlipwayError } from "./errors.js";
+export async function main(app, argv, invokedAs) {
+    const asCli = invokedAs.startsWith(app.bins.cli);
+    if (!asCli && argv.includes("--http")) {
+        const { httpOptions, serveHttpApp } = await import("./serve.js");
+        try {
+            const served = await serveHttpApp(app, process.env, httpOptions(app, process.env, argv));
+            const stop = () => void served.close().finally(() => process.exit(0));
+            process.on("SIGINT", stop);
+            process.on("SIGTERM", stop);
+        }
+        catch (error) {
+            stderrLogger(app.envPrefix, process.env).error(error.message);
+            process.exitCode = error instanceof SlipwayError ? error.exitCode : 1;
+        }
+        return;
+    }
+    if (!asCli && argv.length === 0) {
+        const { serveStdioApp } = await import("./serve.js");
+        await serveStdioApp(app, process.env);
+        return;
+    }
+    process.exitCode = await app.runCli(argv, { bin: asCli ? app.bins.cli : app.bins.mcp });
+}

package/dist/errors.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Errors that carry their own exit code.
+ *
+ * A script branches on the number, a model reads the message and the hint.
+ * Mapping errors to exit codes by matching words in the message breaks the day
+ * someone rewords a message, so every error Slipway raises says which code it
+ * is, and the word matching survives only as a fallback for errors thrown by
+ * code that knows nothing about Slipway.
+ */
+/** The exit-code contract. Scripts depend on these numbers, so they never change. */
+export declare const EXIT: {
+    readonly ok: 0;
+    readonly error: 1;
+    readonly usage: 2;
+    readonly notFound: 3;
+    readonly auth: 4;
+    readonly api: 5;
+    readonly rateLimited: 7;
+    readonly notConfigured: 10;
+    readonly interrupted: 130;
+};
+export type ErrorCode = "usage" | "refused" | "not_found" | "auth" | "api" | "rate_limited" | "not_configured" | "timeout" | "canceled" | "internal";
+export type ErrorOptions = {
+    hint?: string;
+    status?: number;
+    retryAfterSeconds?: number;
+    details?: unknown;
+    cause?: unknown;
+};
+export type ErrorPayload = {
+    error: string;
+    code: ErrorCode;
+    hint?: string;
+    status?: number;
+    retry_after_seconds?: number;
+    details?: unknown;
+};
+export declare class SlipwayError extends Error {
+    readonly code: ErrorCode;
+    readonly exitCode: number;
+    readonly hint?: string;
+    readonly status?: number;
+    readonly retryAfterSeconds?: number;
+    readonly details?: unknown;
+    constructor(message: string, code: ErrorCode, exitCode: number, options?: ErrorOptions);
+    /** The one shape both surfaces report: JSON on stderr in a terminal, an isError result over MCP. */
+    toJSON(): ErrorPayload;
+}
+/** The caller asked for something malformed. Fix the arguments and retry. */
+export declare class UsageError extends SlipwayError {
+    constructor(message: string, options?: ErrorOptions);
+}
+/** A write the guard would not run: read-only mode, destructive writes off, or no confirmation. */
+export declare class RefusedError extends SlipwayError {
+    constructor(message: string, options?: ErrorOptions);
+}
+export declare class NotFoundError extends SlipwayError {
+    constructor(message: string, options?: ErrorOptions);
+}
+export declare class AuthError extends SlipwayError {
+    constructor(message: string, options?: ErrorOptions);
+}
+export declare class ApiError extends SlipwayError {
+    constructor(message: string, options?: ErrorOptions);
+}
+export declare class RateLimitError extends SlipwayError {
+    constructor(message: string, options?: ErrorOptions);
+}
+/**
+ * Nothing is set up yet. This is what someone hits on first run, so it always
+ * names the command that fixes it.
+ */
+export declare class NotConfiguredError extends SlipwayError {
+    constructor(message: string, options?: ErrorOptions);
+}
+export declare class TimeoutError extends SlipwayError {
+    constructor(message: string, options?: ErrorOptions);
+}
+export declare class CanceledError extends SlipwayError {
+    constructor(message: string, options?: ErrorOptions);
+}
+/**
+ * The error for an HTTP status, so an API client needs one line per failure.
+ *
+ * 400 and 422 are usage errors: the upstream API rejected the arguments, and the
+ * caller fixes that by changing them, exactly like a schema failure.
+ */
+export declare function httpError(status: number, message: string, options?: ErrorOptions): SlipwayError;
+/**
+ * Turn anything thrown into a SlipwayError.
+ *
+ * Errors from other libraries arrive with no code, so the fallback reads the
+ * shape they usually have (a numeric `status`, an abort) and only then the
+ * words in the message.
+ */
+export declare function toSlipwayError(error: unknown): SlipwayError;

package/dist/errors.js

@@ -0,0 +1,153 @@
+/**
+ * Errors that carry their own exit code.
+ *
+ * A script branches on the number, a model reads the message and the hint.
+ * Mapping errors to exit codes by matching words in the message breaks the day
+ * someone rewords a message, so every error Slipway raises says which code it
+ * is, and the word matching survives only as a fallback for errors thrown by
+ * code that knows nothing about Slipway.
+ */
+/** The exit-code contract. Scripts depend on these numbers, so they never change. */
+export const EXIT = {
+    ok: 0,
+    error: 1,
+    usage: 2,
+    notFound: 3,
+    auth: 4,
+    api: 5,
+    rateLimited: 7,
+    notConfigured: 10,
+    interrupted: 130,
+};
+export class SlipwayError extends Error {
+    code;
+    exitCode;
+    hint;
+    status;
+    retryAfterSeconds;
+    details;
+    constructor(message, code, exitCode, options = {}) {
+        super(message, options.cause === undefined ? undefined : { cause: options.cause });
+        this.name = new.target.name;
+        this.code = code;
+        this.exitCode = exitCode;
+        this.hint = options.hint;
+        this.status = options.status;
+        this.retryAfterSeconds = options.retryAfterSeconds;
+        this.details = options.details;
+    }
+    /** The one shape both surfaces report: JSON on stderr in a terminal, an isError result over MCP. */
+    toJSON() {
+        const payload = { error: this.message, code: this.code };
+        if (this.hint)
+            payload.hint = this.hint;
+        if (this.status !== undefined)
+            payload.status = this.status;
+        if (this.retryAfterSeconds !== undefined)
+            payload.retry_after_seconds = this.retryAfterSeconds;
+        if (this.details !== undefined)
+            payload.details = this.details;
+        return payload;
+    }
+}
+/** The caller asked for something malformed. Fix the arguments and retry. */
+export class UsageError extends SlipwayError {
+    constructor(message, options) {
+        super(message, "usage", EXIT.usage, options);
+    }
+}
+/** A write the guard would not run: read-only mode, destructive writes off, or no confirmation. */
+export class RefusedError extends SlipwayError {
+    constructor(message, options) {
+        super(message, "refused", EXIT.usage, options);
+    }
+}
+export class NotFoundError extends SlipwayError {
+    constructor(message, options) {
+        super(message, "not_found", EXIT.notFound, options);
+    }
+}
+export class AuthError extends SlipwayError {
+    constructor(message, options) {
+        super(message, "auth", EXIT.auth, options);
+    }
+}
+export class ApiError extends SlipwayError {
+    constructor(message, options) {
+        super(message, "api", EXIT.api, options);
+    }
+}
+export class RateLimitError extends SlipwayError {
+    constructor(message, options) {
+        super(message, "rate_limited", EXIT.rateLimited, options);
+    }
+}
+/**
+ * Nothing is set up yet. This is what someone hits on first run, so it always
+ * names the command that fixes it.
+ */
+export class NotConfiguredError extends SlipwayError {
+    constructor(message, options) {
+        super(message, "not_configured", EXIT.notConfigured, options);
+    }
+}
+export class TimeoutError extends SlipwayError {
+    constructor(message, options) {
+        super(message, "timeout", EXIT.api, options);
+    }
+}
+export class CanceledError extends SlipwayError {
+    constructor(message, options) {
+        super(message, "canceled", EXIT.interrupted, options);
+    }
+}
+/**
+ * The error for an HTTP status, so an API client needs one line per failure.
+ *
+ * 400 and 422 are usage errors: the upstream API rejected the arguments, and the
+ * caller fixes that by changing them, exactly like a schema failure.
+ */
+export function httpError(status, message, options = {}) {
+    const withStatus = { ...options, status };
+    if (status === 401 || status === 403)
+        return new AuthError(message, withStatus);
+    if (status === 404 || status === 410)
+        return new NotFoundError(message, withStatus);
+    if (status === 429)
+        return new RateLimitError(message, withStatus);
+    if (status === 400 || status === 422)
+        return new UsageError(message, withStatus);
+    return new ApiError(message, withStatus);
+}
+/**
+ * Turn anything thrown into a SlipwayError.
+ *
+ * Errors from other libraries arrive with no code, so the fallback reads the
+ * shape they usually have (a numeric `status`, an abort) and only then the
+ * words in the message.
+ */
+export function toSlipwayError(error) {
+    if (error instanceof SlipwayError)
+        return error;
+    const e = error;
+    const message = typeof e?.message === "string" && e.message ? e.message : typeof error === "string" ? error : "Unknown error";
+    const status = typeof e?.status === "number" ? e.status : typeof e?.statusCode === "number" ? e.statusCode : undefined;
+    if (e?.name === "AbortError")
+        return new CanceledError(message, { cause: error });
+    if (e?.name === "TimeoutError")
+        return new TimeoutError(message, { cause: error });
+    if (status !== undefined && status >= 400)
+        return httpError(status, message, { cause: error });
+    const text = message.toLowerCase();
+    if (/rate ?limit|too many requests|\b429\b/.test(text))
+        return new RateLimitError(message, { cause: error });
+    // Before auth: "no token configured" mentions a token, and matching auth first
+    // sends someone who configured nothing looking for a bad credential.
+    if (/not configured|nothing is configured|no [a-z ]*(account|credential|token|key)s? (is |are )?(set|configured)/.test(text))
+        return new NotConfiguredError(message, { cause: error });
+    if (/\b401\b|\b403\b|unauthori[sz]ed|forbidden|invalid[_ ]grant|expired token|token (has )?expired/.test(text))
+        return new AuthError(message, { cause: error });
+    if (/\b404\b|not found|does not exist/.test(text))
+        return new NotFoundError(message, { cause: error });
+    return new SlipwayError(message, "internal", EXIT.error, { cause: error });
+}

package/dist/guard.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Decides whether a write is allowed to run.
+ *
+ * Shipping no writes is not safety: it hands the work back to a person.
+ * Shipping them unguarded is worse. So everything works, the irreversible
+ * calls need an explicit confirmation, and one switch removes every write for
+ * an agent nobody should trust with them.
+ *
+ * Agent mode never confirms anything. A flag that turns on JSON output must
+ * not also say yes to deleting something, because the agent that sets it is
+ * exactly the caller the confirmation exists for.
+ */
+import { type Policy } from "./policy.js";
+import type { Surface, Tool } from "./tool.js";
+/**
+ * Who confirmed a call.
+ *
+ * - `flag`: the caller passed `confirm: true` or `--confirm`.
+ * - `person`: a person approved it in a form the client showed.
+ * - `client`: the client showed its own approval prompt for this exact call.
+ */
+export type ConfirmedBy = "flag" | "person" | "client";
+export type GuardOutcome = "allowed" | "dry-run" | "asked a person" | "blocked: read-only" | "blocked: destructive disabled" | "blocked: no confirm" | "blocked: person declined" | "blocked: no answer" | "blocked: approval invalid";
+export declare class Guard {
+    private readonly policy;
+    private readonly surface;
+    private readonly prefix;
+    constructor(policy: Policy, surface: Surface, prefix: string);
+    /** What the caller can actually type to confirm. A model reads `confirm: true`, a person types `--confirm`. */
+    get confirmFlag(): string;
+    /**
+     * The checks that do not depend on confirmation: read-only mode and the
+     * switch for irreversible writes. Run before asking a person, so nobody is
+     * asked to approve a call that would be refused anyway.
+     */
+    preflight(tool: Tool, summary: string): void;
+    check(tool: Tool, options: {
+        confirmedBy?: ConfirmedBy;
+        dryRun: boolean;
+        summary: string;
+    }): void;
+    /** Append-only record of every attempted write, when an audit log is configured. `started` is a job still running when its call returned. */
+    record(tool: Tool, summary: string, outcome: GuardOutcome | "failed" | "done" | "started", confirmedBy?: ConfirmedBy): void;
+}
+/** Why a tool needs confirming, in the words a refusal and an approval form both use. */
+export declare function consequence(tool: Pick<Tool, "risk">): string;

package/dist/guard.js

@@ -0,0 +1,89 @@
+/**
+ * Decides whether a write is allowed to run.
+ *
+ * Shipping no writes is not safety: it hands the work back to a person.
+ * Shipping them unguarded is worse. So everything works, the irreversible
+ * calls need an explicit confirmation, and one switch removes every write for
+ * an agent nobody should trust with them.
+ *
+ * Agent mode never confirms anything. A flag that turns on JSON output must
+ * not also say yes to deleting something, because the agent that sets it is
+ * exactly the caller the confirmation exists for.
+ */
+import { appendFileSync } from "node:fs";
+import { RefusedError } from "./errors.js";
+import { policyEnvNames } from "./policy.js";
+export class Guard {
+    policy;
+    surface;
+    prefix;
+    constructor(policy, surface, prefix) {
+        this.policy = policy;
+        this.surface = surface;
+        this.prefix = prefix;
+    }
+    /** What the caller can actually type to confirm. A model reads `confirm: true`, a person types `--confirm`. */
+    get confirmFlag() {
+        return this.surface === "cli" ? "--confirm" : "confirm: true";
+    }
+    /**
+     * The checks that do not depend on confirmation: read-only mode and the
+     * switch for irreversible writes. Run before asking a person, so nobody is
+     * asked to approve a call that would be refused anyway.
+     */
+    preflight(tool, summary) {
+        if (tool.risk === "read" && !tool.requireConfirm)
+            return;
+        const names = policyEnvNames(this.prefix);
+        if (this.policy.readOnly && tool.risk !== "read") {
+            this.record(tool, summary, "blocked: read-only");
+            throw new RefusedError(`${tool.name} is unavailable: this server is running with ${names.readOnly}=1.`, {
+                hint: `Unset ${names.readOnly} to allow writes.`,
+            });
+        }
+        if (tool.risk === "destructive" && !this.policy.allowDestructive) {
+            this.record(tool, summary, "blocked: destructive disabled");
+            throw new RefusedError(`${tool.name} is unavailable: this server is running with ${names.allowDestructive}=0.`, {
+                hint: `Unset ${names.allowDestructive} to allow irreversible writes.`,
+            });
+        }
+    }
+    check(tool, options) {
+        if (tool.risk === "read" && !tool.requireConfirm)
+            return;
+        this.preflight(tool, options.summary);
+        if (options.dryRun) {
+            this.record(tool, options.summary, "dry-run");
+            return;
+        }
+        if (tool.requireConfirm && !options.confirmedBy) {
+            this.record(tool, options.summary, "blocked: no confirm");
+            throw new RefusedError(`${tool.name} ${consequence(tool)}, so it will not run without ${this.confirmFlag}. About to: ${options.summary}. Call again with ${this.confirmFlag} if that is what was asked for.`, { hint: `Pass ${this.confirmFlag} only when the user asked for this exact action.` });
+        }
+        this.record(tool, options.summary, "allowed", options.confirmedBy);
+    }
+    /** Append-only record of every attempted write, when an audit log is configured. `started` is a job still running when its call returned. */
+    record(tool, summary, outcome, confirmedBy) {
+        if (!this.policy.auditLog)
+            return;
+        const line = JSON.stringify({
+            at: new Date().toISOString(),
+            surface: this.surface,
+            tool: tool.name,
+            risk: tool.risk,
+            summary,
+            outcome,
+            ...(confirmedBy ? { confirmed_by: confirmedBy } : {}),
+        });
+        try {
+            appendFileSync(this.policy.auditLog, `${line}\n`, { mode: 0o600 });
+        }
+        catch {
+            // A broken audit log must never take the tool call down with it.
+        }
+    }
+}
+/** Why a tool needs confirming, in the words a refusal and an approval form both use. */
+export function consequence(tool) {
+    return tool.risk === "destructive" ? "is public or cannot be undone" : "has an effect that cannot be taken back";
+}

package/dist/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Slipway: one tool definition ships an MCP server and an agent-native CLI.
+ */
+export { slipway, stderrLogger } from "./app.js";
+export type { App, AppDefinition, CliIO, DoctorCheck, DryRun, InvokeOptions, PromptDefinition, ResourceDefinition, ServiceSetting, } from "./app.js";
+export { defineTool, isTool, toolkit } from "./tool.js";
+export type { CacheOptions, Logger, Paginate, Risk, RunContext, Surface, SyncOptions, Tool, ToolContext, ToolDefinition, ToolExample } from "./tool.js";
+export { emptyInput, inputJsonSchema, jsonSchema, outputJsonSchema, validate, CONFIRM_DESCRIPTION } from "./schema.js";
+export type { InferInput, InferOutput, JsonSchema, Schema } from "./schema.js";
+export { ApiError, AuthError, CanceledError, EXIT, NotConfiguredError, NotFoundError, RateLimitError, RefusedError, SlipwayError, TimeoutError, UsageError, httpError, toSlipwayError, } from "./errors.js";
+export type { ErrorCode, ErrorPayload } from "./errors.js";
+export { audio, content, file, image, resourceLink, text } from "./result.js";
+export type { ContentResult } from "./result.js";
+export { readPolicy, policyEnvNames } from "./policy.js";
+export type { ConfirmMode, Policy, PolicyDefaults, ToolSurface } from "./policy.js";
+export { fromOpenAPI, httpExecutor, openapiHash, readOperations, toJsonSchema, toolName } from "./openapi.js";
+export type { Executor, FromOpenAPIOptions, HttpExecutorOptions, Operation, OperationInput, OperationParameter, SkippedOperation } from "./openapi.js";
+export type { BackgroundJob, JobDefinition, JobProgress, JobResult, ServiceJob } from "./jobs.js";
+export type { DataStore, SearchHit, SyncedTool } from "./data.js";
+export type { SyncReport } from "./sync.js";
+export { CLIENTS } from "./install.js";
+export type { ClientId } from "./install.js";
+export { Secrets } from "./redact.js";
+export { annotationsFor, CACHE_META, MAX_RESULT_SIZE_CHARS, REQUIRES_USER_INTERACTION } from "./server.js";
+export { renderDocs, settingsTable, toolReference, toolTable } from "./docs.js";
+/** The Zod instance Slipway is built against. Use it, so every schema in an app comes from one copy. */
+export { z } from "zod";

package/dist/index.js

@@ -0,0 +1,16 @@
+/**
+ * Slipway: one tool definition ships an MCP server and an agent-native CLI.
+ */
+export { slipway, stderrLogger } from "./app.js";
+export { defineTool, isTool, toolkit } from "./tool.js";
+export { emptyInput, inputJsonSchema, jsonSchema, outputJsonSchema, validate, CONFIRM_DESCRIPTION } from "./schema.js";
+export { ApiError, AuthError, CanceledError, EXIT, NotConfiguredError, NotFoundError, RateLimitError, RefusedError, SlipwayError, TimeoutError, UsageError, httpError, toSlipwayError, } from "./errors.js";
+export { audio, content, file, image, resourceLink, text } from "./result.js";
+export { readPolicy, policyEnvNames } from "./policy.js";
+export { fromOpenAPI, httpExecutor, openapiHash, readOperations, toJsonSchema, toolName } from "./openapi.js";
+export { CLIENTS } from "./install.js";
+export { Secrets } from "./redact.js";
+export { annotationsFor, CACHE_META, MAX_RESULT_SIZE_CHARS, REQUIRES_USER_INTERACTION } from "./server.js";
+export { renderDocs, settingsTable, toolReference, toolTable } from "./docs.js";
+/** The Zod instance Slipway is built against. Use it, so every schema in an app comes from one copy. */
+export { z } from "zod";