@outfitter/presets 0.2.0

package/presets/daemon/README.md.template

@@ -0,0 +1,67 @@
+# {{projectName}}
+
+{{description}}
+
+A background daemon with CLI control interface.
+
+## Installation
+
+```bash
+bun add {{packageName}}
+```
+
+## Usage
+
+```bash
+# Start daemon in background
+{{binName}} start
+
+# Start daemon in foreground (for debugging)
+{{binName}} start --foreground
+
+# Check status
+{{binName}} status
+
+# Stop daemon
+{{binName}} stop
+```
+
+## Endpoints
+
+The daemon exposes a Unix socket with the following endpoints:
+
+### GET /health
+
+Returns daemon health information:
+
+```json
+{
+  "status": "ok",
+  "uptime": 12345,
+  "version": "{{version}}"
+}
+```
+
+### POST /shutdown
+
+Gracefully shuts down the daemon.
+
+## Development
+
+```bash
+# Install dependencies
+bun install
+
+# Run daemon in foreground
+bun run dev
+
+# Build
+bun run build
+
+# Run tests
+bun run test
+```
+
+## License
+
+MIT

package/presets/daemon/biome.json.template

@@ -0,0 +1,4 @@
+{
+	"$schema": "https://biomejs.dev/schemas/2.4.4/schema.json",
+	"extends": ["ultracite/config/biome/core/biome.jsonc"]
+}

package/presets/daemon/package.json.template

@@ -0,0 +1,49 @@
+{
+	"name": "{{packageName}}",
+	"version": "{{version}}",
+	"description": "{{description}}",
+	"type": "module",
+	"bin": {
+		"{{binName}}": "./dist/cli.js",
+		"{{binName}}d": "./dist/daemon.js"
+	},
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js"
+		}
+	},
+	"scripts": {
+		"build": "bun build src/cli.ts src/daemon.ts --outdir dist --target bun && bun build src/index.ts --outdir dist --target bun --sourcemap",
+		"dev": "bun --watch src/daemon.ts -- --foreground",
+		"dev:daemon": "bun --watch src/daemon.ts -- --foreground",
+		"typecheck": "tsc --noEmit",
+		"check": "ultracite check",
+		"verify:ci": "bun run typecheck && bun run check && bun run build && bun run test",
+		"test": "bun test",
+		"test:watch": "bun test --watch",
+		"lint": "biome check .",
+		"lint:fix": "biome check . --write",
+		"format": "biome format --write .",
+		"clean:artifacts": "rm -rf dist .turbo"
+	},
+	"dependencies": {
+		"@outfitter/contracts": "workspace:*",
+		"@outfitter/types": "workspace:*",
+		"@outfitter/daemon": "workspace:*",
+		"@outfitter/cli": "workspace:*",
+		"@outfitter/logging": "workspace:*",
+		"commander": "^14.0.2"
+	},
+	"devDependencies": {},
+	"outfitter": {
+		"template": {
+			"kind": "runnable",
+			"placement": "apps",
+			"surfaces": ["cli", "daemon"]
+		}
+	},
+	"license": "MIT"
+}

package/presets/daemon/src/cli.ts.template

