@@ -1,7 +1,17 @@
+```
+░█▀▀░█▀█░█▀▀░▀█▀░█▀█░█▀▄░█░░█░█
+░█▀▀░█▀█░█░░░░█░░█░█░█▀▄░█░░░█░
+░▀░░░▀░▀░▀▀▀░░▀░░▀▀▀░▀░▀░▀▀▀░▀░
+```
+
+<center>
+
 # Factorly
 
 Factorly wraps your existing agent tools — REST APIs, CLIs, MCP servers — into a single endpoint where credentials never reach the agent. Your agent sees tool names and parameters. Factorly injects the auth, makes the call, and returns the data.
 
+</center>
+
 ```bash
 # Your agent runs this — no secrets anywhere in the command
 factorly call github.repos --username octocat --per_page 5
@@ -52,7 +62,10 @@ factorly tools add --name web.fetch --type cli --command curl --args '-s,{url}'
 # Use it on the command line
 factorly call web.fetch --url "https://example.com"
 
-# Start as an MCP server for Claude Code / Cursor
+# Connect to Claude Code / Cursor / Codex
+factorly sync
+
+# Or start manually as an MCP server
 factorly serve
 ```
 
@@ -184,7 +197,7 @@ For HTTP mode (remote/shared): `factorly serve --http :3000` — endpoint at `ht
 - [x] Interactive CLI tools — `interactive: true` for TTY passthrough
 - [x] Call logging (JSONL) + `--verbose` flag
 - [x] Security hardening — param redaction, HTTP token auth, vault ref validation
-- [ ] `factorly sync` — push MCP config into AI clients (Claude Code, Cursor, Codex)
+- [x] `factorly sync` — push MCP config into AI clients (Claude Code, Cursor, Codex)
 - [ ] `factorly logs` — view/query the call log
 - [ ] External vault backends (1Password, GCP Secret Manager, AWS)
 - [ ] Hosted version (Factorly Cloud)
 
@@ -15,6 +15,10 @@ factorly tools add --name x --type cli  # add a tool (non-interactive)
 factorly tools remove <tool>        # remove a tool from config
 factorly tools import openapi <spec>  # generate tools from OpenAPI spec
 factorly call <tool> [--param val]  # call a tool
+factorly sync                       # push MCP config to AI clients
+factorly sync --global              # sync to user-level config (~/.claude/, etc.)
+factorly sync --http localhost:3000 # sync HTTP mode
+factorly sync --remove              # remove factorly from client configs
 factorly status                     # check all tools are reachable
 factorly auth login <provider>      # OAuth login (opens browser)
 factorly auth status [provider]     # show OAuth token status
 
@@ -319,7 +319,7 @@ func init() {
 	importCmd.AddCommand(importOpenAPICmd)
 
 	toolsCmd.AddCommand(toolsListCmd, addCmd, removeCmd, importCmd)
-	rootCmd.AddCommand(versionCmd, toolsCmd, callCmd, initCmd, vaultCmd, authCmd, statusCmd, serveCmd)
+	rootCmd.AddCommand(versionCmd, toolsCmd, callCmd, initCmd, syncCmd, vaultCmd, authCmd, statusCmd, serveCmd)
 }
 
 // loadConfig loads config and builds a registry. Does not open the vault
 
@@ -0,0 +1,233 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/spf13/cobra"
+)
+
+var syncHTTP string
+var syncCommand string
+var syncRemove bool
+var syncGlobal bool
+
+type clientDef struct {
+	Name       string
+	ConfigPath string
+	AlwaysSync bool   // true = always create/update; false = only if DirCheck exists
+	DirCheck   string // only sync if this directory exists (empty = always)
+}
+
+func getClients() []clientDef {
+	if syncGlobal {
+		home, err := os.UserHomeDir()
+		if err != nil {
+			home = "~"
+		}
+		// Claude Code user-level MCP config is inside ~/.claude.json
+		// Cursor uses ~/.cursor/mcp.json
+		// Codex global config uses TOML — not supported yet
+		return []clientDef{
+			{Name: "Claude Code", ConfigPath: filepath.Join(home, ".claude.json"), AlwaysSync: true},
+			{Name: "Cursor", ConfigPath: filepath.Join(home, ".cursor", "mcp.json"), DirCheck: filepath.Join(home, ".cursor")},
+			{Name: "Codex", ConfigPath: "", DirCheck: filepath.Join(home, ".codex")},
+		}
+	}
+	return []clientDef{
+		{Name: "Claude Code", ConfigPath: ".mcp.json", AlwaysSync: true},
+		{Name: "Cursor", ConfigPath: ".cursor/mcp.json", DirCheck: ".cursor"},
+		{Name: "Codex", ConfigPath: ".codex/mcp.json", DirCheck: ".codex"},
+	}
+}
+
+var syncCmd = &cobra.Command{
+	Use:   "sync",
+	Short: "Push Factorly MCP config into AI client config files",
+	Long: `Detect installed AI clients and write the Factorly MCP server entry
+into their config files (.mcp.json, .cursor/mcp.json, etc.).
+
+Existing MCP server entries in the config files are preserved.`,
+	RunE: runSync,
+}
+
+func runSync(cmd *cobra.Command, args []string) error {
+	entry := buildFactorlyEntry()
+	synced := 0
+	activeClients := getClients()
+
+	fmt.Fprintln(os.Stderr)
+	if syncGlobal {
+		fmt.Fprintln(os.Stderr, "  Detected clients (global):")
+	} else {
+		fmt.Fprintln(os.Stderr, "  Detected clients:")
+	}
+
+	for _, c := range activeClients {
+		if !c.AlwaysSync && c.DirCheck != "" {
+			if info, err := os.Stat(c.DirCheck); err != nil || !info.IsDir() {
+				fmt.Fprintf(os.Stderr, "  - %-14s %s not found, skipping\n", c.Name, c.DirCheck+"/")
+				continue
+			}
+		}
+
+		if c.ConfigPath == "" {
+			fmt.Fprintf(os.Stderr, "  ✗ %-14s global sync not supported (uses TOML config)\n", c.Name)
+			continue
+		}
+
+		if syncRemove {
+			removed, err := removeFactorlyFromJSON(c.ConfigPath)
+			if err != nil {
+				fmt.Fprintf(os.Stderr, "  ✗ %-14s %v\n", c.Name, err)
+				continue
+			}
+			if removed {
+				fmt.Fprintf(os.Stderr, "  ✓ %-14s removed from %s\n", c.Name, c.ConfigPath)
+				synced++
+			} else {
+				fmt.Fprintf(os.Stderr, "  - %-14s not configured in %s\n", c.Name, c.ConfigPath)
+			}
+		} else {
+			if err := mergeFactorlyIntoJSON(c.ConfigPath, entry); err != nil {
+				fmt.Fprintf(os.Stderr, "  ✗ %-14s %v\n", c.Name, err)
+				continue
+			}
+			fmt.Fprintf(os.Stderr, "  ✓ %-14s wrote %s\n", c.Name, c.ConfigPath)
+			synced++
+		}
+	}
+
+	fmt.Fprintln(os.Stderr)
+	if syncRemove {
+		fmt.Fprintf(os.Stderr, "  Removed from %d clients.\n", synced)
+	} else {
+		fmt.Fprintf(os.Stderr, "  Synced %d clients.\n", synced)
+	}
+	return nil
+}
+
+func buildFactorlyEntry() map[string]any {
+	if syncHTTP != "" {
+		// HTTP mode
+		url := syncHTTP
+		if url[0] != 'h' {
+			url = "http://" + url
+		}
+		if filepath.Ext(url) == "" && url[len(url)-1] != '/' {
+			url += "/mcp"
+		}
+		return map[string]any{
+			"type": "streamable-http",
+			"url":  url,
+		}
+	}
+
+	// Stdio mode
+	cmd := syncCommand
+	if cmd == "" {
+		cmd = "factorly"
+	}
+
+	serveArgs := []string{"serve"}
+
+	// Add config flag if using non-default config location
+	if configPath != "" {
+		serveArgs = append(serveArgs, "-c", configPath)
+	}
+
+	return map[string]any{
+		"command": cmd,
+		"args":    serveArgs,
+	}
+}
+
+func mergeFactorlyIntoJSON(path string, entry map[string]any) error {
+	var root map[string]any
+
+	data, err := os.ReadFile(path)
+	if err != nil {
+		if !os.IsNotExist(err) {
+			return fmt.Errorf("reading %s: %w", path, err)
+		}
+		root = make(map[string]any)
+	} else if len(strings.TrimSpace(string(data))) == 0 {
+		root = make(map[string]any)
+	} else {
+		if err := json.Unmarshal(data, &root); err != nil {
+			return fmt.Errorf("parsing %s: %w", path, err)
+		}
+	}
+
+	// Ensure mcpServers exists
+	servers, ok := root["mcpServers"].(map[string]any)
+	if !ok {
+		servers = make(map[string]any)
+	}
+
+	servers["factorly"] = entry
+	root["mcpServers"] = servers
+
+	// Ensure parent directory exists
+	if dir := filepath.Dir(path); dir != "." {
+		if err := os.MkdirAll(dir, 0o755); err != nil {
+			return fmt.Errorf("creating directory: %w", err)
+		}
+	}
+
+	out, err := json.MarshalIndent(root, "", "  ")
+	if err != nil {
+		return fmt.Errorf("marshaling: %w", err)
+	}
+	out = append(out, '\n')
+
+	return os.WriteFile(path, out, 0o644)
+}
+
+func removeFactorlyFromJSON(path string) (bool, error) {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return false, nil
+		}
+		return false, fmt.Errorf("reading %s: %w", path, err)
+	}
+
+	var root map[string]any
+	if err := json.Unmarshal(data, &root); err != nil {
+		return false, fmt.Errorf("parsing %s: %w", path, err)
+	}
+
+	servers, ok := root["mcpServers"].(map[string]any)
+	if !ok {
+		return false, nil
+	}
+
+	if _, exists := servers["factorly"]; !exists {
+		return false, nil
+	}
+
+	delete(servers, "factorly")
+	root["mcpServers"] = servers
+
+	out, err := json.MarshalIndent(root, "", "  ")
+	if err != nil {
+		return false, fmt.Errorf("marshaling: %w", err)
+	}
+	out = append(out, '\n')
+
+	if err := os.WriteFile(path, out, 0o644); err != nil {
+		return false, fmt.Errorf("writing %s: %w", path, err)
+	}
+	return true, nil
+}
+
+func init() {
+	syncCmd.Flags().StringVar(&syncHTTP, "http", "", "sync HTTP mode with this address (e.g. localhost:3000)")
+	syncCmd.Flags().StringVar(&syncCommand, "command", "", "custom factorly binary path")
+	syncCmd.Flags().BoolVar(&syncRemove, "remove", false, "remove factorly entry from client configs")
+	syncCmd.Flags().BoolVar(&syncGlobal, "global", false, "sync to user-level config (~/.claude/, ~/.cursor/, ~/.codex/)")
+}
Original file line number	Diff line number	Diff line change
`@@ -319,7 +319,7 @@ func init() {`
`319`	`319`	`importCmd.AddCommand(importOpenAPICmd)`
`320`	`320`
`321`	`321`	`toolsCmd.AddCommand(toolsListCmd, addCmd, removeCmd, importCmd)`
`322`		`- rootCmd.AddCommand(versionCmd, toolsCmd, callCmd, initCmd, vaultCmd, authCmd, statusCmd, serveCmd)`
	`322`	`+ rootCmd.AddCommand(versionCmd, toolsCmd, callCmd, initCmd, syncCmd, vaultCmd, authCmd, statusCmd, serveCmd)`
`323`	`323`	`}`
`324`	`324`
`325`	`325`	`// loadConfig loads config and builds a registry. Does not open the vault`