@pikku/cli 0.12.20 → 0.12.22

package/dist/src/fabric/lib/config.d.ts

@@ -0,0 +1,64 @@
+/**
+ * `fabric.config.json` lives next to `pikku.config.json` in the project root.
+ * Pins the project link (id, default api url) and declares deployable apps
+ * + production domain. Discovered by walking up from cwd until found.
+ */
+export interface ProjectConfig {
+    projectId: string;
+    apiUrl?: string;
+    frontends?: Record<string, FabricAppConfig>;
+    production?: FabricProductionConfig;
+}
+/** One entry per deployable frontend in the repo. Key is a short slug. */
+export interface FabricAppConfig {
+    cwd: string;
+    primary?: boolean;
+    deploy?: boolean;
+    kind?: 'spa' | 'ssr' | 'static';
+    dev?: {
+        command?: string[];
+        port?: number;
+        healthPath?: string;
+    };
+}
+/**
+ * Production custom domain config. Production always maps to `main`; if
+ * `domain` is set, fabric expects users to CNAME `<slug>.<domain>` and
+ * `api.<domain>` at the matching `*.pikkufabric.app` hostnames. If absent,
+ * production lives only on the platform-managed `*.pikkufabric.app`
+ * hostnames.
+ */
+export interface FabricProductionConfig {
+    domain?: string;
+}
+/**
+ * `~/.fabric/auth.json` keys auth tokens by api-url so a single user can
+ * stay logged into prod + local dev side-by-side.
+ */
+export interface AuthFile {
+    tokens: Record<string, string>;
+}
+export declare function findProjectConfig(startDir?: string): Promise<{
+    path: string;
+    config: ProjectConfig;
+} | null>;
+export declare function writeProjectConfig(cwd: string, config: ProjectConfig): Promise<string>;
+export declare function readAuthFile(): Promise<AuthFile>;
+export declare function writeAuthFile(file: AuthFile): Promise<void>;
+export interface ResolvedApiContext {
+    apiUrl: string;
+    token: string | null;
+    projectId: string | null;
+}
+/**
+ * Stitch together the api-url + auth token from the standard sources:
+ *   1. explicit override (e.g. --api-url flag)
+ *   2. fabric.config.json apiUrl
+ *   3. FABRIC_API_URL env var
+ *   4. hardcoded default
+ *
+ * Token comes from ~/.fabric/auth.json keyed by the resolved api-url.
+ */
+export declare function resolveApiContext(opts?: {
+    apiUrlOverride?: string;
+}): Promise<ResolvedApiContext>;

package/dist/src/fabric/lib/config.js