@@ -0,0 +1,96 @@
+#!/usr/bin/env bun
+/**
+ * {{projectName}} CLI entry point
+ *
+ * Commands: start, stop, restart, status
+ */
+
+import { createCLI, command } from "@outfitter/cli";
+import { createLogger } from "@outfitter/logging";
+import { spawn } from "node:child_process";
+import { getSocketPath, getLockPath, isDaemonAlive } from "@outfitter/daemon";
+
+const logger = createLogger({ name: "{{binName}}" });
+
+const TOOL_NAME = "{{binName}}";
+const socketPath = getSocketPath(TOOL_NAME);
+const lockPath = getLockPath(TOOL_NAME);
+
+const program = createCLI({
+	name: "{{binName}}",
+	version: "{{version}}",
+	description: "{{description}}",
+});
+
+program.register(
+	command("start")
+		.description("Start the daemon")
+		.option("-f, --foreground", "Run in foreground")
+		.action(async ({ flags }) => {
+			const foreground = Boolean((flags as { foreground?: boolean }).foreground);
+
+			if (await isDaemonAlive(lockPath)) {
+				logger.warn`Daemon is already running`;
+				process.exit(1);
+			}
+
+			if (foreground) {
+				// Run in foreground - import and run daemon directly
+				const { runDaemon } = await import("./daemon-main.js");
+				await runDaemon();
+			} else {
+				// Spawn daemon in background
+				const daemon = spawn(process.execPath, [import.meta.dir + "/daemon.js"], {
+					detached: true,
+					stdio: "ignore",
+				});
+				daemon.unref();
+				logger.info`Daemon started with PID ${daemon.pid}`;
+			}
+		}),
+);
+
+program.register(
+	command("stop")
+		.description("Stop the daemon")
+		.action(async () => {
+			if (!(await isDaemonAlive(lockPath))) {
+				logger.warn`Daemon is not running`;
+				process.exit(1);
+			}
+			// Signal daemon to stop via HTTP
+			try {
+				const response = await fetch(`http://unix:${socketPath}:/shutdown`, {
+					method: "POST",
+				});
+				if (response.ok) {
+					logger.info`Daemon stopped`;
+				}
+			} catch {
+				logger.error`Failed to stop daemon`;
+				process.exit(1);
+			}
+		}),
+);
+
+program.register(
+	command("status")
+		.description("Check daemon status")
+		.action(async () => {
+			if (await isDaemonAlive(lockPath)) {
+				logger.info`Daemon is running`;
+				// Fetch health info
+				try {
+					const response = await fetch(`http://unix:${socketPath}:/health`);
+					const health = await response.json();
+					console.log(JSON.stringify(health, null, 2));
+				} catch {
+					logger.warn`Could not fetch health info`;
+				}
+			} else {
+				logger.info`Daemon is not running`;
+			}
+		}),
+);
+
+program.parse(process.argv);

package/presets/daemon/src/daemon-main.ts.template

@@ -0,0 +1,79 @@
+/**
+ * {{projectName}} daemon main logic
+ */
+
+import { createLogger } from "@outfitter/logging";
+import {
+	getSocketPath,
+	getLockPath,
+	getDaemonDir,
+	acquireDaemonLock,
+	releaseDaemonLock,
+} from "@outfitter/daemon";
+import { mkdir } from "node:fs/promises";
+
+const logger = createLogger({ name: "{{binName}}d" });
+
+const TOOL_NAME = "{{binName}}";
+const startTime = Date.now();
+
+export async function runDaemon(): Promise<void> {
+	const socketPath = getSocketPath(TOOL_NAME);
+	const lockPath = getLockPath(TOOL_NAME);
+	const daemonDir = getDaemonDir(TOOL_NAME);
+
+	// Ensure daemon directory exists
+	await mkdir(daemonDir, { recursive: true });
+
+	// Acquire lock
+	const lockResult = await acquireDaemonLock(lockPath);
+	if (!lockResult.isOk()) {
+		logger.error`Failed to acquire lock: ${lockResult.error.message}`;
+		process.exit(1);
+	}
+	const lock = lockResult.value;
+
+	logger.info`Daemon starting on ${socketPath}`;
+
+	// Create HTTP server on Unix socket
+	const server = Bun.serve({
+		unix: socketPath,
+		fetch(request) {
+			const url = new URL(request.url);
+
+			if (url.pathname === "/health") {
+				return Response.json({
+					status: "ok",
+					uptime: Date.now() - startTime,
+					version: "{{version}}",
+				});
+			}
+
+			if (url.pathname === "/shutdown" && request.method === "POST") {
+				logger.info`Shutdown requested`;
+				// Schedule shutdown
+				setTimeout(async () => {
+					await releaseDaemonLock(lock);
+					server.stop();
+					process.exit(0);
+				}, 100);
+				return new Response("Shutting down");
+			}
+
+			return new Response("Not found", { status: 404 });
+		},
+	});
+
+	// Handle signals
+	const shutdown = async () => {
+		logger.info`Received shutdown signal`;
+		await releaseDaemonLock(lock);
+		server.stop();
+		process.exit(0);
+	};
+
+	process.on("SIGTERM", shutdown);
+	process.on("SIGINT", shutdown);
+
+	logger.info`Daemon running`;
+}

