@apifuse/provider-sdk 2.0.0-beta.1 → 2.1.0-beta.1

package/bin/apifuse-pack-check.ts

@@ -0,0 +1,87 @@
+#!/usr/bin/env bun
+
+import { execFileSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { z } from "zod";
+
+const PACK_RESULT_SCHEMA = z.array(
+	z.object({
+		filename: z.string(),
+		files: z
+			.array(
+				z.object({
+					path: z.string(),
+				}),
+			)
+			.optional(),
+	}),
+);
+
+const raw = execFileSync("npm", ["pack", "--json", "--dry-run"], {
+	cwd: process.cwd(),
+	encoding: "utf8",
+});
+const parsed = PACK_RESULT_SCHEMA.parse(JSON.parse(raw));
+const first = parsed[0];
+
+if (!first) {
+	throw new Error("npm pack --json --dry-run returned no package metadata.");
+}
+
+const filePaths = (first.files ?? []).map((file) => file.path);
+const requiredPaths = [
+	"bin/apifuse.ts",
+	"bin/apifuse-create.ts",
+	"bin/apifuse-pack-smoke.ts",
+	"src/cli/create.ts",
+	"src/cli/templates/provider/index.ts.tpl",
+	"src/cli/templates/provider/README.md.tpl",
+];
+const forbiddenMatches = filePaths.filter(
+	(path) =>
+		path.startsWith("src/__tests__/") ||
+		path === "src/index.test.ts" ||
+		path === "bin/apifuse-init.ts",
+);
+const missingRequiredPaths = requiredPaths.filter(
+	(path) => !filePaths.includes(path),
+);
+
+if (forbiddenMatches.length > 0) {
+	throw new Error(
+		`Packed artifact still includes forbidden files:\n${forbiddenMatches.join("\n")}`,
+	);
+}
+
+if (missingRequiredPaths.length > 0) {
+	throw new Error(
+		`Packed artifact is missing required public SDK files:\n${missingRequiredPaths.join("\n")}`,
+	);
+}
+
+const packageJsonInput: unknown = JSON.parse(
+	readFileSync("package.json", "utf8"),
+);
+const packageJson = z
+	.object({
+		dependencies: z.record(z.string(), z.string()).optional(),
+		devDependencies: z.record(z.string(), z.string()).optional(),
+	})
+	.parse(packageJsonInput);
+
+if (!packageJson.dependencies?.["@clack/prompts"]) {
+	throw new Error(
+		"@clack/prompts is imported by the public create CLI and must be listed in dependencies.",
+	);
+}
+
+if (packageJson.devDependencies?.["@clack/prompts"]) {
+	throw new Error(
+		"@clack/prompts must not be devDependency-only because the published create CLI imports it at runtime.",
+	);
+}
+
+console.log(`Packed artifact OK: ${first.filename}`);
+for (const filePath of filePaths) {
+	console.log(`  - ${filePath}`);
+}

package/bin/apifuse-pack-smoke.ts

@@ -0,0 +1,122 @@
+#!/usr/bin/env bun
+
+import { execFileSync, spawnSync } from "node:child_process";
+import {
+	existsSync,
+	mkdirSync,
+	mkdtempSync,
+	rmSync,
+	writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { z } from "zod";
+
+const PACK_RESULT_SCHEMA = z.array(
+	z.object({
+		filename: z.string(),
+	}),
+);
+
+const KEEP_TEMP = process.env.APIFUSE_PACK_SMOKE_KEEP_TEMP === "1";
+
+const tempRoot = mkdtempSync(
+	join(tmpdir(), "apifuse-provider-sdk-pack-smoke-"),
+);
+const packDir = join(tempRoot, "pack");
+const consumerDir = join(tempRoot, "consumer");
+
+try {
+	mkdirSync(packDir, { recursive: true });
+	mkdirSync(consumerDir, { recursive: true });
+
+	const packed = packSdk(packDir);
+	const tarballPath = resolve(packDir, packed.filename);
+	const tarballSpecifier = `file:${tarballPath}`;
+
+	writeFileSync(
+		join(consumerDir, "package.json"),
+		`${JSON.stringify(
+			{
+				private: true,
+				type: "module",
+				dependencies: {
+					"@apifuse/provider-sdk": tarballSpecifier,
+				},
+			},
+			null,
+			2,
+		)}\n`,
+	);
+
+	run("bun", ["install"], consumerDir);
+
+	const cliBin = join(consumerDir, "node_modules", ".bin", "apifuse");
+	if (!existsSync(cliBin)) {
+		throw new Error(`Expected CLI bin at ${cliBin}`);
+	}
+
+	run(
+		"bun",
+		[
+			cliBin,
+			"create",
+			"dx-smoke",
+			"--yes",
+			"--json",
+			"--sdk-specifier",
+			tarballSpecifier,
+		],
+		consumerDir,
+	);
+
+	const generatedProviderDir = join(consumerDir, "dx-smoke");
+	run("bun", ["run", "check"], generatedProviderDir);
+	run("bun", ["run", "test"], generatedProviderDir);
+
+	console.log(
+		`Provider SDK packed-artifact smoke passed: ${tarballPath} -> ${generatedProviderDir}`,
+	);
+} finally {
+	if (KEEP_TEMP) {
+		console.log(`Keeping smoke temp directory: ${tempRoot}`);
+	} else {
+		rmSync(tempRoot, { recursive: true, force: true });
+	}
+}
+
+function packSdk(destination: string): { filename: string } {
+	const raw = execFileSync(
+		"npm",
+		["pack", "--json", "--pack-destination", destination],
+		{
+			cwd: process.cwd(),
+			encoding: "utf8",
+			stdio: ["ignore", "pipe", "inherit"],
+		},
+	);
+	const parsed = PACK_RESULT_SCHEMA.parse(JSON.parse(raw));
+	const first = parsed[0];
+	if (!first) {
+		throw new Error("npm pack --json returned no package metadata.");
+	}
+	return first;
+}
+
+function run(command: string, args: string[], cwd: string): void {
+	const result = spawnSync(command, args, {
+		cwd,
+		env: process.env,
+		stdio: "inherit",
+	});
+
+	if (result.error) {
+		throw result.error;
+	}
+
+	if (result.status !== 0) {
+		throw new Error(
+			`Command failed (${[command, ...args].join(" ")}) in ${cwd} with exit code ${result.status}`,
+		);
+	}
+}

package/bin/apifuse-perf.ts

@@ -8,10 +8,7 @@ import { pathToFileURL } from "node:url";
 
 import {
 	type ApiFuseConfig,
-	createAuthManager,
 	createHttpClient,
-	createSessionStore,
-	createStateContext,
 	createTlsClient,
 	executeOperation,
 	getProviderBaseUrl,
@@ -83,9 +80,9 @@ const DEFAULT_WARMUP = 2;
 const DEFAULT_CONCURRENCY = 1;
 const BAR_WIDTH = 20;
 
-async function main() {
+export async function main() {
 	try {
-		const args = parseArgs(process.argv.slice(2));
+		const args = parseArgs(normalizeArgs(process.argv.slice(2)));
 		const providerDirectory = resolve(process.cwd(), args.providerPath);
 		const providerEntry = resolveProviderEntry(providerDirectory);
 		const provider = await loadProvider(providerEntry);
@@ -172,6 +169,10 @@ async function main() {
 	}
 }
 
+function normalizeArgs(argv: string[]): string[] {
+	return argv[0] === "perf" ? argv.slice(1) : argv;
+}
+
 function parseArgs(argv: string[]): CliArgs {
 	let providerPath: string | undefined;
 	let operation: string | undefined;
@@ -568,19 +569,12 @@ async function executeProfileRun(options: {
 	const traceContext = createTraceContext(
 		resolveTraceContextOptions(options.config.trace),
 	);
-	const session = createSessionStore({
-		backend: options.config.session?.storage,
-		databasePath: options.config.session?.path,
-	} as Parameters<typeof createSessionStore>[0]);
-	const authManager = createAuthManager(options.provider.auth, session);
 	const baseContext = createBaseContext({
-		authManager,
 		config: options.config,
 		provider: options.provider,
 		fixtureReplay: options.fixtureReplay,
 		forceFixtureReplay: options.forceFixtureReplay,
 		proxyEnabled: options.proxyEnabled,
-		session,
 		traceContext,
 	});
 	const ctx = wrapWithInstrumentation(baseContext);
@@ -592,21 +586,12 @@ async function executeProfileRun(options: {
 		const normalizedInput = await ctx.trace.span("normalizeRequest", async () =>
 			options.inputSchema.parse(input),
 		);
-		const result = options.provider.auth
-			? await authManager.wrapWithAutoRefresh(ctx, () =>
-					executeOperation(
-						options.provider,
-						options.operationName,
-						ctx,
-						normalizedInput,
-					),
-				)
-			: await executeOperation(
-					options.provider,
-					options.operationName,
-					ctx,
-					normalizedInput,
-				);
+		const result = await executeOperation(
+			options.provider,
+			options.operationName,
+			ctx,
+			normalizedInput,
+		);
 
 		return ctx.trace.span("transformResponse", async () =>
 			options.outputSchema.parse(result),
@@ -633,13 +618,11 @@ async function executeProfileRun(options: {
 }
 
 function createBaseContext(options: {
-	authManager: ReturnType<typeof createAuthManager>;
 	config: ApiFuseConfig;
 	provider: ProviderDefinition;
 	fixtureReplay: FixtureReplay | null;
 	forceFixtureReplay: boolean;
 	proxyEnabled: boolean;
-	session: ReturnType<typeof createSessionStore>;
 	traceContext: ReturnType<typeof createTraceContext>;
 }): ProviderContext {
 	const upstream = {
@@ -663,13 +646,31 @@ function createBaseContext(options: {
 				});
 
 	return {
+		env: {
+			get: (key: string) => process.env[key],
+		},
+		credential: {
+			mode: "none",
+			get: () => undefined,
+			getAll: () => ({}),
+			getAccessToken: () => undefined,
+			getScopes: () => [],
+		},
 		http,
 		tls,
 		browser: createBrowserStub(),
-		session: options.session,
-		state: createStateContext(),
 		trace: options.traceContext,
-		auth: options.authManager.createAuthContext(),
+		auth: createAuthStub(),
+	};
+}
+
+function createAuthStub() {
+	return {
+		requestField: async (name: string) => {
+			throw new ProviderError(`Auth prompt is unavailable for ${name}`, {
+				code: "AUTH_PROMPT_UNAVAILABLE",
+			});
+		},
 	};
 }
 

package/bin/apifuse-record.ts

@@ -8,8 +8,6 @@ import { pathToFileURL } from "node:url";
 
 import {
 	createHttpClient,
-	createSessionStore,
-	createStateContext,
 	createTlsClient,
 	executeOperation,
 	type HttpClient,
@@ -30,8 +28,8 @@ type ProviderRuntime = ProviderDefinition;
 
 type MutableRecord = Record<string, unknown>;
 
-async function main() {
-	const args = parseArgs(process.argv.slice(2));
+export async function main() {
+	const args = parseArgs(normalizeArgs(process.argv.slice(2)));
 	const location = resolveProviderLocation(args.providerPath);
 	const provider = await loadProvider(location.rootDir);
 	const operationName = resolveOperationName(provider, args.operation);
@@ -81,6 +79,10 @@ async function main() {
 	void result;
 }
 
+function normalizeArgs(argv: string[]): string[] {
+	return argv[0] === "record" ? argv.slice(1) : argv;
+}
+
 function parseArgs(argv: string[]): CliArgs {
 	let providerPath: string | undefined;
 	let operation: string | undefined;
@@ -197,7 +199,7 @@ function findProviderRoot(startDirectory: string): string | undefined {
 function looksLikeProviderRoot(directory: string): boolean {
 	return (
 		existsSync(resolve(directory, "index.ts")) &&
-		existsSync(resolve(directory, "manifest.json"))
+		existsSync(resolve(directory, "package.json"))
 	);
 }
 
@@ -278,6 +280,16 @@ function createCaptureContext(baseUrl: string) {
 	});
 
 	const ctx: ProviderContext = {
+		env: {
+			get: (key) => process.env[key],
+		},
+		credential: {
+			mode: "none",
+			get: () => undefined,
+			getAll: () => ({}),
+			getAccessToken: () => undefined,
+			getScopes: () => [],
+		},
 		http,
 		tls,
 		browser: {
@@ -286,8 +298,6 @@ function createCaptureContext(baseUrl: string) {
 				throw new Error("Browser client is not available in apifuse record.");
 			},
 		},
-		session: createSessionStore(),
-		state: createStateContext(),
 		trace: {
 			span: async (_name, fn) => fn(),
 		},

package/bin/apifuse-test.ts

@@ -44,9 +44,9 @@ type ActionableError = {
 	type: "zod";
 };
 
-async function main() {
+export async function main() {
 	try {
-		const args = parseArgs(process.argv.slice(2));
+		const args = parseArgs(normalizeArgs(process.argv.slice(2)));
 		const location = resolveProviderLocation(args.providerPath);
 
 		if (args.isVerbose && !args.isJson) {
@@ -111,6 +111,10 @@ async function main() {
 	}
 }
 
+function normalizeArgs(argv: string[]): string[] {
+	return argv[0] === "test" ? argv.slice(1) : argv;
+}
+
 function parseArgs(argv: string[]): CliArgs {
 	let providerPath: string | undefined;
 	let isJson = false;
@@ -219,7 +223,6 @@ function autoDetectSingleProvider(
 		[
 			`Could not find a provider under ${originalInput}.`,
 			"Expected a directory containing:",
-			"  - manifest.json",
 			"  - index.ts",
 			"  - __tests__/index.test.ts",
 		].join("\n"),
@@ -264,7 +267,6 @@ function collectProviderRoots(directory: string): string[] {
 
 function looksLikeProviderRoot(directory: string): boolean {
 	return [
-		resolve(directory, "manifest.json"),
 		resolve(directory, "index.ts"),
 		resolve(directory, "__tests__", "index.test.ts"),
 	].every((filePath) => existsSync(filePath));

package/bin/apifuse.ts

@@ -1,51 +1,52 @@
 #!/usr/bin/env bun
 
 import packageJson from "../package.json";
+import { COMMAND_MANIFEST, COMMAND_ORDER } from "../src/cli/commands";
 
 const command = process.argv[2];
 
-switch (command) {
-	case "init": {
-		const module = await import("./apifuse-init");
-		await module.main();
-		break;
-	}
-	case "dev": {
-		const module = await import("./apifuse-dev");
-		await module.main();
-		break;
-	}
-	case "check": {
-		const module = await import("./apifuse-check");
-		await module.main();
-		break;
-	}
-	case "--help":
-	case "-h":
-	case undefined:
-		printHelp();
-		break;
-	case "--version":
-	case "-v":
-		console.log(packageJson.version);
-		break;
-	default:
-		console.error(`Unknown command: ${command}`);
-		printHelp();
-		process.exit(1);
+if (command === undefined || command === "--help" || command === "-h") {
+	printHelp();
+	process.exit(0);
+}
+
+if (command === "--version" || command === "-v") {
+	console.log(packageJson.version);
+	process.exit(0);
+}
+
+const manifest = COMMAND_MANIFEST[command as keyof typeof COMMAND_MANIFEST];
+
+if (!manifest) {
+	console.error(`Unknown command: ${command}`);
+	printHelp();
+	process.exit(1);
 }
 
+const module = await import(manifest.modulePath);
+await module.main();
+
 function printHelp() {
 	console.log(`
 apifuse - ApiFuse Provider SDK CLI
 
-Commands:
-  init <name>    Create a new provider
-  dev [path]     Start dev server with hot reload
-  check [path]   Validate provider structure
+Commands:`);
+	for (const name of COMMAND_ORDER) {
+		const item = COMMAND_MANIFEST[name];
+		console.log(`  ${item.name.padEnd(8)} ${item.summary}`);
+	}
 
+	console.log(`
+Examples:`);
+	for (const name of COMMAND_ORDER) {
+		const item = COMMAND_MANIFEST[name];
+		for (const example of item.examples.slice(0, 1)) {
+			console.log(`  ${example}`);
+		}
+	}
+
+	console.log(`
 Options:
   --help         Show this help
-  --version      Show version
-`);
+  --version      Show version`);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@apifuse/provider-sdk",
-	"version": "2.0.0-beta.1",
+	"version": "2.1.0-beta.1",
 	"private": false,
 	"type": "module",
 	"description": "ApiFuse Provider SDK — Build providers with zero architectural constraints",
@@ -12,8 +12,14 @@
 	},
 	"files": [
 		"src",
+		"!src/__tests__",
+		"!src/__tests__/**",
+		"!src/**/*.test.ts",
+		"!src/index.test.ts",
 		"bin",
-		"README.md"
+		"README.md",
+		"AUTHORING.md",
+		"CHANGELOG.md"
 	],
 	"keywords": [
 		"apifuse",
@@ -24,7 +30,6 @@
 		"hono"
 	],
 	"bin": {
-		"apifuse-init": "./bin/apifuse-init.ts",
 		"apifuse": "./bin/apifuse.ts"
 	},
 	"exports": {
@@ -33,6 +38,16 @@
 			"import": "./src/index.ts",
 			"types": "./src/index.ts"
 		},
+		"./provider": {
+			"default": "./src/provider.ts",
+			"import": "./src/provider.ts",
+			"types": "./src/provider.ts"
+		},
+		"./server": {
+			"default": "./src/server/index.ts",
+			"import": "./src/server/index.ts",
+			"types": "./src/server/index.ts"
+		},
 		"./testing": {
 			"default": "./src/testing/index.ts",
 			"import": "./src/testing/index.ts",
@@ -43,21 +58,26 @@
 		"lint": "biome check",
 		"lint:fix": "biome lint --write",
 		"format": "biome format --write",
-		"type-check": "tsc --noEmit",
+		"type-check": "tsgo --noEmit",
 		"test": "bun test",
-		"check": "bun run lint && bun run type-check"
+		"check": "bun run lint && bun run type-check",
+		"pack:check": "bun bin/apifuse-pack-check.ts",
+		"pack:smoke": "bun bin/apifuse-pack-smoke.ts"
 	},
 	"devDependencies": {
-		"@biomejs/biome": "^2.3.13",
-		"@clack/prompts": "^1.2.0",
+		"@biomejs/biome": "^2.4.12",
 		"@types/bun": "latest",
 		"@types/node": "^25.1.0",
-		"typescript": "^5.9.3"
+		"typescript": "^6.0.3"
 	},
 	"dependencies": {
-		"hono": "^4.7.11",
+		"@clack/prompts": "^1.2.0",
+		"ajv": "^8.17",
+		"hono": "^4.12.14",
 		"playwright": "^1.55.1",
 		"playwright-stealth": "^0.0.1",
+		"re2-wasm": "^1.0",
+		"safe-regex": "^2.1",
 		"tlsclientwrapper": "^4.2.0",
 		"zod": "^4.3.6"
 	}