@@ -0,0 +1,62 @@
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { homedir } from 'node:os';
+const DEFAULT_API_URL = 'http://localhost:7103';
+const projectConfigName = 'fabric.config.json';
+const authFilePath = join(homedir(), '.fabric', 'auth.json');
+export async function findProjectConfig(startDir = process.cwd()) {
+    let dir = startDir;
+    while (true) {
+        const candidate = join(dir, projectConfigName);
+        if (existsSync(candidate)) {
+            const raw = await readFile(candidate, 'utf8');
+            return { path: candidate, config: JSON.parse(raw) };
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+export async function writeProjectConfig(cwd, config) {
+    const path = join(cwd, projectConfigName);
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, JSON.stringify(config, null, 2) + '\n', 'utf8');
+    return path;
+}
+export async function readAuthFile() {
+    if (!existsSync(authFilePath))
+        return { tokens: {} };
+    const raw = await readFile(authFilePath, 'utf8');
+    return JSON.parse(raw);
+}
+export async function writeAuthFile(file) {
+    await mkdir(dirname(authFilePath), { recursive: true });
+    await writeFile(authFilePath, JSON.stringify(file, null, 2) + '\n', {
+        encoding: 'utf8',
+        mode: 0o600,
+    });
+}
+/**
+ * Stitch together the api-url + auth token from the standard sources:
+ *   1. explicit override (e.g. --api-url flag)
+ *   2. fabric.config.json apiUrl
+ *   3. FABRIC_API_URL env var
+ *   4. hardcoded default
+ *
+ * Token comes from ~/.fabric/auth.json keyed by the resolved api-url.
+ */
+export async function resolveApiContext(opts = {}) {
+    const projectFile = await findProjectConfig();
+    const apiUrl = opts.apiUrlOverride ??
+        projectFile?.config.apiUrl ??
+        process.env.FABRIC_API_URL ??
+        DEFAULT_API_URL;
+    const auth = await readAuthFile();
+    return {
+        apiUrl,
+        token: auth.tokens[apiUrl] ?? null,
+        projectId: projectFile?.config.projectId ?? null,
+    };
+}

package/dist/src/fabric/lib/console-url.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Map a fabric-api URL to its console URL by convention. Local dev uses
+ * separate ports; prod uses subdomain swap (api.* → console.*).
+ */
+export declare function deriveConsoleUrl(apiUrl: string): string;

package/dist/src/fabric/lib/console-url.js

@@ -0,0 +1,13 @@
+/**
+ * Map a fabric-api URL to its console URL by convention. Local dev uses
+ * separate ports; prod uses subdomain swap (api.* → console.*).
+ */
+export function deriveConsoleUrl(apiUrl) {
+    const url = new URL(apiUrl);
+    if (url.hostname === 'localhost' || url.hostname === '127.0.0.1') {
+        url.port = '7102';
+        return url.toString();
+    }
+    url.hostname = url.hostname.replace(/^api\./, 'console.');
+    return url.toString();
+}

package/dist/src/fabric/lib/git.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Local git probes for the deploy safety checks (clean tree, HEAD == remote,
+ * ref resolution). Shell out to `git` rather than depend on simple-git —
+ * matches what wrangler/vercel/fly do, no runtime dep.
+ */
+export declare class GitError extends Error {
+    command: string;
+    exitCode: number;
+    stderr: string;
+    constructor(command: string, exitCode: number, stderr: string);
+}
+export declare function currentBranch(cwd?: string): Promise<string>;
+/**
+ * Returns the fetch URL for the given remote, with credentials and .git suffix
+ * stripped so it's safe to store server-side or pass to importProject.
+ */
+export declare function getRemoteUrl(remote?: string, cwd?: string): Promise<string>;
+export declare function headSha(cwd?: string): Promise<string>;
+export declare function localBranchHeadSha(branch: string, cwd?: string): Promise<string>;
+export declare function isWorkingTreeClean(cwd?: string): Promise<boolean>;
+export declare function upstreamBranch(cwd?: string): Promise<string | null>;
+export declare function upstreamForBranch(branch: string, cwd?: string): Promise<string | null>;
+export declare function remoteHeadSha(upstream: string, cwd?: string): Promise<string>;
+/**
+ * Resolve a ref (branch / tag / sha) to a sha. Returns null if git can't
+ * resolve it, so callers can fall back to "use HEAD".
+ */
+export declare function resolveRef(ref: string, cwd?: string): Promise<string | null>;
+/**
+ * Spec §7 ancestry check: is `candidate` reachable from `mainRef` (i.e. has
+ * mainRef been merged forward to include candidate)?
+ *
+ * `git merge-base --is-ancestor` exits 0 if candidate is an ancestor of
+ * mainRef, 1 if not, anything else on hard error.
+ */
+export declare function isAncestor(candidate: string, mainRef: string, cwd?: string): Promise<boolean>;
+export interface DeploySafetyResult {
+    branch: string;
+    headSha: string;
+    upstream: string;
+    remoteSha: string;
+}
+/**
+ * Spec §10 deploy ref safety checks. Throws on any failure with a CLI-friendly
+ * message; returns the resolved commit context on pass.
+ */
+export declare function assertDeploySafety(cwd?: string): Promise<DeploySafetyResult>;
+/**
+ * Validate a named branch for deploy without depending on the currently
+ * checked-out branch. This is the Fabric CLI deploy contract: deploy the
+ * target branch, not "whatever branch I happen to be on".
+ */
+export declare function assertNamedBranchDeploySafety(branch: string, cwd?: string): Promise<DeploySafetyResult>;

package/dist/src/fabric/lib/git.js

@@ -0,0 +1,151 @@
+import { spawn } from 'node:child_process';
+/**
+ * Local git probes for the deploy safety checks (clean tree, HEAD == remote,
+ * ref resolution). Shell out to `git` rather than depend on simple-git —
+ * matches what wrangler/vercel/fly do, no runtime dep.
+ */
+export class GitError extends Error {
+    command;
+    exitCode;
+    stderr;
+    constructor(command, exitCode, stderr) {
+        super(`git ${command} failed (${exitCode}): ${stderr.trim()}`);
+        this.command = command;
+        this.exitCode = exitCode;
+        this.stderr = stderr;
+    }
+}
+function git(args, cwd = process.cwd()) {
+    return new Promise((resolve, reject) => {
+        const child = spawn('git', args, { cwd, stdio: ['ignore', 'pipe', 'pipe'] });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (b) => (stdout += b.toString()));
+        child.stderr.on('data', (b) => (stderr += b.toString()));
+        child.on('error', reject);
+        child.on('close', (code) => {
+            if (code === 0)
+                resolve(stdout.trim());
+            else
+                reject(new GitError(args.join(' '), code ?? -1, stderr));
+        });
+    });
+}
+export async function currentBranch(cwd) {
+    return git(['rev-parse', '--abbrev-ref', 'HEAD'], cwd);
+}
+/**
+ * Returns the fetch URL for the given remote, with credentials and .git suffix
+ * stripped so it's safe to store server-side or pass to importProject.
+ */
+export async function getRemoteUrl(remote = 'origin', cwd) {
+    const raw = await git(['remote', 'get-url', remote], cwd);
+    // Convert SSH format (git@github.com:owner/repo.git) to HTTPS
+    const sshMatch = raw.match(/^git@([^:]+):(.+?)(?:\.git)?$/);
+    if (sshMatch) {
+        return `https://${sshMatch[1]}/${sshMatch[2]}`;
+    }
+    return raw.replace(/\.git$/, '').replace(/^(https?:\/\/)[^@]+@/, '$1');
+}
+export async function headSha(cwd) {
+    return git(['rev-parse', 'HEAD'], cwd);
+}
+export async function localBranchHeadSha(branch, cwd) {
+    return git(['rev-parse', '--verify', `${branch}^{commit}`], cwd);
+}
+export async function isWorkingTreeClean(cwd) {
+    const out = await git(['status', '--porcelain'], cwd);
+    return out.length === 0;
+}
+export async function upstreamBranch(cwd) {
+    try {
+        return await git(['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}'], cwd);
+    }
+    catch {
+        return null;
+    }
+}
+export async function upstreamForBranch(branch, cwd) {
+    try {
+        return await git(['rev-parse', '--abbrev-ref', '--symbolic-full-name', `${branch}@{u}`], cwd);
+    }
+    catch {
+        return null;
+    }
+}
+export async function remoteHeadSha(upstream, cwd) {
+    return git(['rev-parse', upstream], cwd);
+}
+/**
+ * Resolve a ref (branch / tag / sha) to a sha. Returns null if git can't
+ * resolve it, so callers can fall back to "use HEAD".
+ */
+export async function resolveRef(ref, cwd) {
+    try {
+        return await git(['rev-parse', '--verify', `${ref}^{commit}`], cwd);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Spec §7 ancestry check: is `candidate` reachable from `mainRef` (i.e. has
+ * mainRef been merged forward to include candidate)?
+ *
+ * `git merge-base --is-ancestor` exits 0 if candidate is an ancestor of
+ * mainRef, 1 if not, anything else on hard error.
+ */
+export async function isAncestor(candidate, mainRef, cwd) {
+    try {
+        await git(['merge-base', '--is-ancestor', candidate, mainRef], cwd);
+        return true;
+    }
+    catch (err) {
+        if (err instanceof GitError && err.exitCode === 1)
+            return false;
+        throw err;
+    }
+}
+/**
+ * Spec §10 deploy ref safety checks. Throws on any failure with a CLI-friendly
+ * message; returns the resolved commit context on pass.
+ */
+export async function assertDeploySafety(cwd) {
+    if (!(await isWorkingTreeClean(cwd))) {
+        throw new Error('Deployment blocked: uncommitted changes detected.\nCommit and push your changes before deploying.');
+    }
+    const branch = await currentBranch(cwd);
+    const upstream = await upstreamBranch(cwd);
+    if (!upstream) {
+        throw new Error(`Deployment blocked: branch ${branch} has no upstream.\nPush it (\`git push -u origin ${branch}\`) before deploying.`);
+    }
+    const head = await headSha(cwd);
+    const remote = await remoteHeadSha(upstream, cwd);
+    if (head !== remote) {
+        throw new Error(`Deployment blocked: local HEAD ${head.slice(0, 8)} ≠ remote ${remote.slice(0, 8)} (${upstream}).\nPush or pull before deploying.`);
+    }
+    return { branch, headSha: head, upstream, remoteSha: remote };
+}
+/**
+ * Validate a named branch for deploy without depending on the currently
+ * checked-out branch. This is the Fabric CLI deploy contract: deploy the
+ * target branch, not "whatever branch I happen to be on".
+ */
+export async function assertNamedBranchDeploySafety(branch, cwd) {
+    let head;
+    try {
+        head = await localBranchHeadSha(branch, cwd);
+    }
+    catch {
+        throw new Error(`Deployment blocked: local branch ${branch} does not exist.\nFetch or create it before deploying.`);
+    }
+    const upstream = await upstreamForBranch(branch, cwd);
+    if (!upstream) {
+        throw new Error(`Deployment blocked: branch ${branch} has no upstream.\nPush it (\`git push -u origin ${branch}\`) before deploying.`);
+    }
+    const remote = await remoteHeadSha(upstream, cwd);
+    if (head !== remote) {
+        throw new Error(`Deployment blocked: ${branch} ${head.slice(0, 8)} ≠ remote ${remote.slice(0, 8)} (${upstream}).\nPush or pull ${branch} before deploying.`);
+    }
+    return { branch, headSha: head, upstream, remoteSha: remote };
+}

package/dist/src/fabric/lib/http.d.ts

@@ -0,0 +1,4 @@
+export declare function getFabricRPC(opts: {
+    apiUrl: string;
+    token: string | null;
+}): any;

package/dist/src/fabric/lib/http.js

@@ -0,0 +1,12 @@
+/**
+ * Type-safe RPC client backed by the snapshot SDK in `../sdk/`. The map is
+ * a copy of fabric's generated rpc-map at the time of the addon's last
+ * release — versioning bumps are taken by republishing this package.
+ */
+import { PikkuRPC } from '../sdk/pikku-rpc.gen.js';
+export function getFabricRPC(opts) {
+    const rpc = new PikkuRPC();
+    rpc.setServerUrl(opts.apiUrl);
+    rpc.setAuthorizationJWT(opts.token);
+    return rpc;
+}

package/dist/src/fabric/lib/not-implemented.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Stub helper for CLI commands that are scaffolded but not yet wired to
+ * fabric-api RPCs. Each T1 task replaces these with real implementations.
+ */
+export declare function notImplemented(commandName: string): never;

package/dist/src/fabric/lib/not-implemented.js

@@ -0,0 +1,8 @@
+/**
+ * Stub helper for CLI commands that are scaffolded but not yet wired to
+ * fabric-api RPCs. Each T1 task replaces these with real implementations.
+ */
+export function notImplemented(commandName) {
+    console.error(`[fabric] \`${commandName}\` is not implemented yet — see GitHub epic #110.`);
+    process.exit(2);
+}

package/dist/src/fabric/lib/output.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Render helpers shared by the fabric read commands.
+ *
+ * These run inside a command's `render` (post-return, human output only).
+ * `--json` is handled globally by the CLI runner, which routes the command's
+ * result through the JSON renderer instead — so these helpers never deal with
+ * the json case. They just turn returned data into a pretty, coloured table.
+ */
+type Cell = string | number | null | undefined;
+/** Dim, secondary text (hints, empty-state lines, labels). */
+export declare const dim: (s: string) => string;
+/** Status / change colours — mirror the console UI: green = good/added,
+ * amber = in-flight/changed, red = failed/removed. */
+export declare const added: (s: string) => string;
+export declare const changed: (s: string) => string;
+export declare const removed: (s: string) => string;
+/** Colour a status token by its meaning (falls back to dim). */
+export declare function statusColor(status: string): string;
+/** Space-padded aligned columns with a dim header — the default human table. */
+export declare function table(headers: string[], rows: Cell[][]): string;
+/** Aligned `key  value` lines with dim keys. */
+export declare function keyValue(rows: [string, string][]): string;
+export {};

package/dist/src/fabric/lib/output.js

@@ -0,0 +1,39 @@
+import chalk from 'chalk';
+const cell = (c) => c === null || c === undefined ? '' : String(c);
+/** Dim, secondary text (hints, empty-state lines, labels). */
+export const dim = (s) => chalk.dim(s);
+/** Status / change colours — mirror the console UI: green = good/added,
+ * amber = in-flight/changed, red = failed/removed. */
+export const added = (s) => chalk.green(s);
+export const changed = (s) => chalk.hex('#d97706')(s);
+export const removed = (s) => chalk.red(s);
+const GOOD = /^(active|healthy|succeeded|success|ready|running|live|ok|added)$/i;
+const BUSY = /^(deploying|planned|suspended|pending|building|provisioning|queued|in_progress|changed)$/i;
+const BAD = /^(failed|error|crashed|unhealthy|dead|removed|cancelled|canceled)$/i;
+/** Colour a status token by its meaning (falls back to dim). */
+export function statusColor(status) {
+    if (GOOD.test(status))
+        return added(status);
+    if (BUSY.test(status))
+        return changed(status);
+    if (BAD.test(status))
+        return removed(status);
+    return dim(status);
+}
+// Strip ANSI so coloured cells still measure/align correctly.
+const visibleLen = (s) => s.replace(/\x1b\[[0-9;]*m/g, '').length;
+/** Space-padded aligned columns with a dim header — the default human table. */
+export function table(headers, rows) {
+    const widths = headers.map((h, i) => Math.max(h.length, ...rows.map((r) => visibleLen(cell(r[i])))));
+    const pad = (c, i) => {
+        const s = cell(c);
+        return s + ' '.repeat(Math.max(0, widths[i] - visibleLen(s)));
+    };
+    const fmt = (r) => r.map(pad).join('  ');
+    return [chalk.dim(fmt(headers)), ...rows.map(fmt)].join('\n');
+}
+/** Aligned `key  value` lines with dim keys. */
+export function keyValue(rows) {
+    const width = Math.max(...rows.map(([k]) => k.length));
+    return rows.map(([k, v]) => `${chalk.dim(k.padEnd(width))}  ${v}`).join('\n');
+}

package/dist/src/fabric/lib/prompt.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Read a line from stdin with optional masking. Used for secret-set when the
+ * user didn't pass `--value` on the command line so we can avoid leaving
+ * the plaintext in shell history.
+ */
+export declare function promptSecret(label: string): Promise<string>;
+/**
+ * Classic yes/no confirmation. Returns `defaultYes` on an empty answer.
+ * Callers must gate on `process.stdin.isTTY` first — there is no human to
+ * answer in a non-interactive session, so prompting there would hang.
+ */
+export declare function promptConfirm(label: string, defaultYes?: boolean): Promise<boolean>;

package/dist/src/fabric/lib/prompt.js

@@ -0,0 +1,32 @@
+import { createInterface } from 'node:readline/promises';
+import { stdin, stdout } from 'node:process';
+/**
+ * Read a line from stdin with optional masking. Used for secret-set when the
+ * user didn't pass `--value` on the command line so we can avoid leaving
+ * the plaintext in shell history.
+ */
+export async function promptSecret(label) {
+    const rl = createInterface({ input: stdin, output: stdout, terminal: true });
+    // Best-effort masking — the readline API doesn't suppress echo natively;
+    // for hardened input you'd want `read -s` or a tty trick, but for our
+    // CLI the standard prompt is fine and matches what wrangler does.
+    process.stdout.write(`${label}: `);
+    const value = await rl.question('');
+    rl.close();
+    return value.trim();
+}
+/**
+ * Classic yes/no confirmation. Returns `defaultYes` on an empty answer.
+ * Callers must gate on `process.stdin.isTTY` first — there is no human to
+ * answer in a non-interactive session, so prompting there would hang.
+ */
+export async function promptConfirm(label, defaultYes = false) {
+    const rl = createInterface({ input: stdin, output: stdout });
+    const answer = (await rl.question(`${label} [${defaultYes ? 'Y/n' : 'y/N'}] `))
+        .trim()
+        .toLowerCase();
+    rl.close();
+    if (!answer)
+        return defaultYes;
+    return answer === 'y' || answer === 'yes';
+}

package/dist/src/fabric/lib/stage.d.ts

@@ -0,0 +1,7 @@
+import type { PikkuRPC } from '../sdk/pikku-rpc.gen.js';
+/**
+ * Resolve a stage UUID from (projectId, branch) via the `listStages` RPC.
+ * The stageId-based read RPCs (listDeployments, listDeploymentWorkers,
+ * getStageDatabaseSchema) need a UUID, but the CLI only knows the branch.
+ */
+export declare function resolveStageId(rpc: PikkuRPC, projectId: string, branch: string): Promise<string>;

package/dist/src/fabric/lib/stage.js

@@ -0,0 +1,14 @@
+/**
+ * Resolve a stage UUID from (projectId, branch) via the `listStages` RPC.
+ * The stageId-based read RPCs (listDeployments, listDeploymentWorkers,
+ * getStageDatabaseSchema) need a UUID, but the CLI only knows the branch.
+ */
+export async function resolveStageId(rpc, projectId, branch) {
+    const { stages } = await rpc.invoke('listStages', { projectId });
+    const stage = stages.find((s) => s.branch === branch);
+    if (!stage) {
+        const known = stages.map((s) => s.branch).join(', ');
+        throw new Error(`No stage for branch "${branch}".${known ? ` Existing: ${known}` : ''}`);
+    }
+    return stage.stageId;
+}

package/dist/src/fabric/sdk/pikku-fetch.gen.d.ts

@@ -0,0 +1,14 @@
+/**
+ * This file was generated by @pikku/cli@0.12.21
+ */
+import { CorePikkuFetch } from '@pikku/fetch';
+import type { HTTPWiringsMap, HTTPWiringHandlerOf, HTTPWiringsWithMethod } from './http-map.gen.d.js';
+export declare class PikkuFetch extends CorePikkuFetch {
+    post<Route extends HTTPWiringsWithMethod<'POST'>>(route: Route, ...args: null extends HTTPWiringHandlerOf<Route, 'POST'>['input'] ? [data?: Exclude<HTTPWiringHandlerOf<Route, 'POST'>['input'], null>, options?: Omit<RequestInit, 'body'>] : [data: HTTPWiringHandlerOf<Route, 'POST'>['input'], options?: Omit<RequestInit, 'body'>]): Promise<HTTPWiringHandlerOf<Route, 'POST'>['output']>;
+    get<Route extends HTTPWiringsWithMethod<'GET'>>(route: Route, ...args: null extends HTTPWiringHandlerOf<Route, 'GET'>['input'] ? [data?: Exclude<HTTPWiringHandlerOf<Route, 'GET'>['input'], null>, options?: Omit<RequestInit, 'body'>] : [data: HTTPWiringHandlerOf<Route, 'GET'>['input'], options?: Omit<RequestInit, 'body'>]): Promise<HTTPWiringHandlerOf<Route, 'GET'>['output']>;
+    patch<Route extends HTTPWiringsWithMethod<'PATCH'>>(route: Route, ...args: null extends HTTPWiringHandlerOf<Route, 'PATCH'>['input'] ? [data?: Exclude<HTTPWiringHandlerOf<Route, 'PATCH'>['input'], null>, options?: Omit<RequestInit, 'body'>] : [data: HTTPWiringHandlerOf<Route, 'PATCH'>['input'], options?: Omit<RequestInit, 'body'>]): Promise<HTTPWiringHandlerOf<Route, 'PATCH'>['output']>;
+    head<Route extends HTTPWiringsWithMethod<'HEAD'>>(route: Route, ...args: null extends HTTPWiringHandlerOf<Route, 'HEAD'>['input'] ? [data?: Exclude<HTTPWiringHandlerOf<Route, 'HEAD'>['input'], null>, options?: Omit<RequestInit, 'body'>] : [data: HTTPWiringHandlerOf<Route, 'HEAD'>['input'], options?: Omit<RequestInit, 'body'>]): Promise<HTTPWiringHandlerOf<Route, 'HEAD'>['output']>;
+    delete<Route extends HTTPWiringsWithMethod<'DELETE'>>(route: Route, ...args: null extends HTTPWiringHandlerOf<Route, 'DELETE'>['input'] ? [data?: Exclude<HTTPWiringHandlerOf<Route, 'DELETE'>['input'], null>, options?: Omit<RequestInit, 'body'>] : [data: HTTPWiringHandlerOf<Route, 'DELETE'>['input'], options?: Omit<RequestInit, 'body'>]): Promise<HTTPWiringHandlerOf<Route, 'DELETE'>['output']>;
+    fetch<Route extends keyof HTTPWiringsMap, Method extends keyof HTTPWiringsMap[Route]>(route: Route, method: Method, data: HTTPWiringHandlerOf<Route, Method>['input'], options?: Omit<RequestInit, 'body'>): Promise<Response>;
+}
+export declare const pikkuFetch: PikkuFetch;

package/dist/src/fabric/sdk/pikku-fetch.gen.js

@@ -0,0 +1,30 @@
+/**
+ * This file was generated by @pikku/cli@0.12.21
+ */
+import { CorePikkuFetch } from '@pikku/fetch';
+export class PikkuFetch extends CorePikkuFetch {
+    async post(route, ...args) {
+        const [data, options] = args;
+        return super.api(route, 'POST', data, options);
+    }
+    async get(route, ...args) {
+        const [data, options] = args;
+        return super.api(route, 'GET', data, options);
+    }
+    async patch(route, ...args) {
+        const [data, options] = args;
+        return super.api(route, 'PATCH', data, options);
+    }
+    async head(route, ...args) {
+        const [data, options] = args;
+        return super.api(route, 'HEAD', data, options);
+    }
+    async delete(route, ...args) {
+        const [data, options] = args;
+        return super.api(route, 'DELETE', data, options);
+    }
+    async fetch(route, method, data, options) {
+        return await super.fetch(route, method, data, options);
+    }
+}
+export const pikkuFetch = new PikkuFetch();