package/presets/daemon/src/daemon.ts.template

@@ -0,0 +1,11 @@
+#!/usr/bin/env bun
+/**
+ * {{projectName}} daemon entry point
+ */
+
+import { runDaemon } from "./daemon-main.js";
+
+runDaemon().catch((error) => {
+	console.error("Daemon failed:", error);
+	process.exit(1);
+});

package/presets/daemon/src/index.ts.template

@@ -0,0 +1,7 @@
+/**
+ * {{projectName}} - Public API exports
+ *
+ * @packageDocumentation
+ */
+
+export { runDaemon } from "./daemon-main.js";

package/presets/daemon/tsconfig.json.template

@@ -0,0 +1,23 @@
+{
+	"compilerOptions": {
+		"target": "ESNext",
+		"module": "ESNext",
+		"moduleResolution": "bundler",
+		"strict": true,
+		"esModuleInterop": true,
+		"verbatimModuleSyntax": true,
+		"skipLibCheck": true,
+		"declaration": true,
+		"declarationDir": "dist",
+		"outDir": "dist",
+		"rootDir": "src",
+		"types": ["bun-types"],
+		"noImplicitAny": true,
+		"strictNullChecks": true,
+		"noUncheckedIndexedAccess": true,
+		"exactOptionalPropertyTypes": true,
+		"noPropertyAccessFromIndexSignature": true
+	},
+	"include": ["src"],
+	"exclude": ["node_modules", "dist"]
+}

package/presets/full-stack/.gitignore.template

@@ -0,0 +1,30 @@
+# Dependencies
+node_modules/
+
+# Build output
+**/dist/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+npm-debug.log*
+
+# Environment
+.env
+.env.local
+.env.*.local
+
+# Test coverage
+coverage/
+
+# Bun
+bun.lockb

package/presets/full-stack/README.md.template

@@ -0,0 +1,30 @@
+# {{projectName}}
+
+{{description}}
+
+## Workspace Layout
+
+```text
+{{projectName}}/
+├── apps/
+│   ├── cli/    # CLI surface
+│   └── mcp/    # MCP server surface
+└── packages/
+    └── core/   # Shared handler layer
+```
+
+## Development
+
+```bash
+# Install dependencies for all workspace members
+bun install
+
+# Build all packages
+bun run build
+
+# Typecheck all packages
+bun run typecheck
+
+# Run all tests
+bun run test
+```

package/presets/full-stack/apps/cli/package.json.template

@@ -0,0 +1,35 @@
+{
+	"name": "{{packageName}}-cli",
+	"version": "{{version}}",
+	"description": "CLI surface for {{projectName}}",
+	"type": "module",
+	"bin": {
+		"{{projectName}}": "./dist/cli.js"
+	},
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js"
+		}
+	},
+	"scripts": {
+		"build": "bun build src/cli.ts --outdir dist --target bun && bun build src/index.ts --outdir dist --target bun --sourcemap",
+		"dev": "bun --watch src/cli.ts",
+		"test": "bun test",
+		"test:watch": "bun test --watch",
+		"typecheck": "tsc --noEmit",
+		"lint": "biome check .",
+		"lint:fix": "biome check . --write",
+		"format": "biome format --write .",
+		"clean:artifacts": "rm -rf dist .turbo"
+	},
+	"dependencies": {
+		"{{packageName}}-core": "workspace:*",
+		"@outfitter/cli": "workspace:*",
+		"@outfitter/contracts": "workspace:*"
+	},
+	"devDependencies": {},
+	"license": "MIT"
+}

package/presets/full-stack/apps/cli/src/cli.ts.template

@@ -0,0 +1,24 @@
+import { createContext } from "@outfitter/contracts";
+import { output } from "@outfitter/cli";
+import { createGreeting } from "{{packageName}}-core";
+
+export async function runCli(argv: readonly string[] = process.argv): Promise<void> {
+	const args = argv.slice(2);
+	const name =
+		args.find((arg) => !arg.startsWith("-")) ?? "World";
+	const excited = args.includes("--excited");
+	const result = await createGreeting(
+		{ name, excited },
+		createContext({ cwd: process.cwd(), env: process.env })
+	);
+
+	if (result.isErr()) {
+		throw result.error;
+	}
+
+	await output(result.value.message, { mode: "human" });
+}
+
+if (import.meta.main) {
+	await runCli();
+}

package/presets/full-stack/apps/cli/src/index.test.ts.template

@@ -0,0 +1,18 @@
+import { describe, expect, test } from "bun:test";
+import { createContext } from "@outfitter/contracts";
+import { createGreeting } from "{{packageName}}-core";
+
+describe("cli surface", () => {
+	test("can use shared core handler", async () => {
+		const result = await createGreeting(
+			{ name: "CLI", excited: true },
+			createContext({ cwd: process.cwd(), env: process.env })
+		);
+
+		expect(result.isOk()).toBe(true);
+		if (result.isErr()) {
+			return;
+		}
+		expect(result.value.message).toBe("Hello, CLI!");
+	});
+});

package/presets/full-stack/apps/cli/src/index.ts.template

@@ -0,0 +1,5 @@
+/**
+ * {{projectName}} CLI - Public API.
+ */
+
+export { runCli } from "./cli.js";

package/presets/full-stack/apps/cli/tsconfig.json.template

@@ -0,0 +1,37 @@
+{
+	"$schema": "https://json.schemastore.org/tsconfig",
+	"compilerOptions": {
+		"target": "ESNext",
+		"module": "ESNext",
+		"moduleResolution": "bundler",
+		"lib": ["ESNext"],
+		"types": ["@types/bun"],
+		"baseUrl": ".",
+		"paths": {
+			"{{packageName}}-core": ["../../packages/core/src/index.ts"]
+		},
+
+		"strict": true,
+		"noImplicitAny": true,
+		"strictNullChecks": true,
+		"noUncheckedIndexedAccess": true,
+		"exactOptionalPropertyTypes": true,
+		"noPropertyAccessFromIndexSignature": true,
+		"noImplicitReturns": true,
+		"noFallthroughCasesInSwitch": true,
+
+		"declaration": true,
+		"declarationMap": true,
+		"sourceMap": true,
+		"outDir": "./dist",
+
+		"esModuleInterop": true,
+		"forceConsistentCasingInFileNames": true,
+		"isolatedModules": true,
+		"verbatimModuleSyntax": true,
+		"skipLibCheck": true,
+		"resolveJsonModule": true
+	},
+	"include": ["src/**/*"],
+	"exclude": ["node_modules", "dist"]
+}

package/presets/full-stack/apps/mcp/package.json.template

@@ -0,0 +1,36 @@
+{
+	"name": "{{packageName}}-mcp",
+	"version": "{{version}}",
+	"description": "MCP surface for {{projectName}}",
+	"type": "module",
+	"bin": {
+		"{{projectName}}-mcp": "./dist/server.js"
+	},
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js"
+		}
+	},
+	"scripts": {
+		"build": "bun build src/server.ts --outdir dist --target bun && bun build src/index.ts --outdir dist --target bun --sourcemap",
+		"dev": "bun --watch src/server.ts",
+		"test": "bun test",
+		"test:watch": "bun test --watch",
+		"typecheck": "tsc --noEmit",
+		"lint": "biome check .",
+		"lint:fix": "biome check . --write",
+		"format": "biome format --write .",
+		"clean:artifacts": "rm -rf dist .turbo"
+	},
+	"dependencies": {
+		"{{packageName}}-core": "workspace:*",
+		"@outfitter/contracts": "workspace:*",
+		"@outfitter/mcp": "workspace:*",
+		"zod": "^4.3.5"
+	},
+	"devDependencies": {},
+	"license": "MIT"
+}

package/presets/full-stack/apps/mcp/src/index.test.ts.template

@@ -0,0 +1,18 @@
+import { describe, expect, test } from "bun:test";
+import { createContext } from "@outfitter/contracts";
+import { createGreeting } from "{{packageName}}-core";
+
+describe("mcp surface", () => {
+	test("can use shared core handler", async () => {
+		const result = await createGreeting(
+			{ name: "MCP" },
+			createContext({ cwd: process.cwd(), env: process.env })
+		);
+
+		expect(result.isOk()).toBe(true);
+		if (result.isErr()) {
+			return;
+		}
+		expect(result.value.message).toBe("Hello, MCP.");
+	});
+});

package/presets/full-stack/apps/mcp/src/index.ts.template

@@ -0,0 +1,6 @@
+/**
+ * {{projectName}} MCP - Public API.
+ */
+
+export { server } from "./mcp.js";
+export { startServer } from "./server.js";

package/presets/full-stack/apps/mcp/src/mcp.ts.template

@@ -0,0 +1,22 @@
+import { createGreeting } from "{{packageName}}-core";
+import { createMcpServer, defineTool } from "@outfitter/mcp";
+import { z } from "zod";
+
+const server = createMcpServer({
+	name: "{{projectName}}-mcp",
+	version: "{{version}}",
+});
+
+const greetTool = defineTool({
+	name: "greet",
+	description: "Generate greeting via shared core handler",
+	inputSchema: z.object({
+		name: z.string().default("World").describe("Name to greet"),
+		excited: z.boolean().default(false),
+	}),
+	handler: async (input, ctx) => createGreeting(input, ctx),
+});
+
+server.registerTool(greetTool);
+
+export { server };

package/presets/full-stack/apps/mcp/src/server.ts.template

@@ -0,0 +1,10 @@
+import { connectStdio } from "@outfitter/mcp";
+import { server } from "./mcp.js";
+
+export async function startServer(): Promise<void> {
+	await connectStdio(server);
+}
+
+if (import.meta.main) {
+	await startServer();
+}

package/presets/full-stack/apps/mcp/tsconfig.json.template

@@ -0,0 +1,37 @@
+{
+	"$schema": "https://json.schemastore.org/tsconfig",
+	"compilerOptions": {
+		"target": "ESNext",
+		"module": "ESNext",
+		"moduleResolution": "bundler",
+		"lib": ["ESNext"],
+		"types": ["@types/bun"],
+		"baseUrl": ".",
+		"paths": {
+			"{{packageName}}-core": ["../../packages/core/src/index.ts"]
+		},
+
+		"strict": true,
+		"noImplicitAny": true,
+		"strictNullChecks": true,
+		"noUncheckedIndexedAccess": true,
+		"exactOptionalPropertyTypes": true,
+		"noPropertyAccessFromIndexSignature": true,
+		"noImplicitReturns": true,
+		"noFallthroughCasesInSwitch": true,
+
+		"declaration": true,
+		"declarationMap": true,
+		"sourceMap": true,
+		"outDir": "./dist",
+
+		"esModuleInterop": true,
+		"forceConsistentCasingInFileNames": true,
+		"isolatedModules": true,
+		"verbatimModuleSyntax": true,
+		"skipLibCheck": true,
+		"resolveJsonModule": true
+	},
+	"include": ["src/**/*"],
+	"exclude": ["node_modules", "dist"]
+}

package/presets/full-stack/package.json.template

@@ -0,0 +1,16 @@
+{
+	"name": "{{packageName}}",
+	"private": true,
+	"version": "{{version}}",
+	"type": "module",
+	"workspaces": ["apps/*", "packages/*"],
+	"scripts": {
+		"build": "bun run --filter '*' build",
+		"dev": "bun run --filter '*' dev",
+		"test": "bun run --filter '*' test",
+		"typecheck": "bun run --filter '*' typecheck",
+		"lint": "bun run --filter '*' lint",
+		"lint:fix": "bun run --filter '*' lint:fix",
+		"format": "bun run --filter '*' format"
+	}
